Java SE 四大内部类
四大内部类
内部类
1、成员内部类
-
调用成员内部类
//在外面的类的最后，写一个方法，调用成员内部类(创建对象，在访问) class Outer08{ class Inner08{ //成员内部类 public void say(){ } } public void t1(){ Inner08 inner08 = new Inner08(); inner08.say(); } } -
可以直接访问外部类的所有成员，包含私有的。
-
外部其他类调用内部类的二种方法
// Outero8.Inner08 inner08 = outero8.new Inner08(); inner08.say(); //2. 在外部类中，编写一个方法，可以返回 Inner08 对象 //方法，返回一个Inner08实例 public Inner08 getInner08Instance(){ return new Inner08(); } //调用 Outer08.Inner08 inner08Instance = outer08.getInner08Instance(); inner08Instance.say(); -
如果成员内部类的成员和外部类的成员重名，会遵守就近原则，可以通过 外部类.this.属性 来访问。
2、静态内部类
public class StaticInnerClass01 {
public static void main(String[] args) {
Outer10 outer10 = new Outer10();
outer10.m1();
//外部其他类 使用静态内部类
//方式1
//直接创建一个 外部类.静态内部类 对象
Outer10.Inner10 inner10 = new Outer10.Inner10();
inner10.say();
//方式2
//编写一个方法，可以返回静态内部类的对象实例
Outer10.Inner10 inner101 = outer10.getInner10();
Outer10.Inner10 inner10_ = Outer10.getInner10_();
inner10_.say();
}
}
class Outer10 {//外部类
private int n1 = 10;
private static String name = "张三";
private static void cry() {}
//Inner10就是静态内部类
//1. 放在外部类的成员位置
//2. 使用static修饰
//3. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
//4. 可以添加任意访问修饰符(public, protected,默认,private),因为它的地位就是一个成员
//5. 作用域：同其他的成员，为整个类体
//6. 如果外部类和静态内部类的成员重名时，静态内部类访问时，默认遵循就近原则，
// 如果想访问外部类的成员，则可以使用（外部类名.成员）
static class Inner10 {
private static String name = "李四";
public void say() {
System.out.println(name + " 外部类name= " + Outer10.name);
cry();
}
}
//外部类访问静态内部类，创建对象，在访问
public void m1() {
Inner10 inner10 = new Inner10();
inner10.say();
}
public Inner10 getInner10() {
return new Inner10();
}
public static Inner10 getInner10_() {
return new Inner10();
}
}
/* 运行结果
李四 外部类name= 张三
李四 外部类name= 张三
李四 外部类name= 张三
*/
3、局部内部类
-
可以直接访问外部类的所有成员，包含私有的
-
不能添加访问修饰符，但是可以使用 final 修饰
-
作用域：仅仅在定义它的方法或代码块中
-
外部类在方法中，可以创建 Inner02 对象，然后调用方法即可
class Outer02{//外部类 public void m1(){//方法 final class Inner02{//局部内部类（本质仍然是一个类） public void f1(){ } } Inner02 inner02 = new Inner02(); inner02.fi(); } } //main 方法中调用 Outer02 outer02 = new Outer02(); outer02.m1(); //调用了fi() 方法 -
（在类的方法中的类，调用的时候可以在此方法最后 new 局部内部类）
-
如果外部类和局部内部类的成员重名，默认遵循就近原则，可以通过 外部类.this.成员 来访问。
4、匿名内部类
-
匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名
-
匿名内部类的基本语法
new 类或接口(参数列表){
类体
};
-
本质还是一个类，内部类，该类没有名字，同时还是一个对象
-
可以直接访问外部类的所有成员，包含私有的
-
不能添加访问修饰符，因为它的地位就是一个局部变量
-
作用域：仅仅在定义它的方法或代码快中
-
匿名内部类访问外部类成员，直接访问
-
外部其他类不能访问匿名内部类（因为匿名内部类地位是一个局部变量）
-
如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则，
如果想访问外部类成员，则可以使用 (外部类名.this.成员) 去访问
public class AnonymousInnerClass {
public static void main(String[] args) {
Outer04 outer04 = new Outer04();
outer04.method();
}
}
class Outer04 { //外部类
private int n1 = 10;
public void method() {
//基于接口的匿名内部类
//3. 需求是 Tiger/Dog 类只是使用一次，后面再不使用
//4. 可以使用匿名内部类来简化开发
//5. tiger的编译类型 A
//6. tiger的运行类型 就是匿名内部类 XXXX => Outer04$1
/*
我们看底层
class XXXX implements A {
@Override
public void cry() {
System.out.println("老虎来了。。。");
}
}
*/
//7. jdk底层在创建匿名内部类 Outer04$1，立即马上就创建了 Outer04$1 实例，并且把地址
// 返回给 tiger
//8. 匿名内部类使用一次，就不能使用了，但是tiger可以多次使用
A tiger = new A() {
@Override
public void cry() {
System.out.println("老虎来了。。。");
}
};
System.out.println("tiger的运行类型=" + tiger.getClass());
tiger.cry();
tiger.cry();
tiger.cry();
//演示基于类的匿名内部类
//1. father编译类型 Father
//2. father运行类型 Outer04$2
//3. 底层会创建匿名内部类
/*
class Outer04$2 extends Father{
}
*/
//4. 同时也返回了 匿名内部类 Outer04$2 的对象
//5. 注意("jack")参数列表会传递给 构造器
Father father = new Father("jack") {
@Override
public void test() {
System.out.println("匿名内部类重写了test方法");
}
};
System.out.println("father的运行类型=" + father.getClass());
father.test();
//基于抽象类的匿名内部类
Animal animal = new Animal(){
@Override
void eat() {
System.out.println("小狗吃骨头。。。");
}
};
animal.eat();
}
}
interface A { //接口
public void cry();
}
class Father {
public Father(String name) { //构造器
System.out.println("接收到的name= " + name);
}
public void test() {
}
}
abstract class Animal { //抽象类
abstract void eat();
}
/*
运行结果
tiger的运行类型=class com.hspedu.practice.Outer04$1
老虎来了。。。
老虎来了。。。
老虎来了。。。
接收到的name= jack
father的运行类型=class com.hspedu.practice.Outer04$2
匿名内部类重写了test方法
小狗吃骨头。。。
*/
public class AnonymousInnerClassDetail {
public static void main(String[] args) {
Outer05 outer05 = new Outer05();
outer05.f1();
System.out.println("main outer05 hashcode=" + outer05);
}
}
class Outer05 {
private int n1 = 99;
public void f1(){
//创建一个基于基本类的匿名内部类
Person01 p = new Person01(){
private int n1 = 88;
@Override
public void hi() {
System.out.println("匿名内部类重写了 hi()方法 n1 = " + n1 +
"外部类的n1=" + Outer05.this.n1);
//Outer05.this 就是调用 f1的 对象
System.out.println("Outer05.this hashcode=" + Outer05.this);
}
};
p.hi(); //动态绑定，运行类型是 Outer05$1
//也可以直接调用，匿名内部类本身也是返回对象
// class 匿名内部类 extends Person {}
new Person01(){
@Override
public void hi() {
System.out.println("匿名内部类重写了 hi()方法,哈哈哈。。。");
}
@Override
public void ok(String str) {
super.ok(str);
}
}.ok("jack");
}
}
class Person01 {
public void hi() {
System.out.println("Person01 hi()");
}
public void ok(String str) {
System.out.println("Person01 ok()" + str);
}
}
/*
运行结果
匿名内部类重写了 hi()方法 n1 = 88外部类的n1=99
Outer05.this hashcode=com.hspedu.practice.Outer05@154617c
Person01 ok()jack
main outer05 hashcode=com.hspedu.practice.Outer05@154617c
*/
public class InnerClassExercise01 {
public static void main(String[] args) {
//当作实参直接传递，简洁高效
f1(new IL() {
@Override
public void show() {
System.out.println("这是一副名画。。。");
}
});
//传统方法
f1(new Picture());
}
//静态方法 形参是接口类型
public static void f1(IL il) {
il.show();
}
}
interface IL {
void show();
}
class Picture implements IL {
@Override
public void show() {
System.out.println("这是一副名画。。。");
}
}
/*
运行结果
这是一副名画。。。
这是一副名画。。。
*/
public class InnerClassExercise02 {
public static void main(String[] args) {
CellPhone cellPhone = new CellPhone();
//1. 传递的是实现了 Bell接口的匿名内部类
//2. 重写了 ring
//3. Bell bell = new Bell() {
// @Override
// public void ring() {
// System.out.println("懒猪起床了。");
// }
// }
cellPhone.alarmClock(new Bell() {
@Override
public void ring() {
System.out.println("懒猪起床了。");
}
});
cellPhone.alarmClock(new Bell() {
@Override
public void ring() {
System.out.println("小伙伴们上课了。");
}
});
}
}
interface Bell{
void ring();
}
class CellPhone{
public void alarmClock(Bell bell){
System.out.println(bell.getClass());
bell.ring();
}
}
/*
运行结果
class com.hspedu.practice.InnerClassExercise02$1
懒猪起床了。
class com.hspedu.practice.InnerClassExercise02$2
小伙伴们上课了。
*/
