打卡第二天：JAVA（OOP）回顾

JAVA（OOP）回顾

1.（方法/构造函数) 的重载

OverLoading： 同一个类中定义了多个方法名相同而参数不同的方法，重载在同一个类中，方法名相同，参数不同（参数的个数、顺序、类型不同）。

2.this关键字

this是一种特殊的引用，指向当前对象，一般有以下两种用法
—如果发生局部变量和成员变量命名冲突时，可以通过this.成员变量名的方式区分成员变量和局部变量。
—一个构造方法中需要调用本类的另一个构造方法，可以通过this()的方式调用，但this()必须要书写在第一行。

3.final关键字

final 关键字用来修饰类、方法和变量，具有以下特点：
—修饰符方法：方法不能重写
—修饰类：类不能继承，final 类中的所有成员方法都会被隐式的指定为 final 方法
—修饰符变量：该变量为常量，如果是引用类型的变量，则在对其初始化之后便不能让其指向另一个对象。

4.static关键字

其核心作用是将成员（变量、方法、代码块等）与类本身关联，而非与类的实例（对象）关联,静态成员的生命周期（与类共存亡），过度使用会导致内存泄漏或逻辑混乱。static 主要有以下几大作用：
—. 修饰静态变量，所有对象共享同一个静态变量，内存中只存在一份副本（存储在方法区的静态区）。
访问方式：可以通过 类名.变量名 直接访问，也可通过实例对象访问。
示例代码：

public class Student {
    // 静态变量（类变量），所有学生共享同一个学校名称
    public static String schoolName = "阳光中学";
    // 实例变量，每个学生有自己的姓名
    private String name;
}

// 访问静态变量
public class Test {
    public static void main(String[] args) {
        System.out.println(Student.schoolName); // 直接通过类名访问
    }
}

—-. 修饰静态方法
特点：静态方法属于类，而非实例，可直接通过类名调用，无需创建对象。
但静态方法中不能直接访问非静态成员（变量 / 方法），因为非静态成员依赖于实例。
静态方法中不能使用 this 或 super 关键字（因 this 指向当前实例，而静态方法无实例关联）。
用途：常用于工具类，或需要独立于实例的功能。
示例代码：

public class MathUtil {
    // 静态方法：计算绝对值
    public static int abs(int num) {
        return num < 0 ? -num : num;
    }
}

// 调用静态方法
public class Test {
    public static void main(String[] args) {
        System.out.println(MathUtil.abs(-5)); // 直接通过类名调用
    }
}

—-. 修饰静态代码块
特点：静态代码块是类中用 static 修饰的代码块，在类加载时（首次使用类时）执行，且只执行一次。
执行顺序：静态代码块 > 构造代码块 > 构造方法（若有多个静态代码块，按定义顺序执行）。
用途：用于类的初始化操作（如加载配置文件、初始化静态变量等）。

示例代码：

public class Database {
    // 静态代码块：初始化数据库连接
    static {
        System.out.println("加载数据库驱动...");
        // 连接数据库的代码...
    }

    public Database() {
        System.out.println("创建数据库实例");
    }
}

// 测试类加载时执行静态代码块
public class Test {
    public static void main(String[] args) {
        new Database(); // 首次使用类，触发静态代码块执行
        new Database(); // 再次创建实例，静态代码块不再执行
    }
}
// 输出：
// 加载数据库驱动...
// 创建数据库实例
// 创建数据库实例

—-. 修饰静态内部类
特点：静态内部类是定义在类内部、被 static 修饰的类，它不依赖于外部类的实例，可独立存在。
与非静态内部类的区别：
静态内部类不能直接访问外部类的非静态成员，需通过外部类实例访问。
创建静态内部类实例时，无需先创建外部类实例。
用途：当内部类与外部类的实例无关，仅为外部类提供辅助功能时使用（如 HashMap 中的 Entry 静态内部类）。
·示例代码：

public class Outer {
    private static int staticNum = 10;
    private int num = 20;

    // 静态内部类
    public static class Inner {
        public void print() {
            System.out.println(staticNum); // 可访问外部类静态成员
            // System.out.println(num); // 错误：不能直接访问外部类非静态成员
        }
    }
}

// 使用静态内部类
public class Test {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner(); // 无需创建Outer实例
        inner.print(); // 输出：10
    }
}

5.继承与多态

—Java只支持单继承，不支持多继承。一个类只能有一个父类，不可以有多个父类。Java支持多层继承(继承体系)。Java继承了父类非私有的成员变量和成员方法，但是请注意：子类是无法继承父类的构造方法的。
子类从父类继承的某个实例方法无法满足子类的功能需要时，需要在子类中对该实例方法进行重新实现，这样的过程称为重写，也叫做覆写、覆盖。
—多态：一种事物的多种形态（多态的前提：继承、重写、向上转型），通过多态可以提高代码的可重用性，降低模块之间的耦合度
示例代码：
抽象父类

// 抽象父类：动物
public abstract class Animal {
    // 抽象方法：发出叫声（由子类具体实现）
    public abstract void makeSound();
    
    // 普通方法：呼吸（所有动物共有的行为）
    public void breathe() {
        System.out.println("动物在呼吸...");
    }
}

定义子类（继承父类并实现多态)

// 子类：狗（继承Animal）
public class Dog extends Animal {
    // 重写父类的抽象方法：狗叫
    @Override
    public void makeSound() {
        System.out.println("小狗：汪汪汪！");
    }
}

// 子类：猫（继承Animal）
public class Cat extends Animal {
    // 重写父类的抽象方法：猫叫
    @Override
    public void makeSound() {
        System.out.println("小猫：喵喵喵！");
    }
}

