Java继承和多态

转载于：http://c.biancheng.net/java/
学好继承和多态是面向对象开发语言中非常重要的一个环节。如果在程序中使用继承和多态得当，整个程序的架构将变得非常有弹性，同时可以减少代码的冗余性。

继承机制的使用可以复用一些定义好的类，减少重复代码的编写。多态机制可以动态调整对象的调用，降低对象之间的依存关系。

本章将详细介绍 Java 中继承的语法和实现，以及多态机制的应用。同时讲解抽象类和接口的实现及区别，最后简单介绍内部类和匿名类的使用。

本章学习要点

1. 掌握 Java 语言中类的继承
2. 掌握 super 关键字的使用
3. 掌握方法重载和重写的区别
4. 理解抽象类的概念
5. 掌握接口的实现
6. 熟悉内部类和匿名类的使用

Java类的封装

封装将类的某些信息隐藏在类内部，不允许外部程序直接访问，只能通过该类提供的方法来实现对隐藏信息的操作和访问。例如：一台计算机内部极其复杂，有主板、CPU、硬盘和内存， 而一般用户不需要了解它的内部细节，不需要知道主板的型号、CPU 主频、硬盘和内存的大小，于是计算机制造商将用机箱把计算机封装起来，对外提供了一些接口，如鼠标、键盘和显示器等，这样当用户使用计算机就非常方便。

封装的特点：

• 只能通过规定的方法访问数据。
• 隐藏类的实例细节，方便修改和实现。

实现封装的具体步骤如下：

1. 修改属性的可见性来限制对属性的访问，一般设为 private。
2. 为每个属性创建一对赋值（setter）方法和取值（getter）方法，一般设为 public，用于属性的读写。
3. 在赋值和取值方法中，加入属性控制语句（对属性值的合法性进行判断）。

例 1

下面以一个员工类的封装为例介绍封装过程。一个员工的主要属性有姓名、年龄、联系电话和家庭住址。假设员工类为 Employee，示例如下：

public class Employee {
    private String name; // 姓名
    private int age; // 年龄
    private String phone; // 联系电话
    private String address; // 家庭住址
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        // 对年龄进行限制
        if (age < 18 || age > 40) {
            System.out.println("年龄必须在18到40之间！");
            this.age = 20; // 默认年龄
        } else {
            this.age = age;
        }
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
}

如上述代码所示，使用 private 关键字修饰属性，这就意味着除了 Employee 类本身外，其他任何类都不可以访问这些属性。但是，可以通过这些属性的 setXxx() 方法来对其进行赋值，通过 getXxx() 方法来访问这些属性。

在 age 属性的 setAge() 方法中，首先对用户传递过来的参数 age 进行判断，如果 age 的值不在 18 到 40 之间，则将 Employee 类的 age 属性值设置为 20，否则为传递过来的参数值。

编写测试类 EmployeeTest，在该类的 main() 方法中调用 Employee 属性的 setXxx() 方法对其相应的属性进行赋值，并调用 getXxx() 方法访问属性，代码如下：

public class EmployeeTest {
    public static void main(String[] args) {
        Employee people = new Employee();
        people.setName("王丽丽");
        people.setAge(35);
        people.setPhone("13653835964");
        people.setAddress("河北省石家庄市");
        System.out.println("姓名：" + people.getName());
        System.out.println("年龄：" + people.getAge());
        System.out.println("电话：" + people.getPhone());
        System.out.println("家庭住址：" + people.getAddress());
    }
}

运行该示例，输出结果如下：

姓名：王丽丽
年龄：35
电话：13653835964
家庭住址：河北省石家庄市

通过封装，实现了对属性的数据访问限制，满足了年龄的条件。在属性的赋值方法中可以对属性进行限制操作，从而给类中的属性赋予合理的值， 并通过取值方法获取类中属性的值（也可以直接调用类中的属性名称来获取属性值）。

Java封装图书信息类

了解上节有关封装的知识后，本节通过完整的例子再次实现封装。要求编写表示图书的 Book 类，实现以下需求：

• 基本信息包括图书名称（bookName）、总页数（pagelbtalNum），其中页数不能少于 200 页，否则输出错误信息，并赋予默认值 200。
• 为各个属性设置赋值和取值方法。
• 具有 details() 方法，该方法在控制台输出每本图书的名称和总页数。

编写 BookTest 测试类，为 Book 对象的属性赋予初始值，并调用 details() 方法输出详细信息。根据上面的描述添加代码，步骤如下。

1）创建 Book 类，首先向该类添加 bookName 变量，并封装该变量。代码如下：

public class Book {
    private String bookName; // 图书名称
    public String getBookName() {
        return bookName;
    }
    public void setBookName(String bookName) {
        this.bookName = bookName;
    }
}

2）在 Book 类中添加 bookTotalNum 变量，并封装该变量，在封装的 setter 方法中判断页数的值是否小于 200。代码如下：

private int bookTotalNum; // 图书总页数
public int getBookTotaiNum() {
    return bookTotalNum;
}
public void setBookTotalNum(int bookTotalNum) {
    if (bookTotalNum < 200) {
        System.out.println(this.bookName + "这本书的页数不能少于 200 页");
        this.bookTotalNum = 200;
    } else {
        this.bookTotalNum = bookTotalNum;
    }
}

3）在 Book 类中添加公有的 details() 方法，输出图书的名称和总页数。代码如下：

public void details() {
    System.out.println(this.bookName + "这本书的总页数是：" + this.bookTotalNum);
}

4）创建 BookTest 测试类，在该类的 main() 方法中创建 Book 类的两个实例对象，然后分别为类中的两个属性赋值，最后调用 details() 方法输出信息。代码如下：

public class BookTest {
    public static void main(String[] args) {
        Book book1 = new Book();
        book1.setBookName("《红与黑》");
        book1.setBookTotalNum(190);
        book1.details();
        System.out.println("************************************");
        Book book2 = new Book();
        book2.setBookName("《格林童话》");
        book2.setBookTotalNum(520);
        book2.details();
    }
}

5）执行上述代码，输出结果如下：

《红与黑》这本书的页数不能少于 200 页
《红与黑》这本书的总页数是：200
************************************
《格林童话》这本书的总页数是：520

Java继承（extends）简明教程

继承是面向对象的三大特征之一。继承和现实生活中的“继承”的相似之处是保留一些父辈的特性，从而减少代码冗余，提高程序运行效率。

Java 中的继承就是在已经存在类的基础上进行扩展，从而产生新的类。已经存在的类称为父类、基类或超类，而新产生的类称为子类或派生类。在子类中，不仅包含父类的属性和方法，还可以增加新的属性和方法。

Java 中子类继承父类的语法格式如下：

修饰符 class class_name extends extend_class {    // 类的主体}

其中，class_name 表示子类（派生类）的名称；extend_class 表示父类（基类）的名称；extends 关键字直接跟在子类名之后，其后面是该类要继承的父类名称。例如：

public class Student extends Person{}

Java 的继承通过 extends 关键字来实现，extends 的英文意思是扩展，而不是继承。extends 很好的体现了子类和父类的关系，即子类是对父类的扩展，子类是一种特殊的父类。从这个角度看，使用继承来描述子类和父类的关系是错误的，用扩展更恰当。

那么为什么国内把 extends 翻译为“继承”呢？子类扩展父类之后就可以获得父类的属性和方法，这与汉语中的继承（子类从父类获得一笔财富称为继承）具有相似性。

Java 与 C++ 定义继承类的方式十分相似。Java 用关键字 extends 代替了 C++ 中的冒号（：）。在 Java 中，所有的继承都是公有继承， 而没有 C++ 中的私有继承和保护继承。

类的继承不改变类成员的访问权限，也就是说，如果父类的成员是公有的、被保护的或默认的，它的子类仍具有相应的这些特性，并且子类不能获得父类的构造方法。

例 1

教师和学生都属于人，他们具有共同的属性：姓名、年龄、性别和身份证号，而学生还具有学号和所学专业两个属性，教师还具有教龄和所教专业两个属性。下面编写 Java 程序代码，使教师（Teacher）类和学生（Student）类都继承于人（People）类，具体的实现步骤如下。

1）创建人类 People，并定义 name、age、sex、sn 属性，代码如下：

public class People {
    public String name; // 姓名
    public int age; // 年龄
    public String sex; // 性别
    public String sn; // 身份证号
    public People(String name, int age, String sex, String sn) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.sn = sn;
    }
    public String toString() {
        return "姓名：" + name + "\n年龄：" + age + "\n性别：" + sex + "\n身份证号：" + sn;
    }
}

如上述代码，在 People 类中包含 4 个公有属性、一个构造方法和一个 toString() 方法。

2）创建 People 类的子类 Student 类，并定义 stuNo 和 department 属性，代码如下：

public class Student extends People {
    private String stuNo; // 学号
    private String department; // 所学专业
    public Student(String name, int age, String sex, String sn, String stuno, String department) {
        super(name, age, sex, sn); // 调用父类中的构造方法
        this.stuNo = stuno;
        this.department = department;
    }
    public String toString() {
        return "姓名：" + name + "\n年龄：" + age + "\n性别：" + sex + "\n身份证号：" + sn + "\n学号：" + stuNo + "\n所学专业：" + department;
    }
}

由于 Student 类继承自 People 类，因此，在 Student 类中同样具有 People 类的属性和方法，这里重写了父类中的 toString() 方法。

注意：如果在父类中存在有参的构造方法而并没有重载无参的构造方法，那么在子类中必须含有有参的构造方法，因为如果在子类中不含有构造方法，默认会调用父类中无参的构造方法，而在父类中并没有无参的构造方法，因此会出错。

