Java学习-内部类

内部类

• 将类A定义在另一个类B里面，A称为内部类(InnerClass)，类B为外部类(Outer Class)

举例

• Thread类内部声明了State类，表示线程的生命周期
• HashMap类中声明了Node类，表示封装key和value

分类

• 成员内部类：直接声明在外部类的里面
  • 使用static修饰的，静态的成员内部类
  • 不使用static修饰的，非静态的成员内部类
• 局部内部类：声明在方法内、构造器内、代码块内的内部类
  • 匿名的局部内部类
  • 非匿名的局部内部类

public class OuterClassTest {
    public static void main(String[] args) {
        //创建Person的静态成员内部类的实例
        Person.Dog dog = new Person.Dog();
        //创建Person的非静态成员内部类实例
        Person person = new Person();
        Person.Bird bird = person.new Bird();
        bird.eat();
        bird.show("秃鹫");
        bird.show1();
    }
}
class Person { //外部类
    String name = "edison";
    int age = 1;
    //静态内部类-只供人类使用
    static class Dog {
        public void eat() {
            System.out.println("狗改不了吃粑粑");
        }
    }
    //非静态成员内部类
    class Bird {
        String name = "猫头鹰";
        public void eat() {
            System.out.println("鸟吃虫子");
        }
        public void show(String name) {
            System.out.println("age = " + age);  //省略了Person.this
            System.out.println("name = " + name);//形参name
            System.out.println("name = " + this.name);        //调用当前对象的name属性
            System.out.println("name = " + Person.this.name); //调用Person.name
        }
        public void show1() {
            eat();
            Person.this.eat();  //外部类的eat
        }
    }
    public void eat() {
        System.out.println("人吃肉");
    }
    public void method() {
        class InnerClass1 {
        }
    }
    public Person() {
        class InnerClass1 {
        }
    }
}

成员内部类的理解

• 从类的角度看
  • 内部类可以声明属性，方法，构造器，代码块，内部类等结构
  • 此内部类可以声明父类，可以实现接口
  • 可以使用final修饰
  • 可以使用abstract修饰
• 从外部类的成员角度看
  • 在内部可以调用外部类的结构，如属性、方法等
  • 除了使用public、缺省权限修饰外，还可以使用private,protected修饰
  • 可以使用static修饰
• 如何创建成员内部类的实例

//匿名内部类使用
package com.lotus.java;

public class OuterClassTest2 {
    public static void main(String[] args) {
        //①提供了接口匿名实现类的对象
        A a = new A() {
            @Override
            public void method() {
                System.out.println("匿名实现类重写的方法method()");
            }
        };
        a.method();
        //②提供了接口匿名实现类的匿名对象
        new A() {
            @Override
            public void method() {
                System.out.println("匿名实现类重写的方法method()");
            }
        }.method();
        //③
        SubB s1 = new SubB();
        s1.method1();
        //④提供了继承于抽象类的匿名子类的对象
        B b = new B() {

            @Override
            public void method1() {
                System.out.println("继承抽象类的子类调用的方法");
            }
        };
        b.method1();
        //⑤提供了继承于抽象类的匿名子类
        new B() {

            @Override
            public void method1() {
                System.out.println("继承抽象类的子类调用的方法");
            }
        }.method1();
        //⑥提供了一个继承于C的子类的对象
        C c = new C() {};
        c.method2();
        //⑦提供了一个继承于C的子类的对象，重写method2方法
        C c1 = new C() {
            @Override
            public void method2() {
                System.out.println("C子类");
            }
        };
        c1.method2();
    }
}
interface A {
    public void method();
}
class SubA implements A {

    @Override
    public void method() {
        System.out.println("SubA");
    }
}
abstract class B {
    public abstract void method1();
}
class SubB extends B {
    @Override
    public void method1() {
        System.out.println("SubB");
    }
}
class C {
    public void method2() {
        System.out.println("C");
    }
}