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
}
}