3）创建 People 类的另一个子类 Teacher，并定义 tYear 和 tDept 属性，代码如下：

public class Teacher extends People {
    private int tYear; // 教龄
    private String tDept; // 所教专业
    public Teacher(String name, int age, String sex, String sn, int tYear, String tDept) {
        super(name, age, sex, sn); // 调用父类中的构造方法
        this.tYear = tYear;
        this.tDept = tDept;
    }
    public String toString() {
        return "姓名：" + name + "\n年龄：" + age + "\n性别:" + sex + "\n身份证号：" + sn + "\n教龄：" + tYear + "\n所教专业：" + tDept;
    }
}

Teacher 类与 Student 类相似，同样重写了父类中的 toString() 方法。

4）编写测试类 PeopleTest，在该类中创建 People 类的不同对象，分别调用它们的 toString() 方法，输出不同的信息。具体的代码如下：

public class PeopleTest {
    public static void main(String[] args) {
        // 创建Student类对象
        People stuPeople = new Student("王丽丽", 23, "女", "410521198902145589", "00001", "计算机应用与技术");
        System.out.println("----------------学生信息---------------------");
        System.out.println(stuPeople);
        // 创建Teacher类对象
        People teaPeople = new Teacher("张文", 30, "男", "410521198203128847", 5, "计算机应用与技术");
        System.out.println("----------------教师信息----------------------");
        System.out.println(teaPeople);
    }
} 

运行程序，输出的结果如下：

----------------学生信息---------------------
姓名：王丽丽
年龄：23
性别：女
身份证号：410521198902145589
学号：00001
所学专业：计算机应用与技术
----------------教师信息----------------------
姓名：张文
年龄：30
性别:男
身份证号：410521198203128847
教龄：5
所教专业：计算机应用与技术

单继承

Java 语言摒弃了 C++ 中难以理解的多继承特征，即 Java 不支持多继承，只允许一个类直接继承另一个类，即子类只能有一个直接父类，extends 关键字后面只能有一个类名。例如，如下代码会导致编译错误：

class Student extends Person,Person1,Person2{…}class Student extends Person,extends Person1,extends Person2{…}

很多地方在介绍 Java 的单继承时，可能会说 Java 类只能有一个父类，严格来讲，这种说法是错误的，应该是一个类只能有一个直接父类，但是它可以有多个间接的父类。例如，Student 类继承 Person 类，Person 类继承 Person1 类，Person1 类继承 Person2 类，那么 Person1 和 Person2 类是 Student 类的间接父类。图 1 展示了单继承的关系。

图 1 图形类之间的关系

从图 1 中可以看出，三角形、四边形和五边形的直接父类是多边形类，它们的间接父类是图形类。图形类、多边形类和三角形、四边形、五边形类形成了一个继承的分支。在这个分支上，位于下层的子类会继承上层所有直接或间接父类的属性和方法。如果两个类不在同一个继承树分支上，就不会存在继承关系，例如多边形类和直线。

如果定义一个 Java 类时并未显式指定这个类的直接父类，则这个类默认继承 java.lang.Object 类。因此，java.lang.Object 类是所有类的父类，要么是其直接父类，要么是其间接父类。因此所有的 Java 对象都可调用 java.lang.Object 类所定义的实例方法。

使用继承的注意点：

1. 子类一般比父类包含更多的属性和方法。
2. 父类中的 private 成员在子类中是不可见的，因此在子类中不能直接使用它们。
3. 父类和其子类间必须存在“是一个”即“is-a”的关系，否则不能用继承。但也并不是所有符合“is-a”关系的都应该用继承。例如，正方形是一个矩形，但不能让正方形类来继承矩形类，因为正方形不能从矩形扩展得到任何东西。正确的继承关系是正方形类继承图形类。
4. Java 只允许单一继承（即一个子类只能有一个直接父类），C++ 可以多重继承（即一个子类有多个直接父类）。

继承的优缺点

在面向对象语言中，继承是必不可少的、非常优秀的语言机制，它有如下优点：

1. 实现代码共享，减少创建类的工作量，使子类可以拥有父类的方法和属性。
2. 提高代码维护性和可重用性。
3. 提高代码的可扩展性，更好的实现父类的方法。

自然界的所有事物都是优点和缺点并存的，继承的缺点如下：

1. 继承是侵入性的。只要继承，就必须拥有父类的属性和方法。
2. 降低代码灵活性。子类拥有父类的属性和方法后多了些约束。
3. 增强代码耦合性（开发项目的原则为高内聚低耦合）。当父类的常量、变量和方法被修改时，需要考虑子类的修改，有可能会导致大段的代码需要重构。

Java super关键字详解

由于子类不能继承父类的构造方法，因此，如果要调用父类的构造方法，可以使用 super 关键字。super 可以用来访问父类的构造方法、普通方法和属性。

super 关键字的功能：

• 在子类的构造方法中显式的调用父类构造方法
• 访问父类的成员方法和变量。

super调用父类构造方法

super 关键字可以在子类的构造方法中显式地调用父类的构造方法，基本格式如下：

super(parameter-list);

其中，parameter-list 指定了父类构造方法中的所有参数。super( ) 必须是在子类构造方法的方法体的第一行。

例1

声明父类 Person 和子类 Student，在 Person 类中定义一个带有参数的构造方法，代码如下：

public class Person {
    public Person(String name) {
    }
}
public class Student extends Person {
}

会发现 Student 类出现编译错误，提示必须显式定义构造方法，错误信息如下：

Implicit super constructor Person() is undefined for default constructor. Must define an explicit constructor

在本例中 JVM 默认给 Student 类加了一个无参构造方法，而在这个方法中默认调用了 super()，但是 Person 类中并不存在该构造方法，所以会编译错误。

如果一个类中没有写任何的构造方法，JVM 会生成一个默认的无参构造方法。在继承关系中，由于在子类的构造方法中，第一条语句默认为调用父类的无参构造方法（即默认为 super()，一般这行代码省略了）。所以当在父类中定义了有参构造方法，但是没有定义无参构造方法时，编译器会强制要求我们定义一个相同参数类型的构造方法。

例2

声明父类 Person，类中定义两个构造方法。示例代码如下：

public class Person {
    public Person(String name, int age) {
    }
    public Person(String name, int age, String sex) {
    }
}

子类 Student 继承了 Person 类，使用 super 语句来定义 Student 类的构造方法。示例代码如下：

public class Student extends Person {
    public Student(String name, int age, String birth) {
        super(name, age); // 调用父类中含有2个参数的构造方法
    }
    public Student(String name, int age, String sex, String birth) {
        super(name, age, sex); // 调用父类中含有3个参数的构造方法
    }
}

从上述 Student 类构造方法代码可以看出，super 可以用来直接调用父类中的构造方法，使编写代码也更加简洁方便。

编译器会自动在子类构造方法的第一句加上super();来调用父类的无参构造方法，必须写在子类构造方法的第一句，也可以省略不写。通过 super 来调用父类其它构造方法时，只需要把相应的参数传过去。

super访问父类成员

当子类的成员变量或方法与父类同名时，可以使用 super 关键字来访问。如果子类重写了父类的某一个方法，即子类和父类有相同的方法定义，但是有不同的方法体，此时，我们可以通过 super 来调用父类里面的这个方法。

使用 super 访问父类中的成员与 this 关键字的使用相似，只不过它引用的是子类的父类，语法格式如下：

super.member

其中，member 是父类中的属性或方法。使用 super 访问父类的属性和方法时不用位于第一行。

super调用成员属性

当父类和子类具有相同的数据成员时，JVM 可能会模糊不清。我们可以使用以下代码片段更清楚地理解它。

class Person {
    int age = 12;
}
class Student extends Person {
    int age = 18;
    void display() {
        System.out.println("学生年龄：" + super.age);
    }
}
class Test {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.display();
    }
}

输出结果为：

学生年龄：12

在上面的例子中，父类和子类都有一个成员变量 age。我们可以使用 super 关键字访问 Person 类中的 age 变量。

super调用成员方法

当父类和子类都具有相同的方法名时，可以使用 super 关键字访问父类的方法。具体如下代码所示。

class Person {
    void message() {
        System.out.println("This is person class");
    }
}
class Student extends Person {
    void message() {
        System.out.println("This is student class");
    }
    void display() {
        message();
        super.message();
    }
}
class Test {
    public static void main(String args[]) {
        Student s = new Student();
        s.display();
    }
}

输出结果为：

This is student class
This is person class

在上面的例子中，可以看到如果只调用方法 message( )，是当前的类 message( ) 被调用，使用 super 关键字时，是父类的 message( ) 被调用。

super和this的区别

this 指的是当前对象的引用，super 是当前对象的父对象的引用。下面先简单介绍一下 super 和 this 关键字的用法。

super 关键字的用法：

• super.父类属性名：调用父类中的属性
• super.父类方法名：调用父类中的方法
• super()：调用父类的无参构造方法
• super(参数)：调用父类的有参构造方法

如果构造方法的第一行代码不是 this() 和 super()，则系统会默认添加 super()。

this 关键字的用法：

• this.属性名：表示当前对象的属性
• this.方法名(参数)：表示调用当前对象的方法

当局部变量和成员变量发生冲突时，使用this.进行区分。

关于 Java super 和 this 关键字的异同，可简单总结为以下几条。

