Java新手小白入门篇 Java面向对象（六）

Java新手小白入门篇 Java面向对象（知识点体系汇总）

• 面向对象知识链接汇总，知识点体系（思维导图）

Java新手小白入门篇 Java面向对象（一）

• Java面向对象（第一天）类，对象，方法的重载，练习题

Java新手小白入门篇 Java面向对象（二）

• Java面向对象（第二天）构造方法，this关键字，内存结构初识，null，NullPointerException，引用类型数组（上），拓展，练习题

Java新手小白入门篇 Java面向对象（三）

• Java面向对象（第三天）引用类型数组（下），继承，super，向上造型（上），拓展，练习题

Java新手小白入门篇 Java面向对象（四）

• Java面向对象（第四天）向上造型（下），重写，访问控制修饰符，static关键字，拓展，练习题

Java新手小白入门篇 Java面向对象（五）

• Java面向对象（第五天）final，static final，abstract关键字（抽象方法，抽象类）

Java新手小白入门篇 Java面向对象（六）

• Java面向对象（第六天）成员内部类（不经常使用），匿名内部类（经常使用）

Java新手小白入门篇 Java面向对象（七）

• Java面向对象（第五天）接口，拓展（类与接口的关系，抽象类与接口的区别），练习题

Java新手小白入门篇 Java面向对象（八）

• Java面向对象（第八天）多态（对象的多态，行为的多态），拓展（面向对象）

Java新手小白入门篇 Java面向对象（九）

• Java面向对象（第九天）简单的内存结构，面向对象三大特征

---

• Java新手小白入门篇系列持续更新中…

---

一、成员内部类

我们将一个类定义在另一个类的内部，就是内部类。

/**
 * 外部类(外部是相对于内部而言)
 */
public class OuterClass {
    /**
     * 内部类
     */
    class InnerClass {
        // ...
    }
}
1
2
3
4
5
6
7
8
9
10
11

• 应用率不高（了解）

• 类中套类，外面的称为外部类，里面的称为内部类，这是一个相对来讲的概念

• 内部类通常只服务与外部类，对外不具备可见性

• 内部类对象通常在外部类中创建，当然也可以在外部类外部创建内部类对象

  • 在外部类内部创建内部类对象
    • Inner inner = new inner();
  • 在外部类内部创建内部类对象
    • Outer.Inner inner = new Quter().new Inner();

• 内部类中可以直接访问外部类的成员（包括私有的）
  

  public class Outer {
  	    private String name = "张三";
  	    class Inner {
  	    	// 设置为私有也可以被外部类访问，图片截图忘记添加 private 
  	        private void test() { 忘记添加了
  	            System.out.println("name = " + name);
  	        }
  	    }
  	    public void action() {
  	        Inner inner = new Inner();
  	        inner.test();
  	    }
  	    public static void main(String[] args) {
  	        Outer outer = new Outer();
  	        outer.action(); // name = 张三
  	    }
  	}
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17

• 内部类有个隐式的引用指向了创建它的外部类对象

  • 隐式：外部类名.this - Outer.this
    

    public class Outer {
        private String name = "张三";
        private int age = 18;
        class Inner {
            void test() {
                System.out.println("name = " + name + " , age = " + age);
            }
        }
        public void action() {
            Inner inner = new Inner();
            inner.test();
        }
        public static void main(String[] args) {
            Outer outer = new Outer();
            outer.action(); // name = 张三 , age = 18
        }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17

  • 如果内部类如果和外部类变量/方法同名，默认使用的就是内部类的变量和方法（就近原则）
    

    public class Outer {
    
        private String name = "张三";
    
        class Inner {
            private String name = "李四";
            void test() {
                System.out.println("name = " + name);
            }
        }
    
        public void action() {
            Inner inner = new Inner();
            inner.test();
        }
    
        public static void main(String[] args) {
            Outer outer = new Outer();
            outer.action(); // name = 李四
        }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21

二、匿名内部类

• 内部类与外部类是继承或者实现的关系
• 匿名内部类使得代码更加简洁（JDK8 之后的 Lambda 更简洁）
• 内部类没有构造方法

1. 匿名内部类的格式

Outer outer = new Outer() { ... }

• 其中 Outer 为外部类的类名
• { ... } 为内部类
• 内部类继承或者实现了外部类（一般来讲这个外部类是抽象类或者接口）

2. 使用场景

• 当一个局部类只使用一次的时候，我们使用匿名内部类
• 因为匿名内部类没有类名，除了定义它的地方，其他地方无法调用。

3. 如何使用

• 匿名内部类在定义的时候已经实例化对象了
• 定义完成就可以直接使用

  • 通过 外部类的引用. 即可，如下面代码

    public class Demo {
        public static void main(String[] args) {
            Outer outer = new Outer() {
                @Override
                void say() {
                    System.out.println("匿名内部类");
                }
            };
            outer.say();
        }
    }
    
    public abstract class Outer {
        abstract void say();
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15