内部类
定义：
一个类的内部又完整的嵌套了另一个类结构，被嵌套的类就被我们称为内部类，嵌套内部类的类被我们称为外部类
//外部类
class Outer
{
//内部类
class Inner
{
}
}
package Innerclass;
//外部其他类
public class c1 {
}
class Outer
{
//属性
private int n1 = 100;
//方法
public void m1()
{
System.out.println("m1()");
}
//内部类
class Inner
{
}
}
内部类的分类
1、定义在外部类局部位置上（比如方法内）
（1）局部内部类（有类名）
（2）匿名内部类（没有类名）
2、定义在外部类的成员位置上
（1）成员内部类（没用static修饰）
（2）静态内部类（使用static修饰）
1、局部内部类
1、局部内部类是定义在外部类的方法中的
2、并且局部内部类可以访问外部类的所有成员包括私有的，访问的方法是直接访问，外部类在方法中可以创建内部类的对象，然后通过内部类的对象去调用其方法
3、不能添加访问修饰符，和局部变量一样，可以用final来修饰
4、作用域只在局部类的方法体内
5、外部其他类不能访问局部内部类（因为局部内部类的地位是一个局部变量）
package Innerclass;
public class LocalInnerClass {
public static void main(String []args)
{
Outer02 outer02 = new Outer02();
outer02.m1();
}
}
//外部类
class Outer02
{
//属性
private int n1 = 100;
//私有方法
private void m2()
{
System.out.println("m2");
}
//方法
public void m1()
{
//局部内部类通常定义在外部类的方法中
//局部内部类
class Inner02
{
//局部内部类可以访问外部类的所有成员，包含私有的
public void f1()
{
m2();
System.out.println("n1 = " + n1);
}
}
Inner02 inner02 = new Inner02();
inner02.f1();
}
}
6、如果外部类和内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员可以使用（外部类名.this.成员）
Out02.this.n2
匿名内部类
1、本质是类
2、内部类, 但实际是有名字的，只不过用完之后会立即被销毁
3、该类是没有名字
4、同时还是一个对象
匿名内部类创建之后，会立马实例化出来，然后这个匿名类内部类就不能再被使用了，但实例化出来的对象是可以反复调用的
基于接口的匿名内部类使用
package Innerclass;
public class AnonymousInnerClass {
public static void main(String []args)
{
Outer04 outer04 = new Outer04();
outer04.method();
}
}
class Outer04
{
private int n1 = 10;
public void method()
{
//基于接口的匿名内部类
//tiger的编译类型？IA
//tiger的运行类型？就是匿名内部类
/*
底层是
class XXXX implements IA
{
public void cry()
{
System.out.println("老虎叫唤...");
}
}
*/
IA tiger = new IA()
{
public void cry()
{
System.out.println("老虎叫唤...");
}
};
System.out.println("tiger的运行类型 = " + tiger.getClass());
tiger.cry();
}
}
interface IA{
public void cry();
}
基于类的匿名内部类
package Innerclass;
public class AnonymousInnerClass {
public static void main(String []args)
{
Outer04 outer04 = new Outer04();
outer04.method();
}
}
class Outer04
{
private int n1 = 10;
public void method()
{
//基于接口的匿名内部类
//tiger的编译类型？IA
//tiger的运行类型？就是匿名内部类
/*
底层是
class XXXX implements IA
{
public void cry()
{
System.out.println("老虎叫唤...");
}
}
*/
IA tiger = new IA()
{
public void cry()
{
System.out.println("老虎叫唤...");
}
};
System.out.println("tiger的运行类型 = " + tiger.getClass());
tiger.cry();
//正常new一个对象
Father father1 = new Father();
System.out.println("father1对象的运行类型是=" + father1.getClass());
//匿名内部类
Father father = new Father()
{
@Override
public void test() {
System.out.println("匿名内部类重写了test方法");
}
};
System.out.println("father对象的运行类型=" + father.getClass());
father.test();
Animal animal = new Animal()
{
@Override
public void say() {
System.out.println("小狗吃骨头");
}
};
animal.say();
}
}
interface IA{
public void cry();
}
class Father
{
public void test() {}
}
abstract class Animal
{
public void say()
{}
}
匿名内部类的使用细节
匿名内部类的定义比较特殊，本身是一个类同时还是一个对象
先定义一个匿名内部类，接收之后，再用生成的对象
不接收直接调用
package Innerclass;
public class AnonymousInnerClassDetail
{
public static void main(String[] args)
{
Outer05 outer05 = new Outer05();
outer05.f1();
}
}
class Outer05
{
private int n1 = 99;
public void f1()
{
Person person = new Person()
{
@Override
public void hi() {
System.out.println("匿名内部类重写了hi");
}
};
person.hi();
//也可以直接调用
new Person()
{
@Override
public void hi() {
System.out.println("匿名内部类重写了hi");
}
}.hi();
}
}
class Person
{
public void hi()
{
System.out.println("Person hi");
}
}
匿名内部类的实践
匿名内部类主要用于当前类只使用一次，使用过后我们就不会再反复使用，这样我们就没有必要专门再写一个类。
package Innerclass;
public class InnerClassExercise01 {
public static void main(String[]args)
{
f1(new IL() {
@Override
public void show() {
System.out.println("这是一幅名画");
}
});
}
public static void f1(IL il)
{
il.show();
}
}
interface IL
{
void show();
}
package Innerclass;
public class InnerClassExercise02 {
public static void main(String[] args)
{
CellPhone cellPhone = new CellPhone();
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)
{
bell.ring();
}
}