1. 子类和父类中变量或方法名称相同时，用 super 关键字来访问。可以理解为 super 是指向自己父类对象的一个指针。在子类中调用父类的构造方法。
2. this 是自身的一个对象，代表对象本身，可以理解为 this 是指向对象本身的一个指针。在同一个类中调用其它方法。
3. this 和 super 不能同时出现在一个构造方法里面，因为 this 必然会调用其它的构造方法，其它的构造方法中肯定会有 super 语句的存在，所以在同一个构造方法里面有相同的语句，就失去了语句的意义，编译器也不会通过。
4. this( ) 和 super( ) 都指的是对象，所以，均不可以在 static 环境中使用，包括 static 变量、static 方法和 static 语句块。
5. 从本质上讲，this 是一个指向对象本身的指针, 然而 super 是一个 Java 关键字。

例 3

在 Animal 类和 Cat 类中分别定义了 public 类型的 name 属性和 private 类型的 name 属性，并且 Cat 类继承 Animal 类。那么，我们可以在 Cat 类中通过 super 关键字来访问父类 Animal 中的 name 属性，通过 this 关键字来访问本类中的 name 属性，如下面的代码：

// 父类Animal的定义
public class Animal {
    public String name; // 动物名字
}
//子类Cat的定义
public class Cat extends Animal {
    private String name; // 名字
    public Cat(String aname, String dname) {
        super.name = aname; // 通过super关键字来访问父类中的name属性
        this.name = dname; // 通过this关键字来访问本类中的name属性
    }
    public String toString() {
        return "我是" + super.name + "，我的名字叫" + this.name;
    }
    public static void main(String[] args) {
        Animal cat = new Cat("动物", "喵星人");
        System.out.println(cat);
    }
}

上述代码演示了使用 super 关键字访问父类中与子类同名的成员变量 name，this 关键字访问本类的 name 变量。运行程序，输出结果如下：

我是动物，我的名字叫喵星人

Java对象类型转换：向上转型和向下转型

将一个类型强制转换成另一个类型的过程被称为类型转换。本节所说的对象类型转换，是指存在继承关系的对象，不是任意类型的对象。当对不存在继承关系的对象进行强制类型转换时，会抛出 Java 强制类型转换（java.lang.ClassCastException）异常。

Java 语言允许某个类型的引用变量引用子类的实例，而且可以对这个引用变量进行类型转换。Java 中引用类型之间的类型转换（前提是两个类是父子关系）主要有两种，分别是向上转型（upcasting）和向下转型（downcasting）。

1）向上转型

父类引用指向子类对象为向上转型，语法格式如下：

fatherClass obj = new sonClass();

其中，fatherClass 是父类名称或接口名称，obj 是创建的对象，sonClass 是子类名称。

向上转型就是把子类对象直接赋给父类引用，不用强制转换。使用向上转型可以调用父类类型中的所有成员，不能调用子类类型中特有成员，最终运行效果看子类的具体实现。

2）向下转型

与向上转型相反，子类对象指向父类引用为向下转型，语法格式如下：

sonClass obj = (sonClass) fatherClass;

其中，fatherClass 是父类名称，obj 是创建的对象，sonClass 是子类名称。

向下转型可以调用子类类型中所有的成员，不过需要注意的是如果父类引用对象指向的是子类对象，那么在向下转型的过程中是安全的，也就是编译是不会出错误。但是如果父类引用对象是父类本身，那么在向下转型的过程中是不安全的，编译不会出错，但是运行时会出现我们开始提到的 Java 强制类型转换异常，一般使用 instanceof 运算符来避免出此类错误。

例如，Animal 类表示动物类，该类对应的子类有 Dog 类，使用对象类型表示如下：

Animal animal = new Dog();    // 向上转型，把Dog类型转换为Animal类型
Dog dog = (Dog) animal; // 向下转型，把Animal类型转换为Dog类型

例 1

下面通过具体的示例演示对象类型的转换。例如，父类 Animal 和子类 Cat 中都定义了实例变量 name、静态变量 staticName、实例方法 eat() 和静态方法 staticEat()。此外，子类 Cat 中还定义了实例变量 str 和实例方法 eatMethod()。

父类 Animal 的代码如下：

public class Animal {
    public String name = "Animal：动物";
    public static String staticName = "Animal：可爱的动物";
    public void eat() {
        System.out.println("Animal：吃饭");
    }
    public static void staticEat() {
        System.out.println("Animal：动物在吃饭");
    }
}

子类 Cat 的代码如下：

public class Cat extends Animal {
    public String name = "Cat：猫";
    public String str = "Cat：可爱的小猫";
    public static String staticName = "Dog：我是喵星人";
    public void eat() {
        System.out.println("Cat：吃饭");
    }
    public static void staticEat() {
        System.out.println("Cat：猫在吃饭");
    }
    public void eatMethod() {
        System.out.println("Cat：猫喜欢吃鱼");
    }
    public static void main(String[] args) {
        Animal animal = new Cat();
        Cat cat = (Cat) animal; // 向下转型
        System.out.println(animal.name); // 输出Animal类的name变量
        System.out.println(animal.staticName); // 输出Animal类的staticName变量
        animal.eat(); // 输出Cat类的eat()方法
        animal.staticEat(); // 输出Animal类的staticEat()方法
        System.out.println(cat.str); // 调用Cat类的str变量
        cat.eatMethod(); // 调用Cat类的eatMethod()方法
    }
}

通过引用类型变量来访问所引用对象的属性和方法时，Java 虚拟机将采用以下绑定规则：

• 实例方法与引用变量实际引用的对象的方法进行绑定，这种绑定属于动态绑定，因为是在运行时由 Java 虚拟机动态决定的。例如，animal.eat() 是将 eat() 方法与 Cat 类绑定。
• 静态方法与引用变量所声明的类型的方法绑定，这种绑定属于静态绑定，因为是在编译阶段已经做了绑定。例如，animal.staticEat() 是将 staticEat() 方法与 Animal 类进行绑定。
• 成员变量（包括静态变量和实例变量）与引用变量所声明的类型的成员变量绑定，这种绑定属于静态绑定，因为在编译阶段已经做了绑定。例如，animal.name 和 animal.staticName 都是与 Animal 类进行绑定。

对于 Cat 类，运行时将会输出如下结果：

Animal：动物
Animal：可爱的动物
Cat：吃饭
Animal：动物在吃饭
Cat：可爱的小猫
Cat：猫喜欢吃鱼

强制对象类型转换

Java 编译器允许在具有直接或间接继承关系的类之间进行类型转换。对于向下转型，必须进行强制类型转换；对于向上转型，不必使用强制类型转换。

例如，对于一个引用类型的变量，Java 编译器按照它声明的类型来处理。如果使用 animal 调用 str 和 eatMethod() 方法将会出错，如下：

animal.str = "";    // 编译出错，提示Animal类中没有str属性animal.eatMethod();    // 编译出错，提示Animal类中没有eatMethod()方法

如果要访问 Cat 类的成员，必须通过强制类型转换，如下：

((Cat)animal).str = "";    // 编译成功((Cat)animal).eatMethod();    // 编译成功

把 Animal 对象类型强制转换为 Cat 对象类型，这时上面两句编译成功。对于如下语句，由于使用了强制类型转换，所以也会编译成功，例如：

Cat cat = (Cat)animal;    // 编译成功，将Animal对象类型强制转换为Cat对象类型

类型强制转换时想运行成功就必须保证父类引用指向的对象一定是该子类对象，最好使用 instanceof 运算符判断后，再强转，例如：

Animal animal = new Cat();
if (animal instanceof Cat) {
    Cat cat = (Cat) animal; // 向下转型
    ...
}

子类的对象可以转换成父类类型，而父类的对象实际上无法转换为子类类型。因为通俗地讲，父类拥有的成员子类肯定也有，而子类拥有的成员，父类不一定有。因此，对于向上转型，不必使用强制类型转换。例如：

Cat cat = new Cat();
Animal animal = cat;    // 向上转型，不必使用强制类型转换

如果两种类型之间没有继承关系，那么将不允许进行类型转换。例如：

Dog dog = new Dog();
Cat cat = (Cat)dog;    // 编译出错，不允许把Dog对象类型转换为Cat对象类型

Java中为什么使用向上转型而不直接创建子类对象？

初学者在学习向上转型可能会很难理解，向上转型并不能调用子类特有属性和方法，我们必须先生成子类实例再赋值给父类引用（向上转型），然后将父类引用向下强制转换给子类引用（向下转型），这样才能调用子类中的所有成员。这看起来像是多次一举，还不如直接创建子类实例。

随着技术的提升，我们在学习其它开源项目时会发现很多地方都用了向上转型和向下转型的技术。本节将带大家了解向上转型和向下转型的意义及使用场景。

例 1

定义父类 Animal，代码如下：

public class Animal {
    public void sleep() {
        System.out.println("小动物在睡觉");
    }
    public static void doSleep(Animal animal) {
        // 此时的参数是父类对象，但是实际调用时传递的是子类对象，就是向上转型。
        animal.sleep();
    }
    public static void main(String[] args) {
        animal.doSleep(new Cat());
        animal.doSleep(new Dog());
    }
}

子类 Cat 代码如下：

public class Cat extends Animal {
    @Override
    public void sleep() {
        System.out.println("猫正在睡觉");
    }
}

子类 Dog 代码如下：

public class Dog extends Animal {
    @Override
    public void sleep() {
        System.out.println("狗正在睡觉");
    }
}

输出结果为：

猫正在睡觉
狗正在睡觉

如果不用向上转型则必须写两个 doSleep 方法，一个传递 Cat 类对象，一个传递 Dog 类对象。这还是两个子类，如果有多个子类就要写很多相同的方法，造成重复。可以看出向上转型更好的体现了类的多态性，增强了程序的间接性以及提高了代码的可扩展性。当需要用到子类特有的方法时可以向下转型，这也就是为什么要向下转型。

