类和对象（上）

目录

一、面向对象

 1、概念

 2、与面向过程的区别

二、类的定义

三、类的实例化

四、this引用

1、作用

2、概念

3、特征

五、对象的构造及初始化

1、初始化对象

2、构造方法

（1）概念

(2)特性

3、默认初始化

4、就地初始化

---

一、面向对象

 1、概念

       众所周知，java是一门纯面向对象的语言，而面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。用面向对象的思想设计程序，有利于大型程序的设计、扩展和维护。

 2、与面向过程的区别

        用传统的洗衣方式来表现面向过程： 

       

        可以发现，传统的洗衣方式，注重的是整个洗衣服的过程。在代码中，我们将每个步骤封装成函数。

        再者，不同质地的衣服它的清洗方式也不同，就不一定符合上面这个过程了，处理起来就很麻烦，换句话说，按照这种方式来写代码，如果需要去维护或者扩展，就会很麻烦了。

        用现代洗衣方式来表现面向对象：

 

 

       通过面向对象的方式，不用考虑洗衣服的过程，用户只需要将衣服放进洗衣机，加入洗衣液，开启洗衣机即可。通过对象之间的交互来完成洗衣。

       再简单举一个例子，面向过程可以看成是蛋炒饭，而面向对象可以看成鸡蛋盖饭，因为蛋炒饭需要将炒好的鸡蛋和饭搅合在一起才可以，而鸡蛋盖饭只需将炒好的鸡蛋盖在饭上而已。

二、类的定义

        面向对象的程序设计关注的是对象，对象就是生活中的一些实体，而类就是用来描述对象的。

        类的定义格式：

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

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

     类中包含的内容成为类的成员。其中，属性主要是用来描述类的，称为类的成员属性或成员变量。方法主要用来说明该类有什么功能，称为类的成员方法。

     举例，定义一个学生类:

public class Student {
    public String name;
    public String gender;
    public int age;

    public void Exam(){
        System.out.println("考试");
    }
    public void DoHomework(){
        System.out.println("做作业");
    }
    public void DoClass(){
        System.out.println("上课");
    }
}

        注意：

        1、一般一个文件当中只定义一个类
        2、main方法所在的类必须要使用public修饰
        3、public修饰的类必须要和文件名相同

三、类的实例化

        在我们定义好一个类之后，就相当于定义了一种新的类型，就可以利用它来定义对象。

        用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。

public class Student {
    //字段
    public String name;
    public String gender;
    public int age;
    //方法
    public void Exam(){
        System.out.println("考试");
    }
    public void DoHomework(){
        System.out.println("做作业");
    }
    public void DoClass(){
        System.out.println("上课");
    }

    public static void main(String[] args) {
        Student stu=new Student();     //通过new来实例化对象stu
        stu.name="Lihaojie";
        stu.gender="男";
        stu.age=21;

        stu.DoClass();
        stu.DoHomework();
        stu.Exam();
    }
}

/*
输出结果：上课
          做作业
          考试
 */

        注意：

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

        说明：

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

四、this引用

1、作用

      看下面这段代码 ：

public class Date {
    public int year;  //字段（属性）
    public int day;
    public int month;
    //方法
    public void setDay(int y, int m, int d){//问题一：被多个对象调用的方法，但是成员方法中并没有任何对对象的说明。
        year = y;
        month = m;
        day = d;
    }
    public void setyear(int year){
        year=year;          //问题二：到底是谁在给谁赋值
    }
    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();
    }
}

 

        这时候就需要了解this引用了。

2、概念

        java编译器给每个“成员方法“增加了一个隐藏的引用类型参数，该引用参数指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中中所有成员变量的操作，都是通过该引用去访问。

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，在编译时会自动还原。

3、特征

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

 

         从字节码层面上看：

 

        那么this引用可否为空呢？

       如上图在24行打一个断点，通过调试的方式运行之后可以发现，他并没有进入到printDate成员方法中，就结束了，此时我们会发现报错了。原因是空指针异常。

      因此，在java中this引用一定不能为空。

 

五、对象的构造及初始化

1、初始化对象

       例如： 

public static void main(String[] args) {
Date d = new Date();
d.setDay(2021,6,9);
d.printDate();
}

 

        可是我们发现，创建好对象后再利用setDay方法初始化很麻烦。

