Java内部类与匿名类

内部类

定义：

一个类的内部又完整的嵌套了另一个类结构，被嵌套的类就被我们称为内部类，嵌套内部类的类被我们称为外部类

//外部类
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();
    }
}

成员内部类

1、成员内部类是定义在外部类的成员位置，并且没有static修饰。

2、成员内部类可以直接访问外部类的所有成员，包括私有成员。

3、外部类访问内部类，就是直接创建一个内部类然后通过类进行访问。

4、我们可以用public、private、protected去修饰，因为它本身就是一个成员

。

package Innerclass;
public class MemberInnerClass {
    public static void main(String [] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();
    }
}
class Outer08{
    private int n1 = 10;
    public String name = "张三";
    class Inner08{
        public void say()
        {
            System.out.println("n1 = " + n1 + " name = " + name);
        }
    }
    public void t1(){
        Inner08 inner08 = new Inner08();
        inner08.say();
    }
}

外部其他类使用成员内部类的两种方式

1、



2、

静态内部类

比上个内部类多了一个static修饰符

1、静态内部类，在外部类的成员位置，有static修饰

2、可以访问外部类的所有静态成员，非静态不能访问

3、作用域为整个类体

package Innerclass;
public class StaticInnerClass {
    public static void main(String[] args) {
        Outer10 outer10 = new Outer10();
        outer10.m1();
    }
}
//外部类
class Outer10{
    private int n1 = 10;
    private static String name = "张三";
    //静态内部类，在外部类的成员位置，有static修饰
    //可以访问外部类的所有静态成员，非静态不能访问
    //作用域为整个类体
    static class Inner10{
        public void say(){
            System.out.println(name);
        }
    }
    public void m1(){
        Inner10 inner10 = new Inner10();
        inner10.say();;
    }
}