> 文档中心 > Java的四种内部类01(局部内部类和匿名内部类)

Java的四种内部类01(局部内部类和匿名内部类)

目录

  • 1.基本介绍
  • 2.局部内部类
    • 细节01
      • 案例
      • 测试结果
    • 细节02
      • 示例
      • 测试结果
  • 3.匿名内部类
    • 1.基于接口的匿名内部类
    • 2.基于类的匿名内部类
    • 匿名内部类细节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();    }}

测试结果

Java的四种内部类01(局部内部类和匿名内部类)

细节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();    }}

测试结果

Java的四种内部类01(局部内部类和匿名内部类)

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(){    }}

测试结果
Java的四种内部类01(局部内部类和匿名内部类)

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(){}}

测试结果
Java的四种内部类01(局部内部类和匿名内部类)

匿名内部类细节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........");    }}

测试结果
Java的四种内部类01(局部内部类和匿名内部类)

医疗百科