比如设计一个父类 FileRead 用来读取文件，ExcelRead 类和 WordRead 类继承 FileRead 类。在使用程序的时候，往往事先不知道我们要读入的是 Excel 还是 Word。所以我们向上转型用父类去接收，然后在父类中实现自动绑定，这样无论你传进来的是 Excel 还是 Word 就都能够完成文件读取。

总结如下：

1. 把子类对象直接赋给父类引用是向上转型，向上转型自动转换。如 Father father = new Son();
2. 指向子类对象的父类引用赋给子类引用是向下转型，要强制转换。使用向下转型，必须先向上转型，为了安全可以用 instanceof 运算符判断。 如 father 是一个指向子类对象的父类引用，把 father 赋给子类引用 son，即Son son =（Son）father;。其中 father 前面的(Son)必须添加，进行强制转换。
3. 向上转型不能使用子类特有的属性和方法，只能引用父类的属性和方法，但是子类重写父类的方法是有效的。
4. 向上转型时会优先使用子类中重写父类的方法，如例 1 中调用的 sleep 方法。
5. 向上转型的作用是减少重复代码，可以将父类作为参数，这样使代码变得简洁，也更好的体现了多态。

Java方法重载

Java 允许同一个类中定义多个同名方法，只要它们的形参列表不同即可。如果同一个类中包含了两个或两个以上方法名相同的方法，但形参列表不同，这种情况被称为方法重载（overload）。

例如，在 JDK 的 java.io.PrintStream 中定义了十多个同名的 println() 方法。

public void println(int i){…}
public void println(double d){…}
public void println(String s){…}

这些方法完成的功能类似，都是格式化输出。根据参数的不同来区分它们，以进行不同的格式化处理和输出。它们之间就构成了方法的重载。实际调用时，根据实参的类型来决定调用哪一个方法。例如：

System.out.println(102);    // 调用println(int i)方法System.out.println(102.25);    // 调用println(double d)方法System.out.println("价格为 102.25");    // 调用println(String s)方法

方法重载的要求是两同一不同：同一个类中方法名相同，参数列表不同。至于方法的其他部分，如方法返回值类型、修饰符等，与方法重载没有任何关系。

使用方法重载其实就是避免出现繁多的方法名，有些方法的功能是相似的，如果重新建立一个方法，重新取个方法名称，会降低程序可读性。

例 1

在比较数值时，数值的个数和类型是不固定的，可能是两个 int 类型的数值，也可能是两个 double 类型的数值，或者是两个 double、一个 int 类型的数值；在这种情况下就可以使用方法的重载来实现数值之间的比较功能。具体实现代码如下：

public class OverLoading {
    public void max(int a, int b) {
        // 含有两个int类型参数的方法
        System.out.println(a > b ? a : b);
    }
    public void max(double a, double b) {
        // 含有两个double类型参数的方法
        System.out.println(a > b ? a : b);
    }
    public void max(double a, double b, int c) {
        // 含有两个double类型参数和一个int类型参数的方法
        double max = (double) (a > b ? a : b);
        System.out.println(c > max ? c : max);
    }
    public static void main(String[] args) {
        OverLoading ol = new OverLoading();
        System.out.println("1 与 5 比较，较大的是：");
        ol.max(1, 5);
        System.out.println("5.205 与 5.8 比较，较大的是：");
        ol.max(5.205, 5.8);
        System.out.println("2.15、0.05、58 中，较大的是：");
        ol.max(2.15, 0.05, 58);
    }
}

编译、运行上面程序完全正常，虽然 3 个 max() 方法的方法名相同，但因为它们的形参列表不同，所以系统可以正常区分出这 3 个方法。当运行时，Java 虚拟机会根据传递过来的不同参数来调用不同的方法。运行结果如下：

1 与 5 比较，较大的是：
5
5.205 与 5.8 比较，较大的是：
5.8
2.15、0.05、58 中，较大的是：
58.0

为什么方法重载不能用方法的返回值类型区分呢？

对于int f( ) { }和void( ) { }两个方法，如果这样调用int result = f();，系统可以识别是调用返回值类型为 int 的方法，但 Java 调用方法时可以忽略方法返回值，如果采用如下方法来调用f();，你能判断是调用哪个方法吗？如果你尚且不能判断，那么 Java 系统也会糊涂。在编程过程中有一条重要规则就是不要让系统糊涂，系统一糊涂，肯定就是你错了。因此，Java 里不能用方法返回值类型作为区分方法重载的依据。

Java方法重写

在子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写（override），又称为方法覆盖。当父类中的方法无法满足子类需求或子类具有特有功能的时候，需要方法重写。

子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强。

在重写方法时，需要遵循下面的规则：

• 参数列表必须完全与被重写的方法参数列表相同。
• 返回的类型必须与被重写的方法的返回类型相同（Java1.5 版本之前返回值类型必须一样，之后的 Java 版本放宽了限制，返回值类型必须小于或者等于父类方法的返回值类型）。
• 访问权限不能比父类中被重写方法的访问权限更低（public>protected>default>private）。
• 重写方法一定不能抛出新的检査异常或者比被重写方法声明更加宽泛的检査型异常。例如，父类的一个方法声明了一个检査异常 IOException，在重写这个方法时就不能抛出 Exception，只能拋出 IOException 的子类异常，可以抛出非检査异常。

另外还要注意以下几条：

• 重写的方法可以使用 @Override 注解来标识。
• 父类的成员方法只能被它的子类重写。
• 声明为 final 的方法不能被重写。
• 声明为 static 的方法不能被重写，但是能够再次声明。
• 构造方法不能被重写。
• 子类和父类在同一个包中时，子类可以重写父类的所有方法，除了声明为 private 和 final 的方法。
• 子类和父类不在同一个包中时，子类只能重写父类的声明为 public 和 protected 的非 final 方法。
• 如果不能继承一个方法，则不能重写这个方法。

例 1

每种动物都有名字和年龄属性，但是喜欢吃的食物是不同的，比如狗喜欢吃骨头、猫喜欢吃鱼等，因此每种动物的介绍方式是不一样的。

下面编写 Java 程序，在父类 Animal 中定义 getInfo() 方法，并在子类 Cat 中重写该方法， 实现猫的介绍方式。父类 Animal 的代码如下：

public class Animal {
    public String name; // 名字
    public int age; // 年龄
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getInfo() {
        return "我叫" + name + "，今年" + age + "岁了。";
    }
}

子类 Cat 的代码如下：

public class Cat extends Animal {
    private String hobby;
    public Cat(String name, int age, String hobby) {
        super(name, age);
        this.hobby = hobby;
    }
    public String getInfo() {
        return "喵！大家好！我叫" + this.name + "，我今年" + this.age + "岁了，我爱吃" + hobby + "。";
    }
    public static void main(String[] args) {
        Animal animal = new Cat("小白", 2, "鱼");
        System.out.println(animal.getInfo());
    }
}

如上述代码，在 Animal 类中定义了一个返回值类型为 String、名称为 getInfo() 的方法，而 Cat 类继承自该类，因此 Cat 类同样含有与 Animal 类中相同的 getInfo() 方法。但是我们在 Cat 类中又重新定义了一个 getInfo() 方法，即重写了父类中的 getInfo() 方法。

在 main() 方法中，创建了 Cat 类的对象 animal，并调用了 getInfo() 方法。输出的结果如下：

喵！大家好！我叫小白，我今年2岁了，我爱吃鱼。

如果子类中创建了一个成员变量，而该变量的类型和名称都与父类中的同名成员变量相同，我们则称作变量隐藏。

Java多态性：Java什么是多态？

多态性是面向对象编程的又一个重要特征，它是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为，这使得同一个属性或方法在父类及其各个子类中具有不同的含义。

对面向对象来说，多态分为编译时多态和运行时多态。其中编译时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的方法。通过编译之后会变成两个不同的方法，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是大家通常所说的多态性。

Java 实现多态有 3 个必要条件：继承、重写和向上转型。只有满足这 3 个条件，开发人员才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而执行不同的行为。

• 继承：在多态中必须存在有继承关系的子类和父类。
• 重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
• 向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才既能可以调用父类的方法，又能调用子类的方法。

例 1

下面通过一个例子来演示重写如何实现多态性。例子使用了类的继承和运行时多态机制，具体步骤如下。

1）创建 Figure 类，在该类中首先定义存储二维对象的尺寸，然后定义有两个参数的构造方法，最后添加 area() 方法，该方法计算对象的面积。代码如下：

public class Figure {
    double dim1;
    double dim2;
    Figure(double d1, double d2) {
        // 有参的构造方法
        this.dim1 = d1;
        this.dim2 = d2;
    }
    double area() {
        // 用于计算对象的面积
        System.out.println("父类中计算对象面积的方法，没有实际意义，需要在子类中重写。");
        return 0;
    }
}

2）创建继承自 Figure 类的 Rectangle 子类，该类调用父类的构造方法，并且重写父类中的 area() 方法。代码如下：

public class Rectangle extends Figure {
    Rectangle(double d1, double d2) {
        super(d1, d2);
    }
    double area() {
        System.out.println("长方形的面积：");
        return super.dim1 * super.dim2;
    }
}

3）创建继承自 Figure 类的 Triangle 子类，该类与 Rectangle 相似。代码如下：

public class Triangle extends Figure {
    Triangle(double d1, double d2) {
        super(d1, d2);
    }
    double area() {
        System.out.println("三角形的面积：");
        return super.dim1 * super.dim2 / 2;
    }
}

4）创建 Test 测试类，在该类的 main() 方法中首先声明 Figure 类的变量 figure，然后分别为 figure 变量指定不同的对象，并调用这些对象的 area() 方法。代码如下：

