Java：内部类

内部类

1.概念：在一个类中定义一个类

public class 类名 {
    修饰符 class 类名 {
    }
}

2.内部类访问特点：

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

public class Outer {
    private int num=20;

    public class Inner{//内部类访问外部类成员
        public void show(){
            System.out.println(num);
        }
    }
    public void method() {//外部类访问内部类的成员
        //show();--报错
        Inner i = new Inner();//创建内部类对象
        i.show();//调用内部类方法
    }

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

普通内部类

普通内部类，普通内部类对象依赖外部类对象而存在，即在创建一个普通内部类对象时首先需要创建其外部类对象
（测试类和Outer类不在一块，分开的）

创造对象方法

public class Demo {
    public static void main(String[] args) {
      //创建内部类对象，并调用方法
      //  Inner oi=new Inner();报错
        Outer.Inner oi=new Outer().new Inner();
        oi.show();
    }
}

上面这种写法针对的是Inner是public，如果Inner是private这样的写法就是失效了，如果Inner是private我们怎么调用Inner的show方法呢：

成员内部类

（在类的成员位置）

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

public class Outer {
    private int num=20;

    private class Inner{//可以有public
        public void show(){
            System.out.println(num);
        }
    }
   public void method(){
        Inner inner=new Inner();
        inner.show();
   }
}

局部内部类

（在类的局部位置，就是类的方法体里）
局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用
该类可以直接访问外部类的成员，也可以访问方法内（局部内部类所在的方法体）的局部变量

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

public class Outer {
    private int num=20;
    public void method(){
	    int num2=10;
	    class Inner{//不可以有public
		    public void show(){
		         System.out.println(num);//输出外部变量，访问外部类的成员
		         System.out.println(num2);//输出局部变量，访问方法内的局部变量
		     }
	   }
	   Inner inner=new Inner();
	   inner.show();
   //在方法内部创建对象并使用该类可以直接访问外部类的成员
    }
}

匿名内部类

（是局部内部类的一种特殊方法，所以同样是在类的方法的方法体内进行声明，本质是继承了该类或者实现该接口的子类匿名对象）

格式（内部类也是在方法体里面书写）

 new 继承的类名或者实现的接口名(){
           @Override
           public void 抽象方法名() {
           //重写方法
           }
       };//分号不要漏

举个例子：

public interface Inner {
    public abstract void show();
}

public class Outer {
    private int num=20;
    public void method(){
       new Inner(){
           @Override
           public void show() {
               System.out.println("匿名内部类");
           }
       };
    }
}

  new Inner(){
           @Override
           public void show() {
               System.out.println("匿名内部类");
           }
       };

本质是一个对象，只不过这个对象没有名字而已，既然是对象，就可以通过对象调方法

  new Inner(){
           @Override
           public void show() {
               System.out.println("匿名内部类");
           }
       }.show();

如果要多次调用这个对象的show方法一直复制肯定不合理，所以：
我们可以看出一个对象是一个Inner类型的实现对象，所以就可以赋给Inner的接口，也就是

 Inner i = new Inner(){
           @Override
           public void show() {
               System.out.println("匿名内部类");
           }
       }.show();

绕来绕去匿名内部类到底有什么用呢？——关键点，匿名内部类的本质就是一个对象，而且是实现了该接口或者继承了该类的，而且是匿名的。

public interface Jumping {
    public abstract void jump();
}

public class Cats implements Jumping{
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}

public class Dogs implements Jumping{
    @Override
    public void jump() {
        System.out.println("狗可以跳高了");
    }
}

public class JumpOperator {
    public void method(Jumping j){
        j.jump();
    }
}

public class Demo {
    public static void main(String[] args) {
    JumpOperator jumpOperator=new JumpOperator();
    Jumping cat=new Cats();
    jumpOperator.method(cat);

    Jumping dog=new Dogs();
    jumpOperator.method(dog);
    }
}

猫可以跳高了
狗可以跳高了

如果有更多的动物可以跳高了，就得定义一个个新的类，这里我们就可以采用匿名内部类代替

public interface Jumping {
    public abstract void jump();
}

public class JumpOperator {
    public void method(Jumping j){
        j.jump();
    }
}

public class Demo {
    public static void main(String[] args) {
        JumpOperator jumpOperator = new JumpOperator();
        jumpOperator.method(new Jumping() {
        //匿名内部类的本质就是一个对象，实现了Jumping这个接口
            @Override
            public void jump() {
                System.out.println("猫可以跳高了");
            }
        });
        jumpOperator.method(new Jumping() {
            @Override
            public void jump() {
                System.out.println("狗可以跳高了");
            }
        });
    }
}