day13 内部类（inner class）

类的五大成员

属性、方法、构造器、代码块、内部类

什么是内部类（inner class）

在一个类的内部声明的另一个类，称为内部类。而嵌套该内部类的类称为外部类（outer class）
内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类的包含关系。

基本语法

class A{// 外部类
	class B{}// 内部类
}
class C{} // 外部其他类

内部类的分类

定义在外部类的局部位置上（如方法内）

1. 局部内部类（有类名）
2. 匿名内部类（无类名）

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

3. 成员内部类（无static修饰）
4. 静态内部类（有static修饰）

局部内部类

package com.yusa.innerclass;

public class OuterClass {
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.method1();

    }

    int n1=3;
    public void method1(){

        class LocalInnerClass{
            int n1=2;
            void localInnerMethod() {
                //直接使用外部类的方法
                method2();
                // 通过在this前加类名来区分n1的来源
                System.out.println(OuterClass.this.n1);
                // this指代的是内部类
                System.out.println(this.n1);
                System.out.println(n1);
            }
        }
        LocalInnerClass localInnerClass = new LocalInnerClass();
        localInnerClass.localInnerMethod();

    }
    public void method2(){}
}
//3
//2
//2

匿名内部类

主要作用：简化语法
有些类只需要使用一次，在之后不会再使用，声明起来会比较繁琐，因为设计出匿名类的使用。
因为语法必定在方法中使用的缘故（有方法就一定有一个外部类），该匿名类必定是内部类，所以叫作匿名内部类。
匿名内部类的声明和创建对象绑定执行，声明匿名内部类后，它的对象随即被创建。
匿名内部类只能使用一次，但是匿名内部类的对象可以使用多次。

基于接口的匿名内部类的使用

首先来看interface的匿名内部类的使用。当实现接口时，需要定义一个类去实现，若该类只用一次，则可以声明成匿名的形式。
语法：

IA ia = new IA() {
// 重写接口内容和匿名内部类的内容
}

public class AnonymousInnerClass {
    public static void main(String[] args) {
        AnonymousInnerClass anonymousInnerClass = new AnonymousInnerClass();
        anonymousInnerClass.method();
    }
    void method(){
    	// 接口类型指向了右边new出来的匿名内部类。实际上的声明式这样的，该类是匿名的且只能使用一次
    	// 	class AnonymousInnerClass$1 implements IA{
    	// 		@Override
        // 		public void cry() {
        // 			System.out.println("AnonymousInnerClass...");
        //   	}
		// } 
		// 向上转型
		// IA ia = new AnonymousInnerClass$1();
		// 编译类型是IA，运行类型是IA接口的实现类匿名内部类
        IA ia = new IA() {
            @Override
            public void cry() {
                System.out.println("AnonymousInnerClass...");
            }
        };
        ia.cry();
        System.out.println(ia.getClass());
    }
}
// 接口
interface IA{
    void cry();
}
//AnonymousInnerClass...
//class com.yusa.innerclass.AnonymousInnerClass$1

基于类的匿名内部类的使用

其次再看class的匿名内部类的使用。当继承一个类时，需要定义一个类去继承，若该类只用一次，则可以声明成匿名的形式。

语法：

Father fa  = new Father() {
// 匿名内部类的实现
};

package com.yusa.innerclass;

public class AnonymousInnerClass {
    public static void main(String[] args) {
        AnonymousInnerClass anonymousInnerClass = new AnonymousInnerClass();
        anonymousInnerClass.method();

    }
    void method(){
//        class AnonymousInnerClass$1 extends Father{
//            @Override
//            void m() {
//                System.out.println("AnonymousInnerClass");
//            }
//        }
//        向上转型
//        Father fa = new AnonymousInnerClass$1();
//      编译类型是Father，运行类型是Father的子类匿名内部类。
        Father fa  = new Father() {
            @Override
            public void m() {
                System.out.println("AnonymousInnerClass...");
            }
        };
        fa.m();
        System.out.println(fa.getClass());
    }
}

class Father{
    void m(){}
}

匿名内部类如果继承的是抽象（abstract）类，则必须实现所有的抽象方法

匿名内部类的使用

匿名内部类的对象作为参数

public class AnonymousInnerClass {
    public static void main(String[] args) {
        AnonymousInnerClass anonymousInnerClass = new AnonymousInnerClass();
        anonymousInnerClass.method(new IA() {
            @Override
            public void m() {
                System.out.println("anonymousInnerClass...");
            }
        });

    }
    void method(IA ia){
        ia.m();
    }
}
interface IA{
    void m();
}

成员内部类

没有static修饰

class Outer{
    int n1=10;
    class Inner{
        // 直接使用外部类的属性
        int n2=n1;
    }
}

外部其他类使用内部类的两种方法

1.先创建外部类的对象，用外部类的对象去new内部类的对象

public class NumberInnerClass {
    // 先创建外部类的对象，用外部类的对象去new内部类的对象
    Outer outer =new Outer();
    Outer.Inner inner = outer.new Inner();
}
class Outer{
    int n1=10;
    class Inner{
        // 直接使用外部类的属性
        int n2=n1;
    }
}

2.在外部类声明一个get方法，返回Inner类的实例

public class NumberInnerClass {
    Outer outer =new Outer();
    Outer.Inner inner = outer.getInner();
}
class Outer{
    int n1=10;
    class Inner{
        // 直接使用外部类的属性
        int n2=n1;
    }
    public Inner getInner(){
        return new Inner();
    }
}

静态内部类

有static修饰

class Outer{
    static int n1=10;
    static class Inner{
        // 直接访问外部类的静态成员，非静态的不可以访问
        int n2=n1;
    }
}

外部其他类使用静态内部类的两种方法
1 外部类名.静态内部类名 引用名= new 外部类名.静态内部类名();

public class NumberInnerClass {
    Outer.Inner inner = new Outer.Inner();
}
class Outer{
    static int n1=10;
    static class Inner{
        // 直接访问外部类的静态属性
        int n2=n1;
    }
}

2.编写一个方法返回静态内部类的对象，这个方法可以加static修饰符，省去了创建对象的步骤。

public class NumberInnerClass {
    Outer.Inner inner = Outer.getInner();
}
class Outer{
    static int n1=10;
    static class Inner{
        // 直接访问外部类的静态属性
        int n2=n1;
    }
    public static Inner getInner(){
        Inner inner = new Inner();
        return inner;
    }
}

小结