public class Test {
    public static void main(String[] args) {
        Figure figure; // 声明Figure类的变量
        figure = new Rectangle(9, 9);
        System.out.println(figure.area());
        System.out.println("===============================");
        figure = new Triangle(6, 8);
        System.out.println(figure.area());
        System.out.println("===============================");
        figure = new Figure(10, 10);
        System.out.println(figure.area());
    }
}

从上述代码可以发现，无论 figure 变量的对象是 Rectangle 还是 Triangle，它们都是 Figure 类的子类，因此可以向上转型为该类，从而实现多态。

5）执行上述代码，输出结果如下：

长方形的面积：
81.0
===============================
三角形的面积：
24.0
===============================
父类中计算对象面积的方法，没有实际意义，需要在子类中重写。
0.0

Java instanceof关键字详解

严格来说 instanceof 是 Java 中的一个双目运算符，由于它是由字母组成的，所以也是 Java 的保留关键字。在 Java 中可以使用 instanceof 关键字判断一个对象是否为一个类（或接口、抽象类、父类）的实例，语法格式如下所示。

boolean result = obj instanceof Class

其中，obj 是一个对象，Class 表示一个类或接口。obj 是 class 类（或接口）的实例或者子类实例时，结果 result 返回 true，否则返回 false。

下面介绍 Java instanceof 关键字的几种用法。

1）声明一个 class 类的对象，判断 obj 是否为 class 类的实例对象（很普遍的一种用法），如以下代码：

Integer integer = new Integer(1);
System.out.println(integer instanceof Integer); // true

2）声明一个 class 接口实现类的对象 obj，判断 obj 是否为 class 接口实现类的实例对象，如以下代码：

Java 集合中的 List 接口有个典型实现类 ArrayList。

public class ArrayList extends AbstractList
implements List, RandomAccess, Cloneable, java.io.Serializable

所以我们可以用 instanceof 运算符判断 ArrayList 类的对象是否属于 List 接口的实例，如果是返回 true，否则返回 false。

ArrayList arrayList = new ArrayList();
System.out.println(arrayList instanceof List); // true

或者反过来也是返回 true

List list = new ArrayList();
System.out.println(list instanceof ArrayList); // true

3）obj 是 class 类的直接或间接子类

我们新建一个父类 Person.class，代码如下：

public class Person {
}

创建 Person 的子类 Man，代码如下：

public class Man extends Person {
}

测试代码如下：

Person p1 = new Person();
Person p2 = new Man();
Man m1 = new Man();
System.out.println(p1 instanceof Man);    // false
System.out.println(p2 instanceof Man);    // true
System.out.println(m1 instanceof Man);    // true

第 4 行代码中，Man 是 Person 的子类，Person 不是 Man 的子类，所以返回结果为 false。

值得注意的是 obj 必须为引用类型，不能是基本类型。例如以下代码：

int i = 0;
System.out.println(i instanceof Integer); // 编译不通过
System.out.println(i instanceof Object); // 编译不通过

所以，instanceof 运算符只能用作对象的判断。

当 obj 为 null 时，直接返回 false，因为 null 没有引用任何对象。

Integer i = 1;
System.out.println(i instanceof null); // false

所以，obj 的类型必须是引用类型或空类型，否则会编译错误。

当 class 为 null 时，会发生编译错误，错误信息如下：

Syntax error on token “null”, invalid ReferenceType

所以 class 只能是类或者接口。

编译器会检查 obj 能否转换成右边的 class 类型，如果不能转换则直接报错，如果不能确定类型，则通过编译。这句话有些难理解，下面我们举例说明。

Person p1 = new Person();
System.out.println(p1 instanceof String);    // 编译报错
System.out.println(p1 instanceof List);    // false
System.out.println(p1 instanceof List<?>);    // false
System.out.println(p1 instanceof List<Person>);    // 编译报错

上述代码中，Person 的对象 p1 很明显不能转换为 String 对象，那么p1 instanceof String不能通过编译，但p1 instanceof List却能通过编译，而instanceof List<Person>又不能通过编译了。关于这些问题，可以查看Java语言规范Java SE8版寻找答案，如图所示。

可以理解成以下代码：

boolean result;
if (obj == null) {
    result = false;    // 当obj为null时，直接返回false
} else {
    try {
        // 判断obj是否可以强制转换为T
        T temp = (T) obj; 
        result = true;
    } catch (ClassCastException e) {
        result = false;
    }
}

在 T 不为 null 和 obj 不为 null 时，如果 obj 可以转换为 T 而不引发异常（ClassCastException），则该表达式值为 true ，否则值为 false 。所以对于上面提出的问题就很好理解了，p1 instanceof String会编译报错，是因为(String)p1是不能通过编译的，而(List)p1可以通过编译。

instanceof 也经常和三目（条件）运算符一起使用，代码如下：

A instanceof B ? A : C

判断 A 是否可以转换为 B ，如果可以转换返回 A ，不可以转换则返回 C。下面通过一个例子来讲解，代码如下：

public class Test {
    public Object animalCall(Animal a) {
        String tip = "这个动物不是牛！";
        // 判断参数a是不是Cow的对象
        return a instanceof Cow ? (Cow) a : tip;
    }
    public static void main(String[] args) {
        Sheep sh = new Sheep();
        Test test = new Test();
        System.out.println(test.animalCall(sh));
    }
}
class Animal {
}
class Cow extends Animal {
}
class Sheep extends Animal {
}

以上代码中，我们声明了一个 Animal 类作为父类，Cow 类和 Sheep 类为 Animal 的子类，在 Test 类的 main 函数中创建类 Sheep 的对象作为形参传递到 animalCall 方法中，因为 Sheep 类的对象不能转换为 Cow 类型，所以输出结果为“这个动物不是牛！”。

Java抽象（abstract）类

Java 语言提供了两种类，分别为具体类和抽象类。前面学习接触的类都是具体类。这一节介绍一下抽象类。

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，那么这样的类称为抽象类。

在 Java 中抽象类的语法格式如下：

<abstract>class<class_name> {
    <abstract><type><method_name>(parameter-iist);
}

其中，abstract 表示该类或该方法是抽象的；class_name 表示抽象类的名称；method_name 表示抽象方法名称，parameter-list 表示方法参数列表。

如果一个方法使用 abstract 来修饰，则说明该方法是抽象方法，抽象方法只有声明没有实现。需要注意的是 abstract 关键字只能用于普通方法，不能用于 static 方法或者构造方法中。

抽象方法的 3 个特征如下：

1. 抽象方法没有方法体
2. 抽象方法必须存在于抽象类中
3. 子类重写父类时，必须重写父类所有的抽象方法

注意：在使用 abstract 关键字修饰抽象方法时不能使用 private 修饰，因为抽象方法必须被子类重写，而如果使用了 private 声明，则子类是无法重写的。

抽象类的定义和使用规则如下：

1. 抽象类和抽象方法都要使用 abstract 关键字声明。
2. 如果一个方法被声明为抽象的，那么这个类也必须声明为抽象的。而一个抽象类中，可以有 0~n 个抽象方法，以及 0~n 个具体方法。
3. 抽象类不能实例化，也就是不能使用 new 关键字创建对象。

例 1

不同几何图形的面积计算公式是不同的，但是它们具有的特性是相同的，都具有长和宽这两个属性，也都具有面积计算的方法。那么可以定义一个抽象类，在该抽象类中含有两个属性（width 和 height）和一个抽象方法 area( )，具体步骤如下。

1）首先创建一个表示图形的抽象类 Shape，代码如下所示。

public abstract class Shape {
    public int width; // 几何图形的长
    public int height; // 几何图形的宽
    public Shape(int width, int height) {
        this.width = width;
        this.height = height;
    }
    public abstract double area(); // 定义抽象方法，计算面积
}

2）定义一个正方形类，该类继承自形状类 Shape，并重写了 area( ) 抽象方法。正方形类的代码如下：

public class Square extends Shape {
    public Square(int width, int height) {
        super(width, height);
    }
    // 重写父类中的抽象方法，实现计算正方形面积的功能
    @Override
    public double area() {
        return width * height;
    }
}

3）定义一个三角形类，该类与正方形类一样，需要继承形状类 Shape，并重写父类中的抽象方法 area()。三角形类的代码实现如下：

public class Triangle extends Shape {
    public Triangle(int width, int height) {
        super(width, height);
    }
    // 重写父类中的抽象方法，实现计算三角形面积的功能
    @Override
    public double area() {
        return 0.5 * width * height;
    }
}

4）最后创建一个测试类，分别创建正方形类和三角形类的对象，并调用各类中的 area() 方法，打印出不同形状的几何图形的面积。测试类的代码如下：

public class ShapeTest {
    public static void main(String[] args) {
        Square square = new Square(5, 4); // 创建正方形类对象
        System.out.println("正方形的面积为：" + square.area());
        Triangle triangle = new Triangle(2, 5); // 创建三角形类对象
        System.out.println("三角形的面积为：" + triangle.area());
    }
}

在该程序中，创建了 4 个类，分别为图形类 Shape、正方形类 Square、三角形类 Triangle 和测试类 ShapeTest。其中图形类 Shape 是一个抽象类，创建了两个属性，分别为图形的长度和宽度，并通过构造方法 Shape( ) 给这两个属性赋值。

在 Shape 类的最后定义了一个抽象方法 area( )，用来计算图形的面积。在这里，Shape 类只是定义了计算图形面积的方法，而对于如何计算并没有任何限制。也可以这样理解，抽象类 Shape 仅定义了子类的一般形式。

正方形类 Square 继承抽象类 Shape，并实现了抽象方法 area( )。三角形类 Triangle 的实现和正方形类相同，这里不再介绍。

