Java中内部类和匿名内部类的详解

àì夳堔傛蜴生んèń 2021-08-29 01:54 372阅读 0赞

# 1、内部类 #

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

## 1.1 成员内部类 ##

定义在类中方法外的类。

**定义格式：**

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

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

**代码举例：**

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

## 1.2 访问特点 ##

成员内部类可以直接访问外部类的成员变量和成员方法。

外部类不可以直接访问内部类的成员变量和成员方法。

**外部类想要访问内部的成员:** 得创建内部类对象来访问内部类成员。

外部类名.内部类名 对象名 = 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();
        }
    }
    
    输出结果:
    心脏在跳动
    心脏不跳了

# 2、匿名内部类 #

一个继承了类的子类的匿名对象 或者一个实现了接口的实现类的匿名对象。

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

1、定义子类

2、重写接口中的方法

3、创建子类对象

4、调用重写后的方法

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

**条件**

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

## 2.1 格式 ##

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();
        }
    }

> **原文作者：**一直千寻
> 
> **原文地址：**[https://www.cnblogs.com/libinhong/p/10990602.html][https_www.cnblogs.com_libinhong_p_10990602.html]
> 
> （感谢原文作者的分享）

> **分享其他学习资料：**
> 
> [Java内部类和匿名内部类的用法][Java]
> 
> [Java 局部内部类、匿名内部类详解][Java 1]

[https_www.cnblogs.com_libinhong_p_10990602.html]: https://www.cnblogs.com/libinhong/p/10990602.html
[Java]: https://blog.csdn.net/guyuealian/article/details/51981163
[Java 1]: https://blog.csdn.net/anlian523/article/details/99709973