内部类详解！！！

概述：

把类定义在其他类的内部，这个类就称为内部类。

特点：

1、内部类可直接访问外部类的成员，包括私有成员。
2、外部类访问内部类，必须创建对象。

成员内部类

成员内部类（非静态）
外部类.内部类 对象名 = new 外部类().new 外部类();
成员内部类（静态）
外部类.内部类 对象名 = new 外部类().内部类();

package org.wdzl.unit04;

/**
 * 成员内部类的修饰符
 *   private：为了提高数据的安全性，
 *        案例：每一台电脑都有CPU
 *
 * class Computer{
 * //内部类
 *    private class CPU{
 *        public void method(){
 *            System.out.println("改装成水冷")
 *        }
 *    }
 *    public void function(){
 *        if(你是专业人士){
 *            CPU cpu = new CPU();
 *            cpu.method();
 *        }
 *    }
 *
 * }
 * //使用内部类功能
 * Computer.CPU cc = new Computer().new CPU();
 * cc.method();
 */
class Outer3{
    private int num = 10;
    static int num2 = 20;


    public static class Inner3{
        public void show(){
            System.out.println(num2);
        }
        public static void show2(){
            System.out.println(num2);
        }
    }

}

public class InnerDemo3 {
    public static void main(String[] args) {
        //成员内部类被static修饰后的访问方式。
        //格式：外部类名.内部类名 对象名 = new 外部类名().内部类名();
        Outer3.Inner3 oi = new Outer3.Inner3();
        oi.show();
        oi.show2();
    }
}

局部内部类

特点：
1、局部变量访问成员变量，该成员变量必须加final关键字。

package org.wdzl.unit04;

/**
 * 局部内部类：
 *    1、局部内部类可以直接访问外部类的成员
 *    2、访问局部内部类里方法，在局部创建内部类的对象，再通过对象去调用内部类中的方法。
 *  面试题：
 *     局部内部类访问局部变量注意事项：
 *       因为局部内部类与局部变量生命周期冲突，所以加入final关键字来解决这个冲突
 *       冲突：
 *         1、局部内部类存储在堆内存当中，方法执行完毕后，它不会被立即回收
 *         2、局部变量存储在栈内存中，方法执行完毕后，会被立即回收
 *         3、局部变量被回收，但是局部内部类中还有对局部内部类的调用。
 *         4、final关键字修饰的变量会变成常量，它的存储区域会改变到堆内存当中。
 *
 *
 */
public class InnerDemo4 {
    public static void main(String[] args) {
        Outer5 outer5 = new Outer5();
        outer5.method();
    }
}
class Outer5{
    public int num = 5;
    private int num2 = 10;
    public void method(){
        int num3 = 20;
        //局部内部类
        class Inner5{
            public void showInfo(){
                System.out.println(num);
                System.out.println(num2);
                System.out.println(num3);
            }
        }
        //只能在成员方法创建成员内部类对象，因为它是在成员方法内的，作用域也在成员方法之中。
        Inner5 inner5 = new Inner5();
        inner5.showInfo();
    }
}

匿名内部类

概述： 内部类的简化
前提： 存在一个类（抽象类）或者接口
格式： new 类名或者接口名(){重写方法};

面试题

package org.wdzl.unit04;

/**
 * 1、内部类与外部类不是继承关系
 * 2、通过外部类名限定this
 *     格式：外部类.this.num；
 */
public class Test {
    public static void main(String[] args) {
        Outer4.Inner4 oi = new Outer4().new Inner4();
        oi.show();
    }
}
class Outer4{
    public int num = 10;
    class Inner4 extends Object{
        public int num = 20;
        public void show(){
            int num = 30;
            System.out.println(num);
            System.out.println(this.num);
            //方式1
            System.out.println(new Outer4().num);
            //方式2
            System.out.println(Outer4.this.num);
        }
    }
}

面试题

package org.wdzl.unit04;

/**
 * 匿名对象面试题：补全代码输出："HelloWorld"
 */

interface Inter7{
    void show();//接口中的方法默认是public abstract
}
class Outer7{
    //补全代码
    //1、 Outer7.method()：所以我们知道method方法是一个静态方法。
    //2、Outer7.method().show();可知：Outer7.method()执行的结果应该是返回了一个对象，只有对象才能继续调用方法。
    //         又由接口Inter得知，method返回的结果应该是Inter接口的实现类对象。
    public static Inter7 method(){
        return new Inter7(){
            @Override
            public void show() {
                System.out.println("Hello World");
            }
        };
    }
}
public class Test1 {
    public static void main(String[] args) {
        Outer7.method().show();
    }
}