🍀 类的组成

成员变量（属性）：描述类的属性。
成员方法（行为）：描述类的行为。
构造方法：为创建的对象分配内存并初始化。
静态变量和静态方法：描述类的公共属性和行为(由类名打点调用)

类是对象的模板，对象是类的实例。

类通常包含属性(也称为成员变量或字段)和成员方法(成员函数)，构造方法(函数)，静态成员(静态变量和方法)，共同描述了一个对象的状态和行为。(类可以是抽象的或也可以是具体的)

对象是类的实例，通过new关键字来创建对象。

静态成员于类本身，而不是属于类的某个实例的。也就是说，无论创建了多少个该类的对象，静态成员都只有一个副本，并且这个副本被所有对象共享，由类名打点调用。

示例代码

// 这是一个表示人的类
public class Person {
    // 属性（也叫成员变量）
    private String name;
    private int age;

    // 构造方法，用来初始化对象
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 方法，表示人的行为
    public void sayHello() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }

    // getter和setter方法，用来获取和设置属性
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

对象实例化

public class Main {
    public static void main(String[] args) {
        // 使用构造方法创建对象
        Person person1 = new Person("Alice", 30);
        person1.sayHello();

        // 使用setter方法修改属性
        person1.setAge(31);
        System.out.println("After one year, " + person1.getName() + " is now " + person1.getAge() + " years old.");
    }
}

🍀 类的属性和方法

属性

属性是类的状态或特征，可以使用访问修饰符（如private、default、protected、public）来控制属性的访问权限

public class Car {
    // 属性
    private String brand;
    private double price;

    // 静态属性
    private static int count;

    // 构造方法
    public Car(String brand, double price) {
        this.brand = brand;
        this.price = price;
        count++;
    }

    // getter和setter方法
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    // 静态方法
    public static int getCount() {
        return count;
    }
}

方法

方法是类的行为或功能。方法的定义包括方法名、参数列表和返回类型

public class Calculator {
    // 实例方法
    public int add(int a, int b) {
        return a + b;
    }

    // 静态方法
    public static int subtract(int a, int b) {
        return a - b;
    }
}

方法的调用

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println("Addition: " + calc.add(5, 3));

        System.out.println("Subtraction: " + Calculator.subtract(5, 3));
    }
}

构造方法

构造方法是用于初始化对象的特殊方法，名称与类名相同，没有返回类型。

{alert type="info"}
访问修饰符 类名(参数列表) {

// 构造方法体

}"
{/alert}

public class Animal {
    String name;
    int age;

    // 构造方法
    Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

静态变量和静态方法
静态变量和静态方法属于类，而不属于某个实例。静态变量用于存储类的公共属性，而静态方法用于实现类的公共行为

public class MathUtil {
    /**
     * 圆周率，一个静态常量
     */
    public static final double PI = 3.14159;

    /**
     * 计算平方数的方法
     * 
     * @param number 要计算平方的数字
     * @return 平方结果
     */
    public static double square(double number) {
        return number * number;
    }
}
//对象实例化与方法调用
public class Main {
    public static void main(String[] args) {
        // 计算圆的面积
        double area = MathUtil.PI * MathUtil.square(5);
        System.out.println("圆的面积：" + area); // 输出: 圆的面积：78.53975
    }
}

🍀 类的三大特性

类有封装，继承，多态三大特性，了解他们之前需要先了解一下访问控制修饰符

public: 访问权限最广，任何地方都可以访问。
protected: 可以被同一包内的类和子类的访问。
default: 没有显式指定修饰符时，默认为default。可以被同一包内的类访问。
private: 访问权限最窄，只能被声明它的类访问。

封装

封装是通过将数据（属性）和行为（方法）封装在类中，保护数据不被外部直接访问。我们通过访问修饰符（如private、protected、public）来控制对属性和方法的访问。

public class Employee {
    private String name;
    private double salary;

    // getter和setter方法，用来安全的访问和修改私有属性
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

  public class Main {
    public static void main(String[] args) {
        Employee emp = new Employee();
        emp.setName("John Doe");
        emp.setSalary(50000);

        System.out.println("Employee Name: " + emp.getName());
        System.out.println("Employee Salary: " + emp.getSalary());
    }
}

上面的this代表当前对象。在某个对象的方法内部，this 指的就是正在调用这个方法的对象本身。

继承
继承允许一个类继承另一个类的属性和方法。被继承的类称为父类（或超类），继承的类称为子类（或派生类）。

// 父类
public class Animal {
    public void eat() {
        System.out.println("This animal eats food.");
    }
}

// 子类
public class Dog extends Animal {
    public void bark() {
        System.out.println("The dog barks.");
    }
}

创建Dog对象可以调用继承自Animal类的方法

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // 输出: This animal eats food.
        dog.bark(); // 输出: The dog barks.
    }
}

也可以用super关键字调用父类的构造方法、属性和方法

多态

多态允许同一个方法在不同对象中有不同的实现，可以通过方法重写或重载和接口实现来实现。

方法重载

public class Calculator {
    // 重载方法，参数为两个整数
    public int add(int a, int b) {
        return a + b;
    }

    // 重载方法，参数为两个双精度浮点数
    public double add(double a, double b) {
        return a + b;
    }
}

构造方法重载

public class Car {
    private String brand;
    private int year;

    // 构造方法重载，此处参数为品牌和年份
    public Car(String brand, int year) {
        this.brand = brand;
        this.year = year;
    }

    // 构造方法重载，此处参数为品牌，赋值默认年份
    public Car(String brand) {
        this(brand, 2022); // 调用另一个构造方法
    }
}

方法重写

//定义Animal接口
public interface Animal {
    // 定义了抽象方法，但并不提供具体的实现
    void makeSound();
}

public class Dog implements Animal {
    // 实现Animal接口的抽象类
    @Override
    public void makeSound() {
        System.out.println("汪汪");
    }
}

public abstract class Animal {
    // 动物发出的声音，子类必须实现
    public abstract void makeSound();

    // 动物睡觉
    public void sleep() {
        System.out.println("Zzz");
    }
}

public class Cat extends Animal {
    // 猫叫
    @Override
    public void makeSound() {
        System.out.println("喵喵");
    }
}

抽象类，抽象方法和接口

// 抽象类
abstract class Animal {
    // 抽象方法：动物发出的声音
    public abstract void makeSound();

    // 非抽象方法：动物睡觉
    public void sleep() {
        System.out.println("Zzz");
    }
}

// 接口
interface Pet {
    // 宠物的喂养方法
    void feed();
}

// 狗类，继承Animal抽象类，实现Pet接口
class Dog extends Animal implements Pet {
    @Override
    public void makeSound() {
        System.out.println("汪汪");
    }

    @Override
    public void feed() {
        System.out.println("喂狗粮");
    }
}