一、面向对象基础

       面向对象编程的核心是将现实世界的事物抽象为 “对象”，对象拥有 “属性”（数据）和 “行为”（方法）。比如，把 “汽车” 抽象为对象，属性有颜色、品牌，行为有行驶、刹车。通过类来定义对象的模板，类是对象的蓝图，对象是类的实例。

二、三大特性

（一）封装

         封装是把对象的属性和行为隐藏起来，仅对外提供公共的访问方式。通过访问修饰符来实现。例如，一个 Person 类，将 name 和 age 用 private 修饰，然后提供 get 和 set 方法供外部访问（访问修饰符：private、protected、public 等）：

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

       这样做的好处是能保护数据的安全性，控制对属性的访问级别，还能在 set 方法中添加逻辑，对数据进行验证等操作。

（二）继承

       继承允许创建一个新类（子类），继承现有类（父类）的属性和方法。子类可以扩展父类的功能，也能重写父类的方法。Java 中用 extends 关键字实现继承，且是单继承（一个类只能继承一个父类）。示例：

class Animal {
    void eat() {
        System.out.println("动物吃东西");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("狗叫");
    }

    // 重写父类方法
    @Override
    void eat() {
        System.out.println("狗吃骨头");
    }
}

       继承能提高代码的复用性，体现出 “is - a” 的关系。 (“is - a” :继承关系，它体现的是一种类与类之间的从属、派生关系，表示一个类是另一个类的一种，是对现实世界中 “属于” 关系的抽象。)

（三）多态

       多态是指同一个行为具有多种不同表现形式或形态的能力。多态的实现依赖于继承、方法重写和父类引用指向子类对象。示例：

class Animal {
    void makeSound() {
        System.out.println("动物发出声音");
    }
}

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

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("狗汪汪叫");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal1 = new Cat();
        Animal animal2 = new Dog();

        animal1.makeSound();
        animal2.makeSound();
    }
}

       运行结果会是 “猫喵喵叫” 和 “狗汪汪叫”。多态让程序更具灵活性和可扩展性，能根据实际对象的类型来调用相应的方法。

三、内部类

       内部类是定义在另一个类内部的类，它能访问外部类的所有成员，包括私有成员。内部类主要有成员内部类、局部内部类、匿名内部类和静态内部类。

四、匿名内部类

       匿名内部类是一种特殊的局部内部类，没有类名，通常用于创建只需要使用一次的类的实例。它必须继承一个父类或者实现一个接口。示例（实现 Runnable 接口，创建线程）：

public class AnonymousInnerClassDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("匿名内部类线程执行：" + i);
                }
            }
        });
        thread.start();
    }
}

       匿名内部类简化了代码编写，在事件监听、线程创建等场景中广泛应用。

五、抽象类

       抽象类是用 abstract 关键字修饰的类，它不能被实例化，只能作为父类被继承。抽象类中可以包含抽象方法（只有方法声明，没有方法体）和普通方法。子类继承抽象类后，必须实现抽象类中所有的抽象方法，否则子类也得声明为抽象类。示例：

abstract class Shape {
    abstract double getArea();

    void display() {
        System.out.println("这是一个图形");
    }
}

class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    double getArea() {
        return Math.PI * radius * radius;
    }
}

       抽象类为子类提供了统一的模板，强制子类实现特定的方法，体现了 “模板方法” 的设计模式思想。

六、接口

       接口是用 interface 关键字定义的，它是一种完全抽象的类型，里面的方法默认是 public abstract（Java 8 及以后可以有默认方法和静态方法），变量默认是 public static final。类实现接口用 implements 关键字，一个类可以实现多个接口，弥补了 Java 单继承的局限性。示例：

interface Flyable {
    void fly();
}

interface Swimmable {
    void swim();
}

class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("鸭子飞翔");
    }

    @Override
    public void swim() {
        System.out.println("鸭子游泳");
    }
}

       接口用于定义类的行为规范，实现了 “has - a” 的关系，支持多态和代码的解耦。( “has - a” :表示的是一个类包含另一个类的对象，也被称为组合关系或聚合关系，体现了类与类之间的包含关系，描述了一个对象拥有另一个对象。)

七、父子类之间转换

（一）向上转型

       子类对象可以赋值给父类引用，这是自动进行的。向上转型后，只能调用父类中定义的方法，若子类重写了父类方法，则调用子类的重写方法。示例：

Animal animal = new Dog(); // 向上转型
animal.eat(); // 调用 Dog 类中重写的 eat 方法

（二）向下转型

       父类引用要转换为子类引用，必须进行强制类型转换，且在转换前要通过 instanceof 关键字判断引用的实际类型，否则可能会出现 ClassCastException 异常。示例：

Animal animal = new Dog();
if (animal instanceof Dog) {
    Dog dog = (Dog) animal; // 向下转型
    dog.bark();
}

       父子类之间的转换是多态实现的重要环节，合理运用能灵活操作对象。

八、Object 基类

   Object 类是 Java 中所有类的根类，每个类都直接或间接继承自 Object 类。Object 类中定义了一些通用的方法，如 equals()、hashCode()、toString()、getClass()、clone()、finalize()、wait()、notify()、notifyAll() 等。

• toString()：返回对象的字符串表示，默认是类名 + “@” + 哈希码的十六进制形式，子类通常会重写该方法以返回更有意义的信息。
• equals()：用于比较两个对象是否相等，默认是比较对象的引用地址，子类常重写该方法来比较对象的内容。
• hashCode()：返回对象的哈希码值，与 equals 方法相关联，一般重写 equals 方法时也要重写 hashCode 方法。