java 内部类和静态内部类的区别和使用方法

      在Java代码的实现过程中，我们经常会使用内部类，内部类的使用也是非常多的，现在罗列一下当前的内部类的知识。

下面说一说内部类（Inner Class）和静态内部类（Static Nested Class）的区别：

1） 非静态内部类有一个很大的优点：可以自由使用外部类的所有变量和方法 。

2） 静态内部类的作用：只是为了降低包的深度，方便类的使用，静态内部类适用于包含类当中，但又不依赖与外在的类，不用使用外在类的非静态属性和方法，只是为了方便管理类结构而定义。在创建静态内部类的时候，不需要外部类对象的引用。

根据Oracle官方的说法：

Nested classes are divided into two categories: static and non-static. Nested classes that are declared static are called static nested classes. Non-static nested classes are called inner classes.

从字面上看，一个被称为静态嵌套类，一个被称为内部类。

从字面的角度解释是这样的：

什么是嵌套？嵌套就是我跟你没关系，自己可以完全独立存在，但是我就想借你的壳用一下，来隐藏一下我自己。

因此，静态内部类的设计天生就是为建造者模式的设计开了一道门。

(1)创建实例

   OutClass.InnerClass obj = outClassInstance.new InnerClass(); //注意是外部类实例.new，内部类

   AAA.StaticInner in = new AAA.StaticInner();//注意是外部类本身，静态内部类

(2)内部类中的this

    内部类中的this与其他类一样是指的本身。创建内部类对象时，它会与创造它的外围对象有了某种联系，于是能访问外围类的所有成员，不需任何特殊条件，可理 解为内部类链接到外部类。 用外部类创建内部类对象时，此内部类对象会秘密的捕获一个指向外部类的引用，于是，可以通过这个引用来访问外围类的成员。

（3）静态内部类

    关键字static中提到Static可以修饰成员变量、方法、代码块，其他它还可以修饰内部类，使用static修饰的内部类我们称之为静态内部类，不过我们更喜欢称之为嵌套内部类。静态内部类与非静态内部类之间存在一个最大的区别，我们知道非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围内，但是静态内部类却没有。没有这个引用就意味着：

1、 它的创建是不需要依赖于外围类的。

2、 它不能使用任何外围类的非static成员变量和方法。

实现的代码如下：

public class OutClassType {

private int age;
private int year;

public static void test(){
System.out.println("OutClassType data.");
}

public class InnerNormalClass{
private int a = 1;
private int b = 2;

public InnerNormalClass(){
System.out.println("init the inner class");
// 普通内部类可以通过this关键字无限访问外部类的成员变量
System.out.println("direct read OutClassType age:"+OutClassType.this.age);

test();
}

public int getA(){
System.out.println("print A.");
return a;
}

public int getB(){
System.out.println("print B.");
return b;
}
}


public static class InnnerStaticClass{
private int c = 15;
private int d = 16;
public int getC(){
System.out.println("print C.");
return c;
}

public int getD(){
return d;
}

public static void testStaticMethod(){
System.out.println("this is static inner class method.");
}
}

public void printInnnerStaticClassData(InnnerStaticClass innnerStaticClass){
System.out.println("print c:"+innnerStaticClass.c+",print d:"+innnerStaticClass.d);
}

public void printInnerNonStaticClassData(InnerNormalClass normalClass){
System.out.println("print a:"+normalClass.a+",print b:"+normalClass.b);
}



public int getAge() {
return age;
}


public void setAge(int age) {
this.age = age;
}


public int getYear() {
return year;
}


public void setYear(int year) {
this.year = year;
}
}

测试代码如下所示：

private static void testInnerClass(){
OutClassType outClassType = new OutClassType();
// 非静态的内部类的初始化只能使用outClassType.new的方式生成
OutClassType.InnerNormalClass innerNormalClass = outClassType.new InnerNormalClass();
// 使用内部类的对象访问内部类成员变量
System.out.println("print the inner method:"+innerNormalClass.getA());

// 静态内部类的初始化和和非静态内部类的初始化不一样，因为不管是静态变量还是静态内部类都是外部类直接所有
OutClassType.InnnerStaticClass innnerStaticClass = new OutClassType.InnnerStaticClass();
System.out.println("print the static class non static method:"+innnerStaticClass.getC());
// 直接调用静态内部类的静态方法
OutClassType.InnnerStaticClass.testStaticMethod();

// 外部类的方法中也可以访问静态内部类的私有属性
outClassType.printInnnerStaticClassData(innnerStaticClass);

// 外部类的方法中也可以访问非静态内部类的私有属性
outClassType.printInnerNonStaticClassData(innerNormalClass);

}

测试结果如下所示：

init the inner class
direct read OutClassType age:0
OutClassType data.
print A.
print the inner method:1
print C.
print the static class non static method:15
this is static inner class method.
print c:15,print d:16
print a:1,print b:2