java 内部类

一、概念

        一般情况下，类和类之间是互相独立的，内部类的意思是打破这种独立，让一个类成为另外一个类的内部信息，和成员变量、成员方法同等级别。

二、分类

        内部类分为四种：成员内部类、静态内部类、局部内部类和匿名内部类。

三、好处

        1、Java 语言具有单继承的特性，内部类可以继承于其他类，达到类似于多继承的效果。

        2、将类隐藏起来，可以更好的控制类的访问权限。

        3、可以帮助我们减少定义类的步骤。

四、成员内部类

4.1 定义

         成员内部类是定义在外部类的成员位置上。

4.2 语法

public class Outer {
    // 定义一个成员内部类
    class Inner {
    }
}

4.3 特点

        1、成员内部类可以直接访问外部类的所有成员，包括私有的成员变量。

        2、外部类调用成员内部类的方式为：先创建对象，再访问。

4.4 实例

public class Outer {
    private int num = 10;
    public void method() {
        Inner i = new Inner();
        i.show();
    }
    class Inner {
        public void show() {
            // 直接访问外部类的私有变量
            System.out.println(num);
        }
    }
}

// 测试类
public class InnerDemo {
    public static void main(String[] args) {
		Outer.Inner oi = new Outer().new Inner();
		oi.show();

        Outer o = new Outer();
        o.method();
    }
}

五、静态内部类

5.1 定义

         静态内部类是定义在外部类的成员位置上，并使用 static 关键字修饰。

5.2 语法

public class Outer {
    // 定义一个静态成员内部类
    static class Inner {
    }
}

5.3 特点

        1、静态内部类只能访问外部类中被 static 修饰的属性和方法，包括私有的。

        2、静态内部类的实例对象可以单独存在，不再依附于外部类对象。

5.4 实例

public class Outer {
    private static int num = 10;
    public void method() {
        Inner i = new Inner();
        i.show();
    }
    static  class Inner {
        public void show() {
            System.out.println(num);
        }
    }
}

// 测试类代码如下
public class Test {
    public static void main(String[] args) {
        // 不用再重新 new 内部类对象了
        Outer.Inner oi = new Outer.Inner();
        oi.show();

        Outer o = new Outer();
        o.method();
    }
}

六、局部内部类

6.1 定义

        局部内部类是定义在方法里面的类，作用范围仅限该方法之中。

6.2 语法

public class Outer {

    public void loadInnerClass{    
        // 定义一个局部内部类
        class Inner {
        }
    }
}

6.3 特点

        1、局部内部类可以直接访问外部类的所有成员，包括私有的成员变量。还可以访问所处方法中的局部变量。

        2、局部内部类只能在定义它的方法中访问。

6.4 实例

public class Outer {
    private String name;
    private int age;

    private void sayHello() {
        System.out.println("Hello World");
    }
    public void localInnerClass() {
        String localName = "localInnerClass";
        class LocalInner {
            public void test() {
                System.out.println(localName);
                System.out.println(name);
                System.out.println(Outer.this.age);
                sayHello();
            }
        }
        LocalInner localInner = new LocalInner();
        localInner.test();
    }
}

// 测试代码如下
public class Test {
    public static void main(String[] args) {
        Outer oi = new Outer();
        oi.localInnerClass();
    }
}

七、匿名内部类

7.1 定义

        没有类名的局部内部类就是匿名内部类，也是在方法里面定义的。

7.2 语法

public class Outer {

    public void loadInnerClass{        
        // 定义一个匿名内部类
        new Inner() {
        }
    }
}

7.3 特点

        1、匿名内部类可以直接访问外部类的所有成员，包括私有的成员变量。

        2、匿名内部类只有所在包的类可以访问。

        3、匿名内部类类中不能存在被 static 修饰属性和方法。

7.4 实例

// 使用了并发编程常用的 Runnable 接口，接口是不能被实例化的
// 我们想要得到一个 Runnable 接口的实例，但是又不想创建一个类来实现它，
// 就可以采用匿名内部类的方式
public class Outer {
    private String name;
    private int age;

    private void sayHello() {
        new Runnable(){
            private String noneName;
            private void test(){
                System.out.println(name);
                System.out.println(Outer.this.name);
            }
            @Override
            public void run() {
                System.out.println("我是一个匿名内部类");
                test();
            }
        }.run();
    }
}

// 测试代码如下
public static void main(String[] args) {
	Outer oi = new Outer();
	oi.sayHello();
}