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

什么是匿名内部类？
匿名内部类，顾名思义，就是不知道这个类到底是什么名字，也就是不知道类名。
匿名内部类的使用场景？
匿名内部类适合创建那种只需要使用一次的类，也就是说创建一个匿名内部类，只需要用一次即可。
匿名内部类如何创建？
new 类名(参数) | 实现接口()
{
// 匿名内部类的类体部分
}
从上面的定义可以看出，匿名内部类必须继承一个父类，或实现一个接口，但最多只能继承一个父类，或者实现一个接口。
两个规则：
	匿名内部类不能是抽象类。
	匿名内部类不能定义构造器。由于匿名内部类没有类名，所以无法定义构造器，但匿名内部类可以初始化块，可以通过初始化块来完成构造器需要完成的工作。

匿名内部类的实现和使用
例1(实现接口)
首先，定义一个匿名类要实现的接口，代码如下
public interface Product{
 double getPrice();
 double 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 Device{
	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内部类和匿名内部类的用法
    【尊重原创，转载请注明出处】http://blog.csdn.net/guyuealian/article/details/51981163
一、内部类:　
      （1）内部类的同名方法
        内部类可以调用外部类的方法，如果内部类有同名方法必须使用"OuterClass.this.MethodName()"格式调用（其中OuterClass与MethodName换成实际外部类名及其方法；this为关键字，表示对外部类的引用）；若内部类无同名方法可以直接调用外部类的方法。
        但外围类无法直接调用内部类的private方法，外部类同样无法直接调用其它类的private方法。注意：内部类直接使用外部类的方法与该方法的权限与是否static无关，它取决于内部类是否有同名方法。
package innerclass;
public class OuterClass {
	private void outerMethod() {
		System.out.println("It's Method of OuterClass");
	}
	public static void main(String[] args) {
		OuterClass t = new OuterClass();
		OuterClass.Innerclass in = t.new Innerclass();
		in.innerMethod();
	}

	class Innerclass {
		public void innerMethod() {
		   OuterClass.this.outerMethod();// 内部类成员方法与外部类成员方法同名时，使用this调用外部类的方法
		   outerMethod();// 内部类没有同名方法时执行外部类的方法
		}
		private void outerMethod() {
			System.out.println("It's Method of Innerclass");
		}
	}
}
     输出结果为：
It's Method of OuterClass
It's Method of Innerclass
    （2）内部类访问外部类的变量必须声明为final
      方法中的局部变量，方法结束后这个变量就要释放掉，final保证这个变量始终指向一个对象。
　  首先，内部类和外部类其实是处于同一个级别，内部类不会因为定义在方法中就会随着方法的执行完毕而跟随者被销毁。问题就来了，如果外部类的方法中的变量不定义final，那么当外部类方法执行完毕的时候，这个局部变量肯定也就被GC了，然而内部类的某个方法还没有执行完，这个时候他所引用的外部变量已经找不到了。如果定义为final，java会将这个变量复制一份作为成员变量内置于内部类中，这样的话，由于final所修饰的值始终无法改变，所以这个变量所指向的内存区域就不会变。
     注意，若使用JDK1.8，方法中内部类的方法是可以直接访问外部类的方法的局部变量，并且不需要声明为final类型。
public class OuterClass {
	int num1 = 0;// 成员变量

	private void outerMethod() {
		int num2 = 0;// 方法内的局部变量
		class Innerclass_1 {
			public void innerMethod() {
				System.out.println(num1);// 方法中内部类的方法，可以正常访问外部类的成员变量
				System.out.println(num2);// JDK1.8以前，方法中内部类的方法，不能直接访问外部类的方法的局部变量，必须声明为final
			}
		}
	}
}
      如果使用JDK1.8以前的版本，Eclipse会出现如下错误提示：

    （3）内部类的实例化
     内部类实例化不同于普通类，普通类可以在任意需要的时候实例化，而内部类必须在外层类实例化以后方可实例化，并与外部类建立关系
     因此在外部类中的非static方法中，是可以实例化内部类对象
	private void outerMethod() {
		System.out.println("It's Method of OuterClass");
		Innerclass in = new Innerclass();//在外部类的outerMethod方法中实例化内部类是可以啊
	}
     但在static方法中，就要注意啦！！！！不能在static方法中直接new内部类，否则出现错误：
     No enclosing instance of type OuterClass is accessible. Must qualify the allocation with an enclosing instance of type OuterClass (e.g. x.new A() where x is an instance of OuterClass).
     这是因为静态方法是在类实例化之前就可以使用的，通过类名调用，这时动态内部类都还没实例化呢，怎么用，总不能调用一个不存在的东西吧。
     如果想在Static方法中new内部类，可以把内部类声明为Static
public class OuterClass {
	private void outerMethod() {
		System.out.println("It's Method of OuterClass");
	}

	public static void main(String[] args) {
		Innerclass in = new Innerclass();
		in.innerMethod();
	}

	static class Innerclass {//把内部类声明为static
		public void innerMethod() {
			System.out.println("It's Method of innerMethod");

		}
	}

}
     当然，一般不使用static的方式，而是推荐这种方法：x.new A() ，其中 x是外部类OuterClass的实例，A是内部类Innerclass
package innerclass;
public class OuterClass {
	private void outerMethod() {
		System.out.println("It's Method of OuterClass");
	}
	public static void main(String[] args) {
		OuterClass.Innerclass in = new OuterClass().new Innerclass();//使用x.new A()的方式
		in.innerMethod();
	}
	class Innerclass {
		public void innerMethod() {
			System.out.println("It's Method of innerMethod");
		}
	}
}
     x.new A() ，其中 x是外部类OuterClass的实例，A是类部类Innerclass，当然可以拆分如下，这样就显然很明白啦：
	public static void main(String[] args) {
		OuterClass out = new OuterClass();//外部实例
		OuterClass.Innerclass in = out.new Innerclass();//外部实例.new 外部类
		in.innerMethod();
	}

    （4）什么情况下使用内部类
     典型的情况是，内部类继承自某个类或实现某个接口，内部类的代码操作创建其的外层类的对象。所以你可以认为内部类提供了某种进
入其外层类的窗口。
    使用内部类最吸引人的原因是：每个内部类都能独立地继承自一个（接口的）实现，所以无论外层类是否已经继承了某个（接口的）实
现，对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个角
度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“多重继承”。
   （5）在静态方法中实例化内部类例子：（内部类放在静态方法中）
package javatest2;
public class JavaTest2 {
	public static void main(String[] args) {
		class Boy implements Person {
			public void say() {// 匿名内部类自定义的方法say
				System.out.println("say方法调用");
			}
			@Override
			public void speak() {// 实现接口的的方法speak
				System.out.println("speak方法调用");
			}
		}
		Person per = new Boy();
		per.speak();// 可调用
		per.say();// 不能调用
	}
}
interface Person {
	public void speak();
}
       per.speak()可调用，而per.say()不能调用，这时因为per是Person对象，要想调用子类的方法，可以强制向下转型为：((Boy) per).say();或者直接改为Boy per = new Boy();。从中可发现，要想调用内部类的自定义的方法，必须通过内部类的对象来调用。那么，匿名内部类连名字都没有，怎么调用内部类自定义的方法？
（二）匿名内部类
      匿名内部类也就是没有名字的内部类正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写，但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口，但最多只能继承一个父类，或实现一个接口。
关于匿名内部类还有如下两条规则：
    1）匿名内部类不能是抽象类，因为系统在创建匿名内部类的时候，会立即创建内部类的对象。因此不允许将匿名内部类定义成抽象类。
    2）匿名内部类不等定义构造器（构造方法），因为匿名内部类没有类名，所以无法定义构造器，但匿名内部类可以定义实例初始化块，
    怎样判断一个匿名类的存在啊？看不见名字，感觉只是父类new出一个对象而已，没有匿名类的名字。
先看段伪代码
abstract class Father(){
....
}
public class Test{
   Father f1 = new Father(){ .... }  //这里就是有个匿名内部类
}
   一般来说，new 一个对象时小括号后应该是分号，也就是new出对象该语句就结束了。但是出现匿名内部类就不一样，小括号后跟的是大括号，大括号中是该new 出对象的具体的实现方法。因为我们知道，一个抽象类是不能直接new 的，必须先有实现类了我们才能new出它的实现类。上面的伪代码就是表示new 的是Father的实现类，这个实现类是个匿名内部类。
    其实拆分上面的匿名内部类可为：
class SonOne extends Father{
  ...       //这里的代码和上面匿名内部类，大括号中的代码是一样的
}
public class Test{
   Father f1 = new SonOne() ;
}
     先看一个例子，体会一下匿名内部类的用法：

    运行结果：eat something
    可以看到，我们直接将抽象类Person中的方法在大括号中实现了，这样便可以省略一个类的书写。并且，匿名内部类还能用于接口上
public class JavaTest2 {
	public static void main(String[] args) {
		Person per = new Person() {
			public void say() {// 匿名内部类自定义的方法say
				System.out.println("say方法调用");
			}
			@Override
			public void speak() {// 实现接口的的方法speak
				System.out.println("speak方法调用");
			}
		};
		per.speak();// 可调用
		per.say();// 出错，不能调用
	}
}

interface Person {
	public void speak();
}
        这里per.speak()是可以正常调用的，但per.say()不能调用，为什么呢？注意Person per = new Person()创建的是Person的对象，而非匿名内部类的对象。其实匿名内部类连名字都没有，你咋实例对象去调用它的方法呢？但继承父类的方法和实现的方法是可以正常调用的，本例子中，匿名内部类实现了接口Person的speak方法，因此可以借助Person的对象去调用。
        若你确实想调用匿名内部类的自定义的方法say()，当然也有方法：
      （1）类似于speak方法的使用，先在Person接口中声明say()方法，再在匿名内部类中覆写此方法。
      （2）其实匿名内部类中隐含一个匿名对象，通过该方法可以直接调用say()和speak()方法；代码修改如下：
public class JavaTest2 {
	public static void main(String[] args) {
		new Person() {
			public void say() {// 匿名内部类自定义的方法say
				System.out.println("say方法调用");
			}

			@Override
			public void speak() {// 实现接口的的方法speak
				System.out.println("speak方法调用");
			}
		}.say();// 直接调用匿名内部类的方法
	}
}
interface Person {
	public void speak();
}

目录

匿名内部类 Anonymous Inner Class

注意事项

匿名内部类 Anonymous Inner Class

1、匿名内部类也就是没有名字的内部类。

2、使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口。创建格式：

new 父类构造器（参数列表）|实现接口（）  {  
     //匿名内部类的类体部分  
}

3、创建匿名内部类时它会立即创建一个该类的实例，该类的定义会立即消失，所以匿名内部类是不能够被重复使用的，适用于单次使用的场景。

import java.util.logging.Logger;

public class HelloWorld {
    public static void main(String[] args) throws InterruptedException {
        Person person = new YellowPerson();
        person.show();
    }
}

abstract class Person {
    public abstract void show();
}

class YellowPerson extends Person {

    @Override
    public void show() {
        Logger logger = Logger.getAnonymousLogger();
        logger.info("我们是黄种人");
    }
}


new YellowPerson(); 假如只需要使用一次，其实也没必要继承 Person 抽象类。可以使用匿名内部类如下。


import java.util.logging.Logger;

public class HelloWorld {
    public static void main(String[] args) throws InterruptedException {
        Person person = new Person() {
            @Override
            public void show() {
                Logger logger = Logger.getAnonymousLogger();
                logger.info("我们是黄种人");
            }
        };
        person.show();
    }
}

abstract class Person {
    public abstract void show();
}


new Person(){...} 中的 {} 就是匿名内部类，相当于继承了 Perser 抽象类。

对于只需要使用一次时，这样的确更方便，因为没必要专门去写一个类继承 Person 了，但是如果希望以后多次使用的，则可以使用具体类来继承。


4、接口也是同理：

import java.util.logging.Logger;

public class HelloWorld {
    public static void main(String[] args) throws InterruptedException {
        //直接使用匿名内部类来新建任务。
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                Logger logger = Logger.getAnonymousLogger();
                logger.info("我是线程：" + Thread.currentThread().getName());
            }
        };
        new Thread(runnable).start();
    }
}



