Java面向对象之内部类

package oop.demo14;

/**
 * 内部类
 * 内部类就是在一个类的内部再定义一个类。比如，A 类中定义一个 B 类，
 * 那么 B 类相对 A 类来说就称为内部类，而 A 类相对 B 类来说就是外部类了。
 * 1、成员内部类
 * 2、静态内部类
 * 3、局部内部类
 * 4、匿名内部类
 */
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);
        }

    }

    /**
     * 静态内部类：static 修饰
     */
    public static class StaticInner{

        //静态内部类方法
        public void in(){
            System.out.println("这是静态内部类的方法");
        }

        //获得外部类的私有属性
        public void getId(){
            /**
             * 此处报错，获取不到 ID，因为程序初次加载 static 静态类，
             * 而外部类中的私有属性 id 还未出生，当然获取不到
             * 除非私有属性静态化，id 通过 static 修饰即可
             * 如：private static int id = 10;
             */
            //System.out.println(id); //此处异常
        }

    }

    /**
     * 局部内部类
     * 类似于局部变量：在方法里面定义的变量叫局部变量
     * 同理，在方法里面定义的类叫局部内部类
     */
    public void method(){
        class LocalInner{
            public void localIn(){
                System.out.println("这是局部内部类的方法");
            }
        }
    }
}

/**
 * 一个 java 类中可以有多个 class 类,但是只能有一个 public class 类
 */
class A{
    public static void main(String[] args) {

    }
}

package oop.demo14;

/**
 * 匿名内部类
 */
public class Test {

    public static void main(String[] args) {
        /**
         * 正常 new 一个对象：
         * 右侧 new 完赋值给左侧，成为一个具体的实例
         * new 一个 Apple，这个 Apple 的名字是 apple
         * 这是正常实例化一个对象，对象名字就叫 apple
         */
        Apple apple = new Apple();
        apple.eat();

        System.out.println("------------- 分隔符 ------------");

        /**
         * 没有名字初始化类
         * new 一个 Apple，直接调用方法
         * 具体不知道这个 Apple 是谁，不知道它的名字
         * 不用将实例保存到变量中
         */
        new Apple().eat(); //匿名内部类

        /**
         * 匿名内部类可以 new 一个接口
         * 我们说过，一个接口不能通过 new 出来，而是通过 implements 关键字去实现
         * 但是在这里就比较特殊了，new 的接口相当于一个匿名内部类，这个匿名内部类通过重写方法实现了这个接口
         * 充当匿名内部类的部分如下：
         * new UserService() {
         *     @Override
         *     public void hello() {
         *
         *     }
         * };
         * 实现接口 就得重写接口中的方法 这个方法返回一个 userService 对象
         */
        UserService userService = new UserService() {
            @Override
            public void hello() {
                System.out.println("重写 hello 方法");
            }
        };

    }
}

//定义一个 Apple 类
class Apple{
    public void eat(){
        System.out.println("1");
    }
}

//定义一个 UserService 接口
interface UserService{
    void hello();
}

package oop.demo14;

public class Application {

    public static void main(String[] args) {

        //实例化外部类
        Outer outer = new Outer();

        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getId();

    }
}