Java面向对象基础：类、实例化与构造方法详解-CSDN博客

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

1.2 面向对象与面向过程

1. 传统洗衣服过程(面向过程)

传统的方式： 注重的是洗衣服的过程 ，少了一个环节可能都不行。

按照该种方式来写代码，将来 扩展或者维护起来会比较麻烦 。

2. 现代洗衣服过程(面向对象)

以 面向对象方式来进行处理，就不关注洗衣服的过程 ，具体洗衣机是怎么来洗衣服，如何来甩干的，用户不用去关心，只需要将衣服放进洗衣机，倒入洗衣粉，启动开关即可，通过对象之间的交互来完成的 。

注意：面向过程和面相对象并不是一门语言，而是解决问题的方法，没有那个好坏之分，都有其专门的应用场景。

二. 类定义和使用

面相对象程序设计关注的是对象，而对象是现实生活中的实体，比如：洗衣机。但是洗衣机计算机并不认识，需要开发人员告诉给计算机什么是洗衣机。

上图左侧就是 对洗衣机简单的描述，该过程称为对洗衣机对象 ( 实体 ) 进行抽象 ( 对一个复杂事物的重新认知 ) ，但是这些简化的抽象结果计算机也不能识别，开发人员可以采用某种面相对象的编程语言来进行描述，比如：Java 语言。

2.1 简单认识类

类是用来对一个实体 ( 对象 ) 来进行描述的 ，主要描述该实体 ( 对象 ) 具有哪些属性 ( 外观尺寸等 ) ，哪些功能 ( 用来干啥) ，描述完成后计算机就可以识别了。

2.2 类的定义格式

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

// 创建类

class ClassName {

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

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

}

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

类中包含的内容称为类的成员:

属性主要是用来描述类的，称之为类的成员属性或者类的成员变量。

方法主要说明类具有哪些功能，称为类的成员方法。

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

        }

}

再如:

class PetDog {

// 狗的属性

        public String name ; // 名字

        public String color ; // 颜色

// 狗的行为

        public void barks () {

                System . out . println ( name + ": 旺旺旺 ~~~" );

        }

        public void wag () {

                System . out . println ( name + ": 摇尾巴 ~~~" );

        }

}

注意事项:

1. 类名注意采用大驼峰定义

2. 成员前写法统一为 public ，后面会详细解释

3. 此处写的方法不带 static 关键字 . 后面会详细解释

4. 一般一个文件当中只定义一个类

5. main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法)

6. public 修饰的类必须要和文件名相同

7. 不要轻易去修改 public 修饰的类的名称，如果要修改，通过开发工具修改。

这样的方式修改,文件名会修改,类名也会被修改.

但,

如果在一个文件中有多个类,此时通过上述方法修改,文件名会修改,但类名不会被修改,需要手动找到public修饰的类,并修改类名.

8. 同级目录底下,类名不能重复. 即在src下创建多个.java文件,所有类名不能重复

三. 类的实例化

3.1 什么是实例化

定义了一个类，就相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是java语言自带的内置类型，而类是用户自定义了一个新的类型,比如上述的：WashMachine类,它们都是类(一种新定义的类型)有了这些自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)。

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

public static void main ( String [] args ) {

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

        dog1 . name = " 阿黄 " ;

        dog1 . color = " 黄色 " ;

        dog1 . barks ();

        dog1 . wag ();

        PetDog dog2 = new PetDog ();

        dog2 . name = " 阿黑 " ;

        dog2 . color = " 黑色 " ;

        dog2 . barks ();

        dog2 . wag ();

}

注:

只要new 就会产生新的对象, 只要是新的对象, 就有新的内存.

只需要通过对象的引用, 去访问对象的成员变量或成员方法即可.

注意事项

1. new 关键字用于创建一个对象的实例 .

2. 使用 . 来访问对象中的属性和方法 .

3. 同一个类通过new 可以创建多个实例 .

3.2 类和对象的说明

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

2. 类是一个引用类型 ，可以用来定义变量 .

回到之前的内容,数据类型可以分为两类,

第一类是基本数据类型,共八种,

第二类是引用类型,包括String 数组类接口等

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

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

探讨四个问题:

1. 引用可以指向引用吗?

不可以,引用只能指向对象

例:

上述代码:dog2这个引用指向了dog1这个引用所指向的对象, 两个引用同时指向一个对象,而不是指向了dog1这个引用

