java内部类

一、内部类是什么

字面意思，在类的内部编写的类就叫内部类！即一个类的内部又完整的嵌套了另一个类结构，被嵌套的类称为内部类(inner class),嵌套其他类的类称为外部类(outer class)。
基本格式：

public class Outer{
        class Inner{
        }
    }

二、内部类类别

1.成员内部类

定义：成员内部类是定义在外部类的成员位置上，并且没有static修饰

创建方法：

代码如下：

成员内部类

public class Outer {
    private int a = 10;

    class Inner{
        private int a = 20;

        public void show(){
            int a = 30;

            System.out.println(Outer.this.a); //10  //System.out.println(new Outer().a);
            System.out.println(this.a); //20
            System.out.println(a);  //30
        }
    }
}

实现类

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

---

使用了private 修饰符

public class Outer {
    private int a = 10;

    private class Inner{
        private int a = 20;
        public void show(){
            int a = 30;

            System.out.println(this.a); //20
            System.out.println(a);  //30
        }
    }
    //在外面创建方法，类似get/set方法
    public Inner getInstance(){
        return new Inner();
    }
}

实现类

public class Test {
    public static void main(String[] args) {
        // Outer.Inner oi = new Outer().new Inner();
        Outer o = new Outer();
        //类似多态，用父类接收
        Object o1 = o.getInstance();
        System.out.println(o1);
        System.out.println(o.getInstance());
    }
}

2.静态内部类

定义：静态内部类是定义在外部类的成员位置上，并且有static修饰

静态内部类

public class Outer {
    static class Inner{
        public void show1(){
            System.out.println("Not static method");
        }
        public static void show2(){
            System.out.println("static method");
        }
    }
}

实现类

public class Test {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer.Inner();
        oi.show1();
        //静态方法的调用
        Outer.Inner.show2();
    }
}

3.局部内部类

定义：局部内部类是定义在外部类的局部位置，比如方法中，并且有类名。

1.局部内部类可以直接访问外部类的所有成员，包含私有的

2.不能添加访问修饰符，因为它的地位就是一个局部变量，局部变量是不能使用修饰符的。但是可以使用final修饰.

3.外部类访问局部内部类要创建对象

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

4.匿名内部类

a.定义

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

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

b.格式

new 类名或者接口名() {
	重写方法;
}；

c.使用场景

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

下面Animal是父类（抽象方法、类）、Swim是接口。

测试类：

public class Test1 {
    public static void main(String[] args) {
//        public class Student   implements Swim      后面是对象（去掉名字）{
//            @Override
//            public void swim() {
//                System.out.println("重写了接口方法");
//            }
//        }
        //Swim接口名
        //这实现了接口多态      发现下面可以lambda
         Swim s = new Swim(){
            @Override
            public void swim() {
                System.out.println("重写了接口方法");
            }
        };

         s.swim();

         //Animal类名
         new Animal(){
             @Override
             public void eat() {
                 System.out.println("重写了父类方法");
             }
         };

        //只使用一次，直接匿名内部类，    与后面‘Animal a’形成多态
         method(new Animal() {
             @Override
             public void eat() {
                 System.out.println("Dog eats bone");
             }
         });
    }

    public static void method(Animal a){
        a.eat();
    }
}

图源黑马