{ }：相当匿名内部类，实现了 Runable 接口。


注意事项

1、使用匿名内部类时，必须是继承一个类或者实现一个接口（两者不可兼得）。

2、匿名内部类中是不能定义构造函数的。因为匿名内部类没有名称，所以也就没有构造器。

3、匿名内部类中不能存在任何的静态成员变量和静态方法。因为创建匿名内部类时它会立即创建一个该类的实例，该类的定义会立即消失，所以匿名内部类是不能够被重复使用的。

4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。

5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

 

匿名内部类编译时会不会生成class文件，下面来验证
我们知道 在一个类里如果有内部类，则编译是会产生两个class文件，一个类class  一个是内部类class，那么匿名内部类会不会也编译出来一个class呢，我们定义一个接口（接口会单独生成一个class），然后匿名生成这个接口的实例，再编译这个类，看看结果如何：
原始类如下：

public class MyClass {

    private MyInterface myInterface = new MyInterface() {
        @Override
        public void onTaskClick() {

        }
    };

    public interface MyInterface {
        void onTaskClick();
    }

}
javac 编译后如下：

   我们看到生成了一个接口的class文件和 MyClass$1.class文件，这个文件是系统自动为我们起了一个名字 1，也就是说即使我们没有为这个class命名，还是被系统赋予了名字
生成的内部类





classMyClass$1
 implements MyClass.MyInterface
{
  MyClass$1(MyClass paramMyClass) {}

  
 public void onTaskClick() {}
}



结论：匿名内部类编译后会生成class文件，名称是 1、2...数字
如果我们增加接口个数并相应增加匿名内部类，再次编译，则会相应生成 MyClass$2.classMyClass$3.class...等class文件