Java中的类和对象

AUGENSTERN_

发布于 2024-04-09 20:29:14

450

发布于 2024-04-09 20:29:14

文章被收录于专栏：畅游IT畅游IT

1 什么是类和对象

在Java中，类近似于C语言中的结构体，类是用来对一个实体(对象)来进行描述的，如下：

class Demo1 {
    public int a = 0;
    private double b = 1.0;
    protected String c = "abcdefg";
    default char d = 'A';
    public static void fun1() {
        
    }
    public void fun2() {
  
    }
    public Demo1(int x, int y) {
        this.x = x;
        this.y = y;
    }

}
public class main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int x = scanner.next.Int();
    int y = scanner.next.Int();
    Demo1 demo = new Demo1(x, y)

}

我们创建了一个Demo类，这个类中有一些成员变量，成员方法，类方法（static修饰的方法），类成员（static修饰的成员），这些变量和成员都是用来描述这个类的特点的；

而最后一行代码

Demo1 demo = new Demo1(x, y)

则是创建了一个对象，并且对其进行了初始化。

这些概念在这里先提出来，后面我还会细说。

至此，可能大家还是对类和对象的概念比较模糊，接下来我举一个例子来进行详细说明：

1.1 定义一个洗衣机类

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("定时功能");
    }
}

?这就是我们创建的一个洗衣机的类：

它包含了很多的属性，包括长，宽，高，颜色，品牌等等；

他还包含很多功能，包括洗衣服，脱水，定时等等；

2 类的实例化

定义了一个类，就相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是java语言自带的内置类型，而类是用户自定义了一个新的类型，比如我们上述的洗衣街类；

有了这些自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)。

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

接下来我们再次定义一个狗类，大家可以自己尝试一下；

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

实例化过程如下：

PetDog dog1 = new PetDog();
PetDog dog2 = new PetDog();
//通过new实例化对象

dog1就是我们实例化的对象，他所包含的属性和行为就是我们PetDog类中所自定义的属性和行为；

2.1 类和对象的说明

1. 类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员.

2. 类是一种自定义的类型，可以用来定义变量.

3. 一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量

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

2.2 通过对象改变属性，进行行为；

上述过程中我们只是创建了一个对象，但是对象的属性我们并没有进行赋值，或者说是进行定义；

接下来我们对对象的属性进行定义：

public class Main {
    public static void main(String[] args) {
        PetDog dog1 = new PetDog(); //通过new实例化对象
        dogh.name = "阿黄";
        dogh.color = "黑黄";
        dogh.barks();
        dogh.wag();
        PetDog dog2 = new PetDog();
        dogs.name = "阿黄";
        dogs.color = "黑黄";
        dogs.barks();
        dogs.wag();
    }
}
//输出结果：
//阿黄: 旺旺旺~~~
//阿黄: 摇尾巴~~~
//赛虎: 旺旺旺~~~
//赛虎: 摇尾巴~~~

我们通过对象名 + “ . ”号的形式来对对象的属性和方法进行访问，来执行PetDog类中的方法；

3 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类中的成员方法对对象进行设置和打印，代码整体逻辑非常简单，没有任何问题；

然而，如果我们将setDay中的变量名y，m，d改为year，mouth，day

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

那运行的结果就会变为：

因为编译器无法判断第一个year和第二个year哪一个是参数，哪一个又是成员变量，所以编译器会默认year为参数，及局部变量优先使用的原则，所以我们的成员变量并没有被赋值，又因为成员变量（局部变量未初始化使用会报错）在创建之时没有初始化，会给定一个默认的初始值，这个初始值是0；所以运行的结果就是如图所示。

这个时候就需要用到我们的this了，当我们把代码改成如下所示

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

?那我们的运行结果就会和第一次一模一样；

接下来让我们来深入了解this引用；

3.1 什么是this引用

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

也就是说，当我们在year之前使用了this .? ，那我们this.后所表示的就是成员变量，而不是参数year；

3.2 this的特性

1. this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型

2. this只能在"成员方法"中使用

3. 在"成员方法"中，this只能引用当前对象，不能再引用其他对象

4. this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法对象的引用传递给该成员方法，this负责来接收

如下：

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

?这样同样是可以编译的，并不会报错；

4 对象的构造和初始化

4.1 如何初始化对象

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

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

想让其编译通过，只需要在使用a之前对其进行赋值或初始化即可；

但如果是对象

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

只需要调用上述的setDate方法即可

但是如果每次初始化都要对其进行方法的调用的话，则会显得很麻烦

那对象有没有其他的初始化的方法呢？

4.2?构造方法

4.2.1 概念

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

构造方法的作用就是给对象的成员进行初始化，并不负责对对象的成员开辟空间。

例如，在刚刚的Date类中，我们可以这样初始化对象：

public Date(int year, int month, int day){
    this.year = year;
    this.month = month;
    this.day = day;
    System.out.println("Date(int,int,int)方法被调用了");
// 构造方法：
// 名字与类名相同，没有返回值类型，设置为void也不行
// 一般情况下使用public修饰
// 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
}

同时，构造方法也可以重载，根据不同的需求对不同发成员进行初始化。

例如：

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)
    {
        this.year = year;
    }

// 带有三个参数的构造方法
    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();
    }
}

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

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();   //Date（）就是默认的构造方法
        d.printDate();
    }
}
// 编译通过

但是一旦用户主动生成了一个构造方法，则编译器不会在自己默认生成一个构造方法

例如：

public static void main(String[] args) {
// 如果编译器会生成，则生成的构造方法一定是无参的
// 则此处创建对象是可以通过编译的
// 但实际情况是：编译期报错
    Date d = new Date();
    d.printDate();
}

4.2.2构造方法中的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(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;
    }
}