面向对象编程：深入理解内部类与抽象类的使用

小鱼儿 2023-10-14 08:26 18阅读 0赞

### 文章目录 ###

*  一、内部类使用：
 *   *  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 继承类：
 *  二、抽象类使用：
 *   *   *  在使用抽象类时，需要注意以下几点：

![在这里插入图片描述][818023a1d3304b78a783d10c312d82a4.gif_pic_center]

内部类和抽象类是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();
        }
    }

注意，在匿名内部类中，可以重写父类或接口的方法，并且可以添加其他方法和字段。匿名内部类的作用域仅限于创建它的代码块，通常在方法中使用。

虽然匿名内部类可以简化代码，但也有一些限制和注意事项：

*  匿名内部类不能有构造方法，因为它没有类名，无法调用构造方法。
 *  匿名内部类只能使用一次，不能在其他地方再次使用。
 *  匿名内部类可以访问外部类的成员变量和方法，但要求这些成员变量和方法必须是 final 或 effectively final 的（Java 8 之后的版本）。

总体来说，匿名内部类是一种灵活且常用的编程技巧，适用于一些简单的类实现或临时的类需求，能够简化代码并增强代码的可读性。

![在这里插入图片描述][96f982767507486481cf828011f4df6b.gif_pic_center]

# 二、抽象类使用： #

抽象类是一种特殊的类，它不能被实例化，只能用作其他类的父类。抽象类中可以包含抽象方法和非抽象方法。抽象方法是没有具体实现的方法，必须在子类中进行重写实现。非抽象方法可以有具体实现，子类可以直接继承和使用。

使用抽象类的主要目的是为了实现代码的复用和扩展性。抽象类将一些通用的方法定义在其中，子类可以继承这些方法，并根据自己的特殊需求进行重写。抽象类还可以通过定义抽象方法来强制子类实现某些功能，这样可以保证子类都具有相同的接口，而具体实现则由子类自行决定。

### 在使用抽象类时，需要注意以下几点： ###

*  抽象类不能被实例化，只能用作其他类的父类。
 *  子类必须实现抽象类中的所有抽象方法，除非子类也是抽象类。
 *  抽象类可以包含非抽象方法，子类可以继承和使用这些非抽象方法。
 *  一个类只能继承一个抽象类，但可以实现多个接口。

总体来说，内部类和抽象类是Java中重要的面向对象编程特性，它们都有自己的应用场景和优势。合理地使用内部类和抽象类可以提高代码的可读性、可维护性和扩展性。

![在这里插入图片描述][dc8297a3e0414cccb1d2d91d3c961997.gif_pic_center]

[818023a1d3304b78a783d10c312d82a4.gif_pic_center]: https://img-blog.csdnimg.cn/818023a1d3304b78a783d10c312d82a4.gif#pic_center
[96f982767507486481cf828011f4df6b.gif_pic_center]: https://img-blog.csdnimg.cn/96f982767507486481cf828011f4df6b.gif#pic_center
[dc8297a3e0414cccb1d2d91d3c961997.gif_pic_center]: https://img-blog.csdnimg.cn/dc8297a3e0414cccb1d2d91d3c961997.gif#pic_center