java内部类

1 内部类

1.1 概述

● 内部类就是定义在一个类里面的类。内部内（寄生），外部内（宿主）

1.2 使用场景

● 内部的完整结构只为外部事务提供服务，那么内部的完整结构可以使用内部类来设计

● 内部类通常可以方便访问外部类的成员，包括私有成员

● 内部类提供了更好的封装性，可用private，protected

1.3 分类

① 静态内部类

② 成员内部类（非静态内部类）

③ 局部内部类

④ 匿名内部类

---

 

2 静态内部类

2.1 什么是静态内部类

● 有static修饰，属于外部类本身

● 特点和使用方法与普通类一样，类有的成分它都有，只是位置在别人里面而已

2.2 创建对象格式

2.3 访问拓展

● 静态内部类可以访问外部类的静态成员

● 静态内部类不可以直接访问外部内的实例成员

2.4 代码实例

【案例1】Outer类

/**
   外部类
 */
public class Outer {
    public static int a = 100;
    public  int b = 200;
    private static String hobby;
    private String hobby2;

    /*
        静态成员内部类
     */
    public static class Inner{
        private String name;
        private int age;
        public static String schoolName;

        public Inner(){};

        public void show(){
            System.out.println("名字："+name);
            System.out.println(hobby);

            //System.out.println(b);          ×
            //System.out.println(hobby2);     ×

            //间接访问
            //Outer o = new Outer();
            //System.out.println(o.hobby);
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }

}

【案例2】test类

public class Test {
    public static void main(String[] args) {

        Outer.Inner in = new Outer.Inner();
        in.setName("张三");
        in.show();

    }
}

 运行结果：

名字：张三
null

---

 

3 成员内部类

3.1 什么是成员内部类

● 无static修饰，属于外部类的对象

● JDK16之前，成员内部类中不能定义静态成员，JDK16开始也可以定义静态成员了

3.2 创建对象格式

3.3 访问拓展

● 成员内部类可以直接访问外部类的静态成员，外部类的静态车成员只有一份可以被共享

● 成员内部类的实例方法可以直接访问外部类的实例成员，因为必须先有外部类对象，才能有成员内部类对象，所以可以直接访问外部类对象的实例成员·。

3.4 代码实例

【案例1】Outer类

/**
   外部类
 */
public class Outer {
    public static int num = 777;
    private String hobby;

    /*
        成员内部类：不能加static修饰(JDK16之前)， 属于外部类的对象
     */
    public class Inner{
        private String name;
        private int age;
        //public static int a = 100; (JDK16前不可使用)

        public void show(){
            System.out.println("名称："+name);
            System.out.println("数量："+num);
            System.out.println("爱好："+hobby);
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }
}

 【案例2】test类

public class Test {
    public static void main(String[] args) {

        Outer.Inner in = new Outer().new Inner();
        in.setName("叶子");
        in.show();

    }
}

 运行结果：

名称：叶子
数量：777
爱好：null

3.5 成员内部类面试题

【案例】请观察如下代码，写出合适的代码对应其注释要求输出的结果。

注意：在成员内部类中访问所在外部类对象，格式：外部类名.this 

【案例】

public class Test2 {
    public static void main(String[] args) {

        People.Heart heart = new People().new Heart();
        heart.show();

    }
}

class People{
    private int heartbeat = 150;

    /**
     成员内部类
     */
    public class Heart{
        private int heartbeat = 110;

        public void show(){
            int heartbeat = 78;
            System.out.println(heartbeat); // 78
            System.out.println(this.heartbeat); // 110
            System.out.println(People.this.heartbeat); // 150
        }
    }
}

运行结果：

78
110
150

 

4 局部内部类 （鸡肋语法，了解即可）

● 局部内部类放在方法、代码块、构造器等执行体中

● 局部内部类的类文件名为：外部类$N内部类.class

【案例】

/**
    目标：了解局部内部类的语法
 */
public class Test {

    static {
         class Dog{

         }

         abstract class Animal{

         }

         interface SportManInter{

         }
    }