2.一个引用能不能同时指向多个对象?

不可以

最终dog1这个引用 只能存储一个对象的地址

3. 这代表dog2这个引用指向一个null对象?

错误,这代表dog2这个引用不指向任何对象.

4.如何交换两个数据?

思考:如果只是简单的局部变量, 存储在栈上,是没办法交换数据的, 所以一定要将数据存储在堆上,才能做到交换数据,不难想到要用引用类型变量.

完整代码如下:

public class Test2 {
    public static void swap(MyValue val1,MyValue val2){
        int tmp=val1.val;
        val1.val=val2.val;
        val2.val=tmp;
    }
    public static void main(String[] args) {
        MyValue num1=new MyValue();
        num1.val=10;

        MyValue num2=new MyValue();
        num2.val=20;
        System.out.println("交换前:"+num1.val);
        System.out.println("交换前:"+num2.val);
        swap(num1,num2);
        System.out.println("交换后:"+num1.val);
        System.out.println("交换后:"+num2.val);
    }
}

执行结果:

四. this引用

4.1 为什么要有this引用

public class Date {
    public int year;//年
    public int month;//月
    public int day;//日

    public void setDate(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) {
        Date date = new Date();
        date.setDate(1945,9,1);
        date.printDate();
    }

}

上述代码,可以对date进行赋值.

如果:局部变量与成员变量命名相同时:则赋值失败.

原因:根据局部变量优先使用原则,此时等号左右两边的变量都是局部变量.

那么如果想要使用成员变量,则需要引入this.

4.2 什么是this引用

this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。

此时,通过this. 这种方式, 使之变成了成员变量,则可以正常运行.

4.3 this引用的特性

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

 public void setDate(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) {
        Date date1 = new Date();
        date1.setDate(1945,9,1);
        date1.printDate();
        Date date2 = new Date();
        date2.setDate(2023,10,1);
        date2.printDate();

    }

结果为

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

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

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

实际上:

5.建议:习惯使用this,无论有无作用

总结:

1. this.成员变量 ---访问成员变量

2. this.成员方法 ---访问当前的成员方法

3. this() ---调用当前类的构造方法(后面会讲)

五. 对象的初始化

5.1 默认初始化

上述代码,未对成员变量初始化就进行打印,并不会报错,结果为:

由此我们得知:

成员变量未初始化可以使用,局部变量未初始化不能使用

成员变量有默认值:

5.2 就地初始化

在声明成员变量时，就直接给出了初始值。只要是new了一个对象,那么就有就地初始化的值.

结果为:

六.构造方法

6.1 概念

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

6.2 特性

public class Date {
    public int year;//年
    public int month;//月
    public int day;//日

    //构造方法
    public Date(){
        this.year=1988;
        this.month=1;
        this.day=1;
        System.out.println("执行了一个不带参数的构造方法");
    }

    public static void main(String[] args) {
        Date date = new Date();
}

结果:

由上述代码,我们得出结论:

1. 当new了一个对象,就会调用构造方法

2.创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次

3. 构造方法至少有一个, 也就是说, 当你没有写任何构造方法时, 编译器/java会自带一个不带参数的构造方法, 只不过默认的这个构造方法没有具体的实现任何功能.

注意： 一旦用户定义了任意一种构造方法，编译器则不再生成不带参数的构造方法。
public class Date {
    public int year;
    public int month;
    public int day;
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public static void main(String[] args) {
        Date d = new Date();
    }
}
结果:

public class Date {
    public int year;//年
    public int month;//月
    public int day;//日

    //构造方法
    public Date(){
        this.year=1988;
        this.month=1;
        this.day=1;
        System.out.println("执行了一个不带参数的构造方法");
    }
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
        System.out.println("带有三个参数的构造方法");
    }

    public static void main(String[] args) {
        Date date = new Date();
        Date date2 = new Date(1988,12,1);

结果:

4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法) ,所以可以用构造方法对对对象进行初始化.

小总结:

对象的产生简单来说一定有2步:

1. 为对象分配内存.

2. 调用合适的构造方法.

小tips:

IDEA编译器运用快捷键可以自动写构造方法:

(鼠标右键)

(按住ctrl就可以随意选择想构造的变量的方法)

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

public class Date {
    public int year;
    public int month;
    public int day;
    public Date(){
        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;
    }
}

注意：