内部类怎么用

内部类：

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

    // 格式： class 外部类名{ 修饰符 class 内部类名{ } } 
    class  A{
        public class B {
        }
    }

内部类的访问特点：

内部类可以直接访问外部类的成员，包括私有
外部类要访问内部类的成员，必须创建对象

   public 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();
        }
    }

成员内部类：

成员内部类的定义位置：

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

成员内部类的使用：

1.创建外部类对象
2.根据外部类对象创建内部类对象

成员内部类的好处：

可以直接使用外部类的成员，包括私有
成员内部类的定义位置

外界创建成员内部类格式：

格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
举例：Outer.Inner oi = new Outer().new Inner();

私有成员内部类：

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

    class Outer {
        private int num = 10;
        private class Inner {// 使用private修饰内部类，外部是访问不到的
            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(); 内部类被private修饰后不能直接访问，这里会报错
            Outer o = new Outer();
            o.method();
        }
    }

静态成员内部类

• 由static修饰的成员内部类
• 静态成员内部类访问格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
• 静态成员内部类中的静态方法：外部类名.内部类名.方法名();

静态内部类只能使用外部类的?

只能使用外部类static修饰的成员变量和成成员方法
静态内部类可以直接访问外部类的静态成员。

代码演示：

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

            public static void method(){
                System.out.println("inner..method");
            }
        }
    }

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

            Outer.Inner.method();
        }
    }

局部内部类：

什么是局部内部类：

局部顾名思义就是，定义在方法中的类

局部内部类的使用：

在定义局部内部类的下面马上使用

局部内部类的好处：

可以直接使用外部类的成员

public class Demo02 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.method();
    }
}


class Outer {
    public void method() {

        class Inner {
            public void show(){
                System.out.println("show方法执行");
            }
        }

        Inner inner = new Inner();
        inner.show();
    }
}

匿名内部类：

什么是匿名内部类：

没有名字的内部类，本质是一个继承了该类或者实现了该接口的子类匿名对象

内部类的前提：

存在一个类或者接口，这里的类可以是具体类也可以是抽象类

匿名内部类的格式：

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

匿名内部类的好处：

可以简化接口的使用，代码更少（不需要有实现类）

匿名内部类的缺点：

匿名内部类没有名字，只能使用一次

匿名内部类调用注意：

匿名内部类可以通过多态的形式接收，例如，接口A中有两个抽象方法，就可以通过多态形式接收

匿名内部类做了什么：

• 匿名内部类把继承/实现、方法重写、创建对象放在一步去操作

代码演示：

    interface Inter {
        void method();
        void method2();
    }

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

	// 需要调用多个方法时可以通过多态接收，再调用
     Inter i = new Inter() {
                @Override
                public void method() {
                    System.out.println("method");
                }
                
  				@Override
                public void method2() {
                    System.out.println("method2");
                }
            };
            i.method();
            i.method2();
        }
    }

匿名内部类开发场景

当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码

   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();
        }
    }