    public static void main(String[] args) {
        class Cat{
            private String name;

            public static int onLineNumber = 100;

            public String getName() {
                return name;
            }

            public void setName(String name) {
                this.name = name;
            }
        }

        interface SportManInter{

        }

        Cat c = new Cat();
        c.setName("叮当猫~");
        System.out.println(c.getName());
    }
}

 

5 匿名内部类

5.1 什么是匿名内部类

5.1.1 概述

● 本质上是一个没有名字的局部内部类，定义在方法体、代码块里面。

● 作用：方便创建子类对象，最终目的为了简化代码编写。

5.1.2 格式

5.1.3 特点

● 匿名内部类没有名字

● 匿名内部类写出来就会产生一个匿名内部类的对象

● 匿名内部类的对象类型相当于是当前new的那个类型的子类类型

5.2 匿名内部类思想引入

【案例1】抽象类 Animal        子类 Tiger

/**
      目标：学习匿名内部类的形式和特点。
 */
public class Test {
    public static void main(String[] args) {

        Animal a = new Tiger();
        a.run();

    }
}

class Tiger extends Animal{
    @Override
    public void run() {
        System.out.println("老虎跑的快~~~");
    }
}

abstract class Animal{
    public abstract void run();
}

运行结果：

老虎跑的快~~~

【案例2】匿名内部类

① 匿名内部类没有名字

② 匿名内部类写出来就会产生一个匿名内部类的对象

③ 匿名内部类的对象类型相当于是当前new的那个类型的子类类型

/**
      目标：学习匿名内部类的形式和特点。
 */
public class Test {
    public static void main(String[] args) {

        Animal a = new Animal() {
            @Override
            public void run() {
                System.out.println("老虎跑的快~~~");
            }
        };
        a.run();

    }
}

abstract class Animal{ 
    public abstract void run();
}

运行结果：

老虎跑的快~~~

5.3 匿名内部类常见使用形式

【案例1】接口Swimming      实现接口类 Student

/**
    目标：掌握匿名内部类的使用形式（语法）
 */
public class Test2 {
    public static void main(String[] args) {
        Student s = new Student();
        go(s);
    }

    /*
        学生、老师、运动员可以一起参加游泳比赛
     */
    public static void go(Swimming s){
        System.out.println("开始。。。");
        s.swim();
        System.out.println("结束。。。");
    }
}

class Student implements  Swimming{
    @Override
    public void swim() {
        System.out.println("学生快乐的自由泳🏊‍");
    }
}

interface Swimming{
    void swim();
}

运行结果：

开始。。。
学生快乐的自由泳🏊‍
结束。。。

【案例2】 观察学生、老师到运动员代码的简化

/**
    目标：掌握匿名内部类的使用形式（语法）
 */
public class Test2 {
    public static void main(String[] args) {
        Swimming s = new Swimming() {
            @Override
            public void swim() {
                System.out.println("学生快乐的自由泳🏊‍");
            }
        };
        go(s);

        System.out.println("---------------------");

        Swimming s1 = new Swimming() {
            @Override
            public void swim() {
                System.out.println("老师泳🏊的贼快~~~~~");
            }
        };
        go(s1);

        System.out.println("---------------------");

        go(new Swimming() {
            @Override
            public void swim() {
                System.out.println("运动员🏊的快飞起来了~~~~~");
            }
        });

    }

    /*
        学生、老师、运动员可以一起参加游泳比赛
     */
    public static void go(Swimming s){
        System.out.println("开始。。。");
        s.swim();
        System.out.println("结束。。。");
    }
}

interface Swimming{
    void swim();
}

 运行结果：

开始。。。
学生快乐的自由泳🏊‍
结束。。。
---------------------
开始。。。
老师泳🏊的贼快~~~~~
结束。。。
---------------------
开始。。。
运动员🏊的快飞起来了~~~~~
结束。。。

 解析：

5.4 匿名内部类真实使用场景演示