Java ------内部类

内部类

        在Java中，允许在一个类的内部定义类，这就叫内部类，其所在的类就是外部类。

        在实际开发中，根据内部类的位置、修饰符和定义方式的不同，内部类可分为成员内部类、 局部内部类、静态内部类、匿名内部类。

成员内部类

        一个类可以定义成员变量、成员方法和还可以定义类就是成员内部类，成员内部类、成员变量和成员方法同一级。

        成员内部类可以无视权限访问外部类的所有成员。

       （测试类）想通过外部类要访问内部类，则要创建内部类对象

        格式如下：外部类名 外部类对象=new 外部类名();

                           外部类名.内部类名 内部类对象=外部类对象.new 内部类名(); 

package 内部类;

public class Example20 {
    public static void main(String[] args){
        //实例化外部类
        Outer outer =new Outer();
        //实例化外部类
        Outer.Inner inner=outer.new Inner();
        inner.show1();
        outer.test2();
    }
}
class Outer{
    int m=0;
    //定义成员方法test1()
    void test1(){
        System.out.println("外部类成员方法test1()");
    }
    //定义成员内部类
    class Inner{
        int n=1;
        void show1(){
            //在成员内部类的方法中访问外部类的成员变量m
            System.out.println("外部类成员变量m="+m);
            //在成员内部类的方法中访问外部类的成员方法test1
            test1();
        }
        void show2(){
            System.out.println("成员内部类方法show2()");
        }
    }
    //外部类方法test2()
    void test2(){
        Inner inner=new Inner();
        System.out.println("内部类的成员变量n="+inner.n);
        inner.show2();
    }
}

局部内部类

         也叫方法内部类，是指定义在某个局部范围中的类，在方法中定义

        访问外部类的所有成员。

        与局部变量同等级

        在外部类访问局部内部类的成员，只能在内部类所属的方法下创建内部类对象，通过该对象访问

package 内部类;

public class Example21 {
    public static void main(String[] args){
        Outer1 outer = new Outer1();
        outer.test2();  //通过外部类对象outer调用创建了局部内部类的方法test2()
    }
}
class Outer1 {
    int m = 0;

    void test1() {
        System.out.println("外部类成员方法test1()");
    }

    void test2() {
        class Inner {
            int n = 1;

            void show() {
                System.out.println("外部类成员变量m=" + m);
                test1();
            }
        }
        //访问局部内部类中的变量和方法
        Inner inner =new Inner();
        System.out.println("局部内部类变量n="+inner.n);
        inner.show();
    }
}

静态内部类

        形式上只是在成员内部类加了static

        功能上静态内部类只能访问外部类的静态成员

通过外部类访问静态内部类成员时，可以通过外部类直接创建一个静态内部类对象。(y因为程序已经提前在静态常量区为静态内部类分配好了内存，所以即使静态内部类没有加载)

格式如下：外部类名.静态内部类名 变量名=new 外部类名.静态内部类名();

package 内部类;

public class Example22 {
    public static void main(String[] args){
        Outer3.Inner inner= new Outer3.Inner();
        inner.show();
    }
}
class Outer3{
    static int m=0;
    //下面的代码定义了一个静态内部类
    static class Inner{
        int n=1;
        void show(){
            //有静态内部类的方法中访问外部类的静态变量m
            System.out.println("外部静态变量m="+m);
        }
    }
}

匿名内部类

        就是没有名称的内部类

        格式：new 类名/接口(){

                        重写抽象方法}

或 new 继承的父类或实现的接口名(){

        匿名内部类的类体

}

        使用条件:作用于类或者接口只有一个抽象方法的时候

方法中的参数可以是接口类型，除了可以传入一个接口实现类，还可以传入实现接口的匿名内部类作为参数

        

interface Animal1{   //定义接口
    void shout();   //定义抽象方法
}


public class Example23 {
    public static void main(String[] args){
        String name ="小花";
        animalShout(new Animal1(){   //调用animalShout()方法,参数为匿名内部类
            @Override  //@Override 注解只能应用于重写父类方法的方法上
            public void shout(){
                System.out.println(name+"喵喵。。。。。");  //访问final修饰的局部变量 jdk8后就不用了
            }
        });
    }
    //定义一个animalShout()方法，创建Animal1 an 作为参数
    public static void animalShout(Animal1 an){   //该方法参数为Animal1接口类型
        an.shout();
    }
}

可以理解为    接口类型 对象          new 接口类型（）{匿名类体}；  分开写