Java抽象类接口内部类用法示例与易错点总结

1. 前言

今天这篇，集中梳理了Java面向对象后半部分的几个关键概念：抽象类、接口、静态成员、包、作用域，以及内部类。

抽象类和接口这部分，理解起来还算顺畅。它们的核心思路都指向同一个方向——定义规范。倒是内部类，尤其是匿名内部类，刚开始接触时，确实会感觉有点绕。它没有类名，却可以直接创建对象并实现功能，从直觉上看，这一点有点反常规。

不过，从功能性的角度来说，匿名内部类确实提供了极大的便利。特别是在外部类内部定义匿名类时，它可以直接访问外部类的private成员。这种灵活度，比单一依赖继承关系更有优势。这里需要说清楚：它并不是打破了继承对private成员的访问限制，而是因为它本身就定义在外部类的“身体”里，所以自然可以访问外部类的私有部分。

2. 抽象类

2.1 抽象方法

当一个父类方法，本身不需要有具体实现，它的存在只是为了强制所有子类都必须去实现它时，就可以将其定义为抽象方法。这是Java抽象类设计的重要用途之一。

抽象方法的关键词是abstract，它没有方法体。

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

这里的run()只定义了方法签名，具体执行逻辑交给子类去填充。

重点关注：如果一个类中包含了抽象方法，那么这个类必须声明为抽象类。

2.2 抽象类的特点

抽象类同样使用abstract关键字来修饰。

abstract class Person {
   ...
}

抽象类有几个很鲜明的特征：

1. 不能直接创建实例；
2. 它的主要用途就是被继承；
3. 它能够强制子类去实现某些特定的方法；
4. 抽象方法的存在，本质上就是在定义一种“行为规范”。

写下面这样的代码是会报错的：

Person p = new Person();

因为Person是抽象类，new这个动作不被允许。

子类继承抽象类后，必须实现其中的抽象方法：

class Student extends Person {
    @Override
    public void run() {
        System.out.println("Student run");
    }
}

如果子类没有实现这些抽象方法，那么它自己也必须被声明为抽象类。

2.3 面向抽象编程

抽象类通常会和多态特性搭配使用，这是Java面向对象编程中的经典技巧。

举个例子：

Person s = new Student();
Person t = new Teacher();

变量声明时的类型是Person，但实际指向的对象可以是Student或者Teacher。

当我们调用：

s.run();

JVM会依据s变量实际指向的具体对象类型，自动调用Student类中覆写的run()方法。

这样做的好处：调用方法时，无需手动判断具体子类是谁，JVM会自动根据实际对象类型，调用正确的那个方法。

上层代码只依赖于抽象类定义的规范，而不关心具体子类的内部实现细节。

3. 接口

3.1 接口是什么？

当一个抽象类没有定义任何字段，并且所有方法都是抽象方法时，它完全可以改写成一个接口。接口在Java中是一种更纯粹的规范定义方式。

接口使用interface关键字定义。

interface Person {
    void run();
    String getName();
}

接口中的方法，默认就是public abstract，所以可以省略这两个修饰符。

也就是说

void run();

和下面这种写法是等价的：

public abstract void run();

和抽象类相比，接口的抽象程度更高，它最主要的用途就是定义一套规范。

3.2 实现接口

一个类要遵循某个接口的规范，需要使用implements关键字。

class Student implements Person {
    private String name;

    public Student(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(name + " run");
    }

    @Override
    public String getName() {
        return name;
    }
}

一个类如果实现了某个接口，就必须提供接口中所有抽象方法的实现。

Java只支持单继承，但这并不妨碍一个类同时实现多个接口。

class Student implements Person, Hello {
}

这也是接口如此重要的原因之一：它在很大程度上弥补了单继承带来的限制。

3.3 抽象类和接口的区别

对比项	抽象类	接口
关键字	abstract class	interface
继承/实现	extends	implements
数量限制	只能继承一个类	可以实现多个接口
实例字段	可以有	不能有实例字段
抽象方法	可以有	可以有
普通方法	可以有	可以有 default 方法

换种方式理解：抽象类像是一个“半成品类”，而接口则更像是一份“能力清单”或者“行为规范”。

3.4 接口继承

接口与接口之间也可以存在继承关系，使用extends关键字。

interface Hello {
    void hello();
}

interface Person extends Hello {
    void run();
    String getName();
}

这样一来，Person接口不仅有自己的run()和getName()方法，也继承了来自Hello接口的hello()方法。

如果一个类实现了Person接口，那么它需要提供三个方法的实现。

3.5 default 方法

在接口中，可以定义带有默认实现的方法，使用default关键字。

interface Person {
    String getName();

    default void run() {
        System.out.println(getName() + " run");
    }
}

实现类可以不去覆写这个default方法，直接使用接口提供的默认版本。

default方法的一个常见用法是：当需要给接口增加新方法时，所有现有的实现类不会因此报错，无需立刻修改代码。

不过有一点需要留意：

接口本身没有实例字段，所以default方法无法直接访问任何实例级别的数据。

4. 接口中的静态字段

接口里可以定义字段。

