类和对象（上）

最新推荐文章于 2024-07-25 13:40:37 发布

Luka.lh

最新推荐文章于 2024-07-25 13:40:37 发布

阅读量147

点赞数 2

分类专栏：类和方法文章标签： java 类

本文链接：https://blog.csdn.net/m0_58715346/article/details/120224358

版权

类和方法专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、面向对象

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!!!

Luka.lh

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
类和对象（上）

目录一、面向对象1、概念2、与面向过程的区别二、类的定义三、类的实例化四、this引用1、作用2、概念3、特征五、对象的构造及初始化1、初始化对象2、构造方法（1）概念(2)特性3、默认初始化4、就地初始化一、面向对象1、概念众所周知，java是一门纯面向对象的语言，而面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。用面向对象的思想设计程序，有利于大型程序的设计、扩展和维护。2、与面向...
复制链接

扫一扫

专栏目录