1. 继承（Inheritance）

概念

继承是面向对象编程的核心特性之一，允许一个类（子类）继承另一个类（父类）的属性和方法。子类可以复用父类的代码，并可以扩展或修改父类的行为。

语法

class 父类 {
    // 父类的属性和方法
}

class 子类 extends 父类 {
    // 子类的属性和方法
}

代码示例

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

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

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.eat();  // 继承自父类的方法
        myDog.bark(); // 子类自己的方法
    }
}

输出：

This animal eats food.
The dog barks.

2. 多态（Polymorphism）

概念

多态是指同一个方法在不同的对象中有不同的表现形式。多态性允许使用父类的引用来调用子类的方法。

实现方式

• 编译时多态：方法重载（Overloading）。
• 运行时多态：方法重写（Overriding）。

代码示例

// 父类
class Animal {
    void sound() {
        System.out.println("Animal makes a sound.");
    }
}

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

// 子类2
class Cat extends Animal {
    void sound() {
        System.out.println("The cat meows.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();  // 父类对象
        Animal myDog = new Dog();        // 子类对象
        Animal myCat = new Cat();        // 子类对象

        myAnimal.sound();  // 调用父类的方法
        myDog.sound();     // 调用子类Dog的方法
        myCat.sound();     // 调用子类Cat的方法
    }
}

输出：

Animal makes a sound.
The dog barks.
The cat meows.

3. final关键字

概念

final关键字用于限制类、方法或变量的修改：

• final类：不能被继承。
• final方法：不能被子类重写。
• final变量：值不能被修改（常量）。

代码示例

final class Animal {  // final类，不能被继承
    final int AGE = 10;  // final变量，值不能修改

    final void eat() {  // final方法，不能被子类重写
        System.out.println("This animal eats food.");
    }
}

// 以下代码会报错，因为Animal是final类
// class Dog extends Animal {}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        myAnimal.eat();
        System.out.println("Age: " + myAnimal.AGE);
    }
}

输出：

This animal eats food.
Age: 10

4. 枚举（Enum）

概念

枚举是一种特殊的类，用于定义一组常量。枚举类型可以增强代码的可读性和安全性。

语法

enum 枚举名 {
    常量1, 常量2, 常量3;
}

代码示例

enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
}

public class Main {
    public static void main(String[] args) {
        Day today = Day.MONDAY;

        switch (today) {
            case MONDAY:
                System.out.println("Today is Monday.");
                break;
            case TUESDAY:
                System.out.println("Today is Tuesday.");
                break;
            default:
                System.out.println("It's another day.");
        }
    }
}

输出：

Today is Monday.

5. 接口（Interface）

概念

接口是一种完全抽象的类，只包含方法的声明，不包含方法的实现。接口定义了一组规范，实现接口的类必须提供这些方法的具体实现。

语法

interface 接口名 {
    void 方法名();
}

class 类名 implements 接口名 {
    public void 方法名() {
        // 方法实现
    }
}

代码示例

interface Animal {
    void sound();  // 接口中的方法没有方法体
}

class Dog implements Animal {
    public void sound() {
        System.out.println("The dog barks.");
    }
}

class Cat implements Animal {
    public void sound() {
        System.out.println("The cat meows.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.sound();
        myCat.sound();
    }
}

输出：

The dog barks.
The cat meows.

6. 抽象类（Abstract Class）

概念

抽象类是一种介于普通类和接口之间的类。它可以包含抽象方法（没有方法体）和具体方法（有方法体）。抽象类不能被实例化，必须通过子类继承并实现抽象方法。

语法

abstract class 抽象类名 {
    abstract void 抽象方法名();  // 抽象方法
    void 具体方法名() {         // 具体方法
        // 方法实现
    }
}

代码示例

abstract class Animal {
    abstract void sound();  // 抽象方法

    void eat() {  // 具体方法
        System.out.println("This animal eats food.");
    }
}

class Dog extends Animal {
    void sound() {
        System.out.println("The dog barks.");
    }
}

class Cat extends Animal {
    void sound() {
        System.out.println("The cat meows.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.sound();
        myDog.eat();

        myCat.sound();
        myCat.eat();
    }
}

输出：

The dog barks.
This animal eats food.
The cat meows.
This animal eats food.

总结