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
 
总结：对象匿名类中继承抽象类，对于抽象类里面的抽象方法，必须要重写，对象抽象类里面的非抽象方法，可重写也可以不重写。

匿名内部类接口实现
 
1.匿名内部类 ：是内部类的简化写法。它的本质是一个 带具体实现的 父类或者父接口的 匿名的 子类对象。
 
开发中，最常用到的内部类就是匿名内部类了。以接口举例，使用一个接口时，得做如下4步操作，
 
1. 定义子类
 
2. 重写接口中的方法
 
3. 创建子类对象
 
4. 调用重写后的方法
 
如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，
 
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。
 
 
 
匿名内部类的定义格式：
 
接口名称 对象名 = new 接口名称() {
 
    // 覆盖重写所有抽象方法
 
};
 
 
 
对格式“new 接口名称() {...}”进行解析：
 
1. new代表创建对象的动作
 
2. 接口名称就是匿名内部类需要实现哪个接口
 
3. {...}这才是匿名内部类的内容
 
举例代码：
 
接口FlyAble
public interface FlyAble {
     public abstract void Fly();
     public abstract void eat();
 }
 
 
 
2. FiyAbleImpl类实现抽象方法
 
package DemoTest.FlyAble;

 public class FlyAbleImpl implements FlyAble {
     @Override
     public void Fly() {
         System.out.println("实现类的间接调用！");
         System.out.println("心牵挂远方！");
     }

     @Override
     public void eat() {
         System.out.println("吃饭！");
     }
 }
 
 
 
3.InnerDome测试类
 public class InnerDome {
     public static void main(String[] args) {
         FlyAble fly = new FlyAble() {
             @Override
             public void Fly() {
                 System.out.println("用匿名对象直接调用接口！");
                 System.out.println("心已经飞过千里！");
             }

             @Override
             public void eat() {
                 System.out.println("用匿名对象直接调用接口！");
                 System.out.println("吃好吃的！");
             }
         };
         fly.Fly();
         fly.eat();
         System.out.println("=================");
         FlyAbleImpl flyAble = new FlyAbleImpl();
         flyAble.Fly();
         flyAble.eat();
     }
 }
 
4.结果：                      
 
用匿名对象直接调用接口！
 
心已经飞过千里！
 
用匿名对象直接调用接口！
 
吃好吃的！
 
=================
 
实现类的间接调用！
 
心牵挂远方！
 
吃饭！
 
3、注意事项:
 
1. 匿名内部类，在【创建对象】的时候，只能使用唯一一次。
 
如果希望多次创建对象，而且类的内容一样的话，那么就需要使用单独定义的实现类了。
 
2. 匿名对象，在【调用方法】的时候，只能调用唯一一次。
 
如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
 
3. 匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】

匿名内部类
 
匿名内部类：没有名称的类，主要用来创建对象（只创建一次）
 匿名内部类需要通过父类或者接口实现。
 语法：
 
父类名/接口名 对象名 = new 父类名/接口名 {
   重写的父类的方法
   或
   实现的接口中的方法
};
 
示例1：普通父类
 
父类：
 
public class A {
    public void fun(){
        System.out.println("A fun");
    }
}
 
测试代码：
 
public static void main(String[] args) {
    class B1 extends  A{

    }
    B1 obj1 = new B1();
    obj1.fun();

    class B2 extends  A{
        @Override
        public void fun() {//重写父类的方法
            System.out.println("B2 fun");
        }
    }
    B2 obj2 = new B2();
    obj2.fun();

    

    A obj11 = new A(){

    };
    obj11.fun();

    A obj22 = new A(){
        @Override
        public void fun() {
            System.out.println("22 fun");
        }
    };
    obj22.fun();

    new A(){
        @Override
        public void fun() {
            System.out.println("33 fun");
        }
    }.fun();
}
 
示例：抽象父类
 
抽象父类：
 
public abstract class CC {
	public void fun() {
		System.out.println("fun");
	}
	public abstract void fun2();
}
 
测试代码：
 
public static void main(String[] args) {
	CC obj = new CC() {

		public void fun2() {
			System.out.println("xixi");
		}

	};
	obj.fun2();
	
	new CC() {

		public void fun2() {
			System.out.println("xixi");
		}

	}.fun2();
}
 
 
示例：接口
 
接口：
 
public interface A {
     void fun();
}
 
测试代码：
 
public static void main(String[] args) {

    class B2 implements A {
        @Override
        public void fun() {//重写父类的方法
            System.out.println("B2 fun");
        }
    }
    B2 obj2 = new B2();
    obj2.fun();

    

    A obj22 = new A() {
        @Override
        public void fun() {
            System.out.println("22 fun");
        }
    };
    obj22.fun();

    new A() {
        @Override
        public void fun() {
            System.out.println("33 fun");
        }
    }.fun();
}

JAVA可以使用如下方法来创建基于接口的匿名实现类对象
 
new<接口名>(){
//重写方法
};
 

package hello2;

/**
 * 创建匿名的接口实现类对象：临时创建了一个没有命名的接口实现类
 * 代码简约化
 *
 */
interface ISay{
	void sayHello();
}
class ISayImpl implements ISay{
	@Override
	public void sayHello() {
		System.out.println("Hello java! 2 ");
	}
}
public class Hello{
	
	public static void main(String []args) {
		//匿名类创建
		ISay isay = new ISay() {
			public void sayHello() {
				System.out.println("Hello java!");
			}
		};
		//匿名类使用
		isay.sayHello();
		
		//非匿名类
		ISayImpl isay2 = new ISayImpl();
		isay2.sayHello();
		
	}
}