内部类总结

内部类

1、内部类概念

在Java中，允许在一个类的内部定义类，这样的类称作内部类，这个内部类所在的类称作外部类

2、内部类分类

• 成员内部类
• 局部内部类
• 静态内部类
• 匿名内部类

3、四种内部类详解

3.1、成员内部类

在一个类中除了可以定义成员变量和成员方法外，还可以定义类，这样的类被称为成员内部类

限制

• 在成员内部类中，可以访问外部类的所有成员，包括成员变量和成员
• 在外部类中，同样也可以访问成员内部类的变量和方法

package com.my.demo;
//测试成员内部类
public class demo01 {
    public static void main(String[] args) {
        //创建外部类对象
        Outer outer = new Outer();

        //创建内部类对象
        Outer.Inner inner = outer.new Inner();

        inner.show02();
        outer.test02();
    }
}

class Outer{
    int m=0;

    public void test01(){
        System.out.println("外部类测试方法！");
    }
    class Inner{
        int n=1;

        //定义内部类方法访问外部类变量和方法
        public void show01(){
            System.out.println("内部类测试方法！");
        }

        public void show02(){
            System.out.println("调用了外部类的测试方法");
            test01();
        }
    }
    //定义外部类方法访问内部类变量和方法
    public void test02(){
        Inner inner = new Inner();
        inner.show01();
    }
}

本质

• 成员内部类对于外部类来说：它的“地位”和外部类的变量、方法“等价”

3.2、局部内部类（方法内部类）

局部内部类也叫方法内部类，定义在某个局部范围中的类；它和局部变量一样都是在方法中定义的

局部内部类和类方法中的局部变量“等价”！

限制

• 在局部内部类中，可以访问外部所有的成员变量和方法

  而局部内部类中的变量和方法，只能在该局部内部类所在的方法中进行访问！！！！

package com.my.demo;

public class demo02 {
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();

        outer02.test02();
    }
}

class Outer02{
    int m=0;

    public void test01(){
        System.out.println("执行了外部类的成员方法");
    }

    public void test02(){
        class Inner02{
            int n=1;

            public void show01(){
                System.out.println("执行了局部内部类的成员方法");
                test01();
            }
        }
        Inner02 inner02 = new Inner02();
        System.out.println("局部方法中调用了局部内部类的方法");
        inner02.show01();
    }
}

本质：

• 局部内部类和类中方法里面的局部变量“等价”

3.3、静态内部类

静态内部类就是使用static关键字修饰的成员内部类

限制

• 静态内部类，只能访问外部类的静态成员
• 外部类访问静态内部成员时，可以跳过外部类从而直接通过内部类访问静态内部类成员（也就是说成员内部类和静态内部类在访问该内部类下的成员时，实例化对象的方式发生了改变）

package com.my.demo;

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

        //注意创建静态内部类实例化对象的方式
        Outer03.Inner03 inner03 = new Outer03.Inner03();
        inner03.show();
    }
}
class Outer03{
    static int m=0;

    static class Inner03{
        public void show(){
            System.out.println("静态内部类访问外部类中的静态变量："+m);
        }
    }

    public void test01(){
        System.out.println("执行外部类中的方法");
    }
}

3.4、匿名内部类

在Java调用某个方法时，如果该方法的参数是一个接口类型，除了可以传入一个参数（这个参数可以是实现该接口的类的类对象（实例）），还可以使用匿名内部类实现接口来作为方法的参数

匿名内部类其实就是没有名称的内部类

仔细理解下面两种方式：

package com.my.demo;

public class demo04 {
    public static void main(String[] args) {
        String name="小花";

        //定义匿名内部类作为参数传递给animalShout()方法
        animalShout(new Animal(){
            public void shout(){
                System.out.println(name+"喵喵");
            }
        });
    }

    //定义静态方法animalShout，接收“接口类型参数”
    public static void animalShout(Animal an){
        an.shout();
    }
}

//定义动物接口
interface Animal{
    public void shout();
}

package com.my.demo;

public class demo05 {
    public static void main(String[] args) {
        
        //匿名内部类方式
        Person person = new Person() {
            public void eat() {
                System.out.println("eat  something!");
            }
        };
        person.eat();
        
        //传统方式
        Child child = new Child();
        child.eat();
    }
}

class Person{
    public void eat(){};
}

class Child extends Person{
    public void eat(){
        System.out.println("eat anything!");
    }
}