文章目录
🎯类的五大成员
💯内部类
🌈局部内部类
✔️匿名内部类
🥗成员内部类
🍗静态内部类
一个类的内部又完整的嵌套了另一个类结构。被嵌套的类成为内部类 (inner class)
在学习内部类之前，先来了解一下类的五大成员
🎯类的五大成员
属性
方法
构造器
代码块
内部类
💯内部类
定义类在局部位置(方法中/代码块) :
局部内部类
匿名内部类
定义在成员位置
成员内部类
静态内部类
🌈局部内部类
局部内部类是定义在外部类的局部位置，通常方法中，并且有类名
可以直接访问外部类的所有成员，包含私有的
不能添加访问修饰符，但是可以使用final 修饰
作用域：仅仅在定义它的方法或代码块中
局部内部类可以直接访问外部类的所有成员
外部类在方法中可以创建内部类实例，然后调用方法即可
外部其他类不能访问局部内部类
如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果
想访问外部类的成员，可以使用：外部类名.this.成员
public class inner05 { public static void main(String[] args) { new Outer01().m(); } } class Outer01 { //外部类 private int n = 50; private void f() { System.out.println("我是外部类的f私有方法，我被调用了"); } public void m() { int n = 100; //重名了，访问遵循就近原则 //局部内部类 class Inner01 { public void f1() { //可以直接访问外部类的所有成员，包含私有的 System.out.println("n=" + n); //访问外部类的属性通过 外部类名.this.成员 System.out.println("n=" + Outer01.this.n); f(); } } //在方法中new内部类并调用方法 new Inner01().f1(); } }
输出：
n=100
n=50
我是外部类的f私有方法，我被调用了
✔️匿名内部类
传统方法，写一个类，实现该接口，并创建对象
新需求，只使用一次，后面不在使用，使用匿名内部类简化开发
cat 的编译类型 AA ，cat 的运行类型是匿名内部类 inner03$1
JDK在底层，创建了匿名内部类inner03$1，new立即就创建了一个inner03$1实例，并且把地址返回给 cat,匿名内部类，使用一次就不能再使用了，但是生成的对象 cat 可以一直使用。
基于接口的匿名内部类
public class inner03 { public static void main(String[] args) { AA cat = new AA(){ @Override public void shot() { System.out.println("喵喵叫"); } }; cat.shot(); System.out.println(cat.getClass()); } } interface AA { //接口 public void shot(); }
输出：
喵喵叫
class innerclass.inner03$1
基于类的匿名内部类
public class inner04 { public static void main(String[] args) { //基于类的匿名内部类 Fa f = new Fa("森") { }; f.say(); System.out.println(); } } class Fa { private String name; public Fa(String name) { this.name = name; } public void say() { System.out.println(this.name + "说话了"); } }
输出：
森说话了
🥗成员内部类
/** * @Author: liu sen * @Version: 1.0 * @Date: 2021/09/06/10:26 */ public class demo08 { public static void main(String[] args) { Outer03 outer03 = new Outer03(); outer03.t1(); //外部其他类访问成员内部类 //1 Outer03.Inner03 inner03 = outer03.new Inner03(); inner03.say(); //2，再外部类中编写一个方法 Outer03.Inner03 getinnero3 = outer03.getInnero3(); getinnero3.say(); } } class Outer03 {//外部类 private int n1 = 10; public String name = "小刘"; private void say(){ System.out.println("say"); } //成员内部类（没有写在方法中或代码块中，就好比是Outer03的一个成员，因此叫成员内部类） //可以添加四种修饰符，因为它的低位就是类成员 //作用域就是整个外部类，其实成员内部类就相当于类成员，那自然作用域就是这个类 //成员内部类可以直接访问外部类成员(属性和方法)，私有也可以 //外部类访问成员内部类，创建对象，再访问 //外部其他类访问成员内部类 public class Inner03 { public void say() { //可以直接访问外部类的所有成员，包含私有的 System.out.println("n1:" + n1 + " name：" + name); //如果外部类和内部类有重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，可以使用 //外部类名.this.类名 去访问，如下 Outer03.this.say(); } } public void t1(){ //使用了成员内部类 Inner03 inner03 = new Inner03(); inner03.say(); } //方法，返回一个Inner03的实例 public Inner03 getInnero3(){ return new Inner03(); } }
🍗静态内部类
/** * @Author: liu sen * @Version: 1.0 * @Date: 2021/09/06/21:41 */ public class demo09 { public static void main(String[] args) { Outer10 outer10 = new Outer10(); outer10.na(); //外部其他类 访问静态内部类 //1,静态内部类可以通过类名直接访问，前提是要满足访问权限 Outer10.Inner10 inner10 = new Outer10.Inner10(); inner10.say(); //2.写一个方法，返回静态内部类的对象实例 Outer10.Inner10 inner101 = outer10.getInner10(); inner101.say(); } } class Outer10 {//外部类 private int n1 = 10; private static String name = "小刘"; private static void cry(){} static class Inner10 {//静态内部类 //在外部类的成员位置，使用 static 修饰 //可以直接访问外部类的所有静态成员，包含私有的，但是不能访问非静态的方法 //可以添加任意地访问修饰符，因为它的低位就是一个成员 //作用域：同其他成员，为整个类体 private static String name = "小张"; public void say(){ // System.out.println(n1);//报错，不允许 //外部类和静态内部类重名，静态内部类访问时默认遵循就近原则 System.out.println(name);//OK //如果想访问外部的成员，可以用(外部类名.成员) System.out.println(Outer10.name); //静态内部类访问外部类，直接访问所有静态成员 cry(); } } public void na(){ //外部类访问静态内部类，先创建对象，再访问 Inner10 inner10 = new Inner10(); inner10.say(); } public Inner10 getInner10(){ return new Inner10(); } }
