基础——内部类，多态

内部类

内部类（Inner Class）是在一个类的内部定义的另一个类。在 Java 中，内部类有四种主要类型：

1. 成员内部类（Member Inner Class）： 成员内部类是定义在另一个类的内部的类。它属于外部类的实例，并可以访问外部类的成员（包括私有成员）。成员内部类可以像普通类一样拥有字段、方法和构造函数。

   class OuterClass {
       // 外部类的成员和方法
   
       class InnerClass {
           // 内部类的成员和方法
       }
   }
   

2. 局部内部类（Local Inner Class）： 局部内部类是定义在方法内部的类。它的作用域被限制在包含它的方法中，通常用于解决某个方法的特定问题。

   class OuterClass {
       void someMethod() {
           class LocalInnerClass {
               // 局部内部类的成员和方法
           }
       }
   }
   

3. 静态嵌套类（Static Nested Class）： 静态嵌套类是定义在另一个类内部的静态类。与成员内部类不同，静态嵌套类不依赖于外部类的实例，因此可以像普通类一样创建实例。

   class OuterClass {
       static class StaticNestedClass {
           // 静态嵌套类的成员和方法
       }
   }
   

4. 匿名内部类（Anonymous Inner Class）： 匿名内部类是没有名字的内部类，通常用于创建一个实现某个接口或继承某个类的临时对象。

   interface MyInterface {
       void doSomething();
   }
   
   MyInterface anonymousInner = new MyInterface() {
       @Override
       public void doSomething() {
           // 实现接口方法的匿名内部类
       }
   };
   

内部类的主要优点之一是它们可以访问外部类的私有成员，这提供了一种封装和组织代码的方式。不过，内部类也增加了代码的复杂性，因此在使用时需要谨慎考虑是否需要内部类的特性。

多态

多态（Polymorphism）是面向对象编程中的一个重要概念，它允许不同类的对象对相同的消息做出不同的响应。多态性有助于提高代码的灵活性和可维护性，同时也是面向对象程序设计的核心原则之一。

多态有两种主要类型：

1. 编译时多态（Compile-Time Polymorphism）：也称为静态多态性或早期绑定。在编译时多态中，方法的调用在编译阶段就已经确定，通常通过方法的名称、参数的数量和类型来决定。这种多态性主要与方法的重载（Overloading）相关，即同一个类中可以有多个方法具有相同的名称但不同的参数列表。

   class Calculator {
       int add(int a, int b) {
           return a + b;
       }
   
       double add(double a, double b) {
           return a + b;
       }
   }
   
   // 编译时多态，根据参数类型选择方法
   Calculator calc = new Calculator();
   int result1 = calc.add(2, 3);         // 调用第一个方法
   double result2 = calc.add(2.5, 3.7);  // 调用第二个方法
   

2. 运行时多态（Run-Time Polymorphism）：也称为动态多态性或晚期绑定。在运行时多态中，方法的调用在程序运行时动态确定，通常与方法的重写（Overriding）和继承有关。运行时多态性实现了基类或接口的引用可以指向派生类的对象，从而实现了多态性。

   class Animal {
       void makeSound() {
           System.out.println("Animal makes a sound");
       }
   }
   
   class Dog extends Animal {
       @Override
       void makeSound() {
           System.out.println("Dog barks");
       }
   }
   
   // 运行时多态，通过基类引用调用派生类方法
   Animal myDog = new Dog();
   myDog.makeSound();  // 调用的是 Dog 类的 makeSound 方法
   输出：Animal makes a sound
              Dog barks
   

在运行时多态中，方法的具体实现是根据对象的实际类型来确定的，而不是根据引用变量的类型。这使得我们可以以统一的方式处理不同类的对象，提高了代码的灵活性和可维护性。

多态是面向对象编程的一个强大概念，它允许我们编写通用的代码，减少重复，同时也提供了一种强大的方式来实现接口、抽象类、继承和方法的重写。