Java基础|内部类还有这些骚操作

在一个类中存在的其他类，叫做内部类。

1 内部类作用

1. 内部类可以很好的实现隐藏，对同一个包中的其他类不可见。一般的非内部类，是不允许有 private 与 protected 权限的，但内部类可以。

2. 内部类拥有外围类的所有元素的访问权限。

3. 使一个类间接实现多重继承。

4. 当定义一个回调函数，使用匿名内部类会使代码变得简洁（匿名内部类应实现接口或是继承一个基类）。

2 内部类原理

内部类既可以访问自身的数据域，也可以访问创建它的外围类对象的数据域。

5. 内部类的对象有一个隐式的引用，它引用了实例化该内部对象的外围类对象。对外围类的引用在构造器中设置，编译器修改了内部类的构造器，添加了外围类引用参数。故可以访问外围类对象的所有属性。

6. 内部类是一种编译器现象与虚拟机无关。

3 内部类分类

局部内部类

1. 定义在一个方法中的类，是局部内部类。不能用 public 或 private 声明。作用域限定在声明这个局部类的块中。

2. 局部内部类可访问包含它的外部类，还可访问这个块中（局部类外）final 属性（即为 final 的局部变量）。

匿名内部类

1. 只创建一个类的对象，就不需要命名。匿名内部类无构造器，取而代之是将构造器参数传递给超类构造器；当匿名内部类实现接口的时候，无构造参数。
2. 多用匿名内部类实现事件监听器和其他回调。现推荐用 lambda 表达式。

静态内部类

1. 当使用内部类只是为了把一个类隐藏在另外一个类的内部，并不需要内部类引用外围类对象。可将内部类声明为 static，以便取消产生的引用。
2. 静态内部类与常规内部类不同，静态内部类可以有静态域和方法。

4 内部类间接多继承用例

ClassA 基类

/**
 * @version $Id: ClassA.java, v 0.1 2017年7月23日 上午10:51:08
 */
public class ClassA {
    public void printA(String ags)
    {
        System.out.println("[ClassA]--printA()--ags:"+ags);
    }
}

ClassB 基类

/**
 * @version $Id: ClassB.java, v 0.1 2017年7月23日 上午10:51:25
 */
public class ClassB {
    public void printB(String ags)
    {
        System.out.println("[ClassB]--printB()--ags:"+ags);
    }
}

Printable 接口

/**
 * @version $Id: Printable.java, v 0.1 2017年7月23日 上午10:52:02
 */
public interface Printable {
    public void print();
}

ClassInner 类（间接多继承）

/**
 * @version $Id: ClassInner.java, v 0.1 2017年7月23日 上午10:55:02
 */
public class ClassInner implements Printable {
    //外部类成员
    private String outerName = "outerName";
    private int    outerAge;
    public void pirntName() {
        System.out.println("[ClassInner]--outerName:" + outerName);
    }
    public void printAge() {
        System.out.println("[ClassInner]--outerAge:" + outerAge);
    }

    /**
     * 继承ClassA
     * @version $Id: ClassInner.java, v 0.1 2017年7月23日 下午5:09:44
     */
    private class InnerClassA extends ClassA {
        //内部类使用外部类的成员
        private String innerAName = outerName;
        //内部类使用外部类的成员
        public void printInnerA() {
            print();
            pirntName();
            printAge();
            System.out.println("[outerName]:" + innerAName);
        }
        //内部类构造器
        public InnerClassA() {
            super();
        }
    }

    /**
     * 继承ClassB，间接多继承
     * @version $Id: ClassInner.java, v 0.1 2017年7月23日 下午5:09:48
     */
    public class InnerClassB extends ClassB {
        private String innerBName;
        public InnerClassB() {
            super();
        }
        //内部类构造器
        public InnerClassB(String innerBName) {
            super();
            this.innerBName = innerBName;
        }

        public String getInnerBName() {
            return innerBName;
        }
        public void setInnerBName(String innerBName) {
            this.innerBName = innerBName;
        }
    }

    /**
     * 获取内部类实例方法
     * @return
     */
    public InnerClassA getInnerClassA() {
        return new InnerClassA();
    }

    /**
     * 获取内部类实例方法
     * @return
     */
    public InnerClassB getInnerClassB() {
        return new InnerClassB();
    }

    /** 
     * @see InnerClass.Printable#printable()
     */
    @Override
    public void print() {
        System.out.println("[Printable]--print()");
    }

    public String getOuterName() {
        return outerName;
    }

    public void setOuterName(String outerName) {
        this.outerName = outerName;
    }

    public int getOuterAge() {
        return outerAge;
    }

    public void setOuterAge(int outerAge) {
        this.outerAge = outerAge;
    }

    /**
     * 测试用例
     */
    @Test
    public void test() {
        //内部类测试用例
        InnerClassA innerClassA = this.getInnerClassA();
        innerClassA.printInnerA();
    }
}

TestCase 测试用例

/**
 * @version $Id: TestCase.java, v 0.1 2017年7月23日 上午10:51:34
 */
public class TestCase {
    @Test
    public void test() {
        ClassInner classInner = new ClassInner();
        classInner.setOuterName("outerName");
        classInner.setOuterAge(20);
        //继承接口的方法
        System.out.println("----继承接口的方法----");
        classInner.print();
        //外部类自己的成员方法
        System.out.println("----外部类成员方法----");
        classInner.printAge();
        classInner.pirntName();
        //创建内部类，方法一通过外部类对象创建,内部类修饰符是private则只能在它的外部类范围使用
        InnerClassB innerClassB1 = classInner.new InnerClassB("innerBName1");
        //创建内部类，方法二在外部类中提供一个获取内部类实例的方法，这种方式常推荐
        InnerClassB innerClassB2 = classInner.getInnerClassB();
        //内部类继承它的父类方法
        System.out.println("----内部类继承父类的方法----");
        innerClassB1.printB(innerClassB1.getInnerBName());
        innerClassB2.setInnerBName("innerClassB2");
        innerClassB2.printB(innerClassB2.getInnerBName());
        //内部类只能在它的内部获取并使用它的外部类成员
        //innerClassB1.print();//错误
    }
}