Java是一门纯面向对象的语言(Object Oriented Program，继承OOP)，在面向对象的世界里，一切皆为对象（创建一个引用变量，同样是对象）。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。用面向对象的思想来涉及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好。

2.2 面向过程

比如你想买个手机，那么你会经历以下过程，每件事情你都要亲力亲为，这就是面向过程编程。

2.3 面向对象

假设你有一个秘书，那么你买手机就可以全程让秘书来操作，那么你会经历以下的步骤：

在这期间，你只会关心你和秘书的对接与操作，秘书具体是怎么买手机的，你并不关心。这就是面向对象编程，其中秘书就是你建立的一个对象。
到此，相信你对于面向过程与面向对象编程应该有一个初步的概念了。

3、类的定义与使用

3.1 什么是类

类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(我们称之为方法)，描述完成后计算机就可以识别了。
比如我们来定义一个电视机，在电视机中有哪些参数呢？

比如：电视机，它是一个品牌，在Java中可以将其看成是一个类别。
属性：产品品牌，型号，产品重量，外观尺寸，颜色...
功能：上网、搜索频道、打游戏等等

那么我们如何来定义一个电视类呢？

3.2 类的定义格式

在java中定义类时需要用到class关键字，具体语法如下：

// 创建类
class ClassName{
    field; // 字段(属性) 或者 成员变量
    method; // 行为 或者 成员方法
}

其中，class为定义类的关键字，ClassName为类的名字，需要注意类名要用大驼峰形式命名，{}中为类的主体。
类中包含的内容称为类的成员。
属性主要是用来描述类的，称之为类的成员属性或者类成员变量。
方法主要说明类具有哪些功能，称为类的成员方法。

下面我们来定义一个电视类：

class Television{
    public String brand; // 品牌
    public String type; // 型号
    public double weight; // 重量
    public double lenght; // 长
    public double weidth; // 宽
    public double height; // 高
    public String color; // 颜色
    public void Internet(){ // 上网功能
    System.out.println("上网功能");
    }
    public void search(){ // 搜索功能
    System.out.println("搜索功能");
    }
}

采用Java语言将电视机类在计算机中定义完成，经过javac编译之后形成.class文件，在JVM的基础上计算机就可以识别了。
注意：

类名注意采用大驼峰定义。
成员前写法统一为public，这里涉及到访问限定符，我们放在下次blog封装中进行讲解。
public修饰的类要和文件名相同，否则会报错，也可以在IDEA中手动更改类名。

4、类的实例化（对象）

其实类的实例化，我们就是创建对象的过程，那么什么是类的实例化呢？

4.1 类的实例化

定义了一个类，就相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是java语言自带的内置类型，
而类是用户自定义了一个新的类型，比如上述的：Television类，这就是类(一种新定义的类型)有了这些自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)。
用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。
我们重新定义一个类，其中包括狗的名字、年龄，以及狗的两种行为

public class PetDog {

    public String name;
    public int age;
    public void barks(){
        System.out.println(name+"汪汪");
    }
    public void wag(){
        System.out.println(name + age+"摇尾巴");
    }

现在我们实例化这个狗类，也就是创建一个狗的对象

public class Main{
    public static void main(String[] args) {
    PetDog dog = new PetDog(); //通过new实例化对象
    dog.name = "富贵";
    dog.color = "黄";
    dog.barks();
    dog.wag();
    PetDog dogs = new PetDog();
    dogs.name = "铁柱";
    dogs.color = "黑";
    dogs.barks();
    dogs.wag();
    }
}

其中，以下两行代码就是建立一个狗的对象。

 PetDog dog = new PetDog(); //通过new实例化对象
 PetDog dogs = new PetDog();//建立另一个对象

注意：
new 关键字用于创建一个对象的实例。
使用 . 来访问对象中的属性和方法，比如：

dog.name; //调用name这个成员变量

dogs.barks(); //调用barks这个成员方法
dogs.wag();//调用wag这个成员方法

同一个类可以创建对个实例对象，这些对象是存储在堆上的，对象中的成员变量是存储在对象内部的，PetDog dog = new PetDog();中的dog是引用变量，用于存储对象的地址，我们通过这个地址，就能访问到这个对象，进而访问这个对象的成员（就是.操作），下面的图方便大家进行理解。

4.2 类和对象的说明

类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员，哪些方法；
类是一种自定义的类型，可以用来定义变量（成员变量）；
一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量。

5、this引用

5.1 为什么要有this引用

先看一个简单的例子：

public class Date {
    public int year;
    public int month;
    public int day;

