Java的内部类

我为杰伦代言

已于 2022-07-06 21:47:09 修改

阅读量537

点赞数

分类专栏： Java基础文章标签： java

于 2022-03-24 22:47:25 首次发布

本文链接：https://blog.csdn.net/weixin_52385232/article/details/123723666

版权

Java基础专栏收录该内容

34 篇文章 0 订阅

订阅专栏

Java的内部类

一个java文件里可以有多个类，但最多只能有一个public修饰。
如果这个java文件中包含public修饰的类，则这个类的名称必须和Java文件名一致。
内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类。

内部类包括：成员内部类、静态内部类、局部内部类、匿名内部类。

成员和静态内部类

静态内部类特点

外部类加载时，静态内部类不会被加载进内存
当有其它方法去调用静态内部类的属性和方法时，静态内部才开始加载并且只加载一次。

public class Outer {
    private int  id=10;
    public void out() {
        System.out.println("这是外部类的方法");
    }
    //成员内部类，静态内部类加个static修饰
   public class Inner{
        public void in() {
            System.out.println("这是内部类的方法");
        }
       //内部类获得外部类的私有属性
       public void getID() {
           System.out.println(id);
       }
    }
}

import test.Demo10.Outer;
public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
    }
}

局部内部类

public class Outer {
    public void method() {
        //局部内部类
        class Inner{ }
    }
}

匿名内部类(重要！！！)

基本说明

匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名

本质是类
内部类
该类没有名字
同时还是一个对象

匿名内部类的基本语法

new 类或接口(参数列表) {

类体

};

匿名内部类的使用

getClass()：获取对象的运行类型

1.基于接口的匿名内部类

tiger的编译类型是：IA
tiger的运行类型是：匿名内部类 xxx => Outer04$1
jdk 底层在创建匿名内部类 Outer04$1后，立即又创建了 Outer04$1实例，并且把地址返回给tiger
匿名内部类使用一次，就不能再使用了

IA tiger = new IA() {
@Override
public void cry() {
System.out.println("老虎叫。。。");
}

} ;

=> 底层是：

class Outer04$1 implements IA {

@Override

public void cry() {

System.out.println("老虎叫。。。");

}

}

public class Demo01 {
    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.method();
    }
}
class Outer04{
    private int n1 = 10;
    public void method(){
        IA tiger = new IA() {
            @Override
            public void cry() {
                System.out.println("老虎叫。。。");
            }
        } ;
        System.out.println("tiger的运行类型="+tiger.getClass());
        tiger.cry();
    }
}
interface IA{
    public void cry();
}

2.基于类的匿名内部类

father的编译类型：Father
father的运行类型：Outer04$2
jdk 底层在创建匿名内部类 Outer04$2后，立即又创建了 Outer04$2实例，并且把地址返回给father
注意 ("jack") 参数列表会传递给 Father(String name) 构造器

Father father = new Father("jack") {

//Father不是抽象类，也可以不重写test()方法

@Override

public void test() {

System.out.println("匿名内部类重写了test方法");

}

};

=> 底层是：

class Outer04$2 extends Father {

//同上保持一样

@Override

public void test() {

System.out.println("匿名内部类重写了test方法");

}

}

public class Demo01 {
    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.method();
    }
}
class Outer04{
    private int n1 = 10;
    public void method(){
        //基于接口的匿名内部类
        IA tiger = new IA() {
            @Override
            public void cry() {
                System.out.println("老虎叫。。。");
            }
        } ;
        System.out.println("tiger的运行类型="+tiger.getClass());
        tiger.cry();
        //基于类的匿名内部类
        Father father = new Father("jack") {
            @Override
            public void test() {
                System.out.println("匿名内部类重写了test方法");
            }
        };
        System.out.println("father的运行类型="+father.getClass());
        father.test();
    }
}

interface IA{
    public void cry();
}
class Father{
    public Father(String name) {
        super();
        System.out.println("接收到name="+name);
    }
    public void test() {

    }
}

匿名内部类的细节

匿名内部类既是一个类的定义，同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，因此可以调用匿名内部类的方法
在匿名内部类中可以直接访问外部类的所有成员，包括私有的
不能添加访问修饰符，因为它的地位就是一个局部变量
作用域：仅仅在定义它的方法或代码块中
外部其它类---不能访问---->匿名内部类，因为匿名内部类的地位是一个局部变量
如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

public class Demo01 {
    public static void main(String[] args) {
        Outer05 outer05 = new Outer05();
        outer05.f1();
    }
}
class Outer05 {
    private int n1 = 99;
    public void f1() {
        Person p = new Person() {
            @Override
            public void hi() {
                System.out.println("匿名内部类重写了hi方法"+n1);
            }
        };
        p.hi();
    }
}
class Person {
    public void hi() {
        System.out.println("Person hi()");
    }
}

public class Demo01 {
    public static void main(String[] args) {
        Outer05 outer05 = new Outer05();
        outer05.f1();
    }
}
class Outer05 {
    private int n1 = 99;
    public void f1() {
        Person p = new Person() {
//            @Override
//            public void hi() {
//                System.out.println("匿名内部类重写了hi方法"+n1);
//            }
        };
        p.hi();
    }
}
class Person {
    public void hi() {
        System.out.println("Person hi()");
    }
}

public class Demo01 {
    public static void main(String[] args) {
        Outer05 outer05 = new Outer05();
        outer05.f1();
    }
}
class Outer05 {
    private int n1 = 99;
    public void f1() {
        new Person() {
            @Override
            public void hi() {
                System.out.println("匿名内部类重写了hi方法"+n1);
            }
        }.hi();
    }
}
class Person {
    public void hi() {
        System.out.println("Person hi()");
    }
}