JAVA学习笔记----静态内部类，局部内部类,匿名内部类

静态内部类

我们知道非静态内部类是外部类的一个对象，我们可以通过将内部类定义成静态的，来将它当作外部类本身
值得一提的是，外部类不能用static来修饰

特性

1.静态内部类可以包含静态成员，也可以包含非静态成员 (复习:接口中只能定义静态的Final变量)

2.因为 静态成员不能访问非静态成员所以静态内部类不能访问外部类的实例成员.因为对象是静态的，所以哪怕是内部类中的实例方法也不能访问外部类的实例成员

3.即使内部类是静态的，外部类也不能直接引用内部类的成员变量(类变量需要调用内部类加变量名来引用，成员变量则需要对内部类实例化

public class STaticINclass {
    public static void main(String[] args){
        new descibe().info();
    }
}
class descibe{
    static class havio{
        private static String name = "Haven";
        private String id = "123456";
    }
    void info(){
        System.out.println(new havio().id);//实例化
        System.out.println(havio.name);
    }
}

内部类的总结

1.外部类调用内部类和普通的调用类一样，都可以用new来调用构造器来创建类的实例

2.注意一点，不要再外部类的静态方法，静态初始化块中定义非静态内部类

3.我们可以先使用外部类的一个方法来调用内部类的成员

在外部类以外的位置使用内部类

class OUt{
    class IN{
        IN(String msg){
            System.out.println(msg);
        }
    }
}
public class STaticINclass {
    public static void main(String[] args){
        OUt.IN in = new OUt().new IN("调用内部类构造器练习");//连续使用两个new，先对外部类实例化，然后再用New给内部类构造器赋值
    }
}

非静态内部类的构造器必须使用外部类的对象来进行调用，也就是说内部类的构造器之前必须存在一个外部类的对象

在外部类以外的位置使用静态内部类

public class STaticINclass {
    public static void main(String[] args){
        OUt.StaticIN in = new OUt.StaticIN("测试测试")
    }
}
class OUt{
    class StaticIN{
        StaticIN(String msg){
            System.out.println(msg);
        }
    }
}

继承静态内部类

class StaticClass extends OUt.StaticIN{}

局部内部类

把内部类定义在方法里面就是 局部内部类

因为实际开发中很少使用局部内部类，JAVA8中引入了一个匿名内部类

如果一个类只使用一次，我们可以通过定义匿名内部类来调用它，在使用后这个类将被垃圾回收

抽象类名 对象名 = new 抽象类名()

{

重写的方法

​ }

public class innersubts {
    public static void main(String[] args){
    DOgmov dg = new DOgmov();
    dg.run();
    }
}
abstract class Dog{
    public abstract void run();
}
class DOgmov extends Dog{
    public void run(){
        System.out.println("dog is running");
    }
}

匿名内部类

如果我们只需要使用DOgmov这个类一次，就可以通过匿名内部类来调用

public class innersubts {
    public static void main(String[] args){
    Dog dg = new Dog() {

        public void run() {
            System.out.println("dog is running");
        }
    };//注意匿名内部类的花括号末尾会有一个分号
    }
}
abstract class Dog{
    public abstract void run();
}

也可以通过匿名内部类来调用抽象父类的构造器

public class innersubts {
    public static void main(String[] args){

        //创建一个用于描述匿名构造类行为的对象
        class Anonymous{
            //传入接口
                public void test(Dog d){
                    //描述行为
                    System.out.println(d.run("dog"));
                }
        }
        Anonymous ay = new Anonymous();
        //用匿名内部类来调用接口构造器
        //传入匿名实现类的实例   实现类(描述行为行为的类).(行为方法)(new 匿名实现类的构造器)
        ay.test(new Dog("xxxxx") {
         
        public void run(String anms) {
            System.out.println(anms + " is running");
        }
    });
    }
}
abstract class Dog{
    private String name
    public abstract void run(String anms);
    Dog(String name){
        this.name= name;
    }
}