内部类详解

1. 作用

1. 采用内部类这种方式，可以隐藏细节和内部结构，封装性更好，让程序的结构更加合理。
		例如：封装的XML的所有类太多，全部类分开写也可以，但是相互调用组装太麻烦。就可使用内部类的方式解决

2. 分类

• 非静态内部类

  • 类中
  • 方法体中的内部类

• 静态内部类

3. 非静态内部类

/**
 * 非静态内部类详解
 */
public class InnerClass {

    private String name;

    private void method() {
        // 本类的方法中创建本类的非静态内部类不需要依赖外部类的对象来创建，可直接new创建
        Inner inner = new Inner();
        inner.InnerMethod();
        System.out.println("外部类成员方法");
    }

    // 类中非静态内部类
    public class Inner {
        private String InnerName;
       	// 非静态内部类不能拥有static静态成员变量和静态方法
        private void InnerMethod() {
            String methodName = "method";
            System.out.println("非静态内部类非静态方法");
            System.out.println(methodName);
            // 访问本内部类的成员变量
            System.out.println(this.InnerName);
            // 非静态内部类使用外部类非静态成员变量
            System.out.println(InnerClass.this.name);
        }
    }

    public void outerMethod() {
        /**
         * 方法体中的内部类
         * 注意：由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和
         * static修饰符。
         */
         class InnerClazz {
            public void InnerMethod() {
                System.out.println("方法体中的非静态内部类，只能在外部类的本方法中使用。");
            }
        }
        // 外部类方法中调用该方法体中的内部类
        InnerClazz innerClazz = new InnerClazz();
        innerClazz.InnerMethod();
    }

    public static void main(String[] args) {
        InnerClass innerClass = new InnerClass();
        innerClass.method();

        // 创建非静态内部类。因为非静态内部类相当于外部类的成员变量，需要通过外部类对象来new的方式创建
        InnerClass.Inner inner = innerClass.new Inner();
    }
}

4. 静态内部类

/**
 * 静态内部类详解
 */
public class InnerClass {
    private String name;
	private static String id;
	
    // 类中静态内部类，和外部类相当于分开的两个类
    public static class Inner {
        private String InnerName;
        private static String InnerId;

        private void innerMethod() {
           	System.out.println("静态内部类非静态方法");
            System.out.println(Inner.this.InnerName);
            System.out.println(Inner.InnerId);
            System.out.println(InnerClass.id);
            // 静态内部类的非静态方法中，不能（编译不通过）访问外部类的非静态成员变量
            System.out.println(InnerClass.this.name);
        }
        private static void InnerMethod() {
            System.out.println("静态内部类静态方法");
            // 静态内部类的静态方法中，不能（编译不通过）访问本内部类的非静态成员变量
            System.out.println(Inner.this.InnerName);
            System.out.println(Inner.InnerId);
            System.out.println(InnerClass.id);
            // 静态内部类的静态方法中，不能（编译不通过）访问外部类的非静态成员变量
            System.out.println(InnerClass.this.name);
        }
    }

    public static void main(String[] args) {
        InnerClass innerClass = new InnerClass();

        // 创建静态内部类。因为静态内部类相当于外部类的静态成员变量或方法，不再依赖对象，可直接通过new创建该静态内部类。
        InnerClass.Inner inner = new Inner();
    }
}

5. 匿名内部类

• 好处：定义好接口即可，不需要单独实现接口。而是在使用接口时才匿名实现，编码方便。

  缺点：耦合太高，将接口实现类同调用者耦合在了一起。而单独实现接口的类的方式则耦合度低

// 接口
public interface Miui {
    // 接口抽象方法
    public void run();
}

// 接口实现类
public class MiuiImpi implements Miui {
    
    @Override
    public void run() {
        System.out.println("接口实现类的重写方法");
    }
}

public class Test {
    public static void main(String[] args) {
        // 通过实现类调用
 		Miui miui = new MiuiImpi();
        miui.run();
        
        /**
         * 通过匿名内部类实现接口，该接口的实现没有名称即匿名内部类。
         * 注意：变量的名称并不是接口实现类的名称，接口的实现类是匿名的
         */
        Miui mu = new Miui() {
            @Override
            public void run() {
                System.out.println("匿名内部类重写方法");
            }
        }
    }
}

5.1 通过内部类实现接口

// 接口
public interface Miui {
    // 接口抽象方法
    public void run();
}

public class Test {
    
     // 内部类实现接口
    public class MiuiImpi implements Miui {

        @Override
        public void run() {
            System.out.println("接口实现类的重写方法");
        }
    }
    
    public static void main(String[] args) {
        Test test = new Test();
        // 通过非静态内部实现类调用
 		Miui miui = test.new MiuiImpi();
        miui.run();
    }
}