javaSE学习-4-类和对象

1. 面向对象的初步认知

1.1 什么是面向对象

面向对象编程（OOP）是一种程序设计范式，它将程序中的数据和操作数据的方法封装到对象中。在面向对象的世界里，一切都被视为对象，这些对象可以拥有数据（成员变量）和行为（方法）。Java 是一门纯粹的面向对象编程语言，几乎所有的代码都是以类和对象的形式存在的。

1.2 面向对象与面向过程

在面向对象编程的思想中，解决问题主要依靠对象之间的交互完成一项任务。

相较之下，面向过程编程更侧重于一系列步骤或操作，通过过程调用来完成任务。

面向对象的优势在于更好地组织和抽象复杂系统，使代码更易扩展、维护和理解。

设计一个简单的图形计算程序，计算不同形状的面积。样设计：

面向过程：

double calculateCircleArea(double radius) {
    return 3.14 * radius * radius;
}

double calculateRectangleArea(double length, double width) {
    return length * width;
}

void main() {
    double circleArea = calculateCircleArea(5.0);
    double rectangleArea = calculateRectangleArea(4.0, 6.0);

    // 进行其他操作...
}
```

定义了两个函数分别用于计算圆和矩形的面积。

在 `main` 函数中调用这些函数来进行计算。

面向对象：

class Circle {
    double radius;

    Circle(double radius) {
        this.radius = radius;
    }

    double calculateArea() {
        return 3.14 * radius * radius;
    }
}

class Rectangle {
    double length;
    double width;

    Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    double calculateArea() {
        return length * width;
    }
}

void main() {
    Circle circle = new Circle(5.0);
    Rectangle rectangle = new Rectangle(4.0, 6.0);

    double circleArea = circle.calculateArea();
    double rectangleArea = rectangle.calculateArea();

    // 进行其他操作...
}

定义了两个类 `Circle` 和 `Rectangle`，每个类都有自己的属性和方法。

通过创建对象，调用对象的方法来进行计算。这种方式更加面向对象，将数据和相关操作封装在对象内部。

面向对象的设计使得代码更易扩展和维护，特别是在处理复杂系统时表现出更大的优势。

2. 类定义和使用

向对象程序设计（Object-Oriented Programming，OOP）关注的是对象，而对象通常是现实生活中的实体或概念的抽象。在面向对象的思想中，问题的解决主要通过对现实世界中的事物进行建模，将其抽象为程序中的对象。

2.1 简单认识类

类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干嘛)

2.2 类的定义格式

在 Java 中，定义一个类需要使用 class 关键字，具体的语法如下所示：

// 创建类
class ClassName {
    // 字段（属性）或者成员变量
    type fieldName;
    
    // 行为或者成员方法
    returnType methodName(parameters) {
        // 方法体
    }
    
    // 其他字段和方法...
}

2.3 定义一个狗类

class Dogg {
    int age;
    String color;
    String name;
    public void bark() {
        System.out.println(name+"汪汪汪");
    }
    public void wag() {
        System.out.println(name+"摇尾巴");
    }
}

通过对象的引用.访问属性进行赋值

实例化对象

public static void main(String[] args) {
        Dogg dog1 = new Dogg();
        dog1.age = 9;
        dog1.name = "小白";
        dog1.color = "黑色";
        System.out.println(dog1.name);
        dog1.bark();
        dog1.wag();
    }

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

Dogg dog2 = new Dogg();

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

可以通过new关键字 实例化多个对象

同一个类可以创建多个实例

dog1, dog都属于引用类型(存储的是对象的地址)

这里在啰嗦一下java中的数据类型

分为两种

1. 基本数据类型(共八种)
2. 引用类型 String 数组 类 接口

这里我提出两个问题

其一是: 引用可以指向 引用吗?

dog1 = dog2;

dog2这个引用指向了 dog1?

类似于

int[] arr1 = {1,2,3};
        int[] arr2;
        arr2 = arr1;

类似于复制粘贴

因此这句话有语病错误 引用是不能指向对象的 引用只能指向对象

这两个引用同时指向的是一个对象

dog1和dog2都指向相同的对象

这是因为引用存储的是对象的地址，所以它们都引用了相同的对象。

另一个问题是 一个引用可不可以指向多个对象?

不可以 一个引用只能指向一个对象

只能存储一个对象的地址

还有一个问题是以下代码能否代表dog2这个引用指向null对象?

Dogg dog2 = null;

dog2这个引用 不执行任何对象

3. 类的实例化

3.1 什么是实例化

实例化是将一个类作为模板，创建该类的具体对象的过程。通过实例化，我们可以在内存中分配空间，并初始化该对象的属性。实例化的结果就是我们所说的对象或实例。

3.2 类和对象的说明

1. 类是一个模型： 类是对一个实体进行描述的模型，它定义了这个实体的属性（成员变量）和行为（方法）。类就像是一个蓝图或设计图，规定了实体应该有哪些特征和功能。

2. 类是一种自定义类型： 类是用户自定义的数据类型，可以用来定义变量。通过类，我们可以创建属于该类型的对象。

3. 多个对象的实例化： 一个类可以实例化出多个对象。每个对象都是该类的一个实例，拥有相同的属性和方法，但是它们是相互独立的。例如：

   
   
   // 定义一个Person类 
   public class Person { String name; int age; } 
   // 实例化两个Person对象 Person person1 = new Person(); 
   Person person2 = new Person();
   
   

   这里，person1和person2都是Person类的实例，但它们是两个独立的对象。

4. 类和对象的比喻： 比方说，可以将类比为建筑设计图，它规定了房子应该有哪些特征和结构，但并不是实际的房子。只有当我们使用设计图实例化出具体的房子对象时，才会占用实际的物理空间，存储房子的具体信息。

class MyValue {
    int value;
}

public class Main4 {
    public static void swap(MyValue v1, MyValue v2) {
        int tmp = v1.value;
        v1.value = v2.value;
        v2.value = tmp;
    }

    public static void main(String[] args) {
        MyValue value1 = new MyValue();
        MyValue value2 = new MyValue();
        value1.value = 10;
        value2.value = 20;
        swap(value1, value2);
        System.out.println(value1.value);
        System.out.println(value2.value);
    }
}

基本类型是无法完成交换的, 只有引用类型才能完成交换

 4. this引用

4.1 为什么要有this引用：

在Java中，this是一个关键字，表示当前对象的引用。它主要用于解决类成员变量与方法参数之间的命名冲突。形参名与成员变量名相同，这时可以使用this引用来明确指定操作的是成员变量而不是方法参数。

public class Date {
    public int year;
    public int month;
    public int date;
    public void setDate(int y, int m, int d){
        year = y;
        month = m;
        date = d;
    }
    public void printDate() {
        System.out.println(year+"年"+month+"月"+date+"日");
    }

    public static void main(String[] args) {
        Date date1 = new Date();
        date1.setDate(2021, 12,21);
        date1.printDate();
    }
}

这里代码正常执行输出结果

2021年12月21日

Process finished with exit code 0

那我们把

public void setDate(int y, int m, int d){
        year = y;
        month = m;
        date = d;
    }

改为

public void setDate(int year, int month, int date){
        year = year;
        month = month;
        date = date;
    }

这时的输出

0年0月0日

因为这里的year month date都是局部变量, 形参名与成员变量名相同

这时可以使用this引用来明确指定操作的是成员变量

public void setDate(int year, int month, int date){
        this.year = year;
        this.month = month;
        this.date = date;
    }

改为以上代码就可以正常运行了

Date date1 = new Date();
        date1.setDate(2021, 12,21);
        date1.printDate();
        Date date2 = new Date();
        date2.setDate(1234,1,23);

那怎么区分this是哪个呢

局部变量优先使用 谁调用这个方法 谁就是this

this关键字主要用于引用当前对象的实例。

当存在局部变量与实例变量同名时，使用this关键字可以明确指定操作的是实例变量而不是局部变量。

 当调用 date1.setDate(2021, 12, 21); 时，this指向的是 date1 对象的实例。

而在 date2.setDate(1234, 1, 23); 中，this指向的是 date2 对象的实例。

this指的是调用它的方法所属的对象。

4.2 什么是this引用

1. 区分实例变量和局部变量： 当方法的参数名和实例变量名相同时，使用this关键字可以明确指定操作的是实例变量。例如，在setDay方法中，this.year表示实例变量，而year表示方法的参数。

2. 在构造函数中调用其他构造函数： 在一个类的构造函数中，可以使用this来调用同一类的其他构造函数。

   public class Example {
       private int x;
       private int y;
   
       // 构造函数1
       public Example(int x) {
           this.x = x;
           this.y = 0;
       }
   
       // 构造函数2，调用构造函数1
       public Example(int x, int y) {
           this(x);  // 调用构造函数1
           this.y = y;
       }
   }
   

3. 作为返回当前对象的引用： 在方法中可以使用this作为返回当前对象的引用，以支持方法的链式调用。

public class Example {
    private int x;
    private int y;

    public Example setX(int x) {
        this.x = x;
        return this;
    }

    public Example setY(int y) {
        this.y = y;
        return this;
    }
}

4.3 this引用的特性：

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

2. this只能在成员方法中使用： this关键字只能在类的成员方法中使用。它不能在静态方法（用static修饰的方法）中使用，因为静态方法与任何实例对象无关。

3. this只能引用当前对象： 在成员方法中，this关键字只能引用当前对象，不能引用其他对象。它代表调用该成员方法的当前对象。

4. this是“成员方法”第一个隐藏的参数： 在成员方法中，this被视为第一个隐藏的参数。编译器会自动传递this作为参数给成员方法。当成员方法被调用时，编译器会负责将调用成员方法的对象的引用传递给该成员方法，而this负责接收这个引用。

5. 对象的构造及初始化

5.1 如何初始化对象

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

要让上述代码通过编译，非常简单，只需在正式使用a之前，给a设置一个初始值即可。如果是对象:

需要调用之前写的SetDate方法才可以将具体的日期设置到对象中。通过上述例子发现两个问题:

1. 每次对象创建好后调用SetDate方法设置具体日期，比较麻烦，那对象该如何初始化?

2. 局部变量必须要初始化才能使用，为什么字段声明之后没有给值依然可以使用?

5.2 构造方法

5.2.1 概念

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

public class Date {
    public int year;
    public int month;
    public int date;
    public Date() {
        year = 2023;
        month = 12;
        date = 20;
    }

public static void main(String[] args) {
        Date date1 = new Date();
        date1.printDate();

2023年12月20日

可以看到没有使用setDate会输出

注释掉Date构造方法呢

输出

0年0月0日

可见输出的是默认值 也就是0 0 0

这种初始化方法叫做默认初始化

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

5.2.2 特性

1. 名字必须与类名相同
2. 没有返回值类型，设置为void也不行

3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)

4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)

构造方法名字与类名相同 没有返回值

通过调试代码可以发现 构造方法是在实例化对象的时候调用的

实例化对象的时候, 会调用一个合适的构造方法

public Date() {
        this.year = 2023;
        this.month = 12;
        this.date = 20;
    }
    public Date(int year, int month, int date){
        this.year = year;
        this.month = month;
        this.date = date;
    }

这两个构造方法之间构成了方法的重载(函数名一样)

一个不带参数 一个带三个参数

构造方法就是根据这些不同的参数 初始化不同的成员变量

因此 对象的产生 简单来说 一定会有两步

1. 为对象分配内存

2. 调用合适的构造方法

如果注释掉不带参数的构造方法

可以观察到编译器报错

因此 一旦类提供了任何一种构造方法 那么编译器就不会再提供任何不带参数的构造方法

5.3 默认初始化

构造方法至少有一个 当没有写任何的构造方法的时候,  编译器/java会自带一个不带参数的构造方法.

只不过默认的这个构造方法, 是没有具体的实现的.

对象的初始化是一定会调用构造方法的

5.4 就地初始化

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

public int year = 1900;
public int month = 1;
public int day = 1;

this方法

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

public Date() {
        this(2002,12,12);
    }
    public Date(int year, int month, int date){
        this.year = year;
        this.month = month;
        this.date = date;
    }

Date date1 = new Date();

这里不带参数进行初始化

那么调用第一个不带参数的方法

之后调用this

this方法是根据自己的参数数量(三个)调用的指定的Date构造方法

需要注意的是 this都放在构造方法的第一行中, 不然会报错

删掉sout恢复正常

另一个就是不能循环调用

绝大多数情况下使用public来修饰，特殊场景下会被private修饰(后序讲单例模式时会遇到)

小技巧: 编译器生成构造方法

在类中, 鼠标右键选择generate

选择 constructer

勾选自己需要的参数, 点击ok即可生成

6. 封装

面向对象的几个重要的特征: 封装, 继承, 多态

6.1 封装的概念

封装是指将类的实现细节进行隐藏，对外只提供接口。简单来说，封装就是套壳屏蔽细节，将数据和操作数据的方法有机结合，隐藏对象的属性和实现细节，仅对外公开接口来与对象进行交互。

6.2 访问限定符

在Java中，主要通过类和访问权限来实现封装。类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知。而访问权限用来控制方法或字段能否直接在类外使用。Java提供了四种访问限定符：

1. public（公共）： 能被任何类访问，没有访问限制。
2. protected（受保护）： 对同一包内的类和所有子类可见，允许访问。
3. default（默认）： (默认的什么都不写的情况下) 如果没有指定任何访问修饰符，则默认为包内可见，不允许访问。
4. private（私有）： 只有在同一类内部可见，不允许访问。

实现封装后, 类外就无法直接拿到这个name

class Stu {
    public String name;
    public int age;
    public void eat() {
        System.out.println(this.name+"正在吃饭");
    }

}

public class Main1 {
    public static void main(String[] args) {
        Stu s1 = new Stu();
        s1.name = "徐涛";
        s1.eat();
    }
    
}

这里定义了一个可以直接使用name和age属性的Student类

name属性实现封装后 类外就无法直接拿到这个name字段了

将

public String name;

修改为

private String name;

6.3 封装扩展之包

6.3.1 包的概念

在Java中，包是一种组织类的机制，用于将相关的类和接口组织在一起。包的概念有助于解决类名冲突、组织代码结构、提高代码的可维护性等问题。一个包可以包含多个类，而且包之间可以存在层次关系。

例如，`java.util` 是Java标准库中包含有关实用工具类的包。

6.3.2 导入包中的类

在Java中，要使用其他包中的类，可以使用 `import` 语句导入相应的包或类。导入包的目的是为了能够在代码中直接使用其他包中的类而不必每次都写完整的包路径。

例如，要使用 `java.util.Date` 类，可以这样导入：

import java.util.Date;

如果需要使用 `java.util` 中的其他类，可以使用通配符 `*`：

import java.util.*;

然而，为了避免命名冲突和提高代码的清晰度，最好还是显式地指定要导入的类名，而不是使用通配符。
 

import java.util.Date;
import java.util.List;

6.3.3 自定义包