java匿名内部类
 
什么是匿名内部类？
匿名内部类的使用场景？
匿名内部类如何创建？
匿名内部类的实现和使用
例1(实现接口)
例2(继承类)
 

 
什么是匿名内部类？
 
匿名内部类，顾名思义，就是不知道这个类到底是什么名字，也就是不知道类名。
 
匿名内部类的使用场景？
 
匿名内部类适合创建那种只需要使用一次的类，也就是说创建一个匿名内部类，只需要用一次即可。
 
匿名内部类如何创建？
 
new 类名(参数) | 实现接口()
{
// 匿名内部类的类体部分
}
从上面的定义可以看出，匿名内部类必须继承一个父类，或实现一个接口，但最多只能继承一个父类，或者实现一个接口。
两个规则：
	匿名内部类不能是抽象类。
	匿名内部类不能定义构造器。由于匿名内部类没有类名，所以无法定义构造器，但匿名内部类可以初始化块，可以通过初始化块来完成构造器需要完成的工作。
 
匿名内部类的实现和使用
 
例1(实现接口)
 
首先，定义一个匿名类要实现的接口，代码如下
 
public interface Product{
 double getPrice();
 String getName();
 
然后，定义一个实体类，实体类定义一个方法，方法的参数为上述的接口对象，到时候会传入一个匿名类对象，这个匿名类实现了上述创建的接口，代码如下
 
public class Anony{
	public void test(Product product){
	System.out.println("购买了一个"+product.getName()+"，花掉了"+product.getPrice());
	}
}
 
最后测试运行：
 
pubic class Test{
	public static void main(String[] args){
		Anony anony=new Anony();
		// 注意，此处要传入一个匿名类对象
		anony.test(new Product(){
			@Override
			public double getPrice(){
					return 578.6;
				}
			@Override
			public String getName(){
					return "联想笔记本";
				}
			}
		);
	}
}
 
输出：
 
购买了一个联想笔记本，花掉了578.6
 
总结：此处匿名内部类的作用就是实现了一个接口，创建了一个实现了该接口的类的对象，然后重写了这个接口中的方法。
 
例2(继承类)
 
首先，定义一个匿名类需要实现的抽象类，代码如下：
 
public abstract class Device{
	private String name;
	public abstract double  getPrice();
	public String getName(){
	 	return name;
	}
	public Device(){}
	public Device(String name){
		this.name=name;
	}
} 
 
然后，定义一个实体类，实体类定义一个方法，方法的参数为上述的抽象类对象，到时候会传入一个匿名类对象，这个匿名类继承了上述创建的抽象类，代码如下
 
public class Anony {

