目录
局部内部类可以有的成分 及 访问外部类的格式 及 局部内部类在类中可以出现的位置:
接口的匿名内部类 及 访问父接口、外部类的格式(重点,使用最多!)。
静态内部类的特点 (重点! 使用较多!):
- 静态内部类是定义在 外部类 中的成员位置,与 外部类 中的静态代码块、静态变量、静态常量、静态方法 为同一级别 的内部类。有static修饰。
- 与其他类一样,类中该有的成分,静态内部类都可以有!
- 可以在静态内部类中直接访问类 外部类 中的所有静态成员,包括私有的。但是不能直接访问类中的实例成员!(除非在静态内部类的成员方法中创建 外部类的对象。)
- 可以和静态方法、静态变量、静态常量、一样 添加任意的访问修饰符,因为静态内部类就是属于类中的一个静态成员!
- 静态内部类的作用域和其他 成员一样,为整个类体。
- 在其他类中 创建静态内部类的对象的语法 :外部类名.静态内部类名 对象引用名 = new 外部类名.静态内部类构造器(); (或者变相的提供方法,给调用者返回静态内部类的对象即可。)
- 如果外部类和静态内部类的成员重名时,静态内部类访问时,默认遵循的是就近原则。如果想访问外部类的成员,则可以使用 < 外部类名.静态成员> 去访问。
- 外部类访问静态内部类的静态成员,直接用 静态内部类名.静态成员。访问静态内部类的实例成员,则 静态内部类 对象引用 = new 静态内部类构造器();再访问即可!
- 静态内部类可以定义:构造器、成员方法、成员变量、成员常量、代码块、静态内部枚举、静态内部接口、静态内部注解(几乎没用过)。(接口中也可以定义静态内部类中)
- 静态内部类应用场景:比如 定义了 一个 BigHospital 类(大医院类),又想在 Hospital 类中定义 Ophthalmology 类(眼科类)或者 Orthopedics类(骨科)或 Gynecology(妇科)等 ……
静态内部类中可以有的成分及访问外部类的格式:
(只要是一个类中可以有的,静态内部类都可以有!静态内部类的.class文件是属于外部类的.class文件里面,所以自然也就能创建外部类的对象访问外部类的实例成员,和直接访问外部类的静态成员!):
public class Outer{ {} static {} private static final String SC = "静态常量"; private static String sa = "静态变量"; private final String IC = "实例常量"; private String ia = "实例变量"; interface O_Interface{public abstract void m();} enum O_Enum{E;} @interface ONote{} public static String sM(){return "静态方法";} public String iM(){return "实例方法";} public static class Inter{ {} static {} interface I_Interface{public abstract void m();} enum I_Enum{E;} @interface INote{} private static final String SC = "静态内部类静态常量"; private static String sa = "静态内部类静态变量"; private final String IC = "静态内部类实例常量"; private String ia = "静态内部类实例变量"; public static String iSM(){ String sc = Inter.SC; return "静态方法";} public void iiM(){ System.out.println(Outer.SC); System.out.println(Outer.sa); System.out.println(new Outer().IC); System.out.println(new Outer().ia); System.out.println(sM()); System.out.println(new Outer().iM()); new O_Interface() { @Override public void m() { System.out.println("外部类的内部接口"); } }.m(); System.out.println("外部类的内部枚举O_Enum.E = " + O_Enum.E); } } } class Test{ public static void main(String[] args) { Outer.Inter inter = new Outer.Inter(); System.out.println("inter.getClass().getName() = " + inter.getClass().getName()); inter.iiM(); } }test:
静态内部类注意事项:
- 静态内部类的的访问权限修饰符是什么,静态内部类的默认的无参构造器就是什么!!!

