内部类

非静态内部类

非静态内部类在使用常用的是直接放入类中，在使用过程中需要通过外部类的的对象才能调用。

public class OuterClass {
    public String outerName;
    public OuterClass(){
        outerName = "外部类";
    }
    public void display(){
        System.out.println(outerName);
    }
    class InnerClass{
        public String innerName;
        public InnerClass(){
            innerName = "内部类";
        }
        public void display(){
            System.out.println(innerName);
        }
    }

    public static void main(String[] args) {
        //外部类的创建
        OuterClass outerClass = new OuterClass();
        //外部类的使用
        outerClass.display();
        //内部类（类中）的创建
        InnerClass  innerClass = outerClass.new InnerClass();
        //内部类的使用
        innerClass.display();
    }
}

 同样还能直接放入方法体中，那样就不需要使用外部类对象就可以直接调用

public class OuterClass {
    public String outerName;
    public OuterClass(){
        outerName = "外部类";
    }
    public void display(){
        System.out.println(outerName);
        class InnerClass{
            public String innerName;
            public InnerClass(){
                innerName = "方法体中的内部类";
            }
            public void display(){
                System.out.println(innerName);
            }
        }
        InnerClass innerClass = new InnerClass();
        innerClass.display();
    }


    public static void main(String[] args) {
        //外部类的创建
        OuterClass outerClass = new OuterClass();
        //外部类的使用
        outerClass.display();
        //内部类（类中）的创建

        //内部类的使用
    }
}

静态内部类

静态内部类可以直接通过类名进行调用，无需外部类的对象。

public class OuterClass {
    public String outerName;
    public OuterClass(){
        outerName = "外部类";
    }
    public void display(){
        System.out.println(outerName);
    }

    public static class InnerClass{
        public String innerName;
        public InnerClass(){
            innerName = "静态内部类";
        }
        public void display(){
            System.out.println(innerName);
        }
    }


    public static void main(String[] args) {
        //外部类的创建
        OuterClass outerClass = new OuterClass();
        //外部类的使用
        outerClass.display();
        //内部类（类中）的创建
        InnerClass innerClass = new InnerClass();
        //内部类的使用
        innerClass.display();
    }
}

匿名内部类

匿名内部类是最常见的内部类的使用方法，它针对接口（抽象类）可以直接使用，无需额外创建一个类来实现它的接口，同样它的缺点也很明显，耦合度高。

 Pet.java

public abstract class Pet {
    public abstract void eat();
}
MyInterface.java

public interface MyInterface {
    public void display();
}
Test.java

public class Test {
    public static void main(String[] args) {
        //接口使用匿名内部类
        MyInterface myInterface = new MyInterface() {
            @Override
            public void display() {
                System.out.println("接口的匿名内部类的使用");
            }
        };
        myInterface.display();
        //抽象类使用匿名内部类
        Pet pet = new Pet() {
            @Override
            public void eat() {
                System.out.println("抽象类使用匿名内部类");
            }
        };
        pet.eat();

    }
}