文章目录

一、内部类使用：
- 1.1 成员内部类：
- - 1.1.1 成员内部类的主要特点是：
- 1.2 局部内部类：
- - 1.2.1 局部内部类的主要特点是：
  - 1.2.2 局部内部类通常用于以下情况：
- 1.3 静态内部类：
- - 1.3.1 静态内部类的主要特点是：
  - 1.3.2 静态内部类通常用于以下情况：
- 1.4 匿名内部类：
- - 1.4.1 实现接口：
  - 1.4.2 继承类：
二、抽象类使用：
- - 在使用抽象类时，需要注意以下几点：

内部类和抽象类是Java中面向对象编程的重要特性，它们分别用于不同的场景和目的。

一、内部类使用：

内部类是定义在另一个类内部的类，它可以直接访问外部类的成员，并且可以起到一定的封装作用。内部类有以下几种类型：

1.1 成员内部类：

定义在类的成员位置，可以访问外部类的所有成员，包括私有成员。创建成员内部类的实例时，需要先创建外部类的实例，然后通过外部类的实例来创建内部类的实例。

成员内部类是定义在类的内部，并且直接在类中的成员位置上定义的类。它和普通成员变量和成员方法类似，可以访问外部类的成员，包括私有成员。成员内部类还可以使用外部类的引用OuterClass.this来访问外部类的实例。

以下是一个成员内部类的代码案例：

public class OuterClass {
    private int outerValue = 10;

    // 成员内部类
    public class InnerClass {
        private int innerValue = 20;

        public void display() {
            System.out.println("Outer value: " + outerValue);
            System.out.println("Inner value: " + innerValue);
        }
    }

    public static void main(String[] args) {
        OuterClass outerObj = new OuterClass();
        OuterClass.InnerClass innerObj = outerObj.new InnerClass();

        innerObj.display();
    }
}

在上面的例子中，OuterClass是外部类，InnerClass是成员内部类。在main方法中，首先创建了外部类的实例outerObj，然后通过outerObj来创建内部类的实例innerObj，这就是成员内部类的使用方法。

1.1.1 成员内部类的主要特点是：

可以直接访问外部类的成员，包括私有成员。
成员内部类必须寄存在外部类的实例对象中，所以不能在没有外部类实例的情况下创建内部类的实例。

成员内部类通常用于以下情况：

与外部类有密切关联，需要直接访问外部类的成员。
需要创建多个相互独立的内部类对象，每个内部类对象都有自己的状态，但又共享外部类的数据。

需要注意的是，如果成员内部类不需要访问外部类的成员，可以将其定义为静态内部类，这样可以节省一些内存开销。静态内部类与外部类没有直接的关联，可以独立地创建对象。

1.2 局部内部类：

定义在方法或代码块内部，作用范围仅限于所在的方法或代码块内。局部内部类可以访问外部方法的参数和局部变量，但要求这些参数和变量必须是 final 或 effectively final 的。
局部内部类是定义在方法内部的类，只能在该方法内部使用，其作用域仅限于方法内部。局部内部类对于外部类以及其他方法是不可见的。

以下是一个局部内部类的代码案例：

public class OuterClass {
    private int outerValue = 10;

    public void outerMethod() {
        int localVar = 5;

        // 局部内部类
        class LocalInnerClass {
            public void display() {
                // 局部内部类可以访问外部类的实例变量和方法
                System.out.println("Outer value: " + outerValue);
                System.out.println("Local variable: " + localVar);
            }
        }

        // 创建局部内部类的实例，并调用其方法
        LocalInnerClass innerObj = new LocalInnerClass();
        innerObj.display();
    }

    public static void main(String[] args) {
        OuterClass outerObj = new OuterClass();
        outerObj.outerMethod();
    }
}

在上面的例子中，OuterClass是外部类，在outerMethod方法内部定义了一个局部内部类LocalInnerClass。局部内部类LocalInnerClass只能在outerMethod方法内部使用。