public interface Person {
    int MALE = 1;
    int FEMALE = 2;
}

接口中定义的字段，默认的修饰符组合是：

public static final

所以，上面的代码和下面这种写法是完全等价的：

public static final int MALE = 1;
public static final int FEMALE = 2;

接口中的字段本质上就是公开的、属于接口级别的静态常量。

5. 静态字段和静态方法

5.1 静态字段

被static关键字修饰的字段，属于类本身，而不是属于某个具体的实例对象。

class Person {
    public static int count;
}

推荐通过类名来访问静态字段：

Person.count = 10;

通过实例去访问，虽然有时候也能编译通过，但容易让人产生误解：

Person p = new Person();
p.count = 10;

不太推荐这种做法，因为它让代码的意图变得不清晰。

简单来说就是：实例字段属于某个对象，静态字段属于这个类。

5.2 静态方法

静态方法同样属于类本身，通过类名来调用。

Math.random();
Arrays.sort(ns);

静态方法在内部不能使用this关键字，因为this代表的是当前实例，而静态方法不属于任何具体实例。

同样，静态方法也不能直接访问实例字段，它只能访问静态字段。

class Person {
    private String name;
    private static int count;

    public static void test() {
        // System.out.println(name); // 错误
        System.out.println(count);   // 正确
    }
}

程序入口main方法本身就是一个静态方法：

public static void main(String[] args) {
}

6. 包 package

6.1 包的作用

包的主要作用是用来组织类，避免出现类名冲突的情况。

在Java源文件的第一行，可以声明这个类属于哪个包：

package ming;

如果一个类定义在ming包下，那么它的完整类名就是：

ming.Person

包名可以有多层结构：

package com.example.demo;

这里有一点需要特别说明：

java.util和java.util.zip是两个完全独立的包，它们之间不存在父子包或继承关系。

6.2 import 导入类

如果不使用import，每次使用类时都需写完整类名：

java.util.Scanner scanner = new java.util.Scanner(System.in);

使用import之后，就可以直接使用简单类名了：

import java.util.Scanner;

Scanner scanner = new Scanner(System.in);

也可以使用通配符导入：

import java.util.*;

这表示导入java.util包下的所有类。

不过，在实际开发中，通配符导入用得不多，因为会让代码的依赖关系变得不够明确。

6.3 自动导入

Java会默认帮我们导入两个来源的类：

1. 当前类所在包下的其他类；
2. java.lang.*包下的所有类。

正因为如此，像String、System这些常用类，不需要手动import。

但java.lang.reflect这种子包下的类并不会被自动导入，需要手动写import语句。

6.4 包名命名建议

在商业项目中，包名通常采用倒置的域名，这样可以有效减少命名冲突。

例如：

com.example.demo
org.apache.commons

一个很好的习惯是：避免自行定义与JDK常用类（如String、System、List）重名的类。

7. 作用域和访问权限

Java中访问权限控制分为四种不同的级别。

修饰符	访问范围
private	只能在本类中访问
无修饰符	同一个包中可以访问
protected	同一个包中可以访问，不同包的子类也可以访问
public	所有类都可以访问

7.1 包作用域

如果一个类、方法或字段没有显式地使用访问修饰符，那么它就属于包作用域。

package hello;

class Person {
    void hello() {
        System.out.println("Hello");
    }
}

在这个例子中，Person类和它的hello()方法都只能被同一个包内的其他类访问。

7.2 访问权限的基本原则

在实践中，一个很好的原则是：如果不确定某个类、字段或方法是否需要对外暴露，最好不要轻易将其声明为public。尽量做到“能少暴露就少暴露”。

这样做可以有效减少外部代码对内部实现的直接依赖，降低代码耦合度。

7.3 局部变量作用域

在方法内部定义的变量，被称为局部变量。

局部变量的作用域从它被声明的位置开始，一直持续到所在代码块的结束。

public void test() {
    int n = 10;

    if (n > 0) {
        int x = 20;
        System.out.println(x);
    }

    // System.out.println(x); // 错误，x 已经超出作用域
}

方法的参数也属于局部变量。

8. 内部类

内部类，顾名思义，就是定义在另一个类内部的类。Java内部类是实现封装和代码组织的重要机制。

Java中最常见的内部类有三种类型：

1. 实例内部类；
2. 匿名内部类；
3. 静态内部类。

8.1 实例内部类

实例内部类定义在另一个类的内部，并且不添加static关键字。

class Outer {
    private String name = "Outer";

    class Inner {
        public void hello() {
            System.out.println("Hello, " + Outer.this.name);
        }
    }
}

实例内部类的对象，必须依附于一个外部类的对象存在。

创建方式如下：

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();

实例内部类会隐式地持有其外部类对象的引用，因此可以访问外部类的private成员。

在需要明确指代外部类对象时，可以使用下面这种语法：

Outer.this

8.2 匿名内部类

匿名内部类是一种特殊的内部类，它没有名字，在使用的过程中边定义边创建。

它常用于需要临时实现某个接口或继承某个类的场合。

比如，实现Runnable接口：

Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("run");
    }
};

