java中的内部类

java中的内部类

1.什么是内部类？

​ 顾名思义，内部类就是定义在内部的类。内部类因为定义的位置不同可以分为成员内部类，静态内部类，局部内部类，匿名内部类

2.为什么要使用内部类？

内容转载：https://blog.csdn.net/leaf__yang/article/details/126221094

官方给的内部类优点如下：
1.每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。内部类使得多继承的解决方案变得完整；
2.方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏；
3.方便编写事件驱动程序；
4.方便编写线程代码。

3.1 成员内部类

成员内部类是定义类的内部，方法的外部的类，依赖于外部类

**特点：**1.内部类可以访问外部类的所有方法和变量

​ 2.在内部类和外部类同名变量时，通过外部类.this.变量名来访问

public class Class04 {
    public static void main(String[] args) {
        //定义一个外部类对象
        Outer1 outer1 = new Outer1();
        //成员内部类依赖于外部类，所以内部类对象依赖于外部类对象创建
        Outer1.Inner inner = outer1.new Inner();
        inner.test();
        //通过类名调用静态方法
        Outer1.Inner.testS();
     }
}
class Outer1{
    private String name = "外部";
    private static int i = 50;
    public void testOuter1(){
        System.out.println("我是外部类的成员方法");
    }
    public static void testStatic(){
        System.out.println("我是外部的静态方法");
    }
    //定义在成员位置的类，成员内部类
    class Inner{
        //可以定义静态方法，也可以定义非静态方法
        String name = "内部";
        static int i = 100;
        int a = 50;
        public void test(){
            //在成员内部类调用外部类变量
            System.out.println(Outer1.this.name);
            //在成员内部类调用外部类的静态变量
            System.out.println(Outer1.i);
            //在成员内部类调用外部成员方法
            new Outer1().testOuter1();
            //在成员内部类调用外部的静态方法
            Outer1.testStatic();
        }
        public static void testS(){
            //在成员内部类的静态方法调用外部类的成员变量
            System.out.println(new Outer1().name);
            //在成员内部类的静态方法调用外部类的静态变量
            System.out.println(Outer1.i);
            //在成员内部类的静态方法调用外部类的成员方法
            new Outer1().testOuter1();
            //在成员内部类的静态方法调用外部类的静态方法
            Outer1.testStatic();
        }
    }
}

3.2静态内部类

静态内部类就是用static修饰的外部类，不依赖于外部类，且在静态内部类不能直接使用外部类的成员变量和方法，需要通过对象调用

public class Class001 {
    public static void main(String[] args) {
        Outer6 outer6 = new Outer6();
        outer6.test();
    }
}
class Outer6{
    private static int i = 10;
    private String name = "外部类";
    static class Inner{
        private static int j = 2;
        private String name = "内部";
        public void testI(){
            //可以直接访问内部类的静态变量
            System.out.println(j);
            //可以直接访问内部类的成员变量
            System.out.println(name);
            //可以直接访问外部的静态变量
            System.out.println(i);
            //不能直接访问外部的成员变量,只能通过对象访问
            System.out.println(new Outer6().name);
        }
        public static void testStatic(){
            //可以直接访问内部类的静态变量
            System.out.println(j);
            //不可以直接访问内部类的成员变量，要通过对象调用
            //System.out.println(name);
            //可以直接访问外部的静态变量
            System.out.println(i);
            //不能直接访问外部的成员变量,只能通过对象访问
            System.out.println(new Outer6().name);
        }
    }
    public void test(){
        Inner in = new Inner();
        in.testI();
    }
}

3.3私有内部类

私有内部类，用private修饰的内部类，只能在外部类中进行操作，创建对象。在其它类中没办法创建对象，也没法对私有的内部类进行操作，一切操作都通过调用外部类来实现

public class Class05 {
    public static void main(String[] args) {
        Outer5 outer5 = new Outer5();
        outer5.testP();
        outer5.test();
    }
}
class Outer5{
    private int i = 5;
    private int j = 55;
    private static String name = "外部";
    public static void testStatic(){
        System.out.println("我是外部类的静态方法");
    }
    public void test(){
        System.out.println("我是外部类的成员方法");
    }
    private class Inner{
        private int j = 50;
        private static int a = 5;
        public static void testS(){
            //调用外部类的成员变量
            System.out.println(new Outer5().i);
            //调用外部类的静态变量
            System.out.println(Outer5.name);
            //调用外部类的成员方法
            new Outer5().test();
            //调用外部类的静态方法
            Outer5.testStatic();
            //调用内部类的成员方法
            System.out.println(new Outer5().new Inner().j);//内部类对象依赖于外部类
        }
        public void test(){
            //调用外部类的成员变量
            System.out.println(i);
            //调用外部类的静态变量
            System.out.println(Outer5.name);
            //调用外部类的成员方法
            new Outer5().test();
            //调用外部类的静态方法
            Outer5.testStatic();
            //调用内部类的成员方法
            System.out.println(Outer5.this.j);
        }
    }
    public void testP(){
        Inner in = new Inner();
        System.out.println(Inner.a);
        System.out.println(in.j);
        
    }
}

3.4局部内部类

局部内部类的特点
1.局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内；
2.局部内部类不可使用权限修饰符 静态(static)修饰符进行修饰 同局部变量相同；
3.局部内部类可以直接访问方法中的属性；
4.局部内部类 可以直接访问方法外部类中属性和方法；
5.局部内部类 创建对象 要在方法内部 局部内部类的外部声明。

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

    }
}
class Outer2{
    private int i = 5;
    private static String name = "外部";
    public void test(){
        int i = 0;
        class Inner{
            private int a = 15;
            private static String name = "内部";
            public void testI(){
                //访问内部类的成员变量i
                System.out.println(i);
                //访问内部类的静态变量name
                System.out.println(name);
                //访问外部类的成员变量i 内部类对象依赖于外部类对象
                System.out.println(Outer2.this.i);
                //访问外部类的静态变量，用类名直接访问
                System.out.println(Outer2.name);
            }
        }
    }

}

3.5匿名内部类

顾名思义，匿名内部类就是没有名字的一种嵌套类。

为什么要使用匿名内部类？

​ 在实际开发中，我们常常在对待一个接口时，首先要写一个类来实现这个接口，重写里边的抽象方法，然后通过这个类创建一个对象，通过这个对象来调用方法。而使用匿名内部类就无需创建类，大大减少了代码量

如何使用

基本格式：

new 接口/类名(参数){
    实现方法(){
        
    }
};

假如我们有一个接口:

interface Animal5{
    void eat();
}

我们在主方法中使用匿名内部类：

Animal5 animal5 = new Animal5(){//new Animal5 :创建了实现父类的子类的对象，子类不能为抽象类   很明显因为不知道子类的类型所以用父类的类型来引用，使用了多态
            @Override//子类要实现父类的抽象方法
            public void eat() {
                System.out.println("eat");
            }
        };
animal5.eat();

匿名内部类也可以用来传递实参。

public static void main(String[] args) {
        Animal5 animal5 = new Animal5(){
            @Override
            public void eat() {
                System.out.println("eat");
            }
        };
        test(new Animal5(){
            @Override
            public void eat() {
                System.out.println("eat");
            }
        });

    }
    public static void test(Animal5 animal){
        System.out.println("Animal");
    }

同时匿名内部类还可以使用在普通类，抽象类上，使用方法同上。