2、构造方法

（1）概念

         构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。

public class Date {
    public int year;  //字段（属性）
    public int day;
    public int month;
    //方法
    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 d1 =new Date(2021,9,11);
        d1.printDate();
    }
}

(2)特性

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

    5、如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。

    例如：此时可以看到用户是没有显式定义构造方法的。

public class Date {
    public int year;  //字段（属性）
    public int day;
    public int month;
    //方法
    
    public void printDate(){
        System.out.println(year + "/" + month + "/" + day);
    }
    public static void main(String[] args) {
        Date d1 =new Date();
        d1.printDate();
    }
}

      那么从反汇编的角度来看，

       但是如果用户定义了构造方法的话，那么编译器不会自动生成无参构造方法。例如我们定义了一个三参数的构造方法，但是在创建对象时没有给到参数，此时编译是会报错的，因为我们已经定义了一个构造方法，无参构方法不会再生成，他会造成实际参数列表与形式参数列表长度不同。

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

        如下代码，就是无参的构造方法通过this调用三参构造方法的。

public class Date {
    public int year;  //字段（属性）
    public int day;
    public int month;
    //方法
    public Date(){
        this(2012,9,11);
    }
    public Date(int year,int month,int day){
        this.day=day;
        this.month=month;
        this.year=year;
    }
    public void printDate(){
        System.out.println(year + "/" + month + "/" + day);
    }
    public static void main(String[] args) {
        Date d1 =new Date();
        d1.printDate();
    }
}

       注意：

        1、this(...)必须是构造方法中的第一条语句。

        2、不可以形成环。

              什么情况下就是形成了环呢？

 

        7、一般使用public来修饰。

3、默认初始化

        我们先考虑一个问题，为什么局部变量在使用时必须初始化，而成员变量不用？

public class Date {
    public int year;  //三个基本类型的成员变量，并没有赋初始值
    public int day;
    public int month;

    public void printDate(){
        System.out.println(year + "/" + month + "/" + day);
    }
    
    public static void main(String[] args) {
        //int a;     编译报错，未初始化变量a
        //System.out.println(a);
        Date d1 =new Date();
        d1.printDate();  //打印当前对象的内容，看看初始值到底是多少
    }
}

        运行结果：

        此结果说明，再给成员变量赋初始值之前，它是有默认值的。

        这是为什么呢，我们就要从创建对象的语句看起

Date d1 =new Date();

        在程序中只是一条简单的语句，在jvm层面要做很多事情：

        1、检测对象对应的类是否加载了，如果没有加载则加载，类在整个的阶段只会加载一次。

        2、为对象分配内存空间

        3、处理并发安全问题

              比如多个线程同时申请对象，jvm要保证给对象分配的空间不冲突。

       4、初始化所分配的空间：

             对象空间被申请好之后，对象中包含的成员已经设置好了初始值

        5、设置对象的头部信息

        6、调用构造方法，给对象中的成员赋值。

        所以以上这六步可以用一张图来表示即

4、就地初始化

        就地初始化是指在声明成员变量时，就给了初始值。

public class Date {
    public int year=2021;//就地初始化
    public int day=11;
    public int month=9;

    public Date(int year,int month,int day){
        this.year=year;
        this.month=month;
        this.day=day;
    }
    public Date(){

    }
    public void printDate(){
        System.out.println(year + "/" + month + "/" + day);
    }

    public static void main(String[] args) {
        Date d1=new Date(1990,5,5);
        d1.printDate();
        Date d2=new Date();
        d2.printDate();
    }
}
/*
   执行过程：1990/5/5
             2021/9/11
 */

    代码编译完成后，编译器会将所有给成员初始化的语句添加到各个构造函数中。从反汇编的角度可以证明：

 

        因此可以发现，当我们使用就地初始化后，如果在初始化对象时，没有给到其成员具体的值，此时就会调用无参的构造方法，按上述原理，无参的构造方法中是有对给成员就地初始化的语句，所以打印该对象的成员就是就地初始化的成员的值。但是当初始化对象时给到具体的成员值，那么就会覆盖就地初始化的值，该对象打印出来的是用户给到的成员值。

Over!!!