    public void setDay(int y, int m, int d){
        year = y;
        month = m;
        day = d;
    }

    public void printDate(){
        System.out.println(year + "/" + month + "/" + day);
    }
    public static void main(String[] args) {
        // 构造三个日期类型的对象 d1 d2 d3
        Date d1 = new Date();
        Date d2 = new Date();
        Date d3 = new Date();
        // 对d1，d2，d3的日期设置
        d1.setDay(2022,5,12);
        d2.setDay(2022,5,13);
        d3.setDay(2022,5,14);
        // 打印日期中的内容
        d1.printDate();
        d2.printDate();
        d3.printDate();
    }
}

其中我们定义了setDay的方法，主函数中可以通过d1.setDay()，来传递参数，进行年、月、日的设定。
我们同时创建了三个对象，这也证明了一个类可以创建多个对象。
代码逻辑相对来说比较简单，但是如果我小小改变一下代码，问题就很大了。

5.1.1 1. 形参名不小心与成员变量名相同

如果将上面的代码其中设置年月日参数的部分改成形参名与成员变量名相同的形式：

public void setDay(int year, int month, int day){
    year = year;
    month = month;
    day = day;
}

这样之后，不论你调用这个方法的时候传递的是什么参数，运行结果都是0

形成这种情况的原因是：year、month、day被认为是形参的局部变量，局部变量自己给自己赋值，没有给成员变量（year、month、day）赋值，结果当然就是0/0/0了。
这里引出一个问题：

三个对象都在调用setDate和printDate函数，但是这两个函数中没有任何有关对象的说明，setDate和printDate函数如何知道打印的是那个对象的数据呢？

这就要用this来解决了。

5.2 什么是this引用

this是指向当前对象的引用(成员方法运行时调用该成员方法的对象，也就是PetDog中的dog)，在成员方法中所有成员变量的操作，都是通过该引用去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。
代码修改如下：

public class Date {
    public int year;
    public int month;
    public int day;
    public void setDay(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
}
    public void printDate(){
        System.out.println(this.year + "/" + this.month + "/" + this.day);
    }
    public static void main(String[] args) {
        // 构造三个日期类型的对象 d1 d2 d3
        Date d1 = new Date();
        Date d2 = new Date();
        Date d3 = new Date();
        // 对d1，d2，d3的日期设置
        d1.setDay(2022,5,12);
        d2.setDay(2022,5,13);
        d3.setDay(2022,5,14);
        // 打印日期中的内容
        d1.printDate();
        d2.printDate();
        d3.printDate();
    }
}

其中，当d1.setDay，即d1调用setDay方法时，this.year就相当于d1.year（month和day相同的分析方法）。
当d2.setDay，同样d2调用setDay方法时，this.year就相当于d2.year。
这里以d1为例，画图进行分析，可以看到调用setDay方法时，this与d1存储的地址相同，指向的对象是同一个对象。也印证了this是指向当前对象的引用。

5.3 this引用的特性

this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型；
this只能在"成员方法"中使用；
在"成员方法"中，this只能引用当前对象，不能再引用其他对象。

6、对象的构造与初始化

6.1 如何初始化对象

在前面的blog中我们知道，在Java方法内部定义一个局部变量时，必须要初始化，否则会编译失败。

public static void main(String[] args) {
    int a;
    System.out.println(a);
}
// Error:(26, 28) java: 未初始化变量a

要让上述代码通过编译，非常简单，只需在正式使用a之前，给a设置一个初始值即可。如果是对象：

public static void main(String[] args) {
    Date d = new Date();
    d.printDate();
    d.setDate(2021,6,9);
    d.printDate();
}
// 代码可以正常通过编译

需要调用之前写的SetDate方法才可以将具体的日期设置到对象中。通过上述例子发现两个问题：

每次对象创建好后调用SetDate方法设置具体日期，比较麻烦，那对象该如何初始化？
局部变量必须要初始化才能使用，为什么字段声明之后没有给值依然可以使用？

6.2 构造方法

6.2.1 概念

构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。

public class Date {
    public int year;
    public int month;
    public int day;
    // 构造方法：
    // 名字与类名相同，没有返回值类型，设置为void也不行
    // 一般情况下使用public修饰
    // 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
    public Date(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
        System.out.println("Date(int,int,int)方法被调用了");
    }
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
    public static void main(String[] args) {
        // 此处创建了一个Date类型的对象，并没有显式调用构造方法
        Date d = new Date(2021,6,9); // 输出Date(int,int,int)方法被调用了
        d.printDate(); // 2021-6-9
    }
}

注意：

在我们创建对象的时候，构造方法就已经发生了，但是在上述代码中并没有显示出来；
构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。

6.2.2 构造方法的特性

构造方法的名字必须与类名相同；
构造方法没有返回值类型，设置为void也不行；
构造方法在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次；
构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)。