在测试类 ShapeTest 的 main( ) 方法中，首先创建了正方形类和三角形类的实例化对象 square 和 triangle，然后分别调用 area( ) 方法实现了面积的计算功能。

5）运行该程序，输出的结果如下：

正方形的面积为：20.0
三角形的面积为：5.0

Java接口（Interface）的定义和实现

抽象类是从多个类中抽象出来的模板，如果将这种抽象进行的更彻底，则可以提炼出一种更加特殊的“抽象类”——接口（Interface）。接口是 Java 中最重要的概念之一，它可以被理解为一种特殊的类，不同的是接口的成员没有执行体，是由全局常量和公共的抽象方法所组成。

定义接口

Java 接口的定义方式与类基本相同，不过接口定义使用的关键字是 interface，接口定义的语法格式如下：

[public] interface interface_name [extends interface1_name[, interface2_name,…]] {
    // 接口体，其中可以包含定义常量和声明方法
    [public] [static] [final] type constant_name = value;    // 定义常量
    [public] [abstract] returnType method_name(parameter_list);    // 声明方法
}

对以上语法的说明如下：

• public 表示接口的修饰符，当没有修饰符时，则使用默认的修饰符，此时该接口的访问权限仅局限于所属的包；
• interface_name 表示接口的名称。接口名应与类名采用相同的命名规则，即如果仅从语法角度来看，接口名只要是合法的标识符即可。如果要遵守 Java 可读性规范，则接口名应由多个有意义的单词连缀而成，每个单词首字母大写，单词与单词之间无需任何分隔符。
• extends 表示接口的继承关系；
• interface1_name 表示要继承的接口名称；
• constant_name 表示变量名称，一般是 static 和 final 型的；
• returnType 表示方法的返回值类型；
• parameter_list 表示参数列表，在接口中的方法是没有方法体的。

注意：一个接口可以有多个直接父接口，但接口只能继承接口，不能继承类。

接口对于其声明、变量和方法都做了许多限制，这些限制作为接口的特征归纳如下：

• 具有 public 访问控制符的接口，允许任何类使用；没有指定 public 的接口，其访问将局限于所属的包。
• 方法的声明不需要其他修饰符，在接口中声明的方法，将隐式地声明为公有的（public）和抽象的（abstract）。
• 在 Java 接口中声明的变量其实都是常量，接口中的变量声明，将隐式地声明为 public、static 和 final，即常量，所以接口中定义的变量必须初始化。
• 接口没有构造方法，不能被实例化。例如：

public interface A {
    publicA(){…}    // 编译出错，接口不允许定义构造方法
}

一个接口不能够实现另一个接口，但它可以继承多个其他接口。子接口可以对父接口的方法和常量进行重写。例如：

public interface StudentInterface extends PeopleInterface {
    // 接口 StudentInterface 继承 PeopleInterface
    int age = 25;    // 常量age重写父接口中的age常量
    void getInfo();    // 方法getInfo()重写父接口中的getInfo()方法
}

例如，定义一个接口 MyInterface，并在该接口中声明常量和方法，如下：

public interface MyInterface {    // 接口myInterface
    String name;    // 不合法，变量name必须初始化
    int age = 20;    // 合法，等同于 public static final int age = 20;
    void getInfo();    // 方法声明，等同于 public abstract void getInfo();
}

实现接口

接口的主要用途就是被实现类实现，一个类可以实现一个或多个接口，继承使用 extends 关键字，实现则使用 implements 关键字。因为一个类可以实现多个接口，这也是 Java 为单继承灵活性不足所作的补充。类实现接口的语法格式如下：

<public> class <class_name> [extends superclass_name] [implements interface1_name[, interface2_name…]] {
    // 主体
}

对以上语法的说明如下：

• public：类的修饰符；
• superclass_name：需要继承的父类名称；
• interface1_name：要实现的接口名称。

实现接口需要注意以下几点：

• 实现接口与继承父类相似，一样可以获得所实现接口里定义的常量和方法。如果一个类需要实现多个接口，则多个接口之间以逗号分隔。
• 一个类可以继承一个父类，并同时实现多个接口，implements 部分必须放在 extends 部分之后。
• 一个类实现了一个或多个接口之后，这个类必须完全实现这些接口里所定义的全部抽象方法（也就是重写这些抽象方法）；否则，该类将保留从父接口那里继承到的抽象方法，该类也必须定义成抽象类。

例 1

在程序的开发中，需要完成两个数的求和运算和比较运算功能的类非常多。那么可以定义一个接口来将类似的功能组织在一起。下面创建一个示例，具体介绍接口的实现方式。

1）创建一个名称为 IMath 的接口，代码如下：

public interface IMath {
    public int sum();    // 完成两个数的相加
    public int maxNum(int a,int b);    // 获取较大的数
}

2）定义一个 MathClass 类并实现 IMath 接口，MathClass 类实现代码如下：

public class MathClass implements IMath {
    private int num1;    // 第 1 个操作数
    private int num2;    // 第 2 个操作数
    public MathClass(int num1,int num2) {
        // 构造方法
        this.num1 = num1;
        this.num2 = num2;
    }
    // 实现接口中的求和方法
    public int sum() {
        return num1 + num2;
    }
    // 实现接口中的获取较大数的方法
    public int maxNum(int a,int b) {
        if(a >= b) {
            return a;
        } else {
            return b;
        }
    }
}

在实现类中，所有的方法都使用了 public 访问修饰符声明。无论何时实现一个由接口定义的方法，它都必须实现为 public，因为接口中的所有成员都显式声明为 public。

3）最后创建测试类 NumTest，实例化接口的实现类 MathClass，调用该类中的方法并输出结果。该类内容如下：

public class NumTest {
    public static void main(String[] args) {
        // 创建实现类的对象
        MathClass calc = new MathClass(100, 300);
        System.out.println("100 和 300 相加结果是：" + calc.sum());
        System.out.println("100 比较 300，哪个大：" + calc.maxNum(100, 300));
    }
}

程序运行结果如下所示。

100 和 300 相加结果是：400
100 比较 300，哪个大：300

在该程序中，首先定义了一个 IMath 的接口，在该接口中只声明了两个未实现的方法，这两个方法需要在接口的实现类中实现。在实现类 MathClass 中定义了两个私有的属性，并赋予两个属性初始值，同时创建了该类的构造方法。因为该类实现了 MathClass 接口，因此必须实现接口中的方法。在最后的测试类中，需要创建实现类对象，然后通过实现类对象调用实现类中的方法。

Java抽象类和接口的联系和区别

前面《Java接口》一节中提到接口是一种特殊的抽象类，接口和抽象类的渊源颇深，有很大的相似之处，所以在选择使用谁的问题上很容易迷糊。本节我们先整理一下 Java 中抽象类和接口的特点，再分析它们具有的相同点、不同点和使用场景。

1）抽象类

在 Java 中，被关键字 abstract 修饰的类称为抽象类；被 abstract 修饰的方法称为抽象方法，抽象方法只有方法声明没有方法体。

抽象类有以下几个特点：

1. 抽象类不能被实例化，只能被继承。
2. 包含抽象方法的类一定是抽象类，但抽象类不一定包含抽象方法（抽象类可以包含普通方法）。
3. 抽象方法的权限修饰符只能为 public、protected 或 default，默认情况下为 public。
4. 一个类继承于一个抽象类，则子类必须实现抽象类的抽象方法，如果子类没有实现父类的抽象方法，那子类必须定义为抽象类。
5. 抽象类可以包含属性、方法、构造方法，但构造方法不能用来实例化对象，只能被子类调用。

2）接口

接口可以看成是一种特殊的类，只能用 interface 关键字修饰。

Java 中的接口具有以下几个特点：

1. 接口中可以包含变量和方法，变量被隐式指定为 public static final，方法被隐式指定为 public abstract（JDK 1.8 之前）。
2. 接口支持多继承，即一个接口可以继承（extends）多个接口，间接解决了 Java 中类不能多继承的问题。
3. 一个类可以同时实现多个接口，一个类实现某个接口则必须实现该接口中的抽象方法，否则该类必须被定义为抽象类。

3）抽象类和接口的区别

接口和抽象类很像，它们都具有如下特征。

• 接口和抽象类都不能被实例化，主要用于被其他类实现和继承。
• 接口和抽象类都可以包含抽象方法，实现接口或继承抽象类的普通子类都必须实现这些抽象方法。

但接口和抽象类之间的差别非常大，这种差别主要体现在二者设计目的上。下面具体分析二者的差别。

接口作为系统与外界交互的窗口，接口体现的是一种规范。对于接口的实现者而言，接口规定了实现者必须向外提供哪些服务（以方法的形式来提供）；对于接口的调用者而言，接口规定了调用者可以调用哪些服务，以及如何调用这些服务（就是如何来调用方法）。当在一个程序中使用接口时，接口是多个模块间的耦合标准；当在多个应用程序之间使用接口时，接口是多个程序之间的通信标准。

从某种程度上来看，接口类似于整个系统的“总纲”，它制定了系统各模块应该遵循的标准，因此一个系统中的接口不应该经常改变。一旦接口被改变，对整个系统甚至其他系统的影响将是辐射式的，会导致系统中大部分类都需要改写。

抽象类则不一样，抽象类作为系统中多个子类的共同父类，它所体现的是一种模板式设计。抽象类作为多个子类的抽象父类，可以被当成系统实现过程中的中间产品，这个中间产品已经实现了系统的部分功能（那些已经提供实现的方法），但这个产品依然不能当成最终产品，必须有更进一步的完善，这种完善可能有几种不同方式。

