内部类（基于b站提莫说java）

/顶级类
//同一个java文件，只能有一个顶级类被声明为public
//被public修饰的类，跟我们的java类同名
public class Outerclass {
    //在类里定义的类是内部类（4种）
    //1.成员内部类
    private String name;
    private static int age=10;
    public class MemberInnerClass {
        void test1(){
            System.out.println("访问外部类成员变量不管修饰级别name:"+name);
        }
    }
    public void soutName(){
        //局部内部类所属方法的局部变量
        int x=10;
        //局部内部类(不能被声明为static,public.,protected,privite,只能是默认)
        //作用范围仅在其所属方法soutName()里使用
        class LocalInnerClass{
            public void test1(){
                System.out.println("访问外部类成员变量不管修饰级别name:"+name);
                System.out.println("局部内部类所属方法的局部变量x:"+x);
            }
        }
        //此可以new LocalInnerClass
        new LocalInnerClass();
        System.out.println(name);
    }
    //尝试在外部类的方法中能否new局部内部类判断局部内部类作用范围
    public String getName() {
        //new LocalInner,new不了
        return name;
    }

    //静态内部类，即成员内部类前加static(因为局部内部类不可以static修饰)
    //静态的类不能访问外部成员变量，因为他是属于对象的，而static修饰后，就从属于类级别
    //静态内部类不依赖于外部类实例（不用创建一个外部类才能访问他），可通过类名直接访问
    //被static关键字修饰，只能访问外部类的！静态！变量
    //静态内部类概念上与外部类趋近，只是嵌套在外部类里面
    public static class StaticInnerClass {
        void test1(){
            System.out.println("test1()");
            System.out.println(age);
        }
    }
    //匿名内部类（没名称）
    //main方法()
    public static void main(String[] args) {
        Swimmer swimmer=new Fish();//new一个swimmer的实现类，此=右边用多态创建了一个他的子类（实现类），就可以调用其方法了
        swimmer.swim();//抽象类以及接口无法创建他们的实例
        //现在有个需求，要执行游泳这个方法，但不去创建他的子类

        //之前说接口不能被直接实例化（要implements），这new的是创建他的子类
        //匿名内部类，此相当于我们去写了一个Swimmer的实现类（例如Fish是他的实现类），只是没给实现类任何命名
        //即只知道父类名称Swimmer，但实现类的名称不知道
        Swimmer swimmer1=new Swimmer() {
            //下面是因为实现类必须去实现接口中的方法
            @Override//方法重写，可ctrl+i找
            public void swim() {
                System.out.println("匿名内部类swim");
            }
        }; /*
        Swimmer swimmer1=new Swimmer() {...}相当于
        class(此没名字)implements Swimmer{
         @Override
         public void swim() {
         System.out.println("匿名内部类swim");
          }}
          ！！！new的是接口的实现类（无名），而不是接口
        */
        //此时已创建了他的实例
        swimmer1.swim();
    }
}

 

 

public interface AnimalInterface {
    //接口中，变量默认为public static final
    int TEST_NUMBER=10;
    void makeSound();
    //从java8开始，接口可以由默认方法
    default void test(){
        System.out.println("test");
    }
}
public interface Swimmer {
    void swim();
}

 output:鱼游泳了
            匿名内部类swim

public class Fish implements Swimmer,AnimalInterface{

    @Override
    public void makeSound() {
        System.out.println("鱼冒泡声");
    }

    @Override
    public void swim() {
        System.out.println("鱼游泳了");
    }
}

使用场景

1.成员内部类：适合与外部类紧密相关，且需要访问外部类成员的场景

2.局部内部类：适合定义在方法和作用域里面，用于临时性任务

3.匿名内部类：（用比较多）里面的实例只使用一次，不用再在文件刻意定义一个类，要的只是重写方法的那段逻辑->简化代码

4.静态内部类：适合与外部类关系不太紧密，不需要访问外部类实例成员的场景