3000字带你学会Java内部类

派小星

于 2022-10-09 08:00:00 发布

阅读量121

点赞数 9

文章标签： java

本文链接：https://blog.csdn.net/m0_73861113/article/details/127217986

版权

内部类

内部类概念

在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类

按照内部类在类中定义的位置不同,可以分为如下两种形式

在类的成员位置：成员内部类
在类的局部位置：局部内部类

内部类的访问特点

内部类可以直接访问外部类的成员，包括私有
外部类要访问内部类的成员，必须创建对象

示例代码：

public class Outer {
    private int num = 10;
    private class Inner {
        public void show() {
            System.out.println(num); //内部类可以直接访问外部类的成员，包括私有
        }
    }
    public void method() {
        Inner i = new Inner();
        i.show();  //外部类要访问内部类的成员，必须创建对象
    }
}

成员内部类

成员内部类的定义位置
- 在类中方法，跟成员变量是一个位置
- 被 private 修饰则是私有成员内部类，被 static 修饰则是静态成员内部类
外界创建成员内部类格式（私有成员内部类和静态成员内部类不能用这种方式）
- 格式：外部类名.内部类名对象名 = 外部类对象.内部类对象;
- Outer.Inner oi = new Outer().new Inner();

class Outer {
    // 当为 public 时，外界创建内部类对象也是像下面这样
    class Inner {
    }
}

class Test {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer().new Inner();
    }
}

私有成员内部类

将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。
示例代码：

class Outer {
    private int num = 10;
    private class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    public void method() {
        Inner i = new Inner();
        i.show();
    }
}

public class InnerDemo {
    public static void main(String[] args) {
        // 这样会报错
		//Outer.Inner oi = new Outer().new Inner();
        Outer o = new Outer();
        o.method();
    }
}

静态成员内部类

创建静态成员内部类对象格式：外部类名.内部类名对象名 = new 外部类名.内部类名();
外界调用静态成员内部类中的静态方法：外部类名.内部类名.方法名();
示例代码

class Outer {
    static class Inner {
        public void show(){
            System.out.println("inner..show");
        }

        public static void method(){
            System.out.println("inner..method");
        }
    }
}

public class Test3Innerclass {
    public static void main(String[] args) {
        // 这样会报错
		//Outer.Inner oi = new Outer().new Inner();
        
        // 外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Outer.Inner oi = new Outer.Inner();
        oi.show();

        Outer.Inner.method(); // 静态成员内部类中静态方法调用方式
    }
}

局部内部类

局部内部类定义位置
- 局部内部类是在方法中定义的类
局部内部类方式方式
- 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
- 该类可以直接访问外部类的成员，也可以访问方法内的局部变量
示例代码（局部内部类在自己平常写和源码中基本不会出现）

class Outer {
    private int num = 10;
    public void method() {
        int num2 = 20;
        class Inner {
            public void show() {
                System.out.println(num);
                System.out.println(num2);
            }
        }
        Inner i = new Inner();
        i.show();
    }
}
public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

匿名内部类

匿名内部类是一种特殊的局部内部类

匿名内部类的前提
- 存在一个类或者接口，这里的类可以是具体类也可以是抽象类
匿名内部类的格式
- 格式：new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }
- 举例：
```
new Inner(){
    @Override
    public void method(){}
} 
```
匿名内部类的本质
- 本质：是一个继承了该类或者实现了该接口的子类匿名对象
匿名内部类的细节

匿名内部类可以通过多态的形式接收

interface Inner {
    void method1();
    void method2();
}
class Test {
    public static void main(String[] args) {
        Inner i = new Inner() {

            @Override
            public void method1() {
                System.out.println("method1……");
            }

            @Override
            public void method2() {
                System.out.println("method2……");
            }
        };
        i.method1();
        i.method2();

        // 如果不以多态的形式接收，那么它后面调用其中一个方法了
        new Inner() {

            @Override
            public void method1() {
                System.out.println("method1……");
            }
            
            @Override
            public void method2() {
                System.out.println("method2……");
            }
        }.method1();
    }

}

匿名内部类在开发中的应用场景

当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码。就比如我们都用到过的：Arrays.sort() 方法，我们就可以传入比较器的匿名对象来让数组按我们想要的方式排序

例子：

class Test {
    public static void main(String[] args) {
        Person zs = new Person("张三", 28);
        Person ls = new Person("李四", 19);
        Person ww = new Person("王五", 99);
        Person[] persons = new Person[]{zs, ls, ww};
        Arrays.sort(persons, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        for (Person person : persons) {
            System.out.println(person);
        }
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

输出结果：