java13 内部类

一、内部类

        在一个类的声明里声明的类

        内部类表示的事物是外部类的一部分，内部类单独出现没有任何意义

1.内部类的特点

        内部类可以直接访问外部类的成员，包括私有，static修饰成员

        外部类要访问内部类的成员，必须创建对象

p92

获取内部类：内部类的类名只用于定义它的类或者语句块中，在外部引用它时，必须给出带有外包类名的全部给出，并且外包类和内包类不允许重名

内部类与类中的字段方法一样是外部类的成员，它的前面也有访问控制符和其他修饰符；外部类只能使用public 或者默认

2.成员内部类

        写在成员位置的，属于外包类的成员；成员内部类可以被一些修饰符所修饰，private,默认，protected，public,static;JDK16之后可以定义静态变量

        a.获取内部类的对象

方法一：在外部类中编写方法，对外提供内部类的对象（private修饰内部类时候）

方法二：直接创建格式：外部类名.内部类名 对象名 = 外部类对象名(外部类对象实例).new  内部类(当成员内部类被非私有修饰时）

        如果用private修饰内部类，外界不能直接创建对象（Outer.Inner oi = new Outer().new Inner();) 此时可以外部类编写方法，对外提供内部类对象/或者修改权限修饰符

//外部类
public class Outer {
    String name;
    private  class Inner{
    }
    public Inner getInstance(){
        return new Inner();
    }//在外部类中编写方法，对外提供内部类的对象
}

//测试类
public class Test1 {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.getInstance();//获取到内部类的对象
       // Outer.Inner inner = o.getInstance();//报错 ，Inner 是私有的
        //解决方法
        //使用Inner的父类接受
        Object inner = o.getInstance();
        //直接使用
        System.out.println(o.getInstance());
    }
}

        b.成员内部类成员变量/方法与外部类成员/方法变量重名时，在内部类访问外部类成员变量：

Outer.this.变量名

package com.heimait02;

public class Outer {
    private int a = 10;
    class Inner{
        private  int a = 20;
        public void show(){
            int a= 30;
            System.out.println(a);//30
            System.out.println(this.a);//20
            System.out.println(Outer.this.a);//10
        }
    }
}

3.静态内部类

静态内部类只能访问外部类中的静态变量和静态方法，如果访问非静态的需要创建外部类对象

        a.创建静态内部类对象的格式：外部类名.内部类名 对象名 = new 外部类名.内部类名（）；

        调用非静态方法的格式：先创建对象，再用对象调用

        调用静态方法的格式：外部类名.内部类名.方法名（）；

package com.heimait03;
//外部类
public class Outer {
    int a =10;
    static int b = 20;
    static class Inner{
        public void show1(){
            System.out.println("非静态的方法被调用了");
            System.out.println(b);
          //  System.out.println(a);//报错
           // 解决：
            Outer o = new Outer();
            System.out.println(o.a);//调用外部类的非静态变量，非静态方法同理

        }
        public static void show2(){
            System.out.println("静态的方法被调用l");
            System.out.println(b);
            //  System.out.println(a);//报错
            // 解决：
            Outer o = new Outer();
            System.out.println(o.a);
        }
    }
}

//测试类
package com.heimait03;

public class Test {
    public static void main(String[] args) {
        //创建静态内部类的对象
        //只要是静态的东西 都可以类名点直接获取
        Outer.Inner oi = new Outer.Inner();
        //调用非静态方法
        oi.show1();
        //调用静态方法
        Outer.Inner.show2();
    }
}

4.局部内部类

将内部类定义在方法里面的就叫局部内部类，类似于方法里面的局部变量；外界是无法直接使用局部内部类的，需要在方法内部创建对象并且使用；该类可以直接访问外部类的成员，也可以访问方法类的局部变量；除了该方法的final据局部变量以外，不能够访问该方法的其他局部变量

//外部类
package com.heimait04;

public class Outer {
    int b = 100;
    public void show()
    {
        int a= 10;
        class Inner{
            String name;
            int age;
            public void method1(){
                System.out.println(a);
                System.out.println(b);
                System.out.println("局部内部类里面的method1方法");
            }
            public  static void method2(){
                System.out.println("局部内部类里面的method2方法");
            }
        }
        Inner i = new Inner();
        System.out.println(i.age);
        System.out.println(i.name);
        i.method1();
        Inner.method2();

    }
}

//测试类
package com.heimait04;
public class Test {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.show();
    }
}

5.匿名内部类

匿名内部类的本质就是隐藏了名字的内部类，可以写在成员位置，也可以写在局部位置

没有类名 在定义类的同时就生成了一个该对象的实例

        a.格式：new 父类名或者接口名（）{重写方法};

包含了继承或者实现，方法重写，创建对象。整体就是一个类的子类对象或者接口的实现类对象

        b.使用场景

当方法的参数是接口或者类的时候，以接口为例，可以传递这个接口的实现类对象，如果实现类只要用一次，就可以用匿名内部类简化代码

匿名类通常用于：

• 实现接口，特别是在接口实现简单且只需使用一次的情况下。
• 继承类，尤其是需要对父类方法做轻微修改时。

Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running in a new thread");
    }
};
new Thread(runnable).start();

 实现只有一个或少量方法的接口

class Animal {
    public void sound() {
        System.out.println("Some generic animal sound");
    }
}

Animal dog = new Animal() {
    @Override
    public void sound() {
        System.out.println("Woof woof");
    }
};

dog.sound();  // 输出：Woof woof

继承现有的类，并且重写其方法，使用与对父类进行轻微修改

        c.应用