本文已参与「新人创作礼」活动，一起开启掘金创作之路。

面向对象进阶-内部类

一 . 成员内部类

package Inner内部类.test1成员内部类;

public class test01 {
    /*
        创建内部类对象格式:
            外部类名.内部类名 对象名 = new 外部类对象().new 内部类对象();

     */
    public static void main(String[] args) {
        //外部类要访问内部类成员就需要创建对象
        Outer.Inner i = new Outer().new Inner();
        System.out.println(i.num);
        i.show();
    }
}

class Outer {
    private int a = 10;

    //在类的成员位置：成员内部类
    //成员内部类也属于(成员),可以被一些修饰符修饰
    class Inner{
        int num = 10;
        public void show(){
            System.out.println("Inner..show");
            //内部类，访问外部类成员，可以直接访问，包括私有
            System.out.println(a);
        }
    }
}

1. 私有成员内部类演示

package Inner内部类.test2私有成员内部类演示;

public class test02 {
    /*
        私有成员内部类演示
     */

    public static void main(String[] args) {
        //Outer.Inner oi = new Outer().new Inner();
        Outer o = new Outer();
        o.method();

    }
}

class Outer{
    private class Inner{
        public void show(){
            System.out.println("inner..show");
        }
    }

    //私有成员内部类访问: 在自己所在的外部类中创建对象访问
    public void method(){
        Inner i = new Inner();
        i.show();
    }
}

2. 静态成员内部类演示

package Inner内部类.test3静态成员内部类演示;

public class test03 {
    /*
        静态成员内部类演示
     */

    public static void main(String[] args) {
        //静态成员内部类访问:外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Outer.Inner oi = new Outer.Inner();
        oi.show();

        //静态成员内部类中的静态方法:外部类名.内部类名.方法名();
        Outer.Inner.method();
    }
}
class Outer{
    static class Inner{
        public void show(){
            System.out.println("inner..show");
        }

        public static void method(){
            System.out.println("inner..method");
        }
    }
}

二 . 局部内部类

package Inner内部类.test4局部内部类;

public class test04 {
    /*
        局部内部类是在方法中定义的类，所以外界是无法直接使用的，需要在方法内部创建对象并使用
        该类可以直接访问外部类成员，也可以访问方法内的局部变量
     */
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

class Outer{

    int a = 10;

    public void method(){
        /*

            Inner是位于方法main()内的局部内部类，若要访问方法内的局部变量b，则b应当使用final修饰。
            被内部类访问的局部变量会被拷贝一份到内部类中，即Inner中存在一个成员变量，用于记录局部变量b的值。
            若局部变量不是final的，其取值就可以被修改，而Inner对象中保存的是其原来的值，这就会出现数据不同步的问题。
            Java为了避免数据不同步的问题，做出了内部类只可以访问final的局部变量的限制。
            在java8中，可以不使用final，如果局部变量被内部类访问，那么该局部变量相当于自动使用了final修饰。

         */
        final int b = 20;
        class Inner{
            public void show(){
                System.out.println("show...");
                System.out.println(a);
                System.out.println(b);
            }
        }

        Inner i = new Inner();
        i.show();
    }
}

！！！匿名内部类

package Inner内部类.test5匿名内部类;
/*
    正常使用接口中的方法的步骤
        1. 创建实现类，通过implements关键字去实现接口
        2. 重写方法
        3. 创建实现类对象
        4. 调用重写后的方法

    匿名内部类:匿名内部类本质上是一个特殊的局部内部类(定义在方法内部)
    前提:需要存在一个接口或类
    格式:
        new 类名或者是接口名() {
            重写方法;
        }
 */

public class test05 {
    public static void main(String[] args) {
        InterImpl ii = new InterImpl();
        ii.show();

        // 匿名内部类的理解 : 将继承|实现，方法重写，创建对象，放在了一步进行。
        new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类中的show方法");
            }
        }.show();

        //接口中存在多个方法
        Inter2 i = new Inter2(){

            @Override
            public void show1() {
                System.out.println("show1...");
            }

            @Override
            public void show2() {
                System.out.println("show2...");
            }
        };
        i.show1();
        i.show2();
    }
}

interface Inter{
    void show();
}

interface Inter2{
    void show1();
    void show2();
}


class InterImpl implements Inter{

    @Override
    public void show() {
        System.out.println("InterImpl 重写的show方法");
    }
}

（匿名内部类的应用场景）

package Inner内部类.test5匿名内部类;

/*
    当方法的形式参数是接口或者抽象类时可以将匿名内部类作为实际参数进行传递
 */
public class test06 {
    public static void main(String[] args) {
        goSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("我们去游泳吧。。。");
            }
        });
    }

    public static void goSwimming(Swimming swimming){
        swimming.swim();
    }
}

/*
    游泳接口
 */
interface Swimming{
    void swim();
}