这段代码背后的含义可以这样理解：

临时定义了一个没有名字的类，这个类实现了Runnable接口，然后立即用这个类创建了一个对象。

匿名内部类之所以让人感觉有点绕，关键就在于这里：它同时完成了“定义类”和“创建对象”这两件事。

当这段代码被编译后，这个匿名内部类会生成一个类似下面这样的class文件：

Outer$1.class

8.3 匿名内部类为什么方便？

如果按照常规的写法，我们可能需要先单独定义一个类：

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("run");
    }
}

然后再去创建这个类的对象：

Runnable r = new MyRunnable();

而使用匿名内部类，可以直接一步到位：

Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("run");
    }
};

如果一个类只用这一次，那么专门给它起个名字、再单独写个文件，就有点多此一举了。

简单来说：匿名内部类非常适合编写那些只需要临时使用一次的接口实现。

8.4 匿名内部类和 private 访问

如果匿名内部类定义在外部类的内部，它同样可以访问外部类的private成员。

来看这个例子：

class Outer {
    private String secret = "private data";

    public Runnable createTask() {
        return new Runnable() {
            @Override
            public void run() {
                System.out.println(secret);
            }
        };
    }
}

在这里，匿名内部类可以直接访问Outer类的私有字段secret。

这也是匿名内部类比较灵活的一个方面：它能非常方便地在外部类的方法内部，直接使用外部类的内部数据。

仍需再次强调：

匿名内部类能访问外部类的private成员，是因为它本身就定义在外部类的“领地”之内，而不是因为它通过继承机制突破了private的限制。

8.5 匿名内部类初始化块

匿名内部类还可以拥有自己的初始化块。

比如：

HashMap map = new HashMap<>() {
    {
        put("A", "1");
        put("B", "2");
    }
};

这段代码中，最外层的{}是匿名类的类体，而内层紧接着的{}则是这个匿名类的初始化块。一切都还是写在类体内部的规矩。

不过这种写法，在初学阶段了解其原理即可，不建议大量使用，因为可读性不算很理想。

8.6 静态内部类

用static关键字修饰的内部类，就是静态内部类。

class Outer {
    static class StaticNested {
    }
}

静态内部类不依赖于外部类的任何实例，可以直接创建：

Outer.StaticNested sn = new Outer.StaticNested();

静态内部类无法访问外部类的实例字段，也无法使用Outer.this这种语法。

它只能访问外部类的静态成员，包括被private修饰的静态字段和静态方法。

9. 今日易错点总结

9.1 抽象类不能直接实例化

像下面这种写法是绝对错误的：

Person p = new Person();

抽象类的主要价值在于被继承。

9.2 接口中的字段默认是常量

接口中定义的所有字段，默认都是：

public static final

它们本质上是常量，而不是实例字段。

9.3 静态方法不能访问 this

this代表的是当前实例，而静态方法属于类自身，不属于任何特定实例。

因此，在静态方法中使用this是非法的。

9.4 包名有层级，但包之间没有继承关系

java.util和java.util.zip是两个完全不同的包。

导入java.util.*并不会自动导入java.util.zip里的任何类。

9.5 protected 不只是“子类可访问”

protected修饰符的访问范围包括：

1. 同一个包中的所有类；
2. 不同包中的子类。

9.6 匿名内部类没有名字，但它确实是一个类

就像这个例子：

Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("run");
    }
};

它并不是单纯地创建了一个Runnable接口的对象，而是创建了一个实现了该接口的匿名类的对象。

9.7 实例内部类和静态内部类不要混

实例内部类依赖于外部类的实例：

Outer.Inner inner = outer.new Inner();

静态内部类则不依赖于外部类的实例，直接创建：

Outer.StaticNested sn = new Outer.StaticNested();

10. 学习小结

今天的内容比较杂，从抽象类、接口，到静态成员、包、作用域，再到内部类，这些都是Java面向对象体系中相当核心的部分。掌握这些内容，对理解Java编程语言的设计思想至关重要。

抽象类和接口，都可以先按照“定义规范”的思路去理解。抽象类适合用在父类需要保留部分基础实现，同时要强制子类去实现另一部分具体方法的情况；而接口则更像一组能力要求，谁实现了接口，谁就必须提供接口所定义的服务。

要说今天最难消化的，还是内部类，尤其是匿名内部类。它没有类名，却能“边定义边创建对象”，刚开始接触确实会感觉有些违反直觉。但从实际功能实现来看，它又确实很方便，特别是在只需要临时实现一次接口的场景下，省去了单独定义一个类的繁琐。

另外，匿名内部类定义在外部类内部时能访问外部类的private成员，这一点让它看起来比单纯的继承更为灵活。不过要牢记：这并非因为继承突破了private的限制，而是因为它本身就是外部类的“内部人”。

总的来说，这一篇内容难度不算特别高，但涉及的概念比较密集。以后再次遇到类似Runnable r = new Runnable() { ... }这种写法时，应该能立刻意识到：这是一个匿名内部类，一个没有名字的临时实现。

11. 参考资料

• 廖雪峰 Java 教程