除此之外，接口和抽象类在用法上也存在差别，如下表所示：

参数	抽象类	接口
实现	子类使用 extends 关键字来继承抽象类，如果子类不是抽象类，则需要提供抽象类中所有声明的方法的实现。	子类使用 implements 关键字来实现接口，需要提供接口中所有声明的方法的实现。
访问修饰符	可以用 public、protected 和 default 修饰	默认修饰符是 public，不能使用其它修饰符
方法	完全可以包含普通方法	只能包含抽象方法、静态方法、默认方法和私有方法，不能为普通方法提供方法实现
变量	既可以定义普通成员变量，也可以定义静态常量	只能定义静态常量，不能定义普通成员变量
构造方法	抽象类里的构造方法并不是用于创建对象，而是让其子类调用这些构造方法来完成属于抽象类的初始化操作	没有构造方法
初始化块	可以包含初始化块	不能包含初始化块
main 方法	可以有 main 方法，并且能运行	没有 main 方法
与普通Java类的区别	抽象类不能实例化，除此之外和普通 Java 类没有任何区别	是完全不同的类型
运行速度	比接口运行速度要快	需要时间去寻找在类种实现的方法，所以运行速度稍微有点慢

一个类最多只能有一个直接父类，包括抽象类，但一个类可以直接实现多个接口，通过实现多个接口可以弥补 Java 单继承的不足。

4）抽象类和接口的应用场景

抽象类的应用场景：

1. 父类只知道其子类应该包含怎样的方法，不能准确知道这些子类如何实现这些方法的情况下，使用抽象类。
2. 从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。

接口的应用场景：

1. 一般情况下，实现类和它的抽象类之前具有 “is-a” 的关系，但是如果我们想达到同样的目的，但是又不存在这种关系时，使用接口。
2. 由于 Java 中单继承的特性，导致一个类只能继承一个类，但是可以实现一个或多个接口，此时可以使用接口。

什么时候使用抽象类和接口：

• 如果拥有一些方法并且想让它们有默认实现，则使用抽象类。
• 如果想实现多重继承，那么必须使用接口。因为 Java 不支持多继承，子类不能继承多个类，但可以实现多个接口，因此可以使用接口。
• 如果基本功能在不断改变，那么就需要使用抽象类。如果使用接口并不断需要改变基本功能，那么就需要改变所有实现了该接口的类。

Java内部类是什么？

在类内部可定义成员变量和方法，且在类内部也可以定义另一个类。如果在类 Outer 的内部再定义一个类 Inner，此时类 Inner 就称为内部类（或称为嵌套类），而类 Outer 则称为外部类（或称为宿主类）。

内部类可以很好地实现隐藏，一般的非内部类是不允许有 private 与 protected 权限的，但内部类可以。内部类拥有外部类的所有元素的访问权限。

内部类可以分为：实例内部类、静态内部类和成员内部类，每种内部类都有它特定的一些特点，本节先详细介绍一些和内部类相关的知识。

在类 A 中定义类 B，那么类 B 就是内部类，也称为嵌套类，相对而言，类 A 就是外部类。如果有多层嵌套，例如类 A 中有内部类 B，而类 B 中还有内部类 C，那么通常将最外层的类称为顶层类（或者顶级类）。

内部类也可以分为多种形式，与变量非常类似，如图 1 所示。

图 1 内部类的分类

内部类的特点如下：

1. 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。
2. 内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否为 private 的。
3. 内部类声明成静态的，就不能随便访问外部类的成员变量，仍然是只能访问外部类的静态成员变量。

**【例1】**内部类的使用方法非常简单，例如下面的代码演示了内部类最简单的应用。

public class Test {
    public class InnerClass {
        public int getSum(int x,int y) {
            return x + y;
        }
    }
    public static void main(String[] args) {
        Test.InnerClass ti = new Test().new InnerClass();
        int i = ti.getSum(2,3);
        System.out.println(i);    // 输出5
    }
}

有关内部类的说明有如下几点。

• 外部类只有两种访问级别：public 和默认；内部类则有 4 种访问级别：public、protected、 private 和默认。
• 在外部类中可以直接通过内部类的类名访问内部类。

InnerClass ic = new InnerClass();    // InnerClass为内部类的类名

• 在外部类以外的其他类中则需要通过内部类的完整类名访问内部类。

Test.InnerClass ti = newTest().new InnerClass();    // Test.innerClass是内部类的完整类名

• 内部类与外部类不能重名。

提示：内部类的很多访问规则可以参考变量和方法。另外使用内部类可以使程序结构变得紧凑，但是却在一定程度上破坏了 Java 面向对象的思想。

我们将在接下来的三节课程里详细讲解 Java 内部类：

• Java实例内部类
• Java静态内部类
• Java局部内部类

Java匿名类，Java匿名内部类

匿名类是指没有类名的内部类，必须在创建时使用 new 语句来声明类。其语法形式如下：

