---

一、类与对象

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); // 输出 10changeValue(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); // 输出 AlicechangeName(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 的作用是声明当前类所在的包，需要放在类(或者文件)的最上面，
// 一个类中最多只有一句 packagepackage 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类...）