Java入门——类和对象（上）

经读者反映与笔者考虑，近期以及往后内容更新将主要以java为主，望读者周知、见谅。

类与对象是什么？

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

面向过程注重的是过程，在整个过程中所涉及的行为，就是功能。

面向对象注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来。

---

1.面向对象是思考问题的一种思考方式，是一种思想。

2.类就是一类对象的统称。对象就是这一类具体化的一个实例。

3.面向对象的好处：将复杂的事情变简单了，只要面对一个对象就行。

简而言之

面向对象就是用代码(类)来描述客观世界的事物的一种方式. 一个类主要包含一个事物的属性和行为。

类和类的实例化

类就是一类对象的统称。对象就是这一类具体化的一个实例。

单的例子：我们做月饼的模子就是一个类，而通过这个模子可以做出月饼，那么在这个例子当中，类就是那个模子，而月饼就是那个对象,所以月饼就是一个实体。一个模子可以实例化无数个对象。

总的来说：类相当于一个模板，对象是由模板产生的样本。一个类，可以产生无数的对象。

声明一个类就是创建一个新的数据类型，而类在Java中属于引用类型，Java使用关键字class来声明类。我们来看以下简单的声明一个类。

// 创建类class <class_name>{     
 field;//成员属性   
 method;//成员方法
}
// 实例化对象<class_name> <对象名> = new <class_name>();

class为定义类的关键字，ClassName为类的名字，{}中为类的主体。

类中的元素称为：成员属性。类中的函数称为：成员方法。

class Person {    
public int age;//成员属性  实例变量   
public String name;    
public String sex;    
public void eat() {
//成员方法       
System.out.println("吃饭!");      
}    
public void sleep() {       
System.out.println("睡觉!");      
}
}

类的实例化

用类类型创建对象的过程，称为类的实例化

1. 类只是一个模型一样的东西，限定了类有哪些成员.

2. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量.

3. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间.

class Person {    
public int age;//成员属性  实例变量    
public String name;    
public String sex;
public void eat() {//成员方法       
System.out.println("吃饭!");      
}    
public void sleep() {       
System.out.println("睡觉!");      
}
}
public class Main{    
public static void main(String[] args) {        
Person person = new Person();//通过new实例化对象        
person.eat();//成员方法调用需要通过对象的引用调用        
person.sleep();        
//产生对象     实例化对象        
Person person2 = new Person();        
Person person3 = new Person();    
}
}

1. new 关键字用于创建一个对象的实例
2. 使用 . 来访问对象中的属性和方法
3. 同一个类可以创建多个实例

类的成员

字段/属性/成员变量

在类中, 有在方法外部定义的变量. 这样的变量我们称为 "字段" 或 "属性" 或 "成员变量"(三种称呼都可以, 一般不会严格区分).

用于描述一个类中包含哪些数据。

class Person {    
public String name;   // 字段    
public int age;
}
class Test {    
public static void main(String[] args) {
Person person = new Person();  
System.out.println(person.name);        
System.out.println(person.age);    
}
}

使用

• 访问对象的字段.
• "访问" 既包含读, 也包含写.
• 对于一个对象的字段如果没有显式设置初始值, 那么会被设置一个默认的初值.

1. 对于各种数字类型, 默认值为 0.
2. 对于 boolean 类型, 默认值为 false.
3. 对于引用类型(String, Array, 以及自定制类), 默认值为 null

字段就地初始化

很多时候我们不希望字段使用默认值, 而是需要我们显式设定初值. 可以这样写:

class Person {    
public String name = "张三";
 public int age = 18;
}

方法

用于描述一个对象的行为.

class Person {    
public int age = 18;    
public String name = "张三";        
public void show() {        
System.out.println("我叫" + name + ", 今年" + age + "岁");    
}
}
class Test {    
public static void main(String[] args) {
        Person person = new Person();        
        person.show();    
}
}

此处的 show 方法, 表示 Person 这个对象具有一个 "展示自我" 的行为.

这样的 show 方法是和 person 实例相关联的. 如果创建了其他实例, 那么 show 的行为就会发生变化

static 关键字

修饰属性

class TestDemo{    
public int a;    
public static int count;
}

count被static所修饰，所有类共享。且不属于对象，访问方式为：类名 . 属性。

修饰方法

如果在任何方法上应用static关键字，此方法称为静态方法。

• 静态方法属于类，而不属于类的对象。
• 可以直接调用静态方法，而无需创建类的实例。
• 静态方法可以访问静态数据成员，并可以更改静态数据成员的值。

class TestDemo{    
public int a;    
public static int count;        
public static void change() {        
count = 100;        
//a = 10; error  不可以访问非静态数据成员    
}
}
public class Main{    
public static void main(String[] args) {        
TestDemo.change()；//无需创建实例对象 就可以调用
System.out.println(TestDemo.count);       
}
}

静态方法和实例无关, 而是和类相关. 因此这导致了两个情况:

• 静态方法不能直接使用非静态数据成员或调用非静态方法(非静态数据成员和方法都是和实例相关的).
• this和super两个关键字不能在静态上下文中使用(this 是当前实例的引用, super是当前实例父类实例的引用, 也是和当前实例相关).

总结复盘

class Person {    
public int age;//实例变量    存放在对象内    
public String name;//实例变量    
public String sex;//实例变量    
public static int count;//类变量也叫静态变量，编译时已经产生，属于类本身，且只有一份。存放在方法区    
public final int SIZE = 10;//被final修饰的叫常量，也属于对象。 被final修饰，后续不可更改    
public static final int  COUNT = 99;//静态的常量，属于类本身，只有一份  被final修饰，后续不可更改    
//实例成员函数    public void eat() {       
int a = 10;//局部变量        
System.out.println("eat()!");      
}    //实例成员函数     
public void sleep() {       
System.out.println("sleep()!");      
}    //静态成员函数     
public static void staticTest(){         
//不能访问非静态成员        
//sex = "man"; error        
System.out.println("StaticTest()");     
}
}
public class Main{    
public static void main(String[] args) {
 //产生对象 实例化对象        
 Person person = new Person();//person为对象的引用        System.out.println(person.age);//默认值为0        System.out.println(person.name);//默认值为null        //System.out.println(person.count);//会有警告!        
 //正确访问方式：        
 System.out.println(Person.count);        System.out.println(Person.COUNT);         
 Person.staticTest();        
//总结：所有被static所修饰的方法或者属性，全部不依赖于对象。        person.eat();        
 person.sleep();    
}
}