11、Java基础篇——面向对象进阶（抽象类&接口&内部类）

1、抽象类

（1）概述

抽象类是一种不能实例化的类，它用于定义一组相关的类共同的属性和方法，并作为其他类的父类进行继承。抽象类可以包含抽象方法和非抽象方法。

（2）abstract使用格式

abstract class ClassName {
    // 成员变量
    // 构造方法

    // 抽象方法（没有方法体）
    abstract void abstractMethod();

    // 非抽象方法
    void nonAbstractMethod() {
        // 方法体
    }
}

（3）抽象类的特征

• 抽象类不能被实例化，只能用作其他类的父类。
• 抽象类可以包含抽象方法和非抽象方法。
• 子类继承抽象类时，需要实现抽象方法。

（4）抽象类的细节

• 抽象类可以有构造方法。
• 抽象类可以拥有成员变量和非抽象方法。
• 抽象类中的抽象方法必须在子类中被实现。
• 如果一个类继承了抽象类，则该类要么是抽象类，要么实现抽象类中的所有抽象方法。

（5）抽象类存在的意义

• 抽象类可以提供一组方法的默认实现，减少代码重复。
• 抽象类可以作为其他类的基类，定义一些通用的属性和方法。

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

    // 非抽象方法
    void sleep() {
        System.out.println("动物在睡觉");
    }
}

// 子类Dog继承自Animal
class Dog extends Animal {
    // 实现抽象方法
    void makeSound() {
        System.out.println("狗在汪汪叫");
    }
}

// 测试类
public class TestAbstract {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();
        dog.sleep();
    }
}

2、接口

（1）概述

接口是一种规范或契约，定义了一组相关的方法，但没有具体的实现。类可以实现一个或多个接口，从而获得接口中定义的方法，并根据需要进行实现。

（2）定义格式

interface InterfaceName {
    // 常量声明（默认为public static final）
    // 抽象方法声明（默认为public abstract）

    // 默认方法（Java 8+，可有方法体）
    default void defaultMethod() {
        // 方法体
    }

    // 静态方法（Java 8+，可有方法体）
    static void staticMethod() {
        // 方法体
    }
}

（3）接口成分的特点

• 常量声明：接口中的变量默认为public static final，可以省略修饰符。
• 抽象方法声明：接口中的方法默认为public abstract，可以省略修饰符。
• 默认方法：接口中的方法可以有默认的实现，使用default关键字。
• 静态方法：接口中的方法可以被静态调用，使用static关键字。

（4）接口与接口的多继承

• 类可以实现多个接口，即一个类可以同时具备多个接口的功能和特性。

// 定义接口Animal
interface Animal {
    // 常量声明
    int LEGS = 4;

    // 抽象方法声明
    void makeSound();

    // 默认方法
    default void eat() {
        System.out.println("动物正在吃东西");
    }
}

// 定义接口Pet
interface Pet {
    // 抽象方法声明
    void play();

    // 静态方法
    static void sleep() {
        System.out.println("宠物正在睡觉");
    }
}

// Dog类实现Animal和Pet接口
class Dog implements Animal, Pet {
    // 实现抽象方法
    public void makeSound() {
        System.out.println("狗在汪汪叫");
    }

    public void play() {
        System.out.println("狗在玩耍");
    }
}

// 测试类
public class TestInterface {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();
        dog.eat();
        dog.play();
        Pet.sleep();
        System.out.println("腿的个数：" + Animal.LEGS);
    }
}

3、内部类

（1）概述

内部类是定义在另一个类内部的类，它可以访问外部类的成员，并提供更好的封装性和代码组织结构。

（2）内部类的分类

• 成员内部类：定义在类的内部，且没有使用static修饰。
• 静态内部类：定义在类的内部，且使用了static修饰。
• 局部内部类：定义在方法或代码块的内部。

（3）成员内部类的细节

• 成员内部类可以访问外部类的所有成员，包括私有成员。
• 成员内部类不能有静态变量和静态方法。
• 成员内部类需要通过外部类的实例去创建。

（4）静态内部类

静态内部类是定义在另一个类内部，并使用static关键字修饰的类。与普通的内部类不同，静态内部类与外部类实例无关，可以独立地创建和访问。

// 外部类Outer
class Outer {
    private int outerData = 1;

    // 成员内部类Inner
    class Inner {
        private int innerData = 2;

        void display() {
            System.out.println("外部类数据：" + outerData);
            System.out.println("内部类数据：" + innerData);
        }
    }
}

// 测试类
public class TestInnerClass {
    public static void main(String[] args) {
        Outer outer = new Outer();           // 创建外部类对象
        Outer.Inner inner = outer.new Inner();// 创建内部类对象
        inner.display();
    }
}

（5）匿名内部类

匿名内部类是一种没有名字的内部类，它可以用来实现接口或继承抽象类，并可以在创建对象的同时定义类的实现或重写方法。

// 接口HelloWorld
interface HelloWorld {
    void sayHello();
}

// 测试类
public class TestAnonymousInnerClass {
    public static void main(String[] args) {
        // 创建匿名内部类对象
        HelloWorld hello = new HelloWorld() {
            public void sayHello() {
                System.out.println("Hello World!");
            }
        };
        hello.sayHello();
    }
}

以上就是Java条件面向对象进阶（抽象类&接口&内部类）的全部内容，作者能力有限，如果不足请及时指出。