20180410 java java面向对象-实例内部类和静态内部类分析
内部类看做是外部类的一个成员，内部类和 外部类里的字段 是一个层级。
所以内部类可以使用public修饰，也可以使用缺省修饰符修饰，也可以使用protected修饰符修饰，也可以使用private修饰符修饰，也可以使用static修饰。
而外部类的修饰符只能是两种：public修饰的 或 缺省修饰符修饰的。
现在说重点了，
/**********************************/
/******* 实例内部类 **********/
/**********************************/
实例内部类解析：
没有使用static修饰的内部类，相当于实例字段 或 实例成员变量。这说明实例内部类属于外部类对象的，而不属于外部类本身的。
实例内部类的特点：
eg:
class Outter
{
//实例内部类
class Inner
{
}
}
//演示实例内部类
class InstanceInnerClassDemo
{
public static void main(String[] args)
{
System.out.println("BAI HE");
//创建Inner的对象
Outter out = new Outter();
out.new Inner();//正确
Inner in = out.new Inner();//错误，因为在Outter里找不到
Outter.Inner in = out.new Inner();//正确
}
}
特点1：创建实例内部类前，必须存在外部类对象，通过外部类对象创建内部类对象（即当存在内部类对象时，一定存在外部类对象）。
特点2：实例内部类的实例自动持有外部类的实例的引用；
0x1234
-------------------
| Outter对象 |
| |
| |
-------------------
-----------------------------
| Inner对象 |
| |
| Outter.this 0x1234 |
-----------------------------
内部类可以直接访问外部类成员。
eg:
class Outter
{
String name = "Outter.name";
//实例内部类
class Inner
{
public void test()
{
System.out.println(name);
}
}
}
//演示实例内部类
class InstanceInnerClassDemo
{
public static void main(String[] args)
{
System.out.println("BAI HE");
//创建Inner的对象
Outter out = new Outter();
Outter.Inner in = out.new Inner();
in.test(); //此时输出 Outter.name
}
}
特点3：外部类中不能直接访问内部类的成员，必须通过内部类的实例去访问。
eg：
class Outter
{
public void ooxx()
{
System.out.println(age);//错误，不能访问到
System.out.println(new Inner().age);//正确，可以访问到
//相当于：this.new Inner().age
}
String name = "Outter.name";
//实例内部类
class Inner
{
int age = 17;
public void test()
{
System.out.println(name);
}
}
}
//演示实例内部类
class InstanceInnerClassDemo
{
public static void main(String[] args)
{
System.out.println("BAI HE");
}
}
特点4：实例内部类中不能定义静态成员，只能定义实例成员(即只能定义不加static的成员)。
eg：
class Outter
{
public void ooxx()
{
System.out.println(age);//错误，不能访问到
System.out.println(new Inner().age);//正确，可以访问到
//相当于：this.new Inner().age
}
String name = "Outter.name";
//实例内部类
class Inner
{
static int age = 17;//错误，不能加static
static public void test()//错误，不能加static
{
System.out.println(name);
}
}
}
//演示实例内部类
class InstanceInnerClassDemo
{
public static void main(String[] args)
{
System.out.println("BAI HE");
}
}
特点5：若实例内部类和外部类存在同名的字段abc或方法bcd()，那么在内部类中：
this.bcd();//表示访问内部类成员
外部类.this.bcd();//表示访问外部类成员
eg：
class Outter
{
public void ooxx()
{
System.out.println(age);//错误，不能访问到
System.out.println(new Inner().age);//正确，可以访问到
//相当于：this.new Inner().age
}
String name = "Outter.name";
//实例内部类
class Inner
{
String name = "Inner.name";
int age = 17;
public void test()
{
String name = "Local.name";
System.out.println(name);//会打印Local.name
System.out.println(this.name);//会打印Inner.name
System.out.println(Outter.this.name);//会打印Outter.name
}
}
}
//演示实例内部类
class InstanceInnerClassDemo
{
public static void main(String[] args)
{
System.out.println("BAI HE");
}
}
/**********************************/
/******* 静态内部类 **********/
/**********************************/
静态内部类就是加了static的内部类。
即：
eg：
class Outter
{
public void ooxx()
{
System.out.println(age);//错误，不能访问到
System.out.println(new Inner().age);//正确，可以访问到
//相当于：this.new Inner().age
}
String name = "Outter.name";
//实例内部类
static class Inner
{
String name = "Inner.name";
int age = 17;
public void test()
{
String name = "Local.name";
System.out.println(name);//会打印Local.name
System.out.println(this.name);//会打印Inner.name
System.out.println(Outter.this.name);//会打印Outter.name
}
}
}
//演示实例内部类
class InstanceInnerClassDemo
{
public static void main(String[] args)
{
System.out.println("BAI HE");
}
}
特点1：在静态内部类中可以定义静态成员和实例成员。
eg：
class Outter
{
String name = "Outter.name";
//静态内部类
static class Inner
{
String name = "Inner.name";//正常，不报错
int age = 17;//正常，不报错
public void test()
{
String name = "Local.name";
}
}
}
//演示实例内部类
class InstanceInnerClassDemo
{
public static void main(String[] args)
{
System.out.println("BAI HE");
}
}
特点2：静态内部类的实例不会自动持有外部类的特定实例的引用。
即 静态内部类是直接属于外部类的，所以静态内部类与外部类的对象没有任何关系，可以没有外部类对象，只需 外部类.内部类名称 就可以调用了。
所以 在创建内部类的实例的时候，不必创建外部类的实例。
eg：
class Outter
{
String name = "Outter.name";
//静态内部类
static class Inner
{
String name = "Inner.name";
int age = 17;
public void test()
{
String name = "Local.name";
}
}
}
//演示实例内部类
class InstanceInnerClassDemo
{
public static void main(String[] args)
{
new Outter.Inner();//创建静态内部类对象，正确
Outter.Inner in = new Outter.Inner();//创建静态内部类对象并赋值给in，正确
}
}
特点3：静态内部类可以直接访问外部类的静态成员，若访问外部类的实例成员，必须通过外部类的实例去访问。
eg：
class Outter
{
String name = "Outter.name";
static String name2 = "name2";
//静态内部类
static class Inner
{
int age = 17;
public void test()
{
System.out.println(name2);//可以，正确
//System.out.println(name);//错误，不能访问外部类的实例成员
//System.out.println(new Outter().name);//正确，通过外部类的实例 //可以访问外部类的实例成员
}
}
}
//演示实例内部类
class InstanceInnerClassDemo
{
public static void main(String[] args)
{
Outter.Inner in = new Outter.Inner();
in.test();//输出 name2
}
}
特点4：测试类(即第三方类)可以通过完整的类名直接访问静态内部类的静态成员(简称 一"静"到底)。
eg:
class Outter
{
//静态内部类
static class Inner
{
static int age = 17;
}
}
//演示实例内部类
class InstanceInnerClassDemo
{
public static void main(String[] args)
{
System.out.println(Outter.Inner.age);//正常，输出17
}
}
