匿名内部类

时间：2020-02-09 22:11:31 阅读：88 评论：0 收藏：0 [点我收藏+]

内部类：

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

成员内部类

成员内部类：定义在类中方法外的类。

定义格式：

class 外部类 { 
  class 内部类{ 
  } 
}

在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如，汽车类 Car 中包含发动机

类 Engine ，这时， Engine 就可以使用内部类来描述，定义在成员位置。

代码举例：

class Car { 
    //外部类 
    class Engine {  
          //内部类 
       } 
  }

访问特点

内部类可以直接访问外部类的成员，包括私有成员。

外部类要访问内部类的成员，必须要建立内部类的对象。

创建内部类对象格式：

外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；

访问演示，代码如下：

定义类：

public class Person { 
    private boolean live = true; 
    class Heart { public void jump() { 
        // 直接访问外部类成员 
        if (live) { System.out.println("心脏在跳动"); 
        } else { System.out.println("心脏不跳了"); 
        } 
        }
    }public boolean isLive() { 
        return live; 
        }
    public void setLive(boolean live) { 
        this.live = live; 
        } 
     }

定义测试类：

public class InnerDemo {
    public static void main(String[] args) { 
        // 创建外部类对象 
        Person p = new Person(); 
        // 创建内部类对象 
        Heart heart = p.new Heart(); 
        // 调用内部类方法 
        heart.jump(); 
        // 调用外部类方法 
        p.setLive(false); 
        // 调用内部类方法 
        heart.jump(); 
        
    }
}

输出结果: 
    心脏在跳动 
    心脏不跳了

内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。

比如，Person$Heart.class

匿名内部类

匿名内部类 ：是内部类的简化写法。它的本质是一个带具体实现的父类或者父接口的匿名的 子类对象。

开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几步操作，

1. 定义子类

2. 重写接口中的方法

3. 创建子类对象

4. 调用重写后的方法

我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。

前提：

匿名内部类必须继承一个父类或者实现一个父接口。

格式：

new 父类名或者接口名(){ 
  // 方法重写 
  @Override 
    public void method() {
    // 执行语句 
    }
  };

使用方式：

以接口为例，匿名内部类的使用，代码如下：

定义接口：

public abstract class FlyAble{
     public abstract void fly(); 
  }

创建匿名内部类，并调用：

public class InnerDemo { 
    public static void main(String[] args) { 
        //1.等号右边:是匿名内部类，定义并创建该接口的子类对象 2.等号左边:是多态赋值,接口类型引用指向子类对象 
        
        FlyAble f = new FlyAble(){ 
            public void fly() { 
                System.out.println("我飞了~~~");
                } 
            };
            //调用 fly方法,执行重写后的方法
            f.fly(); } }
    }
}

通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。代码如下：

public class InnerDemo2 { 
    public static void main(String[] args) { 
        /*1.等号右边:定义并创建该接口的子类对象 2.等号左边:是多态,接口类型引用指向子类对象 */
        FlyAble f = new FlyAble(){ 
            public void fly() { 
                System.out.println("我飞了~~~"); 
                // 将f传递给showFly方法中 
                showFly(f); 
                }
        }
    
            public static void showFly(FlyAble f) { 
                f.fly(); 
                } 
    }

以上两步，也可以简化为一步，代码如下：

public class InnerDemo3 {
    public static void main(String[] args) { 
        /*创建匿名内部类,直接传递给
         * showFly(FlyAble f) 
         * */
        showFly( new FlyAble(){ 
            public void fly() { 
                System.out.println("我飞了~~~"); 
                } 
            }
        );
        }
    public static void showFly(FlyAble f) { 
        f.fly(); 
        } 
    }

匿名内部类

标签：etl bst 类型 ati 语句父类 live 直接成员内部类

原文地址：https://www.cnblogs.com/yangzhixue/p/12288947.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行