Java内部类

Java中内部类主要分为成员内部类、局部内部类、匿名内部类、静态内部类
参考网址：https://www.cnblogs.com/chenssy/p/3388487.html

成员内部类

/*
* 成员内部类
*
* */


public class Supermarket {

    private String name;

    private Supermarket(String name){
        this.name = name;
    }

    private Shelf getShelfInstance(int code){
        return new Shelf(code);
    }

    private void displayOut(){
        System.out.print("超市名 : "+ name);
    }

    /*3 .成员内部类中不能存在任何static的变量和方法*/
    private class Shelf{

        private int code;

        private Shelf(int code){
            this.code = code;
        }

        private int getCode() {
            return code;
        }

        private void setCode(int code) {
            this.code = code;
        }

        private void display(){
            /* 1 .成员内部类也是最普通的内部类，它是外围类的一个成员，所以他是可以无限制的访问外围类的所有 成员属性和方法,尽管是private的*/
            displayOut();
            System.out.print(" | 货架号 : " + code);
            System.out.println();
        }

    }

    public static void main(String[] args) {
        /*4 .成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类。*/
        Supermarket supermarket = new Supermarket("苏果超市");
        Supermarket.Shelf shelf1 = supermarket.getShelfInstance(1);
        Supermarket.Shelf shelf2 = supermarket.getShelfInstance(2);

        /*2 .但是外围类要访问内部类的成员属性和方法则需要通过内部类实例来访问。*/
        shelf1.display();
        System.out.println("-----------------------------------------------");
        shelf2.display();


    }

}

局部内部类

/*局部内部类*/
/*它是嵌套在方法和作用于内的，对于这个类的使用主要是应用与解决比较复杂的问题，想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的，所以就产生了局部内部类，
    局部内部类和成员内部类一样被编译，只是它的作用域发生了改变，它只能在该方法和属性中被使用，出了该方法和属性就会失效。*/

/*定义在方法里*/
public class Games {

    private int code;

    public Games(int code){
        this.code = code;
    }


    public SystemRun game1Run(String howToRun){
        /*定义在方法里的局部内部类*/
        class System4Game1 implements SystemRun{
            private String howToRun;
            private System4Game1(String howToRun){
                defineHowToRun(howToRun);
            }

            @Override
            public void defineHowToRun(String howToRun) {
                this.howToRun = howToRun;
                System.out.println(this.howToRun);
            }
        }

        if(code == 1){
            /*  定义在作用域内的局部内部类*/
            class daojishi{
                private int time;

                public daojishi(int time){
                    this.time = time;
                }

                public void countSecond(){
                    for(int i = 0;i<=time;i++){
                        System.out.println("倒计时 : "+(time-i));
                    }
                }
            }

            daojishi ds = new daojishi(10);
            ds.countSecond();

        }

        return new System4Game1(howToRun);
    }

    public static void main(String[] args) {
        Games games = new Games(1);
        SystemRun systemRun = games.game1Run("该游戏需要下载插件");
    }


}

interface SystemRun{
    void defineHowToRun(String howToRun);
}

匿名内部类

/*匿名内部类*/


public class Zoo {

    public Animal getAnimal(String myname){
        /*这个内部类是没有名字的*/
        return new Animal(myname) {
            @Override
            public void livingHouse() {
                System.out.println(getName() + "来了");
            }
        };
    }

    public Manager getManager(String manager){
        return new Manager() {

            String nameOfManager = manager;

            @Override
            public void manage() {
                System.out.println(nameOfManager + "是管理者");
            }
        };
    }

    public static void main(String[] args) {
        Zoo zoo = new Zoo();
        Animal elephent = zoo.getAnimal("大象");
        elephent.livingHouse();

        Manager manager = zoo.getManager("我");
        manager.manage();
    }


}

abstract class Animal{
    private String name;

    Animal(String name){
        this.name = name;
    }

    String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public abstract void livingHouse();
}

interface Manager{
    void manage();
}

静态内部类

/**
 *静态内部类
 */


public class Room {

    private static int numberId = 1;

    enum DOOR_STATUS{
        CLOSED,
        OPEN
    }

    /**
     *静态内部类
     */
    static class ClosedDoor{

        /* 在静态内部类中可以存在静态成员 */
        static DOOR_STATUS status = DOOR_STATUS.CLOSED;

        void dispaly(){
             /*
             * 静态内部类只能访问外围类的静态成员变量和方法
             * 不能访问外围类的非静态成员变量和方法
             */
            System.out.println("房间 : " + numberId +" | 此门常闭");
        }

    }

    /**
     * 非静态内部类
     */
    class MovableDoor{
        /* 非静态内部类中不能存在静态成员 */
        DOOR_STATUS status;

        public MovableDoor(DOOR_STATUS status){
            this.status = status;
        }

        /* 非静态内部类中可以调用外围类的任何成员,  === 》 不管是静态的还是非静态的  《 === */
        String getStatus(){
            switch (status){
                case OPEN:
                    return "关闭";
                case CLOSED:
                    return "开着";
                default:
                    return "不知道";
            }
        }

        public void dispaly(){
            System.out.println("活动门状态 : "+getStatus());
        }
    }

    MovableDoor getMovableDoor(DOOR_STATUS status){
        return new MovableDoor(status);
    }


    public static void main(String[] args) {
        /* 外围类访问静态内部类：内部类. */
        System.out.print(ClosedDoor.status.toString() + " | ");
         /* 静态内部类 可以直接创建实例不需要依赖于外围类 */
        ClosedDoor closedDoor = new ClosedDoor();
        closedDoor.dispaly();

        Room room = new Room();
        /* 非静态内部的创建需要依赖于外围类 */
        Room.MovableDoor movableDoor = room.getMovableDoor(DOOR_STATUS.OPEN);
         /* 访问非静态内部类的成员需要使用非静态内部类的实例 */
        System.out.println(movableDoor.status.toString());
        movableDoor.dispaly();

        Room.MovableDoor movableDoor1 = room.new MovableDoor(DOOR_STATUS.CLOSED);
        movableDoor1.dispaly();
    }

}