实例内部类的特点 (重点,使用较多):
- 实例内部类是定义在外部类的成员位置,并且没有用static修饰!!
- 实例内部类可以直接访问外部类的所有成员,包括私有的!
- 实例内部类和实例变量、实例常量、实例方法 一样,可以用任意修饰符修饰,因为它的地位就是一个成员,和实例变量、实例常量、实例方法的地位是一样,都是属于对象的!!
- 实例内部类的作用域,和外部类其他成员一样,为整个类体!
- 实例内部类中可以定义:构造代码块、构造器、实例方法、实例变量、实例常量、静态常量。(为什么可以定义静态常量?因为静态常量是在 常量池里面的!常量池里面的东西是可以被堆、栈、方法区 共享的(不是字符串常量池!!!))
- (实例内部类 不能定义 静态方法、静态变量、静态代码块、(因为对象在堆中的、堆中没有静态域 )静态内部枚举、静态内部接口、静态内部注解这些内容,一定义就报错!(堆中没有方法区,字节码文件是在加载到方法区中的!))
- 外部类访问实例内部类的静态常量,则直接 用 实例内部类名.静态常量即可。如果是在外部类的实例方法中 访问 实例内部类 中的 实例成员就需要创建对象,直接 [外部内名.]实例内部类名 对象引用 = new 实例内部类构造器();再访问即可。如果是在外部类的静态方法中 访问实例内部类中的实例成员 创建对象的方式就不一样 :创建对象的方式是: [外部类名.]实例内部类名 对象引用 = new 外部类构造器().new 实例内部类构造器();
- 如果在其他类中访问实例内部类创建对象的方式是:外部类名.实例内部类名 对象引用 = new 外部类构造器().new 实例内部类构造器(); (或者先创建外部类对象,再用对象.new 实力内部类构造器(); 或者 在外部类中 提供可以获取 实例内部类的对象的方法 也是一样的!)
- 如果外部类 和 实例内部类的实例成员重名的时候,实力内部类里面访问的话,默认遵循 就近原则,如果想访问外部类的实例成员,则可以通过 外部类名.this.实例成员 来访问即可。
- 如果实例内部类 想 访问外部类的 父类的成员的时候,则可以通过 外部类名.super.成员 即可访问。
- 实例内部类引用场景:比如定义了 一个 Person 类(人类) ,而由想在 Person 类 中定义一个 Heart 类(心脏)。这时候就可以考虑使用实例内部类 or 静态内部类 都是可以的。
实例内部类可以有的成分 及 访问外部类的格式:
public class Outer{ public static final String S_CONST = "外部类的静态常量"; public static String sVariable = "外部类的静态变量"; public final String I_CONST = "外部类的实例常量"; public String iVariable = "外部类的实例变量"; public static String sM(){return "外部类的静态方法";} public String iM(){return "外部类的实例方法";} protected interface O_Interface{public abstract void m();} protected enum O_Enum{ENUM;} private @interface O_Comment{} public class InstanceInter{ {} public static final String S_CONST = "实例内部类的静态常量"; public final String I_CONST = "实例内部类的实例常量"; public String iVariable = "实例内部类的实例变量"; public String iM(){return "实例内部类的实例方法";} public void access(){ System.out.println("this.getClass().getName() = " + this.getClass().getName()); System.out.println("Outer.S_CONST = " + Outer.S_CONST); System.out.println("Outer.sVariable = " + Outer.sVariable); System.out.println("Outer.this.I_CONST = " + Outer.this.I_CONST); System.out.println("Outer.this.iVariable = " + Outer.this.iVariable); System.out.println("Outer.super.equals(null) = " + Outer.super.equals(null)); System.out.println("sM() = " + sM()); System.out.println("Outer.this.iM() = " + Outer.this.iM()); new O_Interface() { @Override public void m() { System.out.println("实现外部类 内部接口"); } }.m(); System.out.println("外部类 内部枚举O_Enum.ENUM = " + O_Enum.ENUM); } } } class Test{ public static void main(String[] args) { // test Outer.InstanceInter instanceInter = new Outer().new InstanceInter(); instanceInter.access(); } }test:
实例内部类注意事项:
- 实例内部类的的访问权限修饰符是什么,实例内部类的默认的构造器就是什么!!!(它创建实例内部类需要传入一个参数,不难看出这里很明显就是 Outer 的对象啊!所有的实例内部类是需要外部类的对象类创建对象的!)
局部内部类的特点 ( 重点,使用较少。 ):
- 局部内部类是定义在外部类的位置,可以定义在 if分支 、else if 分支、 else 分支、switch分支、 for 循环、while循环、do-while循环、成员方法、构造器、代码块、try语句体、catch语句体、finally语句体中!
- 局部内部类不能添加static 修饰!
- 不能添加访问修饰符,因为局部内部类的地位就是等同于局部变量,局部内部类是不能使用访问修饰符的。但是可以使用final修饰、且只能最多选择使用final修饰!,因为局部变量也可以使用fianl修饰!
- 局部内部类的默认无参构造器修饰符 是 缺省的!!
- 局部内部类的作用范围:仅仅是在局部内部类定义的代码块、分支、语句体 范围中!不能在本类中的其他代码块中、分支中、语句体中创建非当前局部内部类的对象!其他类也不能创建。局部内部类是属于当前作用范围!其他不能访问!
- 局部内部类访问外部类:如果局部内部类是在实例方法中、构造器中、构造代码块中定义 则可以直接访问外部类的所有成员(包括私有的)。如果局部内部类是在静态方法中、静态代码块中定义 则 可以直接访问外部类的静态成员(包括私有的)!如果想访问外部类的实例成员,则需要创建外部类的对象才能访问!(不能在构造代码块中、构造器中创建当前类的对象、会出现 StackOverFlowError 堆栈溢出错误!,在构造代码块中、构造器中定义的局部内部类里面也不能创建当前外部类的对象,也会出现 StackOverFlowError 堆栈溢出错误!但是可以在构造代码块中、构造器中创建非当前类的对象使用! )
- 外部类访问局部内部类中的内容:必须在和局部内部类在一个作用域的前提下,创建局部内部类对象即可访问!
- 如果外部类和局部内部类中的成员重名时,需遵循就近原则,如果想访问外部类的实例成员时,可以使用 外部类名.this.实例成员 才能访问。
- 如果局部内部类想访问外部类的父类的成员的时候:可以使用 外部类名.super.成员即可访问!




703



被折叠的 条评论
为什么被折叠?



