什么是类和对象？this引用是什么？Java如何初始化对象？

**一.**什么是面向对象

    类和对象是属于面向对象编程中的概念，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。用面向对象的思想来涉及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好。

要搞清楚面向对象，我们还是得拿面向过程来进行比较，就拿洗衣服这个事件进行举例

面向过程：

如果是面向过程，那我们的设计思路就是一步一步来，一个一个功能来，其中少了一个环节都不可以，其中每一个环节，我们都需要关注其中的细节，而且这样的设计是不可逆的，对于不同的衣服，我们需要的时间，拧干的力度，都是不同的，如果将来我们要设计“洗鞋子”的话，这个程序就完全不再适用了

面向对象：

但如果是面向对象的思路的话，我们并不关心其中每一步的过程如何，我们只需要划分出来几个对象，让几个对象各司其职，相互之间也不关心彼此的内部细节

我们将整个洗衣服的过程，划分出4个对象：“人”，“衣服”，“洗衣机”，“洗衣粉”，整个过程由4个对象相互交互完成，人也不需要关心洗衣机是怎么转的，衣服是怎么被洗干净的，我们只需要知道我们把衣服和洗衣服交给洗衣机，我们就可以得到洗干净的衣服了

二.类与对象

类的概念

在了解了面向对象的思维和概念后，我们就可以打开类和对象的大门了，面相对象程序设计关注的是对象，而对象是现实生活中的实体，比如：洗衣机。但是洗衣机计算机并不认识，需要开发人员告诉给计算机什么是洗衣机。

在上图左侧，我们可以看见一系列的参数，这些参数是在简单的描述这个洗衣机，该过程称为对洗衣机对象(实体)进行抽象(对一个复杂事物的重新认知)，而这个过程对应在我们的面向对象编程中就是类的概念，类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)，描述完成后计算机就可以识别了。也就是说，类就是我们对于现实世界中的事物或者概念的抽象，而对于这种抽象的概念，我们可以使用面向对象的编程语言描述出来

比如：洗衣机，我们在Java中可以将其看成是一个类别。

• **属性：产品品牌，型号，产品重量，外观尺寸，颜色... **
• **功能：洗衣，烘干、定时.... **

类的定义格式

在java中定义类时需要用到
class
关键字，其中：

• class为定义类的关键字
• ClassName为类的名字
• { } 中为类的主体，类中包含的内容称为类的成员
• 属性主要是用来描述类的，称之为类的成员属性或者类成员变量
• 方法主要说明类具有哪些功能，称为类的成员方法

具体语法如下：

// 创建类

class ClassName {

       field;         // 字段(属性) 或者 成员变量  



       method;   // 行为 或者 成员方法  

}

比如对于我们刚才说到的洗衣机，我们可以做出如下定义：

class WashMachine {
    public String brand; // 品牌
    public String type; // 型号
    public double weight; // 重量
    public double length; // 长
    public double width; // 宽
    public double height; // 高
    public String color; // 颜色
    public void washClothes(){ // 洗衣服
        System.out.println("洗衣功能");
    }
    public void dryClothes(){ // 脱水
        System.out.println("脱水功能");
    }
    public void setTime(){ // 定时
        System.out.println("定时功能");
    }
}

对象的概念

对象是类的实例化，定义了一个类，就相当于在计算机中定义了一种新的类型，与** int ， double 类似，只不过 int 和 double 是 java语言自带的内置类型，而类是用户自定义了一个新的类型，比如上述的：WashMachine 类，就是一个类(一种新定义的类型)，有了这些自定义的类型之后，就可以使用这些类来定义实例，我们将类定义出来的实例就叫做对象，而用类类型创建对象的过程，称为类的实例化**，在java中采用 new关键字，配合类名来实例化对象

比如我们这里有个狗的类，叫做Dog，它有俩个成员变量，俩个成员方法

class Dog {
    public String name;//名字
    public String color;//颜色
    
    // 狗的行为
    public void barks() {
        System.out.println(name + ": 旺旺旺~~~");
    }
    public void wag() {
        System.out.println(name + ": 摇尾巴~~~");
    }
}

