匿名内部类

1.相似于实现类 (具体看代码)
2.父类调用的子类的方法 run.run（）；
3.如果只想创建一个子类对象 就可以使用匿名内部类 操作简单
4.如果想创建多想子类对象 ,就得创建普通子类或者 实现类的方式
5.new Run(){}.run();
6.抽象类有构造方法 子类可以继承父类的非私有属性方法 这里的构造方法是执行子类时加载父类的非私有属性方法
7.格式1:
父类（接口） 对象名 = new 父类（接口）{
重写 父类的方法 （无论抽象与否)
};
格式2:
即使匿名内部类 也是 匿名对象
new 父类（接口）{
重写 父类的方法 （无论抽象与否）
};

package com.qf.demo;
/**
 * 如果只想创建一个  子类对象  ， 就可以用 匿名内部类的形式
 *          操作简单 
 * 如果  想创建多个子类对象, 创建普通子类或者是实现类的方式
 * 
 *
 */
public class Test2 {
    public static void main(String[] args) {
        // 自己么有重新 起名字  
        // 但是没有名字   语法报错
        // 让 Run帮助代替  实现类的名字
         // 父类      =   子类      
        Run run = new Run() // 真正new 的是  实现类的对象
        {// 实现类   没有实现类的名字
            
            public void run() {
                System.out.println("动物跑步");
            }
        };
        run.run();
        run.run();      
        new Run() {
            public void run() {
                System.out.println("小猫跑步");
            }
        }.run();
        // 匿名内部类
        Run run2 = new Run() {
            
            public void run() {
                // TODO Auto-generated method stub
                
            }
        };
        // 线程匿名内部类
        new Runnable() {
            
            public void run() {
                // TODO Auto-generated method stub
                
            }
        };
        
    }
}
interface Run{
    public void run();
}

另外一种是带参数的

package com.qf.demo;
/**
 * 父类（接口）  对象名 = new  父类（接口）{
 *  
 *      // 重写  父类的方法  （无论抽象与否）
 *  
 * }
 * 
 *  即使匿名内部类 也是  匿名对象
 *  new  父类（接口）{
 *  
 *      // 重写  父类的方法  （无论抽象与否）
 *  
 * }
 * 
 * 匿名内部类 只能 创建一次对象
 *      好处: 书写格式简单
 *      弊端： 只能用一次
 *
 */
public class Test3 {

    public static void main(String[] args) {
        //普通调用
        Cat cat = new Cat("猫星人", 2);
        cat.eat();
        
        Cat cat2 = new  Cat("火星喵", 100000);
        cat2.eat();
        
         //匿名内部类(带参数的)
        //向上转型 
        //  父类      new 子类  
        Animal animal = new Animal("",6) {
            @Override
            public void eat() {
                System.out.println("abcd");
            }
            @Override
            public void sleep() {
                System.out.println("heheheh");
            }
            
        };
        //会调用重写以后的
        animal.eat();
        animal.sleep();
        //另外一种方式也可以实现匿名内部类的调用方法
        new Animal("",9){
            @Override
            public void eat() {
                System.out.println("lingwai");
            }
            @Override
            public void sleep() {
                System.out.println("hahaha");
            }
        }.eat();
         
    }
}

 abstract class Animal{
     private String name;
     private int age;
     
     public abstract void eat();

    public Animal(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    
    public void sleep(){
        System.out.println("睡");
    }

 }
 
 class Cat extends Animal{

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("小猫吃鱼");
    }
     
 }
 
 class Dog  extends Animal{

    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("小狗吃骨头");
    }
     
 }

总结匿名内部类:
1.匿名内部类两种方式 :有参数 无参数
2.看文章开头的7格式2中 也可以在分号前面