java内部类学习与总结

我们经常会看到诸如此类的代码：

class A {
    double i = 0;

    public Circle(double radius) {
        this.i = i;
    }

    class B {     //内部类
        public void print() {
            System.out.println("这是内部类");
        }
    }
}

在java中，我们称它为内部类，顾名思义就是在一个类的内部再写一个类的形式，内部类是一种非常有用的特性，它允许你把一些逻辑相关的组织在一起，并控制位于内部类的可视性。

内部类的分类：

1. 常规内部类
2. 静态内部类
3. 匿名内部类
4. 局部内部类

我们先从最简单的常规内部类说起介绍起吧~

常规内部类

代码如下所示：

public class Outter {
    class Inner{
        int i;
        public Inner() {
            i=1;
            System.out.println("Inner内部类产生了");
        }

    }
    public Outter() {
        System.out.println("Outter外部类产生了");
    }
}

********
Outter outter=new Outter();
Outter.Inner inner=outter.new Inner();
//Outter.Inner in=new Outter().new Inner()也可以实现上述相同的效果

输出结果：

这里进行说明：当我们需要去掉用常规内部类的时候，我们需要通过如下的格式去调用:OutterClassName.InnerClassName，好了，用法介绍完毕了，但是你可能会问为什么要用内部类，我在外部类中不一样也可以实现内部类的功能么？

考虑这样的一种情况，当我的一个类要实现接口的时候，我又不想把这个接口公开出来，那该怎么做呢？这时候我们就可以使用内部类进行处理,看代码：

//接口
public interface PrivateMethod {
    void cout();
}
*****
public class Outter {
    class Inner implements PrivateMethod{
        int i;
        public Inner() {
            i=1;
            System.out.println("Inner内部类产生了");
        }
        @Override
        public void cout() {
            System.out.println("我不想让别人知道Outter实现PrivateMethod接口");

        }

    }
    public Outter() {
        System.out.println("Outter外部类产生了");
    }
}
****
{
        Outter outter=new Outter();
        Outter.Inner inner=outter.new Inner();
        inner.cout();
}

结果如下图所示：

这里我们可以看到，我们隐藏了PrivateMethod这个接口对于Outter的实现细节，相当于private修饰符的作用，保证了我们代码不对外公开，只提供实现，很好的保护了代码的安全性。

注意：普通的类(非内部)，不能声明为private或者protected，他们只可以被赋予public或者默认包的访问权限。

匿名内部类

代码如下图所示：

public PrivateMethod newInstance(){
        return new PrivateMethod() {

            @Override
            public void cout() {
                System.out.println("我是匿名内部类");

            }
        };
    }
*****main中的代码
        Outter outter=new Outter();
//      Outter.Inner inner=outter.new Inner();
//      inner.cout();
        outter.newInstance();

我们可以看到结果显示：

在这里我们通过一个方法(其返回值是接口类型)，返回了一个接口实现，但是我们可以看到，在其中我们并没有定义一个变量，而是直接通过new PrivateMethod的形式去实现。关于匿名内部类，在android中，我们经常可以看到:

 iv.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {

            }
        });

这就是一个比较常规的实现，关于匿名类，就介绍道这里。

静态内部类(内嵌内部类)

一般而言(除了静态内部类)，内部类都会保存一个”隐藏”的应用去指向外部类，如果我们不需要引用，也就是内部类的实现与外部类无关，我们可以定义成static class，定义完后就意味着：
1.要创建嵌套类，并不需要其外部类的对象
2.不能从嵌套类的对象中访问非静态的外围类对象

嵌套类还跟常规内部类有一个区别，常规类的字段与方法中，不能放在嵌套类中，反之，也成立。

Outter.class

public static  void say(){
            System.out.println("静态内部类");
        }
    }
******
Outter.staticMethod.say();

我们在Outter.class添加上述代码，在主方法中直接调用Outter.staticMethod.say()，就产生如下的结果:

局部内部类

典型的局部内部类是在一个方法体中创建，局部内部类不能有访问说明符，因为他不是外部类的一部分，但是它可以访问当前代码块的常量以及外围类的所有成员：

//接口类
public interface MyInterFace {
    void getJuBu();
}

//外部类

public class Outter2 {
    MyInterFace getInstance(){
        class InnerJuBu implements MyInterFace{
            @Override
            public void getJuBu() {
            System.out.println("这是局部内部类的实现");   
            }
        }
        return new InnerJuBu();
    }
}
//主方法
Outter2 outter2=new Outter2();
outter2.getInstance();

实现结果：

我们在getInstance()方法中实现了一个返回值为InnerJuBu的内部类，最终向外传递这个内部类，实现类局部内部类的调用。

---

关于内部类的继承：
因为内部类的构造器必须连接到指向其外部类对象的引用，所以在继承内部类的时候，事情会变得有些复杂，主要在于，必须要让秘密的引用初始化，详细的代码如下图所示：

public class Outter2 {
    class Inner{

    }
}

public class InnerExtends extends Outter2.Inner {
    public InnerExtends(Outter2 outter) {
        outter.super();
    }

}

我们看到如果要继承一个内部类，必须要首先继承Outter2.Inner这个内部类，然后我们在其构造函数中调用outter.super()方法，这样就可提供内部类必要的引用，程序才会编译通过。

内部类是否被覆盖：

class Out{
     protected class In{
     }
}

class Demo extends Out{
     public class In{
     }
}

如同上述代码，即是我们在Demo中写了In类，java会认为这是一个全新的类，并不认为这是从父类，也就是Out这个类中继承过来的，如果要继承，应该通过如下的方式：

class Out{
     protected class In{
     }
}

class Demo extends Out {
     public class In extends Out.In{
     }
}

通过继承的方式，我们去重载相关方法实现覆盖。

内部类标识符：
由于每个类都会产生一个.class文件，其中包含了如何创建该类型的对象的全部信息(此信息产生一个”meta-class”，叫做class对象)，内部类也必须产生一个.class文件包含他们的class信息，这些类文件有严格的规则：外部类的名字，加上”$”，再加上内部类的名字如：

class Out{
     protected class In{
     }
}

编译过后则会产生一个Out.class文件以及一个Out$In.class文件，如果内部类是匿名的，则会简单的产生一个数字作为标识符，如Out$1.class

---

为什么需要内部类：
一般来说，内部类继承了某个类或实现某个接口，内部类操作外部类的对象，所以可以认为是内部类提供了某种进入外围类的窗口。
内部类最重要的原因是：

每个内部类都能独立继承一个(接口的)实现，无论外围伦是否已经继承了某个(接口的)实现，对于内部类来说都没有影响。

我们可以借助内部类实现多重继承(若拥有的是抽象或者具体的类，而不是接口)
如:

class D{}
abstract class E{}

class Z extends D{
     E makeE(){
         return new E();
     }

参考文献及资料：
1.《java编程思想》