new <类或接口>() {    // 类的主体};

这种形式的 new 语句声明一个新的匿名类，它对一个给定的类进行扩展，或者实现一个给定的接口。使用匿名类可使代码更加简洁、紧凑，模块化程度更高。

匿名类有两种实现方式：

• 继承一个类，重写其方法。
• 实现一个接口（可以是多个），实现其方法。

下面通过代码来说明。

public class Out {
    void show() {
        System.out.println("调用 Out 类的 show() 方法");
    }
}
public class TestAnonymousInterClass {
    // 在这个方法中构造一个匿名内部类
    private void show() {
        Out anonyInter = new Out() {
            // 获取匿名内部类的实例
            void show() {
                System.out.println("调用匿名类中的 show() 方法");
            }
        };
        anonyInter.show();
    }
    public static void main(String[] args) {
        TestAnonymousInterClass test = new TestAnonymousInterClass();
        test.show();
    }
}

程序的输出结果如下：

调用匿名类中的 show() 方法

从输出结果可以看出，匿名内部类有自己的实现。

提示：匿名内部类实现一个接口的方式与实现一个类的方式相同，这里不再赘述。

匿名类有如下特点：

1）匿名类和局部内部类一样，可以访问外部类的所有成员。如果匿名类位于一个方法中，则匿名类只能访问方法中 final 类型的局部变量和参数。

public static void main(String[] args) {
    int a = 10;
    final int b = 10;
    Out anonyInter = new Out() {
        void show() {
            // System.out.println("调用了匿名类的 show() 方法"+a);    // 编译出错
            System.out.println("调用了匿名类的 show() 方法"+b);    // 编译通过
        }
    };
    anonyInter.show();
}

从 Java 8 开始添加了 Effectively final 功能，在 Java 8 及以后的版本中代码第 6 行不会出现编译错误，详情可点击《Java8新特性之Effectively final》进行学习。

2）匿名类中允许使用非静态代码块进行成员初始化操作。

Out anonyInter = new Out() {
    int i; {    // 非静态代码块
        i = 10;    //成员初始化
    }
    public void show() {
        System.out.println("调用了匿名类的 show() 方法"+i);
    }
};

3）匿名类的非静态代码块会在父类的构造方法之后被执行。

Java使用内部类实现多重继承

多重继承指的是一个类可以同时从多于一个的父类那里继承行为和特征，然而我们知道 Java 为了保证数据安全，只允许单继承。

有些时候我们会认为如果系统中需要使用多重继承，那往往都是糟糕的设想，这时开发人员往往需要思考的不是怎么使用多重继承，而是他的设计是否存在问题。但是，有时候开发人员确实需要实现多重继承，而且现实生活中真正地存在这样的情况，例如遗传，我们既继承了父亲的行为和特征，也继承了母亲的行为和特征。

Java 提供的两种方法让我们实现多重继承：接口和内部类。

例 1

本节我们以生活中常见的遗传例子进行介绍，如儿子（或者女儿）是如何利用多重继承来继承父亲和母亲的优良基因的。

1）创建 Father 类，在该类中添加 strong() 方法。代码如下：

public class Father {
    public int strong() {   
        // 强壮指数
        return 9;
    }
}

2）创建 Mother 类，在该类中添加 kind() 方法。代码如下：

public class Mother {
    public int kind() {    
        // 友好指数
        return 8;
    }
}

3）重点在于儿子类的实现，创建 Son 类，在该类中通过内部类实现多重继承。代码如下：

public class Son {
    // 内部类继承Father类
    class Father_1 extends Father {
        public int strong() {
            return super.strong() + 1;
        }
    }
    class Mother_1 extends Mother {
        public int kind() {
            return super.kind() - 2;
        }
    }
    public int getStrong() {
        return new Father_1().strong();
    }
    public int getKind() {
        return new Mother_1().kind();
    }
}

上述代码定义两个内部类，这两个内部类分别继承 Father（父亲）类和 Mother（母亲）类，且都可以获取各自父类的行为。这是内部类一个很重要的特性：内部类可以继承一个与外部类无关的类，从而保证内部类的独立性。正是基于这一点，多重继承才会成为可能。

4）创建 Test 类进行测试，在 main() 方法中实例化 Son 类的对象，然后分别调用该对象的 getStrong() 方法和 getKind() 方法。代码如下：

public class Test {
    public static void main(String[] args) {
        Son son = new Son();
        System.out.println("Son 的强壮指数：" + son.getStrong());
        System.out.println("Son 的友好指数：" + son.getKind());
    }
}

执行上述代码，输出结果如下：

Son 的强壮指数：10
Son 的友好指数：6

从实现代码和输出结果可以发现，儿子继承父类，变得比父亲更加强壮；同时也继承了母类，只不过友好指数下降。

Java Lambda表达式

Lambda 表达式（Lambda expression）是一个匿名函数，基于数学中的λ演算得名，也可称为闭包（Closure）。现在很多语言都支持 Lambda 表达式，如 C++、C#、Java、 Python 和 JavaScript 等。

Lambda 表达式是推动 Java 8 发布的重要新特性，它允许把函数作为一个方法的参数（函数作为参数传递进方法中），下面通过例 1 来理解 Lambda 表达式的概念。

例 1

先定义一个计算数值的接口，代码如下。

// 可计算接口
public interface Calculable {
    // 计算两个int数值
    int calculateInt(int a, int b);
}

Calculable 接口只有一个方法 calculateInt，参数是两个 int 类型，返回值也是 int 类型。实现方法代码如下：

public class Test{
    /**
     * 通过操作符，进行计算
     *
     * @param opr 操作符
     * @return 实现Calculable接口对象
     */
    public static Calculable calculate(char opr) {
        Calculable result;
        if (opr == '+') {
            // 匿名内部类实现Calculable接口
            result = new Calculable() {
                // 实现加法运算
                @Override
                public int calculateInt(int a, int b) {
                    return a + b;
                }
            };
        } else {
            // 匿名内部类实现Calculable接口
            result = new Calculable() {
                // 实现减法运算
                @Override
                public int calculateInt(int a, int b) {
                    return a - b;
                }
            };
        }
        return result;
    }
}

方法 calculate 中 opr 参数是运算符，返回值是实现 Calculable 接口对象。代码第 13 行和第 23 行都采用匿名内部类实现 Calculable 接口。代码第 16 行实现加法运算。代码第 26 行实现减法运算。

public static void main(String[] args) {
    int n1 = 10;
    int n2 = 5;
    // 实现加法计算Calculable对象
    Calculable f1 = calculate('+');
    // 实现减法计算Calculable对象
    Calculable f2 = calculate('-');
    // 调用calculateInt方法进行加法计算
    System.out.println(n1 + "+" + n2 + "=" + f1.calculateInt(n1, n2));
    // System.out.printf("%d + %d = %d \n", n1, n2, f1.calculateInt(n1, n2));
    // 调用calculateInt方法进行减法计算
    System.out.println(n1 + "-" + n2 + "=" + f1.calculateInt(n1, n2));
    // System.out.printf("%d - %d = %d \n", n1, n2, f2.calculateInt(n1, n2));
}

代码第 5 行中 f1 是实现加法计算 Calculable 对象，代码第 7 行中 f2 是实现减法计算 Calculable 对象。代码第 9 行和第 12 行才进行方法调用。

上述代码中列出了两种输出方式，下面简单介绍一下 Java 中常见的输出函数：

1. printf 主要继承了C语言中 printf 的一些特性，可以进行格式化输出。
2. print 就是一般的标准输出，但是不换行。
3. println 和 print 基本没什么差别，就是最后会换行。

输出结果如下：

10+5=15
10-5=15

例 1 使用匿名内部类的方法 calculate 代码很臃肿，Java 8 采用 Lambda 表达式可以替代匿名内部类。修改之后的通用方法 calculate 代码如下：

/**
* 通过操作符，进行计算
* @param opr 操作符
* @return 实现Calculable接口对象
*/
public static Calculable calculate(char opr) {
    Calculable result;
    if (opr == '+') {
        // Lambda表达式实现Calculable接口
        result = (int a, int b) -> {
            return a + b;
        };
    } else {
        // Lambda表达式实现Calculable接口
        result = (int a, int b) -> {
            return a - b;
        };
    }
    return result;
}

代码第 10 行和第 15 行用 Lambda 表达式替代匿名内部类，可见代码变得简洁。通过以上示例我们发现，Lambda 表达式是一个匿名函数（方法）代码块，可以作为表达式、方法参数和方法返回值。

Lambda 表达式标准语法形式如下：

(参数列表) -> {
// Lambda表达式体
}

->被称为箭头操作符或 Lambda 操作符，箭头操作符将 Lambda 表达式拆分成两部分：

• 左侧：Lambda 表达式的参数列表。
• 右侧：Lambda 表达式中所需执行的功能，用{ }包起来，即 Lambda 体。

Java Lambda 表达式的优缺点

优点：

1. 代码简洁，开发迅速
2. 方便函数式编程
3. 非常容易进行并行计算
4. Java 引入 Lambda，改善了集合操作（引入 Stream API）

缺点：

1. 代码可读性变差
2. 在非并行计算中，很多计算未必有传统的 for 性能要高
3. 不容易进行调试

函数式接口

Lambda 表达式实现的接口不是普通的接口，而是函数式接口。如果一个接口中，有且只有一个抽象的方法（Object 类中的方法不包括在内），那这个接口就可以被看做是函数式接口。这种接口只能有一个方法。如果接口中声明多个抽象方法，那么 Lambda 表达式会发生编译错误：

The target type of this expression must be a functional interface

这说明该接口不是函数式接口，为了防止在函数式接口中声明多个抽象方法，Java 8 提供了一个声明函数式接口注解 @FunctionalInterface，示例代码如下。

// 可计算接口
@FunctionalInterface
public interface Calculable {
    // 计算两个int数值
    int calculateInt(int a, int b);
}

在接口之前使用 @FunctionalInterface 注解修饰，那么试图增加一个抽象方法时会发生编译错误。但可以添加默认方法和静态方法。

@FunctionalInterface 注解与 @Override 注解的作用类似。Java 8 中专门为函数式接口引入了一个新的注解 @FunctionalInterface。该注解可用于一个接口的定义上，一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。

提示：Lambda 表达式是一个匿名方法代码，Java 中的方法必须声明在类或接口中，那么 Lambda 表达式所实现的匿名方法是在函数式接口中声明的。

Java Lambda表达式与匿名内部类的联系和区别

Java Lambda 表达式的一个重要用法是简化某些匿名内部类的写法，因此它可以部分取代匿名内部类的作用。

Lambda 表达式与匿名内部类的相同点如下：

• Lambda 表达式与匿名内部类一样，都可以直接访问 effectively final 的局部变量（如果不了解 Effectively final，可先阅读《Java8新特性之Effectively final》一节），以及外部类的成员变量（包括实例变量和类变量）。
• Lambda 表达式创建的对象与匿名内部类生成的对象一样，都可以直接调用从接口中继承的默认方法。

下面程序示范了 Lambda 表达式与匿名内部类的相似之处。

@FunctionalInterface
interface Displayable {
    // 定义一个抽象方法和默认方法
    void display();
    default int add(int a, int b) {
        return a + b;
    }
}
public class LambdaAndInner {
    private int age = 12;
    private static String name = "C语言中文网";
    public void test() {
        String url = "http://c.biancheng.net/";
        Displayable dis = () -> {
            // 访问的局部变量
            System.out.println("url 局部变量为:" + url);
            // 访问外部类的实例变量和类变量
            System.out.println("外部类的 age 实例变量为：" + age);
            System.out.println("外部类的 name 类变量为：" + name);
        };
        dis.display();
        // 调用dis对象从接口中继承的add()方法
        System.out.println(dis.add(3, 5)); 
    }
    public static void main(String[] args) {
        LambdaAndInner lambda = new LambdaAndInner();
        lambda.test();
    }
}

输出结果为：

url 局部变量为：http://c.biancheng.net/
外部类的 age 实例变量为：12
外部类的 name 类变量为：C语言中文网
8

上面程序使用 Lambda 表达式创建了一个 Displayable 的对象，Lambda 表达式的代码块中的代码第 19、21 和 22 行分别示范了访问“effectively final”的局部变量、外部类的实例变量和类变量。从这点来看， Lambda 表达式的代码块与匿名内部类的方法体是相同的。

与匿名内部类相似的是，由于 Lambda 表达式访问了 url 局部变量，因此该局部变量相当于有一个隐式的 final 修饰，因此同样不允许对 url 局部变量重新赋值。

当程序使用 Lambda 表达式创建了 Displayable 的对象之后，该对象不仅可调用接口中唯一的抽象方法，也可调用接口中的默认方法，如上面程序代码第 26 行所示。

Lambda 表达式与匿名内部类主要存在如下区别。

• 匿名内部类可以为任意接口创建实例——不管接口包含多少个抽象方法，只要匿名内部类实现所有的抽象方法即可；但 Lambda 表达式只能为函数式接口创建实例。
• 匿名内部类可以为抽象类甚至普通类创建实例；但 Lambda 表达式只能为函数式接口创建实例。
• 匿名内部类实现的抽象方法的方法体允许调用接口中定义的默认方法；但 Lambda 表达式的代码块不允许调用接口中定义的默认方法。

对于 Lambda 表达式的代码块不允许调用接口中定义的默认方法的限制，可以尝试对上面的 LambdaAndInner.java 程序稍做修改，在 Lambda 表达式的代码块中增加如下一行：

// 尝试调用接口中的默认方法，编译器会报错
System.out.println(add(3, 5));

虽然 Lambda 表达式的目标类型 Displayable 中包含了 add() 方法，但 Lambda 表达式的代码块不允许调用这个方法；如果将上面的 Lambda 表达式改为匿名内部类的写法，当匿名内部类实现 display() 抽象方法时，则完全可以调用这个 add() 方法，如下面代码所示。

public void test() {
    String url = "http://c.biancheng.net/";
    Displayable dis = new Displayable() {
        @Override
        public void display() {
            // 访问的局部变量
            System.out.println("url 局部变量为:" + url);
            // 访问外部类的实例变量和类变量
            System.out.println("外部类的 age 实例变量为：" + age);
            System.out.println("外部类的 name 类变量为：" + name);
            System.out.println(add(3, 5));
        }
    };
    dis.display();
}