匿名内部类的一点点总结

1.1匿名内部类的概述

内部类：就是在一个类中定义一个类。举例：在类A中定义一个类B，类B就是内部类。CPU就相当于是笔记本的内部类。
 内部类的定义格式：
 public class 类名{
		修饰符 class 类名{}
}

范例：

public class Outer{
	public class Inner{
	}
}

内部类的访问特点 ：
1.内部类可以直接访问外类的成员，包括私有。
2.外部类想要访问内部类的成员，必须创建对象。

1.2 成员内部类

按照内部类在类中的定义位置不同，可以分为如下两种格式：
1.在类的成员位置：成员内部类。
2.在类的局部位置（方法里面）：局部内部类。

成员内部类，如何创建对象并且使用呢?
格式：外部类名.内部类名 对象名 = new 外部类对象.内部类对象;
范例：Outer.Inner oi = new Outer().new Inner();

package com.neibulei;

public class Outer {

    private String name = "哈哈哈";
   /* public class Inner{
        public void show(){
            //内部类可以直接调用外部类的私有
            System.out.println(name);
        }
    }*/

    private class Inner{
        public void show(){
            //内部类可以直接调用外部类的私有
            System.out.println(name);
        }
    }
    public void method(){
        //外部类访问内部类的成员，必须创建对象
        Inner in = new Inner();
        in.show();

    }
}

package com.neibulei;

public class InnerDemo {

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

         Outer ou = new Outer();
         ou.method();
    }
}

1.3 局部内部类

局部内部类是在方法中定义的类，所以外界是无法直接使用的，需要在方法内部创建对象并使用。
在这里插入代码片该类可以直接访问外部类成员，也可以访问方法内的成员变量

package com.neibulei;

public class Outer2 {


    private  String name = "哈哈哈";
    public void method(){
        class  Inner {
            public void  show(){
                System.out.println(name);
            }
        }
        Inner i = new Inner();
        i.show();

    }

}

package com.neibulei;

public class Outer2Demo {

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

1.4匿名内部类

前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类
格式：
new 类名或接口名(){
//重写方法
}
范例：
new Inteer(){

public void show(){
	
}

}
本质：匿名内部类本质上就是一个匿名对象，这个对象它继承了这个类或者实现这个接口

package com.neibulei;

/*
前提：存在一个类或者一个接口
这里的类可以是抽象类也可以是具体类
 */
public class Outer3 {

    public void method(){
       /* new Inter(){

            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        }.show();//对象调用方法*/

        //多次调用
        Inter in = new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };
        in.show();//编译看左边 执行看右边
        in.show();
        in.show();

    }
}
package com.neibulei;

public class Outer3Demo {

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

1.5匿名内部类的应用

//调用接口
public interface Jumping(){
void jump();
}
//接口操作类 里面有一个方法 方法的参数是接口名
public class JumpingOperate{
public void mehod(Jumping j){ //如果一个方法的形参是接口名 那么其实他要的是该接口的实现类对象

    j.jump();
}

}

//测试类–穿件接口的操作类对象 调用method方法

package com.neibulei;

public interface Jumping {
    void jump();
}

package com.neibulei;

public class JumpingOperator {

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

package com.neibulei;

public class JumpingTest {

    public static void main(String[] args) {
        Jumping cat = new Jumping() {
            @Override
            public void jump() {
                System.out.println("喵喵喵跳跳跳跳");
            }
        };

        new JumpingOperator().method(cat);
        new JumpingOperator().method(new Jumping() {
            @Override
            public void jump() {
                System.out.println("汪汪汪跳跳跳跳");
            }
        });

    }

}

效果等同于创建了两个接口实现类 dog和cat 创建两个实现类的对象并调用方法，可以简洁的实现接口。