Java 面向对象（类与对象 成员方法 方法重载 可变参数 构造方法 / 构造器 this关键字 包 访问修饰符）

---

一、类与对象

1. 类与对象的定义

类（Class）：

• 类是Java中的基本构造单元，用于定义对象的属性和行为。
• 类通过关键字 class 定义，然后包含类的名称以及类体中的属性和方法。
• 一个类可以包含零个或多个属性（成员变量）和方法（成员函数）。

class Car {
    // 属性
    String brand;
    String color;
    int maxSpeed;
    
    // 方法
    void drive() {
        System.out.println("Driving at max speed: " + maxSpeed);
    }
}

对象（Object）：

• 对象是类的实例，即类的具体实现。
• 使用 new 关键字创建类的对象，然后通过对象访问其属性和方法。

public class Main {
    public static void main(String[] args) {
        // 创建Car类的对象
        Car myCar = new Car();
        
        // 设置对象的属性
        myCar.brand = "Toyota";
        myCar.color = "Red";
        myCar.maxSpeed = 200;
        
        // 访问对象的方法
        myCar.drive();
    }
}

关系：

• 类定义了对象的结构和行为，对象是类的实例，具有类定义的属性和方法。
• 一个类可以有多个对象实例。
• 类可以继承自其他类，从而形成父子关系，子类可以继承父类的属性和方法，并且可以添加自己的属性和方法。

2. 类和对象的内存分配机制

• Java 内存的结构分析
  1. 栈：一般存放基本数据类型（局部变量）。
  2. 堆：存放对象(Car myCar，数组等)。
  3. 方法区：常量池(常量，比如字符串)，类加载信。

Person p = new Person();
p.name = "小明";
p.age = 1

• Java 创建对象的流程
  1. 先加载 Person 类信息(属性和方法信息, 只会加载一次)
  2. 在堆中分配空间, 进行默认初始化(看规则)
  3. 把地址赋给 $p$，$p$ 就指向对象

二、成员方法

1. 成员方法的定义

访问修饰符 返回数据类型 方法名（形参列表..） {//方法体
	语句;
	return 返回值;
}

1. 形参列表：表示成员方法输入 cal(int n) ， getSum(int num1, int mum2)
2. 返回数据类型：表示成员方法输出, void 表示没有返回值。
3. 方法主体：表示为了实现某一功能代码块。

2. 方法的调用机制

3. 成员方法传参机制

C++有指针和引用可以直接进行对原始数据的修改，而Java由于引用类型属于类，所以得通过类的成员方法对原始数据进行修改。

Java中的方法参数传递机制主要有两种：

按值传递（Pass by Value）（与C++相同）：

• 对于基本数据类型（如 int、double、char 等），方法参数的传递是按值传递的。
• 在方法调用时，传递给方法的是实参的值的拷贝，而不是实参本身。
• 在方法内部对参数的修改不会影响到原始数据。

public class PassByValueExample {
    public static void main(String[] args) {
        int x = 10;
        System.out.println("Before method call: " + x); // 输出 10
        changeValue(x);
        System.out.println("After method call: " + x); // 输出 10
    }

    static void changeValue(int num) {
        num = 20; // 修改参数的值
    }
}

按引用传递（Pass by Reference）的模拟：

• 对于对象类型（如类实例），方法参数的传递在表面上看起来是按引用传递的。
• 但实际上，Java 中的对象参数传递是通过将对象的引用（地址）传递给方法，而不是对象本身。
• 这意味着在方法中对对象属性的修改会影响原始对象。

class Person {
    String name;

    Person(String name) {
        this.name = name;
    }
}

public class PassByReferenceExample {
    public static void main(String[] args) {
        Person person = new Person("Alice");
        System.out.println("Before method call: " + person.name); // 输出 Alice
        changeName(person);
        System.out.println("After method call: " + person.name); // 输出 Bob
    }

    static void changeName(Person p) {
        p.name = "Bob"; // 修改对象属性
    }
}

三、方法重载

与C++一致

案例：类：MyCalculator 方法：calculate
1) calculate(int n1, int n2) //两个整数的和
2) calculate(int n1, double n2) //一个整数，一个 double 的和
3) calculate(double n2, int n1)//一个 double ,一个 Int 和
4) calculate(int n1, int n2,int n3)//三个 int 的和

注意事项和使用细节：

1. 方法名：必须相同。
2. 形参列表：必须不同（形参类型或个数或顺序，至少有一样不同，参数名无要求）。
3. 返回类型：无要求。

四、可变参数

1. 基本概念

通过可变参数 Java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。

2. 基本语法

访问修饰符 返回类型 方法名(数据类型... 形参名) {
	...
}

可以将对应数据类型的数组传入方法的形参中

3. 应用

public int sum(int... nums) {
	//System.out.println("接收的参数个数=" + nums.length);
	int res = 0;
	for(int i = 0; i < nums.length; i++) {
		res += nums[i];
	}
	return res;
}

