Java的四种内部类01(局部内部类和匿名内部类)
目录
1.基本介绍
一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(innper class), 嵌套其他类的类称为外部类(outer class)。是我们类的第五大成员, 内部类最大的特点就是可以直接访问私有属性,并且可以体会类与类之间的包含关系
基本语法
class Outer{//外部类 class inner{//内部类 }} class Other { //外部其他类 }
类的五大成员举例
package com.demo.innerclass;public class innerclass01 { public static void main(String[] args) { }}class outer{//外部类 private int n1=666;//1.属性 //2.构造器 public outer(int n1) { this.n1 = n1; } //3.方法 public void m1{ System.out.println("mi运行"); } //4.代码块 { System.out.println("代码块"); } //内部类 class Inner{ }}
内部类的分类
内部类的分类
定义在外部类局部位置上(比如方法内):
1)局部内部类(有类名)
2)匿名内部类(没有类名,重点)
定义在外部类的成员位置上:
1)成员内部类(没用static修饰)
2)静态内部类(使用static修饰)
2.局部内部类
细节01
•局部内部类的使用
说明:局部内部类是定义在外部类的局部位置,比如方法中,并且有类名。
1.可以直接访问外部类的所有成员,包含私有的
2.不能添加访问修饰符,因为它的地位就是一个局部变量。局部变量是不能使用
修饰符的。但是可以使用final 修饰,因为局部变量也可以使用final
3.作用域:仅仅在定义它的方法或代码块中。
4.局部内部类–访问---->外部类的成员[访问方式:直接访间]
5.外部类—访问---->局部内部类的成员
访问方式:创建对象,再访问(注意:必须在作用域内)
案例
package com.demo.innerclass;import jdk.nashorn.internal.ir.CallNode;public class localinnerclass { public static void main(String[] args) { outer02 o=new outer02(); o.m2(); }}class outer02{//外部类 private int n1=66; public void m1(){ System.out.println("调用m1"); } public void m2(){//方法 //局部内部类是定义在外部类的局部位置,比如方法中,并且有类名。 final class inner02{//局部内部类 //1.可以直接访问外部类的所有成员,包含私有的 public void f1(){ System.out.println("n1="+n1); m1(); //4.局部内部类--访问---->外部类的成员[访问方式:直接访间] } //2.不能添加访问修饰符,因为它的地位就是一个局部变量。局部变量是不能使用 //修饰符的。但是可以使用final 修饰,因为局部变量也可以使用final //class inner03 extends inner02{ }ERROR //3.作用域:仅仅在定义它的方法或代码块中。 //5.外部类---访问---->局部内部类的成员 //访问方式:创建对象,再访问(注意:必须在作用域内) //6.外部类在方法中,可以创建inner02对象,然后调用方法即可 } inner02 t=new inner02(); t.f1(); }}
测试结果
细节02
1.外部其他类—不能访问--------》局部内部类(局部内部类相当于一个局部变量)
2.如果外部类和局部内部类的成员重名时,默认遵循就近原则,如果想访问外部类的成员,则可以使用(外部类名.this.成员)去访问
示例
package com.demo.innerclass;import jdk.nashorn.internal.ir.CallNode;public class localinnerclass { public static void main(String[] args) { outer02 o=new outer02(); o.m2(); System.out.println("outer的hashcode="+o); }}class outer02{//外部类 private int n1=66; public void m1(){ System.out.println("调用m1"); } public void m2(){//方法 //局部内部类是定义在外部类的局部位置,比如方法中,并且有类名。 final class inner02{//局部内部类 //1.可以直接访问外部类的所有成员,包含私有的 private int n1=444; public void f1(){ System.out.println("n1="+n1); System.out.println("外部类的n1="+outer02.this.n1); System.out.println("outer02.this的hashcode="+outer02.this); m1(); //4.局部内部类--访问---->外部类的成员[访问方式:直接访间] } //2.不能添加访问修饰符,因为它的地位就是一个局部变量。局部变量是不能使用 //修饰符的。但是可以使用final 修饰,因为局部变量也可以使用final //class inner03 extends inner02{ }ERROR //3.作用域:仅仅在定义它的方法或代码块中。 //5.外部类---访问---->局部内部类的成员 //访问方式:创建对象,再访问(注意:必须在作用域内) //6.外部类在方法中,可以创建inner02对象,然后调用方法即可 } inner02 t=new inner02(); t.f1(); }}
测试结果
3.匿名内部类
1.匿名内部类是定义在外部类的局部位置,比如方法中,并且没有类名
2.基本语法
new 类或接口(参数列表){
类体
}
3.匿名内部类本质是类,没有名字,同时还是一个对象
1.基于接口的匿名内部类
package com.demo.innerclass;//演示匿名内部类的使用public class AnonymousInnerclass { public static void main(String[] args) { outer04 o = new outer04(); o.f(); }}class outer04{//外部类 private int n1=66; public void f(){ //基于接口的匿名内部类 //1.使用IA接口,创建对象 //传统方式,写一个类,实现该接口,并创建对象 //可以用匿名内部类简化开发 //..jdk底层在创建匿名内部类时,outer04¥1就会被立即创建,并把地址返回给tiger ///匿名内部类使用一次,就不能再使用 IA tiger =new IA() { @Override public void cry() { System.out.println("老虎在哭"); } }; //tiger的编译类型IA //tiger地运行类型。匿名内部类 tiger.cry(); }}interface IA{//接口 public void cry();}class father{ public father(String name) {//构造器 } public void test(){ }}
测试结果
2.基于类的匿名内部类
package com.demo.innerclass;//演示匿名内部类的使用public class AnonymousInnerclass { public static void main(String[] args) { outer04 o = new outer04(); o.f(); }}class outer04{//外部类 private int n1=66; public void f(){ //基于接口的匿名内部类 //1.使用IA接口,创建对象 //传统方式,写一个类,实现该接口,并创建对象 //可以用匿名内部类简化开发 //..jdk底层在创建匿名内部类时,outer04¥1就会被立即创建,并把地址返回给tiger ///匿名内部类使用一次,就不能再使用 IA tiger =new IA() { @Override public void cry() { System.out.println("老虎在哭"); } }; //tiger的编译类型IA //tiger地运行类型。匿名内部类 tiger.cry(); //基于基于类的匿名内部类 //f1的编译类型 father //f1的运行类型 outer04¥2 //底层会创建匿名内部类 father f1=new father("demolong"){ @Override public void test() { System.out.println("从匿名内部类重写test方法"); } }; System.out.println("f1的运行类型="+f1.getClass()); f1.test(); //基于抽象类的匿名内部类 animal an01=new animal() { @Override void eat() { System.out.println("动物吃饭"); } }; an01.eat(); }}interface IA{//接口 public void cry();}class father{ public father(String name) {//构造器 } public void test(){ }}abstract class animal{ void eat(){}}
测试结果
匿名内部类细节01
//1.匿名内部类可以直接访问外部类的所有成员
2.不能添加访问修饰符,因为它的本质是一个局部变量。
3.作用域:仅仅在定义他的方法或代码块中
4.外部其他类不能访问匿名内部类
5.如果外部类和匿名内部类的成员重名时,默认遵循就近原则,如果想访问外部类的成员,则可以使用(外部类名.this.成员)去访问
package com.demo.innerclass;public class AnonymousInnerclassdetial { public static void main(String[] args) { outer05 oo=new outer05(); oo.f1(); }}class outer05{ private int n1=66; public void f1(){ //创建一个基于类的匿名内部类 Person person = new Person(){ @Override public void hi() { //1.匿名内部类可以直接访问外部类的所有成员 System.out.println("匿名内部类重写了hi方法。。。+n1="+n1); } }; person.hi();//动态绑定 //也可以直接调用 new Person(){ @Override public void hi() { System.out.println("匿名内部类再次重写了hi方法02。。。"); } }.hi(); }}class Person{ public void hi(){ System.out.println("hi........"); }}
测试结果