一、继承的概念与应用

1.1 继承的概念

• 定义：继承描述了事物之间的从属关系，允许一个类（子类）继承另一个类（父类）的属性和方法。
• 实现方式：使用extends关键字。

特点：

• Java支持单继承，即一个类只能继承一个父类。
• 支持多层继承，即父类还可以继承其他类。

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

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

1.2 方法的重写

• 目的：允许子类修改从父类继承来的方法。
• 规则：方法名、参数列表、返回值类型必须与被重写的方法相同。

class Animal {
    void sound() {
        System.out.println("动物的声音");
    }
}

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

1.3 super关键字

作用：访问父类的属性和方法，调用父类的构造方法。

使用场景：

• 访问父类属性：super.attribute
• 调用父类方法：super.method()
• 调用父类构造方法：super()

区别： this用于引用当前对象的属性和方法，super用于引用父类。

class Person {
    String name = "Person";
    Person() {
        System.out.println("Person Constructor");
    }
}

class Employee extends Person {
    String department = "HR";
    Employee() {
        super(); // 调用父类的构造方法
        System.out.println("Employee Constructor");
    }
}

二、final关键字的应用

2.1 final修饰类

• 含义：被final修饰的类不能被继承。

final class President {
    void giveSpeech() {
        System.out.println("Giving speech");
    }
}

// class Citizen extends President { // 错误：无法继承final类
// }

2.2 final修饰方法

• 含义：子类不能重写被final修饰的方法。

class Vehicle {
    final void start() {
        System.out.println("Vehicle started");
    }
}

class Car extends Vehicle {
    // void start() { // 错误：不能重写final方法
    // }
}

2.3 final修饰变量

• 含义：被final修饰的变量一旦赋值后不可更改。

final int CONSTANT = 10;
// CONSTANT = 20; // 错误：final变量的值不能被修改

三、抽象类与接口

3.1 抽象类

• 定义：包含一个或多个抽象方法的类。
• 特点：不能实例化，必须被继承。

abstract class Shape {
    abstract void draw();
}

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

3.2 接口

• 定义：完全抽象的类，可以包含常量、抽象方法和默认方法。
• 实现：使用implements关键字。

interface Drawable {
    void draw();
}

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

四、多态与Object类

4.1 多态的概念

• 定义：允许不同类的对象对同一消息做出响应。

class Animal {
    void sound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Woof");
    }
}

public class TestPolymorphism {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();
        myAnimal.sound(); // 输出 Woof
    }
}

4.2 Object类

• 定义：所有类的根父类，提供一些通用方法如equals()、hashCode()、toString()。

class MyClass {
    @Override
    public String toString() {
        return "MyClass instance";
    }
}

public class Test {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        System.out.println(obj.toString()); // 自定义的toString输出
    }
}

五、内部类

5.1 成员内部类

• 定义：定义在另一个类中的类。

class Outer {
    class Inner {
        void greet() {
            System.out.println("Hello from inside");
        }
    }
}

5.2 局部内部类

• 定义：在方法或构造方法中定义的类。

class Outer {
    void test() {
        class Inner {
            void greet() {
                System.out.println("Hello from local inner class");
            }
        }
        new Inner().greet();
    }
}

5.3 静态内部类

• 定义：静态嵌套类，可以独立于外部类的实例。

class Outer {
    static class StaticInner {
        void greet() {
            System.out.println("Hello from static inner class");
        }
    }
}

5.4 匿名内部类

• 定义：没有名字的内部类，通常用于实现接口或继承其他类。

button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        System.out.println("Button clicked");
    }
});

六、上机实操学习

6.1 创建对象并执行对应的方法。

6.2 要求：

• 1.定义3个功能接口：过滤接口Filter，有过滤方法void filtration()；添加接口 Add，有添加糖的方法void addSugar()；封装接口 Filling，有封装方法void fill ()。
• 2.定义净水器类 WaterMachine，WaterMachine 类有name属性，为name属性提供必要的getter/setter方法，并只提供满参构造方法；WaterMachine类需要实现过滤和封装的功能，WaterMachine类中重写的方法内都需要调用get方法获取净水器的名称并提示当前执行的是哪个方法，执行fill
  ()方法时需要先执行filtration()方法。
• 3.定义糖水机类 SyrupMachine，SyrupMachine类有name属性，为name属性提供必要的get/set方法，并只提供满参构造方法；SyrupMachine类需要实现过滤、添加和封装的功能，SyrupMachine类中重写的方法内都需要调用get方法获取糖水机的名称并提示当前执行的是哪个方法，执行addSugar()方法时需先执行filtration()方法，执行fill
  ()方法时需要先执行addSugar()方法。

七、定义功能接口

7.1 过滤接口 Filter

• 方法：void filtration()

7.2 添加接口 Add

• 方法：void addSugar()

7.3 封装接口 Filling

• 方法：void fill()

interface Filter {
    void filtration();
}

interface Add {
    void addSugar();
}

interface Filling {
    void fill();
}

八、定义净水器类 WaterMachine

8.1 类属性和构造方法

• 属性：name，String类型。
• 构造方法：满参构造方法，初始化name属性。

8.2 实现接口

• 实现Filter和Filling接口。

方法实现：

• filtration()：执行过滤操作，调用get方法获取名称并提示。
• fill()：执行封装操作，先执行filtration()，再提示当前操作。

class WaterMachine implements Filter, Filling {
    private String name;

    public WaterMachine(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public void filtration() {
        System.out.println(getName() + " is performing filtration.");
    }

    @Override
    public void fill() {
        filtration();
        System.out.println(getName() + " is filling after filtration.");
    }
}

九、定义糖水机类 SyrupMachine

9.1 类属性和构造方法

• 属性：name，String类型。
• 构造方法：满参构造方法，初始化name属性。

9.2 实现接口

• 实现Filter、Add和Filling接口。

方法实现：

• filtration()：执行过滤操作，调用get方法获取名称并提示。
• addSugar()：执行添加糖操作，调用get方法获取名称并提示。
• fill()：执行封装操作，先执行addSugar()，再提示当前操作。

class SyrupMachine implements Filter, Add, Filling {
    private String name;

    public SyrupMachine(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public void filtration() {
        System.out.println(getName() + " is performing filtration.");
    }

    @Override
    public void addSugar() {
        filtration();
        System.out.println(getName() + " is adding sugar after filtration.");
    }

    @Override
    public void fill() {
        addSugar();
        System.out.println(getName() + " is filling after adding sugar.");
    }
}

十、测试类与方法执行

10.1 创建对象

• 创建WaterMachine和SyrupMachine对象。

10.2 执行方法

• 调用fill()方法，观察执行流程和输出。

public class TestMachines {
    public static void main(String[] args) {
        WaterMachine waterMachine = new WaterMachine("Water Purifier");
        SyrupMachine syrupMachine = new SyrupMachine("Syrup Dispenser");

        System.out.println("Testing Water Machine:");
        waterMachine.fill();

        System.out.println("\nTesting Syrup Machine:");
        syrupMachine.fill();
    }
}

十一、运行结果

• 运行TestMachines类，将展示以下输出，验证方法的执行顺序和逻辑。

Testing Water Machine:
Water Purifier is performing filtration.
Water Purifier is filling after filtration.

Testing Syrup Machine:
Syrup Dispenser is performing filtration.
Syrup Dispenser is adding sugar after filtration.
Syrup Dispenser is filling after adding sugar.

通过这个练习，可以了解如何在Java中实现多个接口，并在类中正确地执行和调用方法，同时理解方法执行的顺序和逻辑。