public class VarArgsExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        double[] doubles = {1.1, 2.2, 3.3, 4.4, 5.5};
        
        // 调用方法，传递数组给可变参数
        printNumbers(numbers);
        printDoubles(doubles);
    }

    // 方法接受可变参数
    static void printNumbers(int... nums) {
        System.out.print("Numbers: ");
        for (int num : nums) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
    
    // 同样的方法接受可变参数
    static void printDoubles(double... nums) {
        System.out.print("Doubles: ");
        for (double num : nums) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

五、 构造方法 / 构造器

与C++类似

1. 特点

1. 方法名和类名相同
2. 没有返回值
3. 在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。

2. 使用案例

public class Car {
    // 属性
    String brand;
    String color;
    int maxSpeed;

    // 构造方法
    public Car(String brand, String color, int maxSpeed) {
        this.brand = brand;
        this.color = color;
        this.maxSpeed = maxSpeed;
    }

    // 方法
    void drive() {
        System.out.println("Driving " + color + " " + brand + " at max speed: " + maxSpeed);
    }

    public static void main(String[] args) {
        // 创建Car类的对象，并调用构造方法进行初始化
        Car myCar = new Car("Toyota", "Red", 200);

        // 调用对象的方法
        myCar.drive(); // 输出 Driving Red Toyota at max speed: 200
    }
}

3. 对象创建的流程

六、this关键字

与C++的this指针一致

在Java中，this 是一个关键字，用于引用当前对象。

1. 运用场景

1. 区分局部变量和实例变量：
   当实例变量和局部变量同名时，可以使用 this 关键字来区分它们。this 引用的是当前对象的实例变量，而不是局部变量。

2. 在构造方法中调用其他构造方法：
   在一个构造方法中调用同一个类的另一个构造方法时，可以使用 this 关键字。

3. 传递当前对象给其他方法：
   可以将当前对象作为参数传递给其他方法，或者返回当前对象。

由于Java没有缺省参数 所以采用重载来达到类似效果
如下面 运用 this关键字调用另一个构造方法 来达到缺省参数的效果

2. 使用案例

public class Person {
    // 实例变量
    String name;
    int age;

    // 构造方法1：使用this关键字调用另一个构造方法
    public Person() {
        this("John", 30); // 调用另一个构造方法
        // 由于Java没有缺省参数 所以采用重载来达到类似效果
    }

    // 构造方法2：接受参数来初始化对象
    public Person(String name, int age) {
        this.name = name; // 使用this引用当前对象的实例变量
        this.age = age;   // 使用this引用当前对象的实例变量
    }

    // 方法：打印对象的信息
    public void display() {
        System.out.println("Name: " + this.name + ", Age: " + this.age);
    }

    // 方法：传递当前对象给其他方法
    public Person getPerson() {
        return this;
    }

    public static void main(String[] args) {
        // 创建Person对象
        Person person1 = new Person();
        person1.display(); // 输出 Name: John, Age: 30

        // 创建Person对象，并传递给其他方法
        Person person2 = new Person("Alice", 25);
        Person person3 = person2.getPerson();
        person3.display(); // 输出 Name: Alice, Age: 25
    }
}

七、包

1. 包的三大作用

• 区分相同名字的类。
• 当类很多时，可以很好的管理类。
• 控制访问范围。

2. 包的基本语法

package com.hspedu;

说明

1. package 关键字，表示打包。
2. com.hspedu 表示包名。

3. 包的本质

4. 使用案例

5. 包的命名规则

6. 常用的包

一个包下,包含很多的类,java 中常用的包有；

1) java.lang.* //lang 包是基本包，默认引入，不需要再引入
2) java.util.* //util 包，系统提供的工具包, 工具类，使用 Scanner
3) java.net.* //网络包，网络开发。
4) java.awt.* //是做 java 的界面开发，GUI

7. 引入包

8. 注意事项

//package 的作用是声明当前类所在的包，需要放在类(或者文件)的最上面，
// 一个类中最多只有一句 package

package com.hspedu.pkg;

//import 指令 位置放在 package 的下面，在类定义前面,可以有多句且没有顺序要求
import java.util.Scanner;
import java.util.Arrays;

//...

八、访问修饰符

1. 简介

Java 提供四种访问控制修饰符号，用于控制方法和属性（成员变量）的访问权限（范围）：

1. 公开级别：用 public 修饰，对外公开
2. 受保护级别：用 protected 修饰，对子类和同一个包中的类公开
3. 默认级别：没有修饰符号，向同一个包的类公开。
4. 私有级别：用 private 修饰，只有类本身可以访问，不对外公开。

2. 访问范围

3. 注意事项

1. 修饰符可以用来修饰类中的属性，成员方法以及类。
2. 只有默认的和public才能修饰类，并且遵循上述访问权限的特点。
3. 成员方法的访问规则和属性完全一样。

//com.hspedu.modifier:需要很多文件来说明（A类，B类，Test类...）