Java内部类-（通俗易懂）匿名内部类

内部类的概念：在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类

class Outer {
     public class Inner {
     
    }
}

内部类的访问特点 ：

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

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

public class Outer {
    private int num = 10;
    public class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    public void method() {
        Inner i = new Inner();
        i.show();
    }
}

1.1 成员内部类

位置：在类中方法，跟成员变量一个位置

外界创建成员内部类格式（万能）：

• 格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;

• 举例：Outer.Inner oi = new Outer().new Inner();

（1）私有成员内部类

• 将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。

class Outer {
    private int num = 10;
    private class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    public void method() {
        Inner i = new Inner();
        i.show();
    }
}
public class InnerDemo {
    public static void main(String[] args) {
                //Outer.Inner oi = new Outer().new Inner();
                //oi.show();
        Outer o = new Outer();
        o.method();
    }
}

（2）静态成员内部类

• 静态成员内部类访问格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();

• 静态成员内部类中的静态方法：外部类名.内部类名.方法名();

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

        public static void method(){
            System.out.println("inner..method");
        }
    }
}
public class Test3Innerclass {
  public static void main(String[] args) {
        // 外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Outer.Inner oi = new Outer.Inner();
        oi.show();
        Outer.Inner.method();
    }
}

1.2 局部内部类

局部内部类定义位置

• 局部内部类是在方法中定义的类

局部内部类方式方式

• 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用

• 该类可以直接访问外部类的成员，也可以访问方法内的局部变量

class Outer {
    private int num = 10;
    public void method() {
        int num2 = 20;
        class Inner {
            public void show() {
                System.out.println(num);
                System.out.println(num2);
            }
        }
        Inner i = new Inner();
        i.show();
    }
}
public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

1.3 匿名内部类

★匿名类：是只在创建对象时才会编写类体的一种写法。匿名类的特点是“现用现写”。

★语法：最后一个大括号之后有分号。

★本质：匿名内部类：匿名的这个对象继承了这个类，或者实现了这个接口吗，new标志了这是一个对象，new后面的那个是该对象继承的那个类或者是实现的那个接口。

（1）匿名内部类可以通过多态的形式接受：

Inter i = new Inter(){
  @Override
    public void method(){  
    }
}

(2)匿名内部类直接调用方法

interface Inter{
    void method();
}

class Test{
    public static void main(String[] args){
        new Inter(){
            @Override
            public void method(){
                System.out.println("我是匿名内部类");
            }
        }.method();        // 直接调用方法
    }
}

(3)综合运用

interface Swimming {
    void swim();
}
public class TestSwimming {
    public static void main(String[] args) {
        goSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("老铁, 我们去游泳吧");
            }
        });
    }
    public static void goSwimming(Swimming swimming){
        /*
            Swimming swim = new Swimming() {
                @Override
                public void swim() {
                    System.out.println("老铁, 我们去游泳吧");
                }
            }
         */
        swimming.swim();
    }
}

注意事项：

public interface Ceshi {
    boolean say();
}

public class Test02 {
    public static void main(String[] args) {
        new Ceshi(){
            @Override
            public boolean say() {
                System.out.println("-----");
                return false;
            }
        }.say();
    }
//如果不写.say方法什么也不会输出，因为咱们创建就是一个对象，并没有更多的要求，也没去调用
}