类和对象（Java语言）

类和对象（Java语言）

类和对象（Java语言）

• 前言
• 面向过程编程和面向对象编程
• 类和类的实例化
• • 类
  • 类的实例化
• 类的成员
• • 字段/属性/成员变量
  • 方法

前言

接触到了类和对象，就是真正Java核心的地方了，也是重难点。那么我们一直会有疑问什么是类？什么是对象呢？这篇博客将会给予我们答案。

面向过程编程和面向对象编程

了解类和对象我们就需要理解面向过程和面向对象编程的区别所在，以洗衣服为例：

1. 如果是面向过程，那么就是先拿盆->防水->放衣服->放洗衣粉->手搓->换水->手搓->拧干->晾衣服。
   

2. 如果是面向对象，通过洗衣服，我们分析出总过有四个对象：人、衣服、洗衣粉、洗衣机，我们并不关心洗衣机是如何工作的。只需要知道这4个对象通过交互完成洗衣的过程，人将衣服放进洗衣机、导入洗衣粉等等。而类就可以理解成对象属性的集合，比如有洗衣粉、洗衣液，那么洗衣粉和洗衣液都是用来洗衣服用的我们就可以将这两者归为一类而类有产生洗衣粉和洗衣液这两个对象。

类和类的实例化 类

通过上面的解释我们可以得出：类就是一类对象的统称。对象就是这一类具体化的一个实例。
基本语法：

class {  
    field;//成员属性
    method;//成员方法
}

由此我们知道类中包含两种，一种是成员属性：比如年龄，性别，姓名等等，一种是成员方法（也就是成员行为）：比如吃饭，睡觉，上学等等。举个例子：

class Person {
    public String name;
    public int age;

    public void eat() {
        System.out.println(name + " 正在吃饭");
    }

    public void sleep() {
        System.out.println(name + " 正在睡觉");
    }
}

我们定义一个Person类，类中有两个属性，姓名和年龄两种；有两个方法：eat（）方法和（）sleep（）方法。此处的方法和原来的定义方法是不一样的，此处写的方法不带 static 关键字。

类的实例化

类的实例化我们就可以理解为创建对象的过程就叫做类的实例化。举个例子：现在我们有一个房型的图纸（类），我们用这个图纸建造了4个一摸一样的房子（对象），这个过程就叫做类的实例化。我们看代码：

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();
 }
}

通过这个例子我们知道Person是一个类，我们通过new就可以创建一个对象，这个对象就有了类中的属性和方法，我们通过使用"."来访问对象中的属性和方法。当然一个类是可以创建多个对象，但是对象的名字是不能相同的。
总结：

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

类的成员 字段/属性/成员变量

在类中, 但是方法外部定义的变量. 这样的变量我们称为 “字段” 或 “属性” 或 “成员变量”(三种称呼都可以, 一般不会严格区分)。我们举个简单的例子：

class Person {
    //属性->字段->成员变量
    //普通的成员变量都是属于对象的
    public String name;
    public int age;
}

这个是普通的成员变量，是每个对象都有的也就是说有一个对象，就单独有普通的成员变量，就像例子中的name和age，如果访问打印是不会相互影响的。

public static void main(String[] args) {
        Person person = new Person();
        person.name = "bit";
        person.age = 99;
        System.out.println(person.name);
        System.out.println(person.age);
        System.out.println("========================");
        Person person1 = new Person();
        person1.name = "jj";
        person1.age = 18;
        System.out.println(person1.name);
        System.out.println(person1.age);
    }

我们可以看到打印是不会影响的，但是成员变量中除了普通的成员变量还有静态成员变量。

class Person {
    //属性->字段->成员变量
    //普通的成员变量都是属于对象的
    public String name;
    public int age;
    //静态成员变量
    public static int count;
}

其中count就是静态成员变量，静态成员变量与普通成员变量的区别就在于，普通成员变量不会相互影响，每个变量都有，而静态成员变量是大家共有的，怎样体现的呢？我们举个例子：

public static void main(String[] args) {
        Person person=new Person();
        person.count++;
        System.out.println(person.count);
        System.out.println("=============");
        Person person1=new Person();
        person1.count++;
        System.out.println(person1.count);
    }

我们可以看到，我们定义两个Person类型的变量（person和person1），我们先用person访问count静态成员变量，让count++（初始值为0），再用person1访问count静态成员变量，让count++，然后打印两次的结果，如果是普通成员变量，那么结果都应该是1，但是因为count是静态成员变量，所以person和person1是共用count的。但是实际意义上静态成员是属于类的，而不是某个对象的，因此正确的代码应是这样的：

public static void main(String[] args) {
        //Person person=new Person();
        Person.count++;
        System.out.println(Person.count);
        System.out.println("=============");
        //Person person1=new Person();
        Person.count++;
        System.out.println(Person.count);
    }

既节省了创建变量的空间，也防止了警告的产生。
注：

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

默认值规则

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

方法

方法是用于描述对象的行为，同样的方法也有两种一种是普通方法，一种是静态方法，普通方法是需要对象才可以引用的，但是静态方法不需要对象，静态方法是属于类的，静态方法直接通过类名引用就能使用。

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();
   }
}

这时普通的方法需要我们创建person变量在进行引用完成打印。

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);   
   }
}

静态方法通过类名直接访问完成打印。
关于静态方法与静态变量有一些易错点我们总结一下：
易错点：
易错点1：

Person person = null;

这个引用不指向任何的对象。

---

易错点2：

Person person = new Person();
Person person2 = person;

person2这个引用指向person这个引用所指向的对象，简而言之就是person2和person指向相同的对象。

---

易错点3：

Person person = new Person();
person = new Person();
person = new Person();
person = new Person();
person = new Person();

一个引用不可以同时指向多个对象，最终person指向的是最后一次指向的对象。

---

易错点4：
引用不一定在栈上，也可以在堆上。

在Test类中创建一个person引用变量，person引用变量指向对象，对象有两个属性name和age两个属性。

---

易错点5:
静态方法可以访问静态数据成员，并可以更改静态数据成员的值，（但是静态成员变量不能在静态方法和普通方法中定义）

class TestDemo{
    public int a;
    public static int count;
    
    public static void change() {
        count = 100;
        //a = 10; error 不可以访问非静态数据成员
        //static int a; error 不可以定义静态成员变量
   }
}

---

易错点6： 普通方法可以使用静态方法，但是静态方法不能使用普通方法（除非创建对象）

public void print() {
        staticFunc();
        System.out.println("姓名: " + name + " 年龄: " + age);
    }
    //类方法
    public static void staticFunc(){
        System.out.println("static::func()");
    }

关于类和对象的涉及的知识就是这么多了，如果有什么错误或者建议欢迎大家私信或者评论，谢谢各位！