JAVA笔记——内部类详解

感想：现在越发的觉得自己的基础知识薄弱，java基础没学好。打好基础，才是迈向成功的第一步。

内部类种类

内部类分为四种：普通内部类、局部内部类、静态内部类、匿名内部类。现在仔细的讲一讲。

1.普通内部类

第一种，普通内部类，可以访问外部类的所有成员变量以及方法。而外部类想要访问内部类的方法或者变量，需要先创建内部类对象，然后才能访问，值得注意的是，外部类获得内部类对象后，可以通过 “.” 直接访问内部类的私有成员。修饰符可以实private\protected\public\默认

案例：

public class CommonInnerClass {
    private String name;
    private static final String staticName = "静态姓名";

    public CommonInnerClass(String name) {
        this.name = name;
    }

    public void printInnerClassVar(){
        InnerClass innerClass = new InnerClass();
        System.out.println(innerClass.nickname);
    }

    private class InnerClass{
        private String nickname = "昵称";

        public String getNickname() {
            return nickname;
        }

        public void setNickname(String nickname) {
            this.nickname = nickname;
        }

        public void printOutClassVar(){
            //内部类可以方法外部类的所有成员和方法
            System.out.println(name);
            System.out.println(staticName);
        }
    }

    public static void main(String[] args) {
        CommonInnerClass commonInnerClass = new CommonInnerClass("张三");
        commonInnerClass.printInnerClassVar();

        InnerClass innerClass = commonInnerClass.new InnerClass();
        innerClass.printOutClassVar();

    }
}

2.局部内部类

第二种，局部内部类，局部内部类是定义在方法或者某个作用域里面，在jdk8中，能访问该方法或作用域以及外部类里面的所有变量（private public prote、非final字段）,局部内部类不能有类修饰符

public class MethodInnerClass {

    private String name = "OutName";
    private final String finalName = "finalName";

    public void MethodClass(){
        String name = "MethodName";
        class innerClass{
            public innerClass() {
            }

            public void printVar(){
                //这里访问了外部类的private字段（没用final修饰）
                System.out.println("MethodClass的Name字段："+name);
                System.out.println("外部类的Name字段："+MethodInnerClass.this.name);

            }
        }
        innerClass innerClass = new innerClass();
        innerClass.printVar();
    }

    public static void main(String[] args) {
        new MethodInnerClass().MethodClass();
    }
}

3.静态内部类

第三种，静态内部类，静态内部类只能访问外部类中被static修饰的变量或者方法。静态内部类通过 new 外部类.内部类()的方法获取对象。静态内部类可以有静态/非静态的变量和方法。静态方法可以直接调用，静态方法里卖弄的变量只能是静态变量。

案例：

public class StaticInnerClass {


    private String name1 = "一般名称";
    private static String staticName = "静态名称";

    private static class InnerClass{
        //非静态变量
        private String name = "内部类名称";
        //通过内部类对象调用
        public void printVar(){
            System.out.println(this.name);
            System.out.println(staticName);
        }

        //
        public static void printVar2(){
           // System.out.println(this.name);  这里是静态方法，只能访问静态变量
            System.out.println(staticName);
        }
    }
    public static void main(String[] args) {
        //通过对象访问普通方法
        InnerClass innerClass = new StaticInnerClass.InnerClass();
        innerClass.printVar();
        //直接调用内部类的static方法
        StaticInnerClass.InnerClass.printVar2();
    }
}

4.匿名内部类

第四种，匿名内部类，匿名内部类在做安卓开发的适合使用的特别多，匿名内部类是唯一一个没用构造函数的类我们直接重写接口方法即可。不用去写一个接口的实现类，然后再new一个对象。大大提高了我们的开发速度。
案例：

public class annoClass {


    public static void main(String[] args) {
        //使用匿名类开启线程任务
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类");
            }
        }).start();

        //使用接口实现方式开启线程任务。
        RunnableImpl runnable = new RunnableImpl();
        new Thread(runnable).start();

    }

}

class RunnableImpl implements Runnable {

    @Override
    public void run() {
        System.out.println("使用实现类的方式调用");
    }
}

总结：内部类我们再实际开发中经常用到。其实我们平常用到的大多数是普通内部类、匿名内部类和静态内部类。其他的我倒是没怎么使用。内部类也是面试会问的问题。