Java匿名内部类

Pragma mark — NO.1 匿名内部类

public class Main {

    public static void main(String[] args) {

      Outer o = new Outer();
      o.print();
      o.method1();

    }
}
/*
* 匿名内部类
* 就是内部类的简化写法
* 前提:存在一个类或者接口
* 这里的类可以是具体类也可以是抽象类
* 格式:
* new 类名或者接口名（） {
*   重写方法;
* };
*本质是:
* 是一个继承了该类或者是实现了该接口的子类匿名对象
* */

//创建一个接口
interface  Inter {
    public  void method();
}

//先用有名字的内部类实现外部接口
class  Outer {
    //内部类实现外部接口
    class Inner implements Inter {
        public void method(){
            System.out.println("这是一个内部类实现接口");
        }
    }

    //再整个方法
    public void print(){
        Inner i = new Inner();
        i.method();
    }

    //匿名内部其实是局部内部类，必须放在方法中
    public void method1 (){

        //注意匿名内部类的书写格式
        //new 后面如果是类名就是继承自父类的名字
        //如果是接口名，就是这个类要实现的接口
        //整个这个代表子类对象，那么可以调用这个重写后的method方法。要好好理解下
        new Inter () {//实现Inter接口
            public void method(){
                System.out.println("我是一个匿名内部类");
            }
        }.method();//这后面这个分号不能丢了
    }
}

Pragma mark — NO.2 匿名内部类调用多个重写方法

public class Nimingneibulei1 {
    public static void main (String[] args){
        Test1 t = new Test1();
        t.method();
    }

}
//匿名内部类中重写多个方法调用

interface Inter1 {

    public void show1();
    public void show2();
}

class Test1 {
//通过如下例子我们就建议匿名内部类就用在只调用一个方法的情况
    public void method(){
        //匿名内部类
//        new Inter1() {
//
//            public void show1(){
//
//                System.out.println("这是show1方法");
//            }
//            public void show2(){
//                System.out.println("这是show2方法");
//            }
//
//        }.show1();
//
//        new Inter1() {
//
//            public void show1(){
//
//                System.out.println("这是show1方法");
//            }
//            public void show2(){
//                System.out.println("这是show2方法");
//            }
//
//        }.show2();

        //换个简单点的写法
       Inter1 i =  new Inter1() {

            public void show1(){

                System.out.println("这是show1方法");
            }
            public void show2(){
                System.out.println("这是show2方法");
            }
       };
       i.show1();
       i.show2();
    }
}

Pragma mark — NO.3 匿名内部类的应用

public class Nimingneibulei2 {
    public static void main (String[] args){
        //我们要求是调用PersonDemo中的method方法
        PersonDemo pd = new PersonDemo();
        //这里要求我们传一个抽象类对象，但是抽象类对象不能够初始化。
        //所以要我们传一个匿名内部类进去,这里不能直接传抽象类对象，我们可以
        //传两种，要么传有名的子类对象，要么传匿名内部对象
//        Person p = new Student();
//        pd.method(p);

        //我们用匿名内部类来做一下--匿名内部类当做参数传递，把匿名内部类当做一个对象
        pd.method(new Person(){
              //重写show()方法
            public void show(){
                System.out.println("匿名内部类实现");
            }
        });

    }
}

//写个抽象类
abstract  class  Person{
    public  abstract void show();
}

//普通类
class PersonDemo {
    public  void method(Person p){
        p.show();
    }
}
//再创建个子类对象去继承抽象类
class Student extends Person {
    public void show(){
        System.out.println("我是一个有名的子类");
    }
}