java内部类小结

1，本文总结了java4种内部类，包括

• 成员内部类：在外部类内部定义的非静态类；成员内部类不能独立存在，如 UML中类间的组合关联关系；
• 静态内部类：在外部类内部定义的静态类；静态类与外部类关系密切，但可以独立存在，如UML中类间的聚合关联关系；
• 局部内部类：在方法内部定义的内部类；其作用域在方法内部；
• 匿名内部类：顾名思义，没有名字的内部类，通常用于实现接口，没有自定义构造器；；

2，本文给出了 相关的测试用例；

3，内部类的作用

• 1，内部类有自己的实现，有助于外部类实现多继承；1个外部类里面定义多个内部类，每个内部类继承一个父类，就变相实现了多继承；
• 2，提高代码内聚程度；

1）成员内部类：在外部类内部定义的非静态类；成员内部类不能独立存在；

2）代码结构

public class Topic78 {
    private String name;
    public Topic78(String name) {
        this.name = name;
    }
    // 成员内部类
    public class MemberInnerClass {
        private int age;
        public MemberInnerClass(int age) {
            this.age = age;
        }
        // 在外部类定义内部，使用外部类.this指针 指向对外部类对象的引用
        public String hello() {
            return "hello " + Topic78.this.name;
        }
    }
}

3）测试用例

public class MemberInnerClassTest {
    public static void main(String[] args) {
        Topic78 topic78 = new Topic78("lisi");
        // 创建成员内部类
        // 在外部类定义外部，使用外部类对象.new指针 指向对外部类对象的引用
        Topic78.MemberInnerClass memberInnerClass = topic78.new MemberInnerClass(18);
        System.out.println(memberInnerClass.hello()); // hello lisi
    }
}

注意： 成员内部类使用到了 外部类对象.new 和 外部类.this 两个指针；

1. 外部类对象.new 指针：指向对外部类对象的引用； （创建内部类对象时使用）
2. 外部类.this 指针：指向对外部类对象的引用；（在内部类使用外部类对象的属性时使用）

1）定义：静态内部类，在外部类内部定义的静态类；静态类与外部类关系密切，但可以独立存在，如UML中的聚合；

2）代码结构

public class Topic77 {
    
    public static class StaticInnerClass {
        String name;
        public StaticInnerClass(String name) {
            this.name = name;
        }
        public void sayHello() {
            System.out.println("hello " + name);
        }
    }
}

3）测试用例：；

public class StaticInnerClassTest {
    public static void main(String[] args) {
        Topic77.StaticInnerClass staticInnerClass = new Topic77.StaticInnerClass("zhangsan");
        staticInnerClass.sayHello();  // hello zhangsan
    }
}

1）定义：局部内部类， 在方法内部定义的内部类；

• 其作用域：是当前方法块，以及访问外部类的所有成员；但无法在当前方法之外定义和使用它；

2）代码结构

public class LocalInnerClassTest {
    private String name;
    public LocalInnerClassTest(String name) {
        this.name = name;
    }
    public void sayHello() {
        // 在方法内部定义局部内部类
        // 其作用域：是当前方法块，以及访问外部类的所有成员；（无法在当前方法之外定义和使用它）
        class LocalInnerClass {
            public String hello() {
                return "hello " + name;
            }
            public String nice2MeetYou() {
                return "nice to meet you";
            }
        }
        LocalInnerClass localInnerClass = new LocalInnerClass();
        System.out.println(localInnerClass.hello());
        System.out.println(localInnerClass.nice2MeetYou());
    }
    
    public static void main(String[] args) {
        new LocalInnerClassTest("lisi").sayHello();
    }
}

3）测试用例：

同上；

hello lisi
nice to meet you

1）定义：匿名内部类，顾名思义，没有名字的内部类，通常用于实现接口，没有自定义构造器；

2）代码结构： 并发编程实现Runnable接口

public class AnonymousInnerClassTest {
    public static void main(String[] args) {
        // 通过匿名内部类实现 Runnable接口，简化代码
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("hello world");
            }
        };
        runnable.run();
    }
}