part 6 - 类和对象
目录
一. 类 (Class)
二. 对象 (Object)
创建对象示例：
三. 构造方法 (Constructor)
构造方法的重载
this 引用
使用 this 示例：
四. 包 (Package)
五. 封装 (Encapsulation)
六. static 关键字
1. 静态成员变量 (Static Variables)
示例：
2. 静态成员方法 (Static Methods)
示例：
七. 代码块 (Code Blocks)
执行顺序
一. 类 (Class)
类是 Java 中的一种引用数据类型，它是创建对象的蓝图。类中包含了属性（变量）和行为（方法），这些共同定义了该类的对象将具有什么样的特性和行为。
public class Car {
// 属性
String brand;
int year;
// 方法
void drive() {
System.out.println("The car is driving.");
}
}类的成员变量的初始默认值：
基本类型：0，（boolean 的默认值是 false）
引用类型：null
二. 对象 (Object)
对象是类的一个实例。创建一个对象的过程称为实例化。在 Java 中，使用 new 关键字来创建一个对象。
创建对象示例：
Car myCar = new Car();
myCar.brand = "Toyota";
myCar.year = 2020;
myCar.drive(); // 输出: The car is driving.三. 构造方法 (Constructor)
构造方法是一种特殊的方法，用于初始化新创建的对象。它的名称必须与类名相同，并且没有返回类型。
public class Car {
private String brand;
private int year;
// 无参构造方法
public Car() {
brand = "Unknown";
year = 1900;
}
// 带参数的构造方法
public Car(String brand, int year) {
this.brand = brand;
this.year = year;
}
}
- 类的实例化的过程中就会调用类的构造方法，当没有写构造方法时，会调用系统默认的无参构造方法，该方法没有任何代码操作。一旦自己写了构造方法，系统提供的构造方法则会失效。
- 类的构造方法在实例化对象的生命周期里只触发一次。
构造方法的重载
构造方法可以重载，即在一个类中定义多个构造方法，每个构造方法有不同的参数列表。
public class Car {
private String brand;
private int year;
public Car() {
brand = "Unknown";
year = 1900;
}
public Car(String brand) {
this.brand = brand;
year = 1900;
}
public Car(int year) {
brand = "Unknown";
this.year = year;
}
public Car(String brand, int year) {
this.brand = brand;
this.year = year;
}
}也可以在一个构造方法 a里复用另外一个构造方法 b，但调用构造方法的那行代码必须在 a 的第一行。
public class Car {
private String brand;
private int year;
public Car(String brand) {
this.brand = brand;
year = 1900;
}
public Car(String brand, int year) {
this(String brand);
this.year = year;
}
}this 引用
this 是一个关键字，它代表当前对象的引用。this 可以用来区分成员变量与局部变量同名的情况，也可以用于调用其他构造函数或重载的方法。当一个实例化对象调用对象中的方法时，会默认将对象本身作为一个参数传递给方法。说白了，就是谁调用这个方法 this 指代的就是谁。
举个例子，来解释 this 存在的必要性：
class Car {
public Car (String brand, int year) {
brand = brand;
year = year;
}
// 属性
String brand;
int year;
// 方法
void drive() {
System.out.println("The car is driving.");
}
}
public class Test {
public static void main(String[] args) {
Car car = new Car("a", 1);
System.out.println(car.year);
}
}
此时 year 的打印结果为 0，原因是构造方法中的形参名和类中的成员变量名冲突，而在构造方法中，优先使用成员变量，而类中的成员变量的默认值是 0，所以 year = year 的打印结果就是0。此时就需要使用 this 来避免这个问题。
使用 this 示例：
class Car {
public Car (String brand, int year) {
this brand = brand;
this year = year;
}
// 属性
String brand;
int year;
// 方法
void drive() {
System.out.println("The car is driving.");
}
}
public class Test {
public static void main(String[] args) {
Car car = new Car("a", 1);
System.out.println(car.year);
}
}使用 this 关键字需要注意的点
- this 只能在成员方法里使用，不能再方法外，因为 this 依赖于方法中第一个隐藏的参数，也就是对象本身。
- 在成员方法里，this 只能引用当前对象，不能引用其他对象
四. 包 (Package)
包是 Java 中组织类的一种方式，可以看作是一个命名空间。使用包可以避免类名冲突，并且可以控制类的访问范围。命名规范是最好小写。
package com.example;
public class Car {
// 类内容
}五. 封装 (Encapsulation)
封装是面向对象编程的基本原则之一，它是指将数据（属性）和操作数据的方法绑定在一起作为一个单元处理，并尽可能隐藏对象的内部细节，只暴露必要的接口给外部。
public class Car {
private String brand; // 私有化属性
private int year;
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
}六. static 关键字
static 关键字在 Java 中是一个非常重要的概念，主要用于声明类级别的成员（变量或方法）。使用 static 关键字声明的成员属于类本身，而不是类的实例。这意味着所有的实例共享同一个 static 成员。以下是 static 关键字的一些主要用途和特点：
1. 静态成员变量 (Static Variables)
静态变量也称为类变量，因为它们属于类而不是类的实例。静态变量在类加载时初始化，且只有一个副本，所有实例共享这个副本。
示例：
public class Car {
public static int numberOfCars = 0; // 静态变量
private String brand;
private int year;
public Car(String brand, int year) {
this.brand = brand;
this.year = year;
numberOfCars++; // 每次创建对象时增加
}
public static void printNumberOfCars() {
System.out.println("Number of cars: " + numberOfCars);
}
public static void main(String[] args) {
Car car1 = new Car("Toyota", 2020);
Car car2 = new Car("Honda", 2021);
Car.printNumberOfCars(); // 输出: Number of cars: 2
}
}2. 静态成员方法 (Static Methods)
静态方法也称为类方法，因为它们属于类而不是类的实例。静态方法可以通过类名直接调用，而不需要创建对象。静态方法不能访问非静态成员（实例变量和实例方法），因为它们没有 this 引用。
示例：
public class MathUtils {
public static int add(int a, int b) {
return a + b;
}
public static void main(String[] args) {
int result = MathUtils.add(5, 3); // 直接通过类名调用静态方法
System.out.println("Result: " + result); // 输出: Result: 8
}
}七. 代码块 (Code Blocks)
代码块是在大括号 {} 内的一组语句。根据它们的位置不同，可以分为实例初始化块、静态初始化块和普通代码块。
- 实例初始化块：每次创建对象时都会被执行，通常用于初始化对象的属性。
- 静态初始化块：当类第一次被加载时执行，用于初始化静态成员。
- 普通代码块：在方法体内，用于执行特定逻辑。
public class CodeBlockExample {
// 静态变量
static int staticVar = 0;
// 实例变量
int instanceVar = 0;
// 静态初始化块
static {
System.out.println("Static initialization block 1");
staticVar = 10;
}
// 静态初始化块
static {
System.out.println("Static initialization block 2");
staticVar += 5;
}
// 实例初始化块
{
System.out.println("Instance initialization block 1");
instanceVar = 100;
}
// 实例初始化块
{
System.out.println("Instance initialization block 2");
instanceVar += 50;
}
// 构造方法
public CodeBlockExample() {
System.out.println("Constructor");
instanceVar += 10;
}
public static void main(String[] args) {
System.out.println("Before creating object");
// 创建第一个对象
CodeBlockExample obj1 = new CodeBlockExample();
System.out.println("obj1.staticVar: " + CodeBlockExample.staticVar);
System.out.println("obj1.instanceVar: " + obj1.instanceVar);
// 创建第二个对象
CodeBlockExample obj2 = new CodeBlockExample();
System.out.println("obj2.staticVar: " + CodeBlockExample.staticVar);
System.out.println("obj2.instanceVar: " + obj2.instanceVar);
}
}执行顺序
- 静态初始化块：在类第一次被加载时执行，且只执行一次。静态初始化块在所有实例初始化之前执行。
- 实例初始化块：在每次创建对象时执行，执行顺序在构造方法之前。
- 构造方法：在每次创建对象时执行，执行顺序在实例初始化块之后。
- 普通代码块：在方法体内，按代码出现的顺序执行。
输出：
Before creating object
Static initialization block 1
Static initialization block 2
Instance initialization block 1
Instance initialization block 2
Constructor
obj1.staticVar: 15
obj1.instanceVar: 160
Instance initialization block 1
Instance initialization block 2
Constructor
obj2.staticVar: 15
obj2.instanceVar: 160
- 静态初始化块是为了初始化静态成员变量 ，两者的执行是按顺序进行。
- 实例化代码块是给成员变量初始化，两者的执行是按顺序进行。