内部类（成员内部类、局部内部类（包括匿名内部类））

这是我参与8月更文挑战的第8天，活动详情查看：8月更文挑战

一个事物的内部包含另外一个事物。一个类里面包含另外一个类，这个类叫内部类，包含它的叫它外部类。

例如：身体和心脏的关系；汽车和引擎的关系。

心脏、引擎只有在身体和汽车中才有用。内部类也同样。

分类：

　　1.成员内部类；

　　2.局部内部类（包括匿名内部类）；

1.成员内部类

/* 修饰符 class 外部类名称{ 修饰符 class 内部类名称{ ...... } ...... } */
public class Outer {
    private String name;

    public class Inter{
        public void InterMethod(){
            System.out.println("内部方法");
            System.out.println("姓名:" + name);   // 成员内部类能够访问外部类属性
        }
    }
    public void fun1(){
        Inter in = new Inter();
        in.InterMethod();
    }
}
复制代码

编译后，这个类的class文件保存在磁盘里

内部类的使用方式

　　在外部类中能够直接经过 new 对象的方式使用。

　　在其余类中访问：

　　　　1.间接方式：在外部类的方法中使用内部类，而在其余类中使用就 new 外部类调用这个方法；

/** * 其余类使用内部类 */
public class OuterDemo1 {
    public static void main(String[] args) {
        Outer out = new Outer();
        out.fun1();
    }
}
复制代码

　　　　2.直接方式，直接建立出内部类

　　　　公式: 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称()；

public class OuterDemo2 {
    public static void main(String[] args) {
        Outer.Inter in = new Outer().new Inter();

        in.InterMethod();
    }
}
复制代码

问题:在外部类、内部类、内部类方法体出现相同名称属性，如何输出相应的值呢？

解决：

public class OuterDemo3 {

    private String name ="外";

    class Inter{
        private String name = "内";
        public void interMethod(){
            String name = "方法";
            System.out.println(name);   // 输出: 方法，就近原则
            System.out.println(this.name);   // 输出: 内
            System.out.println(OuterDemo3.this.name);    // 输出: 外
        }
    }
}
复制代码

2.局部内部类

　　在方法体内定义一个类，出了这个方法，就没法使用这个类（因此其余类没法使用【局部内部类】）

　　普及：

　　权限修饰符的使用规则:

　　public > protected > (default) > private

　　1.外部类：能使用 public / (defautl) 修饰

　　2.成员内部类： public / protected / (default) / private

　　3.局部内部类：什么都不写

public class Test {

    public void fun(){
        final int num = 100;
        class Fun{
            private void fun2(){
                System.out.println(num);
            }
        }
        Fun fun = new Fun();
        fun.fun2();
    }
}
复制代码

问题：为何访问所在方法的局部变量，必需要有final修饰？

缘由（本质是生命周期问题）：

　　1.内部类 new 出来的对象在堆内存中；

　　2.局部变量跟着方法，在栈内存中；

　　3.方法运行完，马上出栈，局部变量跟着消失；

　　4.但 new 出来的对象，会在堆内存持续存在，直到垃圾回收；

　　5.因此，要将该内存复制到常量池才能保存继续使用。

3.匿名内部类（重要）

　　往常，咱们要使用接口方法，得先定义该接口的实现类 -> 重写该接口的全部抽象方法 -> new 实现类使用。

　　而若是接口的实现类只是用惟一的一次，那么这种状况就能够省略该实现类的定义，而改成使用 【匿名内部类】

接口

public interface MyInteface {
    void method();
}
复制代码

使用【匿名内部类】

/** * 格式： * 接口名称 对象名 = new 接口名称(){ * // 覆盖重写全部抽象方法 * }; */
public class AnonymityTest2 {
    public static void main(String[] args) {
        MyInteface my = new MyInteface(){
            @Override
            public void method() {
                System.out.println("匿名内部类方法");
            }
        };
        my.method();
    }
}
复制代码

　　不少人一开始可能会有误解：不是【匿名内部类】吗？ MyInteface my = new MyInteface(){...} 这不是有名字么？

　　先看，对于"new MyInteface(){...};" 的解析：

　　　　1). new 表明对象建立的动做；

　　　　2). 接口名称 【匿名内部类】要实现的接口；

　　　　3). {...} 这才是【匿名内部类】的内容，里面重写着接口的全部抽象方法

　　它光秃秃的，的确没名没姓的。

　　而 MyInteface my = new MyInteface(){...} 中的 my 是对象名，它是供你调用匿名类方法的对象。

ps:匿名内部类、匿名对象

一、【匿名内部类】表示，在建立对象是，只能使用惟一一次，通常用于书写接口的实现类。

　　　　若是但愿屡次建立对象，并且类的内容同样的话，那仍是单独定义实现类更方便。

public class AnonymityTest2 {
    public static void main(String[] args) {
        MyInteface my1 = new MyInteface(){
            @Override
            public void method() {
                System.out.println("匿名内部类方法");
            }
        };
        my1.method();
        MyInteface my2 = new MyInteface(){
            @Override
            public void method() {
                System.out.println("匿名内部类方法");
            }
        };
        my2.method();
    }
}
复制代码

2.【匿名对象】表示，在调用方法时，只能调用惟一一次。

　　　　若是但愿同一对象，调用屡次方法，那么仍是给对象起个名把。

new MyInteface(){
            @Override
            public void method1() {
                System.out.println("匿名内部类方法1");
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类方法2");
            }
        }.method1();
        
        new MyInteface(){
            @Override
            public void method1() {
                System.out.println("匿名内部类方法1");
            }
            @Override
            public void method2() {
                System.out.println("匿名内部类方法2");
            }
        }.method2();
复制代码

3.二者不是一回事

【匿名内部类】是省略了 <实现类 / 子类>

【匿名对象】是省略了 <对象名称>

二者不是一回事。

public class AnonymityTest {
    public static void main(String[] args) {
        fun1();
    }

    private static void fun1() {
        // 对于 Thread 来讲，这就是【匿名对象】
        // 对于 Runnable 来讲，这就是【匿名内部类】
        new Thread( new Runnable(){
            @Override
            public void run() {

            }
        }).start();
    }
}
复制代码