    public void test(Device device){
        System.out.println("购买了一个"+device.getName()+"花费了"+device.getPrice());
    }
}
 
最后测试运行：
 
pubic class Test{
	public static void main(String[] args){
		Anony anony=new Anony();
		// 注意，此处要传入一个匿名类对象
		anony.test(new Device("海尔电视机"){
			@Override
			public double getPrice(){
					return 578.6;
				}
		);
		Device device=new Device(){
			@Override
			public double getPrice(){
				return 556.56;
			}
			@Override
			public String getName(){
				return "美的电视机";
			}
		};
		annoy.test(device);
	}
}
 
输出：
 
购买了一个海尔电视机，花掉了578.6
购买了一个美的电视机，花掉了556.56
 
总结：对象匿名类中继承抽象类，对于抽象类里面的抽象方法，必须要重写，对象抽象类里面的非抽象方法，可重写也可以不重写。

Java匿名内部类
 
什么是匿名内部类
 
匿名内部类，顾名思义，就是没有名字的类，一个带具体实现的父类或者父接口的匿名的`子类对象。匿名内部类格式如下
 
new name（[参数列表]）{   //name为父类或者是接口的名字
	//方法重写
	Override
	..........
}
 
特点
 
1.匿名内部类不能定义任何静态成员、方法。
 

 
 
2.匿名内部类中的方法不能是抽象的；
 因为在创建匿名内部类的时候，会立即创建它的实例，可知匿名内部类不能是抽象类，必须实现接口或抽象父类的所有抽象方法。
 3.匿名内部类访问的外部类成员变量或成员方法必须用static修饰；
 
 4.匿名内部类 必须和创建对象一起存在
 
 5.匿名内部类创建的对象一定是普通类或抽象类的子类，一定是接口的实现类对象
 
6.匿名内部类常用于重写父类或者接口中的方法，也可以定义新的属性和方法，但是上转型对象无法调用子类新增的属性和方法（同多态）
 
 
7.匿名内部类因为没有类名，可知匿名内部类不能定义构造器
 
8.当匿名内部类和外部类有同名变量（方法）时，默认访问的是匿名内部类的变量（方法），要访问外部类的变量（方法）则需要加上外部类的类名。
 
 
此时为了输出外部类的weight需要使用外部类名.变量名来调用
 

匿名内部类
 
内部类分4种：成员内部类，静态内部类，局部内部类和匿名内部类。我们今天讨论的就是其中最常见的匿名内部类。从名称可以看出，就是没有名字的类，因为没有名字，所以总归和其它普通类有一些些区别：
 
类如果没有名字，就只能在定义类的时候直接实例化，否则这个类永远得不到使用，也就没有意义。但这样也就代表这个类不能重复使用，不能在其它地方继续实例化了。
类如果没有名字，那怎么创建这个对象的引用呢？所以匿名内部类必须继承一个父类或者实现一个接口，然后通过父类引用匿名内部类实例，再通过多态特性调用方法。不过，只能继承一个父类，或实现一个接口。
定义完就立刻需要实例化，也就代表这个类不可能是抽象类，所以也就不能拥有任何抽象方法。
类没有名字，所以也不存在类变量，类方法，类初始化块，也没有构造函数。
匿名内部类如果需要访问外部类局部变量，则只能是final局部变量(java8开始可以不用final修饰，但必须是final使用格式)，这是为了保证数据的一致性，外部类局部变量会成为匿名内部类的成员变量。
按上面的限制，我们看demo。
 
先定义一个输出对象的接口：
 
public interface IOut {

    void println(String msg);

}
 
再定义一个抽象类：
 
public abstract class BaseOut implements IOut {
    private final int bufferSize;

    public BaseOut() {
        bufferSize = 1024;
    }

    public BaseOut(int bufferSize) {
        this.bufferSize = bufferSize;
    }

    @Override
    public abstract void println(String msg);

}
 
开始演示：
 
public class Run {

    public static void main(String[] args) {
        // 1.定义的时候直接实例化
        // 2.实现了接口
        final IOut out0 = new IOut() {
            // static String name;  // 4.不能有静态成员
            // static void print() {}   // 4.不能有静态方法
            // static {}    // 4.不能有静态初始化块
            // abstract void print();   // 3.不能有抽象方法
            @Override
            public void println(String msg) {
                System.out.println(msg);
            }
        };
        // 2.继承了父类,无参构造函数
        BaseOut out1 = new BaseOut() {
            @Override
            public void println(String msg) {
                out0.println(msg);  // 5.使用了外部类局部变量,final修饰
            }
        };
        // 2.继承了父类,有参构造函数
        BaseOut out2 = new BaseOut(2048) {
            @Override
            public void println(String msg) {
                out1.println(msg);  // 5.使用了外部类局部变量,java8可以不用final修饰
            }
        };
    }

}
 
lambda(匿名方法)
 
在演示lambda之前，先修改下IOut接口，添加默认方法和静态方法：
 
@FunctionalInterface
public interface IOut {

    void println(String msg);

    /**
     * 默认方法,由实现类调用
     */
    default void print(String msg) {
        System.out.print(msg);
    }

    /**
     * 静态方法
     */
    static void printf(String fmt, Object... args) {
        System.out.printf(fmt, args);
    }

}
 
最重要的，加了一个注解：@FunctionalInterface，表明这个接口是函数式接口：有且只有一个抽象方法的接口。这个注解是给编译器严格检查使用的，同时也代表：可以添加这个注解的接口，在创建对应的匿名内部类时，可以使用lambda：
 
public class Run {

    public static void main(String[] args) {
        // 函数式接口,内部类实现只有一个函数,这个时候使用lambda
        IOut out0 = (msg) -> {
            System.out.println(msg);
        };
        // 参数列表只有一个参数,去掉括号
        IOut out1 = msg -> {
            System.out.println(msg);
        };
        // 方法体只有一条语句,去掉花括号和分号
        IOut out2 = msg -> System.out.println(msg);
        // 很巧的,方法体实现只是引用了其它对象的方法,使用方法引用
        IOut out3 = System.out::println;
    }

}
 
从上面的简单示例可以看出：如果一个接口是函数式接口，并且创建这个函数式接口的匿名内部类时，也只是实现了抽象方法，不添加任何其它方法，保证实现的方法唯一时，就可以使用lambda(匿名函数)。因为确定实现的就是那个函数，所以函数名可以省去，只要申明形参名(为了给方法体使用)，形参类型都可以省去，然后使用符号->连接方法体。
 
lambda的简化写法：
 
形参列表如果有且只有一个参数，可以省去括号。
方法体如果只有一条语句，可以省去花括号和分号。如果有返回值，连return都可以省去。
方法体如果只有一条语句，又正好满足一定的条件，可以使用更精简的方法引用和构造器引用(本篇不讨论这个)。
lambda能实现的，匿名内部类都能实现，匿名内部类能实现的，lambda有时就无能为力了，主要有以下区别：
 
匿名内部类可以为任意接口或类创建匿名内部类，但lambda目标类型只能是函数式接口，只能是接口，就算是只有一个抽象方法的抽象类也不行。
匿名内部类可以有成员变量，初始化块，多个普通方法，实现或重写多个方法，但lambda只能有一个方法体。
匿名内部类可以调用父类或接口继承得到的默认方法，lambda不行。
上面说的第3点，具体看demo：
 
public class Run {

    public static void main(String[] args) {
        // 匿名内部类
        IOut out0 = new IOut() {
            @Override
            public void println(String msg) {
                println(msg);    // 实例方法
                IOut.printf(msg); // 静态方法
            }
        };
        // lambda
        IOut out1 = msg -> {
            // 无法调用继承得到的默认方法
            IOut.printf(msg);
        };
    }

}
 
 

Java匿名内部类实现线程的创建
 
package com.zr;
/*
    匿名内部类实现线程的创建
 */
public class DemoThread {
    public static void main(String[] args) {
        //主线程main
        for (int i = 0; i <20 ; i++) {
            //Thread.currentThread().getName()获取线程名
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }

        //匿名内部类创建新线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <20 ; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                }
            }
        }).start();
    }
}