内部类总结

内部类

package com.grg.day12.test;

/**
 * @Author Grg
 * @Date 2023/11/13 14:19
 * @PackageName:com.grg.day12.test
 * @ClassName: Test
 * @Description: 又是码代码的一天
 * @Version plus max 宇宙无敌终极版本
 */
public class Test {
    public static void main(String[] args) {
        /*
             需求:写一个Javabean类描述汽车。
            属性:汽车的品牌，车龄，颜色，发动机的品牌，使用年限。
            内部类的访问特点:
              内部类可以直接访问外部类的成员，包括私有
              外部类要访问内部类的成员，必须创建对象

         */
        Car c = new Car();
        c.carName = "bl";
        c.carAge = 1;
        c.carColor = "粉色";

        c.show();
    }
}

package com.grg.day12.test;

/**
 * @Author Grg
 * @Date 2023/11/13 14:20
 * @PackageName:com.grg.day12.test
 * @ClassName: Car
 * @Description: 又是码代码的一天
 * @Version plus max 宇宙无敌终极版本
 */
public class Car {
    String carName;
    int carAge;
    String carColor;

    public void show(){
        System.out.println(carAge);

        Engine e = new Engine();
        System.out.println(e.engineName);
    }

    class Engine{
        String engineName;
        int engineAge;

        public void show(){
            System.out.println(engineName);
            System.out.println(carName);
        }
    }
}

1.什么是内部类

写在一个类里面的类就叫做内部类

2.什么时候用到内部类

B类表示的事物是A类的一部分，且B单独存在没有意义

比如：汽车的发动机，ArrayList的迭代器，人的心脏等等

3.内部类的分类

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

4.成员内部类

• 写在成员位置，属于外部类的成员
• 成员内部类可以被一些修饰符所修饰，比如: private，默认，protected,public，static等
• 在成员内部类里面，JDK16之前不能定义静态变量，JDK 16开始才可以定义静态变量。

5.获取成员内部类对象

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

public class Outer {

    private class Inner {
		//static int a ;   jdk16+
        //error:  Static declarations in inner classes are not supported at language level '11'
    }
    
    public Inner getInstance() {
        return new Inner();
    }
}

public class Test {
    public static void main(String[] args) {
        /*
               1. 在外部类中编写方法，对外提供内部类的对象。
               2. 直接创建格式:外部类名.内部类名 对象名=外部类对象.内部类对象;
         */
        //Outer.Inner oi = new Outer().new Inner();

        Outer o = new Outer();
        Object instance = o.getInstance();
        System.out.println(o.getInstance());
    }
}

6.静态内部类

静态内部类只能访问外部类中的静态变量和静态方法，如果想要访问非静态的需要创建对象。（静态只能访问静态）

1. 创建静态内部类对象的格式:外部类名.内部类名 对象名=new外部类名.内部类名();
2. 调用非静态方法的格式:先创建对象，用对象调用
3. 调用静态方法的格式:外部类名.内部类名.方法名();

静态内部类是一种特殊的成员内部类

7.局部内部类

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

public class Test {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.show();
    }
}

public class Outer {

    public void show(){

        int a = 10;
        //局部内部类
        class Inner{
            String name;
            Inner age;

            public void method1(){
                System.out.println(a);
                System.out.println("1");
            }

            public void method2(){
                System.out.println("2");
            }
        }

        //创建局部内部类的对象
        Inner i = new Inner();
        System.out.println(i.age);
        System.out.println(i.name);
        i.method1();
        i.method2();
    }
}

8.匿名内部类(重点)

匿名内部类本质上就是隐藏了名字的内部类

构造格式：
    new 类名或者接口名(){
    重写方法;
}

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

public static void main(String[] args) {
        new Swim(){
            @Override
            public void swim() {
                System.out.println("swim");
            }
        };
    }

public abstract class Animal {
    public abstract void eat();
}

public static void main(String[] args) {
        new Animal(){
            @Override
            public void eat() {
                System.out.println("eat");
            }
        };
    }

• 如果一个类只使用一次 ，匿名内部类可以直接当作参数进行参数传递
• 匿名内部类可以直接当作 一个接口实现类的对象/一个类的子类 来使用
• 匿名内部类，可以写在成员位置，可以写在局部位置
• 匿名内部类的格式，包含了继承或实现，方法重写，创建对象

使用场景：

如果这个实现类（接口情况下）只需要使用一次，就可以直接使用匿名内部类，用来简化代码。