Java 面向对象通俗演义

Java 的面向对象编程（OOP）是其核心特性之一，通过封装、继承、多态和抽象等概念，实现模块化、可维护和可扩展的软件设计。

1. 基本概念

类（Class）：类是对象的蓝图，定义对象的属性和行为。
我们可以把类看做一个菜谱，我们可以通过菜谱以及优秀的厨艺（构造器）在做出一道可口的饭菜（也就是对象）。
对象（Object）：对象是类的实例，通过类创建。

对象是类的实例，通过类的构造方法进行实例化。例如：

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person("Alice", 30);
        Person person2 = new Person("Bob", 25);

        person1.greet();  // 输出：Hello, my name is Alice and I am 30 years old.
        person2.greet();  // 输出：Hello, my name is Bob and I am 25 years old.
    }
}

同时，我们也要注意对象变量和对象的区分

实例变量（Instance Variable）：类中定义的变量，属于对象。
方法（Method）：类中定义的函数，描述对象的行为。

2. 封装（Encapsulation）

访问控制符：private、protected、public 和 default，控制类成员的访问权限。
getter 和 setter 方法：用于访问和修改私有变量。
构造方法（Constructor）：用于创建对象时初始化其状态。

3. 继承（Inheritance）

单继承：Java 中一个类只能继承一个直接父类。
extends 关键字：用于继承父类。
super 关键字：用于访问父类的构造方法、方法和变量。
方法重写（Method Overriding）：子类重写父类的方法以提供新的实现。

4. 多态（Polymorphism）

编译时多态（静态绑定）：通过方法重载实现。
With method overloading, multiple methods can have the same name with different parameters
运行时多态（动态绑定）：通过方法重写和接口实现。
多态的好处：提高代码的灵活性和可扩展性。

5. 抽象（Abstraction）

抽象类（Abstract Class）：使用 abstract 关键字定义，不能实例化，可以包含抽象方法和具体方法。
抽象方法（Abstract Method）：没有方法体的抽象类中的方法，子类必须实现。
接口（Interface）：定义方法的集合，类可以实现多个接口，使用 implements 关键字。

6. 类的高级特性

内部类（Inner Class）：定义在另一个类中的类，包括成员内部类、局部内部类、匿名内部类和静态内部类。
静态成员（Static Member）：使用 static 关键字定义，属于类而不是对象。
静态代码块：用于初始化静态数据。

7. 设计原则和模式

SOLID 原则：单一职责原则、开放封闭原则、里氏替换原则、接口隔离原则和依赖倒置原则。
常见设计模式：单例模式、工厂模式、观察者模式、装饰器模式、策略模式等。

8. Java 特有的面向对象特性

泛型（Generics）：提高代码的通用性和类型安全。
枚举（Enum）：定义一组常量。
反射（Reflection）：运行时获取类的信息和操作类的能力。

9. 常见关键字和概念

this 关键字：引用当前对象。
final 关键字：用于修饰类、方法和变量，表示不可变。
instanceof 关键字：用于检查对象是否是某个类的实例。
接口与抽象类的区别：接口强调行为，而抽象类提供部分实现。

示例代码

封装

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

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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 Animal {
    public void makeSound() {
        System.out.println("Animal makes sound");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.makeSound();  // 输出: Dog barks
    }
}

抽象类和接口

abstract class Shape {
    abstract void draw();
}

class Circle extends Shape {
    void draw() {
        System.out.println("Drawing Circle");
    }
}

interface Drawable {
    void draw();
}

class Rectangle implements Drawable {
    public void draw() {
        System.out.println("Drawing Rectangle");
    }
}

public class Test {
    public static void main(String[] args) {
        Shape s = new Circle();
        s.draw();  // 输出: Drawing Circle

        Drawable d = new Rectangle();
        d.draw();  // 输出: Drawing Rectangle
    }
}