内部类

内部类就是在一个类的内部再定义一个类，如A类中定义一个B类，那么B类相对于A类来说就是内部类，A类相对于B类来说就是外部类

1.（成员）内部类

（1）成员内部类可以获得外部类的私有属性和方法

（2）注意如何创建内部类，先创建外部类，在此基础上再创建内部类

public class Outer {
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性或方法
        public void getID(){
            System.out.println(id);
            out();
        }
    }
}
class Test {
    public static void main(String[] args) {
        Outer outer=new Outer();
        Outer.Inner inner=outer.new Inner();
        inner.in();//这是内部类的方法
        inner.getID();//10
    }
}

（3）可以定义内部接口，且可以定义另外一个内部类实现这个内部接口

public class Outer06 {
    public interface Fly{
        void fly();
    }
    public class Inner06 implements Fly{
        @Override
        public void fly() {
            System.out.println("fly");
        }
    }
    public static void main(String[] args) {
        Outer06 outer06=new Outer06();
        Outer06.Inner06 inner06=outer06.new Inner06();
        inner06.fly();//fly
    }
}

（4）内部类不能定义static元素

public class Outer {
    public class Inner{
        public static void in(){//报错，不能使用static
            System.out.println("这是内部类的方法");
        }
    }
}

 （5）内部类可以多嵌套

public class Outer05 {
    public class Inner{
        public class In{
            
        }
    }
}
class TestOuter05{
    public static void main(String[] args) {
        Outer05 out =new Outer05();
        Outer05.Inner inner =out.new Inner();
        Outer05.Inner.In in =inner.new In();
    }
}

2.静态内部类

（1）静态内部类无法调用外部类非静态的属性

public class Outer1 {
    private int id=10;
    public void out(){
        System.out.println("这是外部类的静态方法");
    }
    public static void out1(){
        System.out.println("这是外部类的静态方法");
    }
    public static class Inner1{//静态内部类无法调用外部类中非静态的属性和方法
        public void in(){
            System.out.println("这是静态外部类的方法");
            out();//报错
            out1();
        }
    }
}

（2）static内部类具备所有外部类的特性，注意创建静态内部类的方法

public class Outer02 {
    public static class Inner2{
        public static void run(){//可以定义static方法
            System.out.println("run");
        }
        public void run1(){
            System.out.println("run1");
        }
    }
}
class Test {
    public static void main(String[] args) {
        Outer02.Inner2 inner1=new Outer02.Inner2();//特别注意
        inner1.run1();
        inner1.run();
    }
}

3.局部内部类

在类的方法中定义类

public class Outer03 {
    public void method(){
        class Inner3{
            public void in3(){
                System.out.println("这是局部内部类");
            }
        }
    }
}

4.匿名内部类

public class Outer04 {
    public static void main(String[] args) {
        //没有名字初始化类，不用将十里保存到变量中
        new A().eat();
        //new B()匿名内部类可以new接口
        B b=new B(){
            @Override
            public void speak() {
                System.out.println("speak");
            }
        };
        b.speak();
    }
}
class A{
    public void eat(){
        System.out.println("eat");
    }
}
interface B{
    void speak();
}