java基础之匿名内部类

内部类:
　　概述: 类里边还有一个类, 里边那个类叫内部类, 外边那个类叫外部类.
　

分类:
　　成员内部类: 定义在成员位置的内部类.
　　局部内部类: 定义在局部位置的内部类.

格式:
　　new 类名或者接口名(){
　　　　//重写类或者接口中 所有的 抽象方法;
　　};

本质:
　　就是一个继承了类或者实现了接口的 匿名的子类对象. 匿名内部类不是类, 而是子类对象.

匿名内部类的实际应用:
　　1) 当对 对象方法(成员方法) 仅调用一次的时候.
　　2) 可以作为方法的实参进行传递.

建议:
　　当接口中或者抽象类中的 抽象方法仅有一个的时候, 就可以 考虑使用匿名内部类.

代码说明:

public class DemoClass { //外部类
    
    String name;    //成员变量
    
    class Inner1 {    //成员内部类
        
    }
    
    //成员方法
    public void show() {
        int num = 10;    //局部变量, 基本类型
        
        Object obj = new Object();    //局部变量, 引用类型
        
        //局部内部类.   局部变量, 引用类型
        class Inner2{
            
        }
    }
}

应用举例:

public static void main(String[] args) {                   
    // 对, Jumpping#jump(); 调三次.                            
    //1) 当对 对象方法(成员方法) 仅调用一次的时候.                           
    Jumping jm = new Jumping() {        //多态                                                            
        @Override                                          
        public void jump() {                               
            System.out.println("我会跳");                     
        }                                                                                               
    };                                                     
    jm.jump();                                             
    jm.jump();                                             
    jm.jump();                                             
                                                           
    //2) 可以作为方法的实参进行传递.                                    
    show(new Jumping() {                                   
                                                           
        @Override                                          
        public void jump() {                               
            System.out.println("我会跳, 可以作为方法的实参进行传递");      
        }                                                  
    });                                                    
}                                                          
                                                           
                                                           
public static void show(Jumping jm) {                      
    jm.jump();                                             
}                                                          

public interface Jumping {
    final public static int num = 10;
    
    
    public abstract void jump();
}

public static void main(String[] args) {                  /*                                                    
     *  通过匿名内部类实现.                                    
     *  new 类名或者接口名(){                                    
       　　//重写类或者接口中 所有的 抽象方法;                          
        };                                                
     */                                                   
    new Animal() {                                        
        public void eat() {                               
            System.out.println("我是匿名内部类的方式实现的, 猫吃鱼");     
        }                                                 
    }.eat();                                              
}                                                         

/**
 * 抽象类: Animal
 * @author
 *
 */
public abstract class Animal {
    public abstract void eat();
}