下面列举了无参数的构造方法和带有三个参数的构造方法，印证了构造方法可以重载。

public class Date {
    public int year;
    public int month;
    public int day;
    // 无参构造方法
    public Date(){
        this.year = 2000;
        this.month = 7;
        this.day = 21;
    }
    // 带有三个参数的构造方法
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
    public static void main(String[] args) {
        Date d = new Date();
        d.printDate();
    }
}

上述两个构造方法：名字相同，参数列表不同，因此构成了方法重载。

5. 如果用户没有显式定义，编译器会生成一份默认的构造方法，且会将成员变量赋值为它对应的“0”，生成的默认构造方法一定是无参的。

public class Date {
    public int year;
    public int month;
    public int day;
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
    public static void main(String[] args) {
        Date d = new Date();
        d.printDate();
    }
}

上述Date类中，没有定义任何构造方法，编译器会默认生成一个不带参数的构造方法。
注意：一旦用户定义，编译器则不再生成。

6. 构造方法中，可以通过this调用其他构造方法来简化代码。

如下代码中，我们创建了两个构造方法，一个是带有三个参数的构造方法，一个是无参数的构造方法；
在无参数的构造方法中，我们可以用this(参数)来调用带有三个参数的构造方法。

注意：

this(参数.....)必须是构造方法中第一条语句，否则会报错；
在无参数的构造方法中调用三个参数的构造方法之后，在三个参数的构造方法中就不能在调用无参数的构造方法了，不可以形成环。

6.3 默认初始化

为什么局部变量在使用时必须要初始化，而成员变量可以不用呢？

public class Date {
    public int year;
    public int month;
    public int day;
    public Date(int year, int month, int day) {
// 成员变量在定义时，并没有给初始值, 为什么就可以使用呢？
        System.out.println(this.year);
        System.out.println(this.month);
        System.out.println(this.day);
    }

要弄清楚这个过程，就需要知道 new 关键字背后所发生的一些事情：

Date d = new Date(2021,6,9);

检测对象对应的类是否加载了，如果没有加载则加载；
为对象分配内存空间（在堆上开辟空间）
处理并发安全问题（比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突）
初始化所分配的空间：如果你没有定义构造方法，编译器会自动为成员设置初始值，即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值，比如：

注意：

如果你自己定义了构造方法，那么编译器不会给你赋初始值了，会给调用你的构造方法，如果你的构造方法中的成员变量没有初始化完全，那么剩余的成员编译器仍然会赋值初始值。

6.4 就地初始化

在声明成员变量时，就直接给出了初始值。

public class Date {
    public int year = 2022;
    public int month = 10;
    public int day = 1;

    //无参数的构造方法
    public Date(){
    }
    
    //三个参数的构造方法
    public Date(int year, int month, int day) {
    }
    public static void main(String[] args) {
        Date d1 = new Date(2022,1,1);
        Date d2 = new Date();
    }
}

7、总结

到此，相信大家对Java中的类和对象已经有了一定的概念，下次blog我们会更新封装的概念，也非常重要，期待大家的关注！

Java小试牛刀—类与对象

1、前言

2、面向对象与面向过程

2.1 什么是面向对象