测试类（体现多态的使用）

 public class Test {
    public static void main(String[] args) {
        // 多态核心：父类引用指向子类对象
        Animal animal1 = new Dog(); // 父类引用指向Dog对象
        Animal animal2 = new Cat(); // 父类引用指向Cat对象
        
        // 调用同一方法makeSound()，表现出不同行为（多态）
        animal1.makeSound(); // 输出：小狗：汪汪汪！
        animal2.makeSound(); // 输出：小猫：喵喵喵！
        
        // 调用父类的普通方法（子类未重写，直接使用父类实现）
        animal1.breathe(); // 输出：动物在呼吸...
        animal2.breathe(); // 输出：动物在呼吸...
    }
}

6.抽象类案例代码：

 // 抽象类：交通工具（无法实例化，只能被继承）
abstract class Vehicle {
    protected String name;  // 交通工具名称
    protected double speed; // 速度（km/h）

    // 构造方法：初始化名称和速度
    public Vehicle(String name, double speed) {
        this.name = name;
        this.speed = speed;
    }

    // 普通方法：启动（所有交通工具通用的实现）
    public void start() {
        System.out.println(name + "启动了...");
    }

    // 普通方法：停止（所有交通工具通用的实现）
    public void stop() {
        System.out.println(name + "停止了。");
    }

    // 抽象方法：行驶方式（必须由子类实现，因不同工具行驶方式不同）
    public abstract void run();
}

// 子类1：汽车（继承抽象类Vehicle，必须实现run()方法）
class Car extends Vehicle {
    // 调用父类构造方法
    public Car(String name, double speed) {
        super(name, speed);
    }

    // 实现抽象方法：汽车的行驶方式
    @Override
    public void run() {
        System.out.println(name + "在公路上以" + speed + "km/h的速度行驶（四个轮子滚动）");
    }
}

// 子类2：自行车（继承抽象类Vehicle，必须实现run()方法）
class Bicycle extends Vehicle {
    // 调用父类构造方法
    public Bicycle(String name, double speed) {
        super(name, speed);
    }

    // 实现抽象方法：自行车的行驶方式
    @Override
    public void run() {
        System.out.println(name + "在自行车道以" + speed + "km/h的速度行驶（脚踏驱动）");
    }
}

// 测试类（public类，文件名需为VehicleTest.java）
public class VehicleTest {
    public static void main(String[] args) {
        // 抽象类不能实例化，只能通过子类对象使用
        Vehicle car = new Car("特斯拉Model 3", 120);
        Vehicle bike = new Bicycle("捷安特", 15);

        // 调用普通方法（继承自父类）
        car.start();
        bike.start();

        // 调用抽象方法（子类实现，体现多态）
        car.run();
        bike.run();

        // 调用普通方法
        car.stop();
        bike.stop();
    }
}

抽象类的核心特点（通过案例体现）
不能实例化：Vehicle 是抽象类，无法直接创建对象（如 new Vehicle(…) 会报错），只能通过子类实例化。
包含抽象方法：run() 被 abstract 修饰，没有方法体，强制子类必须实现。（否则子类也需声明为抽象类）。
可包含普通方法：start()、stop() 是普通方法，提供通用实现，子类可直接使用或重写。
作为父类体现多态：父类引用（Vehicle car）指向子类对象（new Car(…)），调用 run() 时执行子类的实现，体现多态特性。
何时使用抽象类？
当多个类存在共性（属性 / 方法），但部分行为（方法）无法统一实现（需子类各自实现）时，适合用抽象类。例如：

7.接口

案例代码

// 定义支付接口（规范支付功能）
interface Payment {
    // 接口中的常量（默认public static final）
    String CURRENCY = "人民币";

    // 抽象方法：发起支付（默认public abstract）
    void pay(double amount);

    // 抽象方法：查询支付状态
    String queryStatus(String orderId);
}

// 微信支付类（实现Payment接口，必须实现所有方法）
class WeChatPayment implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("使用微信支付" + amount + CURRENCY);
    }

    @Override
    public String queryStatus(String orderId) {
        return "微信支付订单[" + orderId + "]：已支付";
    }
}

// 支付宝支付类（实现Payment接口）
class AlipayPayment implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("使用支付宝支付" + amount + CURRENCY);
    }

    @Override
    public String queryStatus(String orderId) {
        return "支付宝订单[" + orderId + "]：已支付";
    }
}

// 测试类（public类）
public class PaymentTest {
    public static void main(String[] args) {
        // 接口引用指向实现类对象（多态）
        Payment wechat = new WeChatPayment();
        Payment alipay = new AlipayPayment();

        // 调用支付方法（不同实现类表现不同，体现多态）
        wechat.pay(99.0);
        alipay.pay(199.0);

        // 调用查询状态方法
        System.out.println(wechat.queryStatus("WX123456"));
        System.out.println(alipay.queryStatus("ALI789012"));
    }
}

接口的核心特点:
—接口中的方法默认是 public abstract（可省略不写），只有声明，没有方法体。
—接口中的变量默认是 public static final（常量），必须初始化，且无法修改。
—类通过 implements 关键字实现接口，必须实现接口中所有抽象方法（否则该类需声明为抽象类）。
—一个类可以实现多个接口（弥补 Java 单继承的限制），接口之间也可以通过 extends 继承（支持多继承）
—接口是 Java 中实现多态和代码解耦的重要手段，广泛用于框架设计

接口VS抽象类
设计目的：
定义功能规范（“能做什么”）VS 定义类的模板（“是什么”+“能做什么”）
继承 / 实现 :
类可实现多个接口，接口可多继承接口 VS 类只能单继承抽象类