java基础语知识（8）
类之间的关系
在类之间，最常见的关系有：
- 依赖（“uses-a”）;
- 聚合（“has-a”）;
- 继承（“is-a”）。
- 依赖：一种使用关系，即一个类的实现需要另一个类的协助，使用关系具有偶然性、临时性、非常弱，被使用类的变化会影响到使用类。在 Java 中表现为局部变量、方法的参数或者对静态方法的调用。例如
class Driver中方法drive1(Car car)、drive2()、drive3()分别通过形参、局部变量、静态方法调用体现对Car类的依赖。- 聚合：关联关系的特例，是强关联关系，体现整体与部分的关系，且部分可以离开整体而单独存在，它们有各自的生命周期，部分可属于多个整体对象，也可为多个整体对象共享。在 Java 中一般使用成员变量形式实现，一般用
setter方法给成员变量赋值。例如class Driver中Car mycar，若赋予 “车是司机财产一部分” 语义，可表示聚合关系。- 继承（泛化）：是一种继承关系，表示一般与特殊的关系，指定子类如何获得父类的所有特征和行为。通过关键字
extends明确标识。例如class Dog extends Animal，表示Dog类继承自Animal类，Dog类拥有Animal类的属性和方法，还可拥有自己特有的属性和方法。
对象与对象变量
想要使用对象，首先必须先构造对象，并且对其指定初始状态。然后对对象应用方法。
在java程序设计语言中，要使用构造器（constructor, 或称构造函数）构造新实例。构造器是一种特殊的方法，用来构造并初始化对象。
构造器的定义
构造器的名称必须与类名完全相同，并且没有返回类型（连 void 也不能有）。
基本语法如下：
[访问修饰符] 类名([参数列表]) {
// 构造器的方法体
}构造器的特点
- 名称与类名相同：构造器的名称必须和所在类的名称一致，这是 Java 语言的规定，用于明确标识这是一个构造器。大小写也需要一致。
- 没有返回类型：构造器不能声明返回类型，包括 void 也不可以。这是因为构造器的主要目的是创建并初始化对象，而不是返回一个值。
- 在创建对象时自动调用：当使用 new 关键字创建一个对象时，会自动调用相应类的构造器来完成对象的初始化工作。
对象（Object）
定义
对象是类的一个实例。类是对一类事物的抽象描述，规定了这类事物所具有的属性和行为；而对象则是类在现实世界中的具体个体，它拥有类所定义的属性和行为的具体值。例如，“汽车” 可以看作一个类，而某一辆具体的红色宝马汽车就是 “汽车” 类的一个对象。
创建对象
在 Java 中，使用 new 关键字来创建对象，其一般步骤如下：
- 声明类类型的变量：指定要创建对象的类型。
- 使用
new关键字创建对象：调用类的构造器来初始化对象。
class Car {
String color;
String brand;
// 构造器
public Car(String color, String brand) {
this.color = color;
this.brand = brand;
}
public void showInfo() {
System.out.println("This is a " + color + " " + brand + " car.");
}
}
public class Main {
public static void main(String[] args) {
// 创建 Car 对象
Car myCar = new Car("red", "BMW");
myCar.showInfo();
}
}在上述代码中，Car 是一个类，myCar 是 Car 类的一个对象。通过 new Car("red", "BMW") 调用 Car 类的构造器创建了一个具体的汽车对象，并对其属性进行了初始化。
对象变量（Object Variable）
定义
对象变量是用来引用对象的变量，它存储的是对象在内存中的引用（地址），而不是对象本身。可以把对象变量看作是指向对象的一个 “指针”，通过这个变量可以访问和操作对象的属性和方法。
对象变量的声明和赋值
声明对象变量的语法与声明基本数据类型变量类似，需要指定变量的类型和名称。赋值时，将 new 关键字创建的对象的引用赋给对象变量。
示例代码如下：
class Dog {
String name;
public Dog(String name) {
this.name = name;
}
public void bark() {
System.out.println(name + " is barking!");
}
}
public class Main {
public static void main(String[] args) {
// 声明对象变量
Dog myDog;
// 创建对象并将引用赋值给对象变量
myDog = new Dog("Buddy");
myDog.bark();
}
}在上述代码中，
Dog myDog;声明了一个Dog类型的对象变量myDog，myDog = new Dog("Buddy");将创建的Dog对象的引用赋给了myDog变量，之后就可以通过myDog来调用Dog对象的方法。
对象和对象变量的区别
-
存储内容不同
- 对象：对象是在堆内存中实际分配的一块内存区域，包含了对象的属性值等具体数据。
- 对象变量：对象变量存储的是对象在堆内存中的引用（地址），它位于栈内存中。
-
生命周期不同
- 对象：对象的生命周期从使用
new关键字创建开始，直到没有任何对象变量引用它，并且被 Java 的垃圾回收机制回收为止。 - 对象变量：对象变量的生命周期取决于它的作用域。当对象变量超出其作用域时，它就会被销毁，但对象本身不一定被销毁，只要还有其他对象变量引用它。
- 对象：对象的生命周期从使用
-
操作方式不同
- 对象：对象本身不能直接进行操作，需要通过对象变量来访问和操作对象的属性和方法。
- 对象变量：可以通过对象变量来调用对象的方法、访问对象的属性等。
- 需要注意的是，对象变量并没有实际包含一个对象，它只是引用一个对象。
- 在java中，任何对象变量的值都是对存储在另一个地方的某个对象的引用。
注：很多人误以为 Java 对象变量等同于 C++ 引用。实则不然，C++ 无 null 引用且引用不可赋值。Java 对象变量类似 C++ 对象指针，如 Java 的 Date birthday; 等同于 C++ 的 Date* birthday; ，且二者用 new 初始化语法相近。变量复制后，二者指向同一对象指针，Java 的 null 引用对应 C++ 的 NULL 指针。
this关键字
在 Java 中，this关键字是一个引用，指向当前对象的实例，主要有以下几种用法：
引用当前对象的成员变量
当类中方法的局部变量和成员变量同名时，根据就近原则，方法会优先使用局部变量。若想访问被覆盖的成员变量，则需使用this前缀。例如：
public class Teacher {
private String name;
private double salary;
private int age;
public Teacher(String name,double salary,int age) {
this.name = name;
this.salary = salary;
this.age = age;
}
}上述代码中，构造方法的参数与成员变量同名，通过
this.name、this.salary、this.age明确操作的是成员变量。
调用当前对象的其他方法
this关键字可在方法内部调用当前对象的其他方法，能避免与方法参数或局部变量同名的方法名冲突，确保调用的是当前对象的方法。示例如下：
public class Dog {
public void jump() {
System.out.println("正在执行jump方法");
}
public void run() {
this.jump();
System.out.println("正在执行run方法");
}
}访问本类的构造方法
this()用于访问本类的构造方法，且必须是构造方法中的第一条语句。例如：
public class Student {
String name;
public Student() {
this("张三");
}
public Student(String name) {
this.name = name;
}
public void print() {
System.out.println("姓名：" + name);
}
}无参构造方法
Student()中，this("张三")调用了有参构造方法Student(String name)。
实现链式调用
在方法返回this关键字，可实现链式调用，即能在同一个对象上连续调用多个方法。示例：
public class Calculator {
private int result;
public Calculator add(int number) {
this.result += number;
return this;
}
public Calculator subtract(int number) {
this.result -= number;
return this;
}
public int getResult() {
return this.result;
}
}
// 链式调用示例
Calculator calculator = new Calculator();
calculator.add(5).subtract(3);
int result = calculator.getResult(); 上述代码中，
add和subtract方法都返回this，实现了链式调用。此外，使用
this关键字还有一些注意事项：
- 不能在静态方法中使用，因为静态方法属于类本身，而非任何对象。
this关键字的值不能被赋值给另一个变量，因其只是一个引用，不是对象。- 应避免滥用，以免影响代码的可读性和可维护性。
- this可以区分成员变量和局部变量。
构造方法
构造方法注意事项
1. 构造方法的定义- 如果没有定义构造方法，系统将给出一个默认的无参数构造方法。 - 如果定义了构造方法，系统将不再提供默认的构造方法。
2. 构造方法的重载 - 带参构造方法和无参数构造方法，两者方法名相同，但是参数不同，这叫做构造方法的重载。
3. 推荐的使用方式- 无论是否使用，都手动书写无参数构造方法，和带全部参数的构造方法。
无参数构造方法
如果类中没有定义任何构造方法，Java 编译器会自动提供一个默认的无参数构造方法。当然，也可以手动定义无参数构造方法。示例如下：
class Book {
String title;
int pageCount;
// 无参数构造方法
public Book() {
title = "默认书名";
pageCount = 0;
}
public void displayInfo() {
System.out.println("书名: " + title);
System.out.println("页数: " + pageCount);
}
}
public class Main {
public static void main(String[] args) {
// 创建Book对象时，调用无参数构造方法
Book myBook = new Book();
myBook.displayInfo();
}
}在上述代码中，Book类定义了一个无参数构造方法，在创建Book对象时，该构造方法会被调用，将title初始化为 “默认书名”，pageCount初始化为 0。
带全部参数构造方法
带参数的构造方法用于在创建对象时，为对象的成员变量赋初始值。示例如下：
class Person {
String name;
int age;
String address;
// 带全部参数构造方法
public Person(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
public void showInfo() {
System.out.println("姓名: " + name);
System.out.println("年龄: " + age);
System.out.println("地址: " + address);
}
}
public class Main {
public static void main(String[] args) {
// 创建Person对象时，调用带全部参数构造方法
Person person = new Person("张三", 25, "北京市");
person.showInfo();
}
}这里
Person类的构造方法接受name、age、address三个参数，在创建Person对象时，通过传递相应的参数来初始化对象的成员变量。
构造方法重载
一个类中可以有多个构造方法，只要它们的参数列表不同，这就是构造方法重载。示例如下：
class Circle {
double radius;
String color;
// 无参数构造方法
public Circle() {
radius = 1.0;
color = "红色";
}
// 带一个参数构造方法
public Circle(double radius) {
this.radius = radius;
color = "蓝色";
}
// 带两个参数构造方法
public Circle(double radius, String color) {
this.radius = radius;
this.color = color;
}
public void printInfo() {
System.out.println("半径: " + radius);
System.out.println("颜色: " + color);
}
}
public class Main {
public static void main(String[] args) {
// 使用不同的构造方法创建对象
Circle circle1 = new Circle();
Circle circle2 = new Circle(2.5);
Circle circle3 = new Circle(3.0, "绿色");
circle1.printInfo();
circle2.printInfo();
circle3.printInfo();
}
}在
Circle类中，定义了三个构造方法，分别是无参数、带一个参数、带两个参数的构造方法。通过构造方法重载，可以根据不同的需求，以不同的方式来创建Circle对象。
标准的javabean类
JavaBean 是一种符合特定编程规范的 Java 类，在 Java 开发中用于封装数据和提供访问数据的方法，方便在不同组件间传递数据等。
在java中：
- 类是公共的（public）：保证其他类能够访问该 JavaBean 类。
- 有一个公共的无参构造方法：便于在反射等机制以及框架（如 Spring）创建对象时使用，比如在框架初始化对象实例时，会首先调用这个无参构造方法。
- 属性私有（private）：对数据进行封装，保证数据的安全性，防止外部直接访问和修改。
- 通过公共的 getter 和 setter 方法访问属性：提供了受控的方式来访问和修改私有属性，同时也可以在这些方法中添加业务逻辑，比如数据验证等。
组成部分
- 私有属性：用于存储数据，例如：
private String name;
private int age;上述代码中，name和age就是JavaBean类的私有属性。
2. 无参构造方法：
public MyBean() {
}无参构造方法在创建对象时若没有传入参数，会默认初始化对象的属性。
3. getter 方法：用于获取私有属性的值，命名规范是get加上属性名，且首字母大写（对于布尔类型属性，若属性名是is开头，则 getter 方法为is属性名），例如：
public String getName() {
return name;
}
public int getAge() {
return age;
}4.setter 方法：用于设置私有属性的值，命名规范是set加上属性名，且首字母大写，例如：
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
} 一个完整的JavaBean示例如下：
public class Person {
// 私有属性
private String name;
private int age;
// 无参构造方法
public Person() {
}
// getter方法
public String getName() {
return name;
}
public int getAge() {
return age;
}
// setter方法
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
}在使用时，可以：
public class Main {
public static void main(String[] args) {
Person person = new Person();
person.setName("Alice");
person.setAge(25);
System.out.println("姓名：" + person.getName() + "，年龄：" + person.getAge());
}
}注意事项
- 类名需要见名知意。
- 成员变量使用private修饰。
- 提供至少两个构造方法： 无参构造方法。 带全部参数的构造方法。
- 成员方法： 提供每一个成员变量对应的setXxx()/getXxx()。 如果还有其他行为，也需要写上。
Java 内存分配区域
Java 内存主要分为以下几个区域：
- 栈（Stack）：方法运行时所进入的内存，局部变量也是在这里存储。每个方法在执行时会创建一个栈帧用于存储局部变量表、操作数栈、动态链接、方法出口等信息。方法执行结束，栈帧就会被销毁。例如，在一个方法中定义的
int num = 10;，num这个局部变量就存储在栈内存中。- 堆（Heap）：
new出来的对象和数组等都在堆内存中开辟空间并产生地址。堆是 Java 内存管理的核心区域，是被所有线程共享的一块内存区域，其生命周期从 JVM 启动开始，直到 JVM 停止。对象的实例化、内存分配等操作都在堆中进行，比如new Student();创建的学生对象就存放在堆内存中。- 方法区（Method Area）：字节码文件加载时进入的内存，存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。例如
HelloWorld.class、Test.class等字节码文件在加载时就会进入方法区。另外，像static修饰的静态变量也存储在方法区。- 本地方法栈（Native Method Stack）：与虚拟机使用的本地方法相关，为 Native 方法服务。比如 Java 调用 C 或 C++ 的本地代码时，相关的内存操作就在本地方法栈进行。
- 寄存器：用于存储指令、操作数等，是 CPU 内部的高速存储区域，与 Java 内存模型的关系相对间接，主要供 CPU 快速访问数据。
一个对象的内存分配过程（以Student s = new Student();为例）
- 加载 class 文件：JVM 首先会查找并加载
Student类的字节码文件（.class文件）到方法区，解析类的元数据信息，如类的字段、方法等。- 申明局部变量：在栈内存中声明一个名为
s的局部变量，此时它还没有指向任何有效的对象。- 在堆内存中开辟一个空间：使用
new关键字在堆内存中为Student对象分配一块内存空间，这块空间用于存储对象的实例变量等数据。- 默认初始化：堆内存中为对象分配的空间会进行默认初始化，比如对于基本数据类型的成员变量，
int类型默认初始化为0，boolean类型默认初始化为false等；对于引用类型的成员变量，默认初始化为null。- 显示初始化：按照类中成员变量定义时的赋值语句进行初始化，例如
private int age = 18;，如果有这样的定义，此时age就会被初始化为18。- 构造方法初始化：调用
Student类的构造方法，对对象进行进一步的初始化操作，构造方法中可以对成员变量进行赋值等操作。- 将堆内存中的地址值赋值给左边的局部变量：把在堆内存中创建的
Student对象的地址赋值给栈内存中的局部变量s，此时s就指向了堆内存中的Student对象，后续就可以通过s来操作该对象。
多个对象引用指向同一个对象的内存情况
假设有以下代码：
Student s1 = new Student();
Student s2 = s1;
- 首先按照上述单个对象创建过程，
new Student();在堆内存中创建一个Student对象，同时在栈内存中创建局部变量s1并指向堆中的对象。- 执行
Student s2 = s1;时，在栈内存中又创建了一个局部变量s2，并将s1中存储的对象地址赋值给s2，这样s1和s2都指向了堆内存中的同一个Student对象。此时，如果通过s1修改对象的属性，s2访问该对象时也会看到属性的变化，因为它们指向的是同一个对象。
不同对象的内存情况
当有多个不同对象创建时，比如：
Student s1 = new Student();
Student s3 = new Student();
- 每次执行
new Student();都会在 堆内存中开辟独立的空间创建新的Student对象。- 栈内存中分别有
s1和s3两个局部变量，它们各自指向堆内存中不同的Student对象，这两个对象的属性相互独立，修改s1指向对象的属性不会影响s3指向的对象。