我们可以使用** new关键字来为狗这个概念实例化一个对象，在下面这段代码中，就代表了我们对狗这个类实例化了一个对象Labrador**(拉布拉多)，而这条Labrador(拉布拉多)的名字叫“豆豆”，是黑色的皮毛，会汪汪叫会摇尾巴

    public static void main(String[] args) {
        Dog Labrador = new Dog();
        Labrador.name = "豆豆";
        Labrador.color = "黑色";
        Labrador.barks();
        Labrador.wag();
    }

一个类允许有多个对象，也就是说，我们这里还可以示例化很多对象，这里就表示我们这个Dog类有俩个对象，分别是Labrador(拉布拉多)和Husky(哈士奇)，他们都有各自的属性和方法

    public static void main(String[] args) {
        Dog Labrador = new Dog();
        Labrador.name = "豆豆";
        Labrador.color = "黑色";
        Labrador.barks();
        Labrador.wag();
        
        Dog Husky = new Dog();
        Labrador.name = "二哈";
        Labrador.color = "黑白相间";
        Labrador.barks();
        Labrador.wag();
    }

注意

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

关于类和对象的说明

• 类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员
• 类是一种自定义的类型，可以用来定义变量
• 一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量
• 类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

三.this****引用

为什么要有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(2020, 9, 15);
        d2.setDay(2020, 9, 16);
        d3.setDay(2020, 9, 17);
        // 打印日期中的内容
        d1.printDate();
        d2.printDate();
        d3.printDate();
    }
}

以上代码定义了一个日期类，然后main方法中创建了三个对象，并通过Date类中的成员方法对对象进行设置和打印，代码整体逻辑非常简单，没有任何问题，但是细思之下有个疑问：

形参名不小心与成员变量名相同的话会是怎么样呢？

在这种情况下，编译器很难对我们给出的方法进行判断，那方法体中到底是谁给谁赋值？成员变量给成员变量？参数给参数？参数给成员变量？成员变量参数？

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

什么是this引用

这个时候就需要使用我们的** this引用了，this引用指向当前对象**(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

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

this****引用的特性

• this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类
• this只能在"成员方法"中使用，在"成员方法"中
• this只能引用当前对象，不能再引用其他对象
• this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法对象的引用传递给该成员方法，this负责来接收

四.对象的构造及初始化

在Java方法内部定义一个局部变量时，必须要初始化，否则会编译失败

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

构造方法

构造方法(也称为构造器)是一个特殊的成员方法，**名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次，我们可以利用构造方法的这个特性来对对象初始化**

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(2023, 11, 5); // 输出Date(int,int,int)方法被调用了
        d.printDate();
    }
}

特性

• 名字必须与类名相同
• 没有返回值类型，设置为void也不行
• 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)
• 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)
• 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的，但一旦用户定义，编译器则不再生成
• 不能形成环

    public class Date {
        public int year;
        public int month;
        public int day;
        
        // 无参构造方法
        public Date() {
            this.year = 1900;
            this.month = 1;
            this.day = 1;
        }
        
        // 带有三个参数的构造方法
        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);
        }
    }

另外构造方法中，可以通过this调用其他构造方法来简化代码，但需要注意**this(...)必须是构造方法中第一条语句 **

public class Date {
    public int year;
    public int month;
    public int day;
    
    // 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
    // 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
    // 但是this(1900,1,1);必须是构造方法中第一条语句
    public Date() {
        //System.out.println(year); 注释取消掉，编译会失败,因为this(...)必须是构造方法中第一条语句
        this(1900, 1, 1);
        this.year = 1900;
        this.month = 1;
        this.day = 1;
    }
    
    // 带有三个参数的构造方法
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
}

不能形成环意思是说，我们不能形成一个死循环，就像下面这样

public Date(){
        this(1900,1,1);
        }
public Date(int year, int month, int day) {
        this();
        }

就地初始化

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

public class Date {
    public int year = 1900;
    public int month = 1;
    public int day = 1;
    public Date(){
    }
    public Date(int year, int month, int day) {
    }
    public static void main(String[] args) {
        Date d1 = new Date(2021,6,9);
        Date d2 = new Date();
    }
}

本次分享就到此为止了，感谢您的支持，如有不同意见，欢迎评论区积极讨论，私信都会看的，您的三连支持就是博主分享的最大动力，我那我们下次再见