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



2.匿名内部类中的方法不能是抽象的；

因为在创建匿名内部类的时候，会立即创建它的实例，可知匿名内部类不能是抽象类，必须实现接口或抽象父类的所有抽象方法。

3.匿名内部类访问的外部类成员变量或成员方法必须用static修饰；



4.匿名内部类  必须和创建对象一起存在



5.匿名内部类创建的对象一定是普通类或抽象类的子类，一定是接口的实现类对象
6.匿名内部类常用于重写父类或者接口中的方法，也可以定义新的属性和方法，但是上转型对象无法调用子类新增的属性和方法（同多态）

7.匿名内部类因为没有类名，可知匿名内部类不能定义构造器
8.当匿名内部类和外部类有同名变量（方法）时，默认访问的是匿名内部类的变量（方法），要访问外部类的变量（方法）则需要加上外部类的类名。


此时为了输出外部类的weight需要使用外部类名.变量名来调用

java匿名内部类

匿名内部类：没有类名的类就称作为匿名内部类。

匿名内部类的好处：简化书写。

匿名内部类的使用前提：必须存在继承或者实现关系才能使用。

匿名内部类一般是用于实参。

实例1：

abstract class Animal{

    public abstract Animal run();

    public abstract void sleep();
}
**重点内容**
class Outer{

    public void print(){
        //需求： 在方法内部定义一个类继承Animal类，然后调用run方法与sleep()。

        /*
        //局部内部类
        class Dog extends Animal{

            public void run(){
                System.out.println("狗在跑..");
            }

            public void sleep(){
                System.out.println("狗趴在睁开眼睛睡..");
            }
        }

        //创建对象
        Dog d = new Dog();
        d.run();    
        d.sleep();
        */  
        //匿名内部类 ：匿名内部类只是没有类名，其他的一概成员都是具备的。
        // 匿名内部类与Animal是继承 的关系。  目前是创建Animal子类的对象. 
    Animal  a = new Animal(){  //多态

            //匿名内部的成员 
            public Animal run(){
                System.out.println("狗在跑..");
                return this;
            }

            public void sleep(){
                System.out.println("狗趴在睁开眼睛睡..");
            }

            //特有的方法
            public void bite(){
                System.out.println("狗在咬人..");
            }

        };

        a.bite();
        a.run();
        a.sleep();

    }
}

class Demo6 
{
    public static void main(String[] args) 
    {
        //System.out.println("Hello World!");

        Outer outer = new Outer();
        outer.print();

    }
}

实例2：



//实现关系下匿名内部类
interface Dao{

    public void add();
}

class Outer{

    public void print(){
        //创建一个匿名内部类的对象
        new Dao(){   //不是接口不能创建对象吗？怎么现在又可以了？

             public void add(){
                System.out.println("添加成功");
             }
        }.add();
    }
}

class Demo7 
{
    public static void main(String[] args) 
    {
        test(new Dao(){

            public void add(){
                System.out.println("添加员工成功");
            }
        });
    }

    //调用这个方法...
    public static void  test(Dao d){  //形参类型是一个接口引用..
        d.add();
    }
}

interface A{
public void infoprint();

}

class B{
public void  fun1(){
this.fun2(new A(){
public void infoprint(){
System.out.println("hello world!");
}
});
}
public  void fun2(A a){
a.infoprint();
}

}

public class Pet{
public static void main(String args[]){
new B().fun1();
}

}

JAVA匿名内部类



一、内部类的定义

内部类（nested classes），面向对象程序设计中，可以在一个类的内部定义另一个类。嵌套类分为两种，即静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。内部类是JAVA语言的主要附加部分。内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分。

　　内部类是JAVA语言的主要附加部分。嵌套类从JDK1.1开始引入。其中inner类又可分为三种：

　　　　其一、在一个类（外部类）中直接定义的内部类； 

　　　　其二、在一个方法（外部类的方法）中定义的内部类; 

　　　　其三、匿名内部类。 

　　　　

　　为什么需要内部类？

　　　　⒈ 内部类对象可以访问创建它的对象的实现，包括私有数据； 

　　　　⒉ 内部类不为同一包的其他类所见，具有很好的封装性； 

　　　　⒊ 使用内部类可以很方便的编写事件驱动程序； 

　　　　⒋ 匿名内部类可以方便的定义运行时回调； 

　　　　5.内部类可以方便的定义 

　　　每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个角度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“多重继承”。



二、内部类分类



1.成员内部类



2.方法内部类



3.匿名内部类



三、匿名内部类的使用

匿名内部类由于没有名字，所以它的创建方式有点儿奇怪。创建格式如下：



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

在这里我们看到使用匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一个接口。同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用。当然这个引用是隐式的。



public abstract class Bird {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public abstract int fly();
}

public class Test {

    public void test(Bird bird){
        System.out.println(bird.getName() + "能够飞 " + bird.fly() + "米");
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.test(new Bird() {

            public int fly() {
                return 10000;
            }

            public String getName() {
                return "大雁";
            }
        });
    }
}
------------------
Output：
大雁能够飞 10000米

在Test类中，test()方法接受一个Bird类型的参数，同时我们知道一个抽象类是没有办法直接new的，我们必须要先有实现类才能new出来它的实现类实例。所以在mian方法中直接使用匿名内部类来创建一个Bird实例。 

     由于匿名内部类不能是抽象类，所以它必须要实现它的抽象父类或者接口里面所有的抽象方法。 

    对于这段匿名内部类代码其实是可以拆分为如下形式：



public class WildGoose extends Bird{
    public int fly() {
        return 10000;
    }

    public String getName() {
        return "大雁";
    }
}

WildGoose wildGoose = new WildGoose();
test.test(wildGoose);

在这里系统会创建一个继承自Bird类的匿名类的对象，该对象转型为对Bird类型的引用。 

对于匿名内部类的使用它是存在一个缺陷的，就是它仅能被使用一次，创建匿名内部类时它会立即创建一个该类的实例，该类的定义会立即消失，所以匿名内部类是不能够被重复使用。对于上面的实例，如果我们需要对test()方法里面内部类进行多次使用，建议重新定义类，而不是使用匿名内部类。



四、注意事项



1.不使用匿名内部类来实现抽象方法



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

class Child extends Person {
    public void eat() {
        System.out.println("eat something");
    }
}

public class Demo {
    public static void main(String[] args) {
        Person p = new Child();
        p.eat();
    }
}

运行结果：eat something 

可以看到，我们用Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person类的引用 

但是，如果此处的Child类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？

这个时候就引入了匿名内部类



2.在接口上使用匿名内部类




interface Person {
    public void eat();
}

public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

运行结果：eat something

由上面的例子可以看出，只要一个类是抽象的或是一个接口，那么其子类中的方法都可以使用匿名内部类来实现

最常用的情况就是在多线程的实现上，因为要实现多线程必须继承Thread类或是继承Runnable接口



3.Thread类的匿名内部类实现



public class Demo {
    public static void main(String[] args) {
        Thread t = new Thread() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        t.start();
    }
}

运行结果：1 2 3 4 5



4.Runnable接口的匿名内部类实现



public class Demo {
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        Thread t = new Thread(r);
        t.start();
    }
}

运行结果：1 2 3 4 5