1.2.1 局部内部类的主要特点是：

定义在方法内部，只能在该方法内部使用，其作用域仅限于方法内部。
局部内部类可以访问外部方法的局部变量以及外部类的实例变量和方法，但局部变量必须为final或effectively final（即不可修改）。
局部内部类对于外部类以及其他方法是不可见的，只能在定义它的方法内部使用。

1.2.2 局部内部类通常用于以下情况：

当某个类的功能只在一个特定的方法内部使用，并且不希望该类对其他方法可见时，可以将其定义为局部内部类。
局部内部类可以对代码进行更加细粒度的封装，提高代码的安全性和可读性。

总之，局部内部类适用于只在特定方法内部使用的情况，其作用域仅限于该方法内部。

1.3 静态内部类：

用 static 修饰的内部类，类似于一个普通的类，只是它被嵌套在其他类内部而已。静态内部类不能访问外部类的非静态成员，只能访问外部类的静态成员。

使用内部类的时候要根据实际需要选择不同的内部类类型。例如，如果内部类需要访问外部类的成员，可以使用成员内部类；如果内部类只在某个方法中使用，并且不需要访问外部类的非 final 变量，可以使用局部内部类；如果内部类不依赖外部类的实例，可以使用静态内部类。

静态内部类是定义在类的内部，并且被static关键字修饰的类。与成员内部类不同，静态内部类不依赖于外部类的实例，可以直接创建内部类的实例，而不需要先创建外部类的实例。

以下是一个静态内部类的代码案例：

public class OuterClass {
    private static int outerValue = 10;

    // 静态内部类
    public static class StaticInnerClass {
        private int innerValue = 20;

        public void display() {
            System.out.println("Outer value: " + outerValue);
            System.out.println("Inner value: " + innerValue);
        }
    }

    public static void main(String[] args) {
        // 创建静态内部类的实例，不需要先创建外部类的实例
        StaticInnerClass innerObj = new StaticInnerClass();
        innerObj.display();
    }
}

在上面的例子中，OuterClass是外部类，StaticInnerClass是静态内部类。在main方法中，直接创建了静态内部类的实例innerObj，无需先创建外部类的实例。

1.3.1 静态内部类的主要特点是：

可以直接创建内部类的实例，无需先创建外部类的实例。
静态内部类不能访问外部类的非静态成员，只能访问外部类的静态成员。

1.3.2 静态内部类通常用于以下情况：

当内部类不需要访问外部类的实例变量或方法时，可以将其定义为静态内部类，这样可以节省内存开销。
静态内部类可以作为一个独立的类来使用，可以避免与外部类的实例耦合在一起。

总之，静态内部类适用于不需要访问外部类实例成员的情况，且它与外部类实例无关。

1.4 匿名内部类：

匿名内部类是一种特殊的内部类，它没有显式地定义一个类名，而是直接在使用的地方创建一个实例。通常情况下，使用匿名内部类可以简化代码，特别是在需要创建一个只用一次的类的情况下。

匿名内部类通常用于以下情况：

1.4.1 实现接口：

当需要创建一个实现某个接口的类的实例时，可以使用匿名内部类。例如：

interface MyInterface {
    void doSomething();
}

public class MyClass {
    public void methodWithInterface() {
        MyInterface myInterface = new MyInterface() {
            @Override
            public void doSomething() {
                System.out.println("Doing something...");
            }
        };
        myInterface.doSomething();
    }
}

1.4.2 继承类：

当需要创建一个继承自某个类的实例时，可以使用匿名内部类。例如：

class MyBaseClass {
    void display() {
        System.out.println("Base class method.");
    }
}

public class MyClass {
    public void methodWithInheritance() {
        MyBaseClass myBaseClass = new MyBaseClass() {
            @Override
            void display() {
                System.out.println("Overridden method.");
            }
        };
        myBaseClass.display();
    }
}