Java的内部类

1. 什么是内部类?

类的五大成员：属性、方法、构造方法、代码块、内部类

在一个类的里面，再定义一个类。
举例：在A类的内部定义B类，B类就被称为内部类

package Neibulei;

import Interface.Person;

public class Car {
    private String Carname;
    private int Carage;
    private String Carcolor;
    
    class engine
    {
        private String name;
        private int age;

        public engine(String name, int age) {this.name = name;this.age = age;}
        public engine() {}
        public String getName() {return name;}
        public void setName(String name) {this.name = name;}
        public int getAge() {return age;}
        public void setAge(int age) {this.age = age;}
    }

    public Car() {}

    public Car(String carname, int carage, String carcolor) {
        Carname = carname;
        Carage = carage;
        Carcolor = carcolor;
    }

    public String getCarname() {return Carname;}
    public void setCarname(String carname) {Carname = carname;}
    public int getCarage() {return Carage;}
    public void setCarage(int carage) {Carage = carage;}
    public String getCarcolor() {return Carcolor;}
    public void setCarcolor(String carcolor) {Carcolor = carcolor;}
    public void  show (){
        System.out.println(this.Carname);
        engine e = new engine();
        System.out.println(e.name);
    }
}

package Neibulei;

public class Main {
    public static void main(String[] args) {
        Car c = new Car();
    }
}

Java 的内部类是定义在其他类内部的类。内部类可以访问包含它的外部类的成员，包括私有成员。它提供了一种组织代码的方式，可以将相关的类组织在一起。

2. 内部类的分类

成员式内部类

• 成员内部类
• 静态内部类

局部式内部类

• 局部内部类
• 匿名内部类

2.1 成员式内部类

2.1.1 成员内部类（Member Inner Class）

• 成员内部类是定义在其他类内部的普通类。
• 成员内部类可以访问外部类的所有成员，包括私有成员。
• 成员内部类的实例必须依赖于外部类的实例。

public class OuterClass {
    private int outerVar;

    public class InnerClass {
        public void display() {
            System.out.println("OuterVar from OuterClass: " + outerVar);
        }
    }
}

写在成员位置的，属于外部类的成员。

获取成员内部类对象

• 方式一：在外部类中编写方法，对外提供内部类的对象。
• 方式二：直接创建格式:外部类名.内部类名对象名=外部类对象.内部类对象;

//我要创建的是谁的对象?
//内部类的对象
Outer.Inner oi = new outer().new Inner();

2.1.2 静态内部类（Static Nested Class）

• 静态内部类是定义在其他类内部的静态类。
• 静态内部类可以直接访问外部类的静态成员，但不能访问非静态成员。
• 静态内部类的实例不依赖于外部类的实例。

public class OuterClass {
    private static int staticVar;

    public static class StaticInnerClass {
        public void display() {
            System.out.println("StaticVar from OuterClass: " + staticVar);
        }
    }
}

• 创建静态内部类对象的格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
Outer.Inner oi = new Outer.Inner();
• 调用非静态方法的格式：先创建对象，用对象调用
• 调用静态方法的格式： 外部类名.内部类名.方法名();

2.2 局部式内部类

2.2.1 局部内部类（Local Inner Class）

1. 将内部类定义在方法里面就叫做局部内部类，类似于方法里面的局部变量。
2. 外界是无法直接使用，需要在方法内部创建对象并使用。
3. 该类可以直接访问外部类的成员，也可以访问方法内的局部变量。

• 局部内部类是定义在方法内部的类。
• 局部内部类只能在方法内部被访问，作用范围仅限于该方法。
• 局部内部类可以访问外部方法的参数和局部变量，但这些变量必须是 final 或者事实上是 final 的。
• 示例：

public class OuterClass {
    public void outerMethod() {
        final int localVar = 10;

        class LocalInnerClass {
            public void display() {
                System.out.println("LocalVar from OuterMethod: " + localVar);
            }
        }

        LocalInnerClass localInner = new LocalInnerClass();
        localInner.display();
    }
}

2.2.2 匿名内部类（Anonymous Inner Class）

• 匿名内部类是没有类名的内部类，通常用于创建一个只需要一次使用的类的实例。
• 匿名内部类通常是在创建对象的同时定义类，并且通常是继承一个类或实现一个接口。

public interface MyInterface {
    void myMethod();
}

public class OuterClass {
    public void createAnonymousInner() {
        MyInterface anonymousInner = new MyInterface() {
            @Override
            public void myMethod() {
                System.out.println("Implementation of MyMethod in Anonymous Inner Class");
            }
        };
        anonymousInner.myMethod();
    }
}

package Niming;

public interface Swim {
    public abstract void swim();
}

package Niming;

public class Test {
    public static void main(String[] args) {
        new Swim(){
            @Override
            public void swim() {
                System.out.println("重写了游泳的方法");
            }
        };
    }
}

如果是接口那么就是实现关系，如果是类那么就是继承关系

1. 什么是匿名内部类?
   隐藏了名字的内部类，可以写在成员位置，也可以写在局部位置。
2. 匿名内部类的格式?

new 类名或者接口名() {
	重写方法;
};

3. 格式的细节
   包含了继承或实现，方法重写，创建对象。
   整体就是一个类的子类对象或者接口的实现类对象
4. 使用场景
   当方法的参数是接口或者类时，以接口为例，可以传递这个接口的实现类对象
   如果实现类只要使用一次，就可以用匿名内部类简化代码

内部类在设计模式、事件处理、图形用户界面等场景中常常发挥重要作用，它提供了更灵活的封装和组织代码的方式。但在使用时需要注意避免过度嵌套和过于复杂的结构。