【Java基础系列教程】第七章 Java面向对象详解（二）_面向对象三大特征

矫情吗；* 2024-04-28 13:14 103阅读 0赞

## 一、OOP特征一：封装(Encapsulation) ##

### 1.1 为什么要封装? ###

在研究封装性之前，我们先来看一段代码：

class Book {
        String title;
        double price;
    
        public void getInfo() {
            System.out.println("图书的名称：" + title + " 图书的价格：" + price);
        }
    }
    
    public class BookTest {
        public static void main(String args[]) {
            Book book = new Book();
            book.title = "Java开发";
            book.price = -89.9;
            book.getInfo();
        }
    }

**运行结果：**

图书的名称：Java开发 图书的价格：-89.9

以上代码没有任何语法错误，却存在一个业务逻辑的错误，因为图书的价格不能为负数。

使用者对类内部定义的属性(对象的成员变量)的直接操作会导致数据的错误、混乱或安全性问题。

造成这种情况的的原因在于：  
当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。  
  
但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private)，此时，针对于属性就体现了封装性。

我们需要将Book类中的属性设置为对外不可见（只能是本类访问），可以使用private关键字来定义属性。

### 1.2 封装的体现 ###

Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：  
隐藏一个类中不需要对外提供的实现细节；  
使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；  
便于修改，增强代码的可维护性；

1、修改属性的可见性 —> 设为private

2、创建共有(public)的 getter / setter方法 —> 用于属性的读写

3、在getter / setter方法中加入属性控制语句 —> 对属性值的合法性进行判断

#### 1.2.1 属性私有化 ####

class Book {
        String title;
        private double price;
    
        public void getInfo() {
            System.out.println("图书的名称：" + title + " 图书的价格：" + price);
        }
    }
    
    public class BookTest {
        public static void main(String args[]) {
            Book book = new Book();
            book.title = "Java开发";
            book.price = -89.9;
            book.getInfo();
        }
    }

**提示:**

错误提示：  
The field Book.price is not visible  
运行报错:  
java: price 在 Book 中是 private 访问控制

注意：不同工具的提示各不相同。但是大致意思相似，都是表明该字段是不可见的，也就是隐藏起来了。

我们发现，在访问属性的时候，外部的对象无法再直接调用类中的属性了，此时就相当于Book类的属性对外部不可见。

但是，要想让程序可以正常运行，那么必须让外部可以操作Book类的属性。在Java开发中，针对属性有这样的定义，在类中定义的属性都要求使用private声明，如果属性需要被外部所使用，那么按照要求，定义属性相应的setter和getter方法。

#### 1.2.2 提供操作属性的方法 ####

以Book类中的String price 为例：

（1）setter方法是设置属性内容：  
public void setPrice(double price)  
主要：有参数。  
（2）getter方法是取得属性内容:  
public double getPrice()  
注意：无参数。

**示例：为封装属性设置操作方法。**

class Book {
    
        String title;
        private double price;
    
        public double getPrice() {
            return price;
        }
    
        public void setPrice(double price) {
            this.price = price;
        }
    
        public void getInfo() {
            System.out.println("图书的名称：" + title + " 图书的价格：" + price);
        }
    }
    
    public class TestDemo {
        public static void main(String args[]) {
            Book book = new Book();
            book.title = "Java开发";
            book.setPrice(-89.9);
            book.getInfo();
        }
    }

**运行结果：**

图书的名称：Java开发 图书的价格：-89.9

发现，图书的价格是负数，需要加入检查业务逻辑错误的代码，可以在setter中增加验证，如果值为正，赋值，否则为默认值0.0：

public void setPrice(double price) {
        if (price < 0) {
            System.out.println("Wrong number of price!");
            return;
        }
        this.price = price;
    }

对于数据验证，在Java标准开发中应该由辅助代码完成。在实际开发中，setter往往只是简单的设置属性内容，getter只是简单的取得属性内容。

开发建议：以后在定义类的时候，所有的属性都要编写private封装，封装之后的属性如果需要被外部操作，则编写setter、getter。  
上述操作其实就是封装的部分体现。  
  
封装的体现：  
1、属性的封装。  
2、不对外暴露的私有的方法。  
3、构造函数的封装。（单例模式）  
等

**举例结合异常：**

public class Human {
        private int age;
        private String name;
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) throws Exception {
            // 封装age的检验逻辑，而不是暴露给每个调用者去处理
            if (age > 120 || age < 0) {
                throw new Exception("Invalid value of age");
            }
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }

### 1.3 封装的好处 ###

1、只能通过规定方法访问数据  
  
2、隐藏类数据的实现细节  
  
3、方便修改实现  
  
4、方便加入控制语句　  
  
5、可以修改属性的读(getter)写(setter)权限  
如果只提供getter,那么表示只读;  
如果只提供setter,那么表示只写;(一般很少)

### 1.4 封装总结 ###

封装(encapsulation)又叫隐藏实现(Hiding the implementation)，就是只公开代码单元的对外接口，而隐藏其具体实现。

比如手机，手机的键盘，屏幕，听筒等，就是其对外接口。你只需要知道如何按键就可以使用手机，而不需要了解手机内部的电路是如何工作的。再比如我要用洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内部的结构吗？有必要碰电动机吗？封装机制就像手机和洗衣机一样只将对外接口暴露，而不需要用户去了解其内部实现。

封装的思想保证了类内部数据结构的完整性，使用户无法轻易直接操作类的内部数据，这样降低了对内部数据的影响，提高了程序的安全性和可维护性。  
  
封装就是隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

我们程序设计追求“高内聚，低耦合”。  
高内聚：类的内部数据操作细节自己完成，不允许外部干涉；  
低耦合：仅对外暴露少量的方法用于使用。

jdk常用类里面有很多方法，有一部分是隐藏起来的，不让外部程序直接使用，只能在类的方法里面调用，该暴露的暴露出来。

## 二、OOP特征二：继承(Inheritance) ##

### 2.1 为什么要使用继承? ###

为描述和处理学生信息，定义类Student:

public class Student {
        public String name;
        public int age;
        public Date birthDate;
        public String school;
    
        public String getInfo() {
            return "名字: " + name + ",年龄: " + age + ",出生日期: " + birthDate;
        }
    
        public void sleep() {
            System.out.println("睡觉行为");
        }
    
        public void study() {
            System.out.println("学习行为");
        }
    }

为描述和处理员工信息，定义类Employee:

public class Employee {
        public String name;
        public int age;
        public Date birthDate;
        public String company;
    
        public String getInfo() {
            return "名字: " + name + ",年龄: " + age + ",出生日期: " + birthDate;
        }
    
        public void sleep() {
            System.out.println("睡觉行为");
        }
    
        public void work() {
            System.out.println("工作行为");
        }
    }

为描述和处理厨师信息，定义类Chef:

public class Chef {
        public String name;
        public int age;
        public Date birthDate;
        public String grade;
    
        public String getInfo() {
            return "名字: " + name + ",年龄: " + age + ",出生日期: " + birthDate;
        }
    
        public void sleep() {
            System.out.println("睡觉行为");
        }
    
        public void cooking() {
            System.out.println("做饭行为");
        }
    }

以上三个类，我们会发现有相同的行为和特征，都有name、age、birthDate属性 和 gettInfo、sleep方法，那么类似的抽象实体有很多，比如：Teacher类、Customer类、Waiter类等；如果我们都按照现在的写法去做，那么相当于N个类里面都要定义相同的属性和行为，这个代码的重用率太低;

针对于这个问题，我们应该要想办法提高代码的重用性。  
  
具体怎么做呢？  
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。  
  
此处的多个类称为子类(派生类)，单独的这个类称为父类(基类或超类)。可以理解为:“子类 is a 父类”。

继承性的好处/作用:  
继承就是为了提高代码的复用性，减少代码的冗余；  
便于功能的扩展；  
为多态性的使用，提供了前提。

注意：不要仅为了获取其他类中某个功能而去继承。

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_19_color_FFFFFF_t_70_g_se_x_16][]

### 2.2 继承是什么? ###

按照现有类的类型来创建新类，无需改变现有类的形式，采用现有类的形式并在其中添加新代码，这种方法就叫做继承。继承会使子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法。也就是说，子类和父类是“相似的”。

下面举一个继承的例子：

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_12_color_FFFFFF_t_70_g_se_x_16][]

上图所示，动物继承生物类；老虎又继承动物类。从这个例子中可以明显看出：越往上的类是越抽象，越往下的类越具体。而在我们在设计的时候，父类也往往是比较抽象的类。

继承是Java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

继承就是子类继承父类‘所有’的特征和行为，使得子类对象（实例）具有父类的成员变量和方法，或类从父类继承方法，使得子类具有父类相同的行为。  
  
继承是所有OOP语言和Java语言不可缺少的组成部分。当创建一个类时，总是在继承，因此，除非已明确指出要从其他类中继承，否则就是在隐式地从Java的标准根类Object进行继承

### 2.3 继承的体现 ###

关键字 extends 表明正在构造的新类派生于一个已存在的类。

已存在的类被称为超类（super class）、基类（base class）或父类（parent class）；  
  
新类被称为子类（subclass）、派生类（derived class）或孩子类（child class）。

类继承语法规则:  
class Subclass extends SuperClass\{ \}

继承的体现：  
1、一旦子类继承父类以后，子类中就获取了父类中声明的所有的属性和方法。  
特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。  
2、子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展，我们称之为子类的扩展。  
在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。  
子类和父类的关系，不同于子集和集合的关系。

#### 2.3.1 编写父类：提取共有的属性和方法 ####

public class Person {
        public String name;
        public int age;
        public Date birthDate;
    
        public String getInfo() {
            return "名字: " + name + ",年龄: " + age + ",出生日期: " + birthDate;
        }
    
        public void sleep() {
            System.out.println("睡觉行为");
        }
    }

#### 2.3.2 编写子类：继承父类 ####

使用extends关键字，让子类继承父类，那么子类就拥有了父类定义的属性和方法，无需重复定义；

**子类示例代码：**

public class Student extends Person{
        public String school;
    
        public void study() {
            System.out.println("学习行为");
        }
    }
    
    public class Employee extends Person{
        public String company;
    
        public void work() {
            System.out.println("工作行为");
        }
    }
    
    public class Chef extends Person{
        public String grade;
    
        public void cooking() {
            System.out.println("做饭行为");
        }
    }

**测试类示例代码：**

public class ExtendsTest {
        public static void main(String[] args) {
            Student student = new Student();
    
            // Student类里面没有定义这三个属性，但是因为继承了Person类，就拥有了Person类定义的属性
            student.name = "张三";
            student.age = 22;
            student.birthDate = new Date(1992, 12, 22);
    
            // school属性是Student类里面定义的，我们可以称之为子类的扩展
            student.school = "北京大学";
    
            // Student类里面没有定义这两个，但是因为继承了Person类，就拥有了Person类定义的方法
            student.getInfo();
            student.sleep();
    
            // study()是Student类里面定义的，我们也可以称之为子类的扩展
            student.study();
    
            // 其他类似
        }
    }

#### 2.3.3 理解私有继承 ####

某些书本表明“子类只能继承父类的非私有属性和方法”，然而事实并非如此，实际上“Java中子类可以继承父类所有的属性和方法”，只不过因为私有的原因，子类不能调用父类的私有方法。

//父类
    public class Father {
    
        private String name = "张三";//私有属性
        private String sex = "男";
    
        public void tell() {
            System.out.println("姓名：" + name);
            System.out.println("性别：" + sex);
        }
    
        private void speak() {
            System.out.println(name + "is speaking!");
        }
    
        private void sleep(){
            System.out.println("sleep...");
        }
    
        public void eat(){
            System.out.println("eat...");
            sleep();
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    }
    
    //子类
    public class Child extends Father {
    
    }
    
    //测试类
    public class TestJava {
    
        public static void main(String[] args) {
    
            Child c = new Child();
            c.tell();// tell方法是可以用的
            // c.speak();//报错，父类的私有方法不可见
    
            c.eat();
        }
    
    }

可以看到测试类中即使没有给Child类对象的属性进行赋值，tell方法依旧是可用的。如果Child类中没有继承父类的私有属性，那么tell方法应该会报错。由此得出的结论是，子类会继承父类的所有东西，而修饰符只是影响属性或者方法对外是否可见。

Java官方文档的解释：子类不能继承父类的私有属性，但是如果子类中公有的方法影响到了父类私有属性，那么私有属性是能够被子类使用的。

理解：子类不能直接访问父类中私有的(private)的成员变量和方法。

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_16_color_FFFFFF_t_70_g_se_x_16][]

### 2.4 继承的规则 ###

Java只支持单继承和多层继承，不允许多重继承。

1、一个类可以被多个子类继承。  
2、Java中类的单继承性：一个类只能有一个父类（直接父类）。

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16][]

3、子父类是相对的概念。  
4、子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类。  
5、子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法。

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 1][]

### 2.5 继承总结 ###

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，还可以以此基础添加新方法和成员变量来满足需求。  
  
继承需要符合的关系是：is-a，父类更通用，子类更具体。

Java只支持单继承和多层继承，不允许多重继承。

继承就是为了提高代码的复用性，减少代码的冗余，更加便于功能的扩展，并且为多态性的使用，提供了前提。  
  
代码重用是一点，最重要的还是所谓向上转型，即父类的引用变量可以指向子类对象，这是Java面向对象最重要特性多态的基础。

不能被继承的父类成员：构造方法，构造函数不能被继承，但是子类可以通过super()显示调用父类的构造函数

**继承的优缺点**

在面向对象语言中，继承是必不可少的、非常优秀的语言机制，它有如下优点：  
代码共享，减少创建类的工作量，每个子类都拥有父类的方法和属性;  
提高代码的重用性；  
子类可以形似父类，但又异于父类；（拥有了父类的共性,还可以拥有自己的特性）;  
提高代码的可扩展性，实现父类的方法就可以“为所欲为”了。（方法的重写）  
提高产品或项目的开放性。

自然界的所有事物都是优点和缺点并存的，继承的缺点如下：  
继承是侵入性的。只要继承，就必须拥有父类的所有属性和方法；  
降低代码的灵活性。子类必须拥有父类的属性和方法，让子类自由的世界中多了些约束；  
增强了耦合性。当父类的常量、变量和方法被修改时，需要考虑子类的修改，而且在缺乏规范的环境下，这种修改可能带来非常糟糕的结果——大段的代码需要重构。

## 三、四种访问权限修饰符 ##

在 Java 语言中提供了多个作用域修饰符，其中常用的有 public、private、protected、final、abstract、static、transient 和 volatile，这些修饰符有类修饰符、变量修饰符和方法修饰符。

本节主要讲解访问控制修饰符；

在实际生活中，如果要获取某件物品，与其直接穿过堡垒的墙壁，从而导致墙壁毁灭和破坏，不如通过门口的警卫请求进入堡垒的许可。一般而言，这对对象同样适用：没有对象的许可（即对象的属性是私有的），不能直接访问该对象的私有属性。

信息隐藏是 OOP 最重要的功能之一，也是使用访问修饰符的原因。在编写程序时，有些核心数据往往不希望被用户调用，需要控制这些数据的访问。  
  
对类成员访问的限制是面向对象程序设计的一个基础，这有利于防止对象的误用。只允许通过一系列定义完善的方法来访问私有数据，就可以（通过执行范围检查）防止数据赋予不正当的值。例如，类以外的代码不可能直接向一个私有成员赋值。同时，还可以精确地控制如何以及何时使用对象中的数据。

通过使用访问控制修饰符来限制对对象私有属性的访问，可以获得 3 个重要的好处。  
防止对封装数据的未授权访问。  
有助于保证数据完整性。  
当类的私有实现细节必须改变时，可以限制发生在整个应用程序中的“连锁反应”。

Java面向对象的基本思想之一是封装细节并且公开接口。

Java语言采用访问控制修饰符来控制类及类的方法和变量的访问权限，从而向使用者暴露接口，但隐藏实现细节。

访问控制符是一组限定类、属性或方法是否可以被程序里的其他部分访问和调用的修饰符。Java权限修饰符public、protected、 (缺省)、 private置于类的成员定义前，用来限定对象对该类成员的访问权限。

类的访问控制符只能是默认的或者 public，方法和属性的访问控制符有 4 个，分别是 public、 private、protected 和 默认的，其中 friendly 是一种没有定义专门的访问控制符的默认情况。

**访问控制修饰符的权限如表所示：**

<table> 
 <thead> 
  <tr> 
   <th>访问范围</th> 
   <th>private</th> 
   <th>friendly(默认)</th> 
   <th>protected</th> 
   <th>public</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>同一个类</td> 
   <td>可访问</td> 
   <td>可访问</td> 
   <td>可访问</td> 
   <td>可访问</td> 
  </tr> 
  <tr> 
   <td>同一包中的其他类</td> 
   <td>不可访问</td> 
   <td>可访问</td> 
   <td>可访问</td> 
   <td>可访问</td> 
  </tr> 
  <tr> 
   <td>不同包中的子类</td> 
   <td>不可访问</td> 
   <td>不可访问</td> 
   <td>可访问</td> 
   <td>可访问</td> 
  </tr> 
  <tr> 
   <td>不同包中的非子类</td> 
   <td>不可访问</td> 
   <td>不可访问</td> 
   <td>不可访问</td> 
   <td>可访问</td> 
  </tr> 
 </tbody> 
</table>

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 2][]

**private**

用 private 修饰的类成员，只能被该类自身的方法访问和修改，而不能被任何其他类（包括该类的子类）访问和引用。因此，private 修饰符具有最高的保护级别。例如，设 PhoneCard 是电话卡类，电话卡都有密码，因此该类有一个密码域，可以把该类的密码域声明为私有成员。

**friendly（缺省）**

如果一个类没有访问控制符，说明它具有默认的访问控制特性。这种默认的访问控制权规定，该类只能被同一个包中的类访问和引用，而不能被其他包中的类使用，即使其他包中有该类的子类。这种访问特性又称为包访问性（package private）。

同样，类内的成员如果没有访问控制符，也说明它们具有包访问性，或称为友元（friend）。定义在同一个文件夹中的所有类属于一个包，所以前面的程序要把用户自定义的类放在同一个文件夹中（Java 项目默认的包），以便不加修饰符也能运行。

**protected**

用保护访问控制符 protected 修饰的类成员可以被三种类所访问：该类自身、与它在同一个包中的其他类以及在其他包中的该类的子类。使用 protected 修饰符的主要作用，是允许其他包中它的子类来访问父类的特定属性和方法，否则可以使用默认访问控制符。

**public**

当一个类被声明为 public 时，它就具有了被其他包中的类访问的可能性，只要包中的其他类在程序中使用 import 语句引入 public 类，就可以访问和引用这个类。

类中被设定为 public 的方法是这个类对外的接口部分，避免了程序的其他部分直接去操作类内的数据，实际就是数据封装思想的体现。每个 Java 程序的主类都必须是 public 类，也是基于相同的原因。

## 四、方法的重写 ##

**定义：**  
在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。

重写以后，在程序执行时，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。  
约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法

**要求：**  
1、子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表；  
2、子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型；  
父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void。  
父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类。  
父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)。  
3、子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限；  
子类不能重写父类中声明为private权限的方法；怎么体现？  
1、工具提示，各种IDE工具都会对重写的方法有一定的标识；  
2、在父类定义私有x方法，在子类定义公共x方法，然后通过父类y方法调用x方法，发现调用的是父类的x方法，如果是重写的方法，应该调的是子类的x；  
4、子类方法抛出的异常不能大于父类被重写方法的异常；

**注意：**  
子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。

**示例代码一：**

public class Person {
        public String name;
        public int age;
    
        public String getInfo() {
            return "Name: "+ name + "\n" +"age: "+ age;
        }
    }
    
    public class Student extends Person {
        public String school;
    
        //重写方法
        public String getInfo() { 
            return "Name: "+ name + "\nage: "+ age 
                + "\nschool: "+ school;
        }
        public static void main(String args[]){
            Student s1=new Student();
            s1.name="Bob";
            s1.age=20;
            s1.school="school2";
            System.out.println(s1.getInfo()); //Name:Bob age:20 school:school2
        }
    }
    
    // 这是一种“多态性”：同名的方法，用不同的对象来区分调用的是哪一个方法。
    public static void main(String args[]){
        Person p1=new Person();
        //调用Person类的getInfo()方法
        p1.getInfo();
        
        Student s1=new Student();
        //调用Student类的getInfo()方法
        s1.getInfo();
    }

**示例代码二：**

class Parent {
        public void method1() {}
    }
    
    class Child extends Parent {
        //非法，子类中的method1()的访问权限private比被覆盖方法的访问权限public小
        private void method1() {} 
    }
    
    public class UseBoth {
        public static void main(String[] args) {
            Parent p1 = new Parent();
            Child c1 = new Child();
            p1.method1();
            c1.method1();
        }
    }

**思考：**

如果现在父类的一个方法定义成private访问权限，在子类中将此方法声明为default访问权限，那么这样还叫重写吗？(NO)

**继承成员变量和继承方法的区别:**

子类继承父类：  
若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中。  
对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量。

## 五、关键字：super ##

### 5.1 为什么要使用super？ ###

定义员工类：Employee，员工类有name、salary、hireDay属性；

import java.util.Date;
    
    public class Employee {
        private String name;
        private double salary;
        private Date hireDay;
    
        public Employee() {
        }
    
        public Employee(String n, double s, int year, int month, int day) {
            name = n;
            salary = s;
            GregorianCalendar calendar = new GregorianCalendar(year, month, day);
            hireDay = calendar.getTime();
        }
    
        public String getName() {
            return name;
        }
    
        public double getSalary() {
            return salary;
        }
    
        public void setSalary(double salary) {
            this.salary = salary;
        }
    
        public Date getHireDay() {
            return hireDay;
        }
    
        public void setHireDay(Date hireDay) {
            this.hireDay = hireDay;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
    }

尽管 Employee 类是一个超类，但并不是因为它位于子类之上或者拥有比子类更多的功能。

恰恰相反，子类比超类拥有的功能更加丰富。在 Manager 类中，增加了一个用于存储奖金信息的成员变量，以及一个用于设置这个成员变量的方法：

public class Manager extends Employee{
    
        private double bonus;
    
        public void setBonus(double bonus) {
            this.bonus = bonus;
        }
    }

然而，尽管在 Manager 类中没有显式地定义 getName 和 getHireDay 等方法，但属于 Manager 类的对象却可以使用它们，这是因为 Manager 类自动地继承了超类 Employee 中的这些方法。同样，从超类中还继承了 name、salary 和 hireDay 这 3 个成员变量。这样一来，每个 Manager 类对象就包含了4个成员变量：name、salary、hireDay 和 bonus。

在通过扩展超类定义子类的时候，仅需要指出子类与超类的不同之处。因此在设计类的时候，【应该将通用的方法放到超类中，而将具有特色用途的方法放在子类中】，这种将通用的功能放到超类的做法，在面向对象程序设计中十分普遍。

然而，超类中的有些方法对子类 Manager 并不一定适用。例如，在 Manager 类中的 getSalary 方法应该返回薪水和奖金的总和。为此，需要提供一个新的方法来覆盖（override）超类中的这个方法：

@Override
    public double getSalary() {
        return salary + bonus;//won't work
    }

然而，这个方法并不能运行。这是因为 Manager 类的 getSalary 方法不能直接地访问超类的私有变量。也就是说，尽管每个 Manager 对象都拥有一个名为 salary 的变量，但在 Manager 类的 getSalary 方法中并不能够直接地访问 salary 变量。只有 Employee 类的方法才能够访问私有部分。如果 Manager 类的方法一定要访问私有变量，就必须借助共有的接口，Employee 类中的共有方法正式这样一个接口。

@Override
    public double getSalary() {
        // return getSalary() + bonus;  写法错误
        
        // 只能调用父类获取薪资的方法
        return super.getSalary() + bonus;
    }

**那么这个super是用来干嘛的呢?**

### 5.2 super的理解 ###

在Java类中使用super来调用父类中的指定操作：  
super可用于访问父类中定义的属性；  
super可用于调用父类中定义的成员方法；  
super可用于在子类构造器中调用父类的构造器；

**注意：**  
我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."  
特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。  
特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。  
super的追溯不仅限于直接父类；  
super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识。  
严格来说：super 不是一个对象的引用，不能将 super 赋给另一个对象变量，它只是一个指示编译器调用超类方法的特有关键字。

**super三种语法格式：**

访问父类构造方法  
super();　父类无参的构造方法  
super(name); 父类有参的构造方法

访问父类属性  
super.name;

访问父类方法  
super.方法名();

### 5.3 访问父类属性和方法 ###

与 this 类似，super 相当于是指向当前对象的父类(super代表父类的内存空间的标识)，这样就可以用 super.xxx 来引用父类的成员。

public class Parent {
        // 姓氏
        protected String lastName = "张";
    
        // 名字
        protected String firstName;
    
        // 年龄
        protected int age;
    
        // 获取信息
        public String getInfo() {
            return "lastName: " + lastName + "\nfirstName: " + firstName + "\nage: " + age;
        }
    }
    
    public class Child extends Parent {
        // 姓氏
        protected String lastName = "王";
    
        private String school = "school name";
    
        public String getSchool() {
            return school;
        }
    
        public String getInfo() {
            return super.getInfo() + "\nschool: " + school;
        }
    
        public void compare() {
            System.out.println("parent lastName:" + super.lastName);
            System.out.println("child lastName:" + lastName);
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            Child c = new Child();
    
            c.compare();
    
            System.out.println(c.getInfo());
        }
    }

**运行结果：**

parent lastName:张  
child lastName:王  
lastName: 张  
firstName: null  
age: 0  
school: school name

可以看到，这里既调用了父类的方法，也调用了父类的变量。

### 5.4 访问父类构造方法 ###

super(参数)：调用父类中的某一个构造函数（应该为构造函数中的第一条语句）。

子类中所有的构造器默认都会访问父类中空参数的构造器。

当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器。同时，只能”二选一”，且必须放在构造器的首行。

如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错。

创建子类时，编译器会自动调用父类的无参构造函数。

如果父类没有定义无参构造函数，子类必须在构造函数的第一行代码使用super()显示调用类默认拥有无参构造函数，如果定义了其他有参构造函数，则无参函数失效，所以父类没有定义无参构造函数，不是指父类没有写无参构造函数。

看下面的例子，父类为Human，子类为Programmer：

public class Human{
        // 定义了有参构造函数，默认无参构造函数失效
        public Human(String name){
        }
    }
    
    public class Programmer extends Human{
        public Programmer(){
            // 如不显示调用，编译器会出现如下错误
            // Implicit super constructor Human() is undefined. Must explicitly invoke another constructor
            super( "x" );
        }
    }

**示例代码：**

class Person {
        Person() {
            System.out.println("父类·无参数构造方法： " + "A Person.");
        }//构造方法(1)
    
        Person(String name) {
            System.out.println("父类·含一个参数的构造方法： " + "A person's name is " + name);
        }//构造方法(2)
    }
    
    public class Chinese extends Person {
        Chinese() {
            super(); // 调用父类构造方法（1）
            System.out.println("子类·调用父类无参数构造方法： " + "A chinese coder.");
        }
    
        Chinese(String name) {
            super(name);// 调用父类具有相同形参的构造方法（2）
            System.out.println("子类·调用父类含一个参数的构造方法： " + "his name is " + name);
        }
    
        Chinese(String name, int age) {
            this(name);// 调用具有相同形参的构造方法（3）
            System.out.println("子类：调用子类具有相同形参的构造方法：his age is " + age);
        }
    
        public static void main(String[] args) {
            Chinese cn = new Chinese();
            cn = new Chinese("codersai");
            cn = new Chinese("codersai", 18);
        }
    }

**运行结果：**

父类·无参数构造方法： A Person.
    
    子类·调用父类”无参数构造方法“： A chinese coder.
    
    父类·含一个参数的构造方法： A person's name is codersai
    
    子类·调用父类”含一个参数的构造方法“： his name is codersai
    
    父类·含一个参数的构造方法： A person's name is codersai
    
    子类·调用父类”含一个参数的构造方法“： his name is codersai
    
    子类：调用子类具有相同形参的构造方法：his age is 18

从本例可以看到，可以用 super 和 this 分别调用父类的构造方法和本类中其他形式的构造方法。

例子中 Chinese 类第三种构造方法调用的是本类中第二种构造方法，而第二种构造方法是调用父类的，因此也要先调用父类的构造方法，再调用本类中第二种，最后是重写第三种构造方法。

### 5.5 super 和 this的异同 ###

super(参数)：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）;this(参数)：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）;

super:　它引用当前对象的父类中的成员（用来访问父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参）  
this：它代表当前对象名（在程序中易产生二义性之处，应使用 this 来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用 this 来指明成员变量名）

调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用 super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。

super() 和 this() 类似,区别是，super() 从子类中调用父类的构造方法，this() 在同一类内调用其它方法。

super() 和 this() 均需放在构造方法内第一行。

尽管可以用this调用一个构造器，但却不能调用两个。

this 和 super 不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有 super 语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。

this() 和 super() 都指的是对象，所以，均不可以在 static 环境中使用。包括：static 变量,static 方法，static 语句块。

从本质上讲，this 是一个指向本对象的指针, 然而 super 是一个 Java 关键字。

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 3][]

## 六、类初始化顺序 ##

Java类初始化的顺序经常让人犯迷糊，接下来我们从JVM的角度，对Java非继承和继承关系中类的初始化顺序进行试验，尝试给出JVM角度的解释。

### 6.1 非继承关系中的初始化顺序 ###

对于非继承关系，主类InitialOrderWithoutExtend中包含了静态成员变量（类变量）SampleClass 类的一个实例，普通成员变量SampleClass 类的2个实例（在程序中的顺序不一样）以及一个静态代码块，其中静态代码块中如果静态成员变量sam不为空，则改变sam的引用。main()方法中创建了2个主类对象，打印2个主类对象的静态成员sam的属性。

**示例代码：**

/*
     * 非继承关系的初始化
     * InitialOrderWithoutExtend 和 SampleClass 没有继承关系
     * 只是在InitialOrderWithoutExtend 引用了SampleClass类
     */
    public class InitialOrderWithoutExtend {
    	// 静态的优先级都很高,那么到底是静态代码块优先级高还是静态变量优先级高? 优先级一致,谁先定义先执行谁
    	
    	// 静态成员变量sam,这个sam的值是实例化了一个SampleClass,调用的是有参构造函数
    	static SampleClass sam = new SampleClass("静态成员sam初始化 "); 
    	
    	// 普通成员变量sam1,调用的也是SampleClass有参构造函数
    	SampleClass sam1 = new SampleClass("普通成员sam1初始化"); 
    	
    	// 静态代码块: 有且仅执行一次
    	static {
    		System.out.println("static块执行");
    		if (sam == null) {
    			System.out.println("sam is null");
    		}else {
    			sam = new SampleClass("静态块内初始化sam成员变量");
    		}
    	}
    	
    	// 普通成员变量sam2,调用的也是SampleClass有参构造函数
    	SampleClass sam2 = new SampleClass("普通成员sam2初始化");
    
    	// InitialOrderWithoutExtend默认无参
    	InitialOrderWithoutExtend() {
    		System.out.println("InitialOrderWithoutExtend默认构造函数被调用");
    	}
    	
    	{
    		System.out.println("InitialOrderWithoutExtend的普通代码块");
    	}
    
    	public static void main(String[] args) {
    		// 创建第1个主类对象
    		System.out.println("第1个主类对象：");
    		InitialOrderWithoutExtend ts = new InitialOrderWithoutExtend();
    
    		// 创建第2个主类对象
    		System.out.println("第2个主类对象：");
    		InitialOrderWithoutExtend ts2 = new InitialOrderWithoutExtend();
    
    		// 查看两个主类对象的静态成员：
    		System.out.println("2个主类对象的静态对象：");
    		System.out.println("第1个主类对象, 静态成员sam.s: " + ts.sam);
    		System.out.println("第2个主类对象, 静态成员sam.s: " + ts2.sam);
    	}
    }
    
    class SampleClass {
    	// 成员变量s
    	String s;
    
    	// 有参构造函数
    	SampleClass(String s) {
    		this.s = s;
    		System.out.println(s);
    	}
    	
    	// 无参构造函数
    	SampleClass() {
    		System.out.println("SampleClass默认构造函数被调用");
    	}
    	
    	// 如果方法上面定义了Override,那么表示这个方法是重写的
    	@Override
    	public String toString() {
    		// s的默认值null,如果给了值就是给定值
    		return this.s;
    	}
    }

**输出结果：**

静态成员sam初始化 
    static块执行
    静态块内初始化sam成员变量
    第1个主类对象：
    普通成员sam1初始化
    普通成员sam2初始化
    InitialOrderWithoutExtend的普通代码块
    InitialOrderWithoutExtend默认构造函数被调用
    第2个主类对象：
    普通成员sam1初始化
    普通成员sam2初始化
    InitialOrderWithoutExtend的普通代码块
    InitialOrderWithoutExtend默认构造函数被调用
    2个主类对象的静态对象：
    第1个主类对象, 静态成员sam.s: 静态块内初始化sam成员变量
    第2个主类对象, 静态成员sam.s: 静态块内初始化sam成员变量

**由输出结果可知，执行顺序为：**  
static静态代码块和静态成员  
普通成员,构造代码块  
构造函数执行  
当具有多个静态成员和静态代码块或者多个普通成员时，初始化顺序和成员在程序中申明的顺序一致。

注意到在该程序的静态代码块中，修改了静态成员sam的引用。

main()方法中创建了2个主类对象，但是由输出结果可知，静态成员和静态代码块只进行了一次初始化，并且新建的2个主类对象的静态成员sam.s是相同的。由此可知，类的静态成员和静态代码块在类加载中是最先进行初始化的，并且只进行一次。该类的多个实例共享静态成员，静态成员的引用指向程序最后所赋予的引用。

**图示：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_15_color_FFFFFF_t_70_g_se_x_16][]

### 6.2 继承关系中的初始化顺序 ###

此处使用了3个类来验证继承关系中的初始化顺序：Father父类、Son子类和Sample类。  
  
父类和子类中各自包含了普通（构造）代码区、静态代码区、静态成员、普通成员。运行时的主类为InitialOrderWithExtend类，main()方法中创建了一个子类的对象，并且使用Father对象指向Son类实例的引用（父类对象指向子类引用，多态）。

非静态代码区、静态代码区见: 代码块分类；

**示例代码：**

public class InitialOrderWithExtend {
        public static void main(String[] args) {
            Father ts = new Son();
        }
    }
    
    class Father {
        {
            System.out.println("父类 非静态块 1  执行");
        }
        static {
            System.out.println("父类 static块 1  执行");
        }
        static Sample staticSam1 = new Sample("父类 静态成员 staticSam1 初始化");
        Sample sam1 = new Sample("父类 普通成员 sam1 初始化");
        static Sample staticSam2 = new Sample("父类 静态成员 staticSam2 初始化");
        static {
            System.out.println("父类 static块 2  执行");
        }
    
        Father() {
            System.out.println("父类 默认构造函数被调用");
        }
    
        Sample sam2 = new Sample("父类 普通成员 sam2 初始化");
    
        {
            System.out.println("父类 非静态块 2  执行");
        }
    
    }
    
    class Son extends Father {
        {
            System.out.println("子类 非静态块 1  执行");
        }
    
        static Sample staticSamSub1 = new Sample("子类 静态成员 staticSamSub1 初始化");
    
        Son() {
            System.out.println("子类 默认构造函数被调用");
        }
    
        Sample sam1 = new Sample("子类 普通成员 sam1 初始化");
        static Sample staticSamSub2 = new Sample("子类 静态成员 staticSamSub2 初始化");
    
        static {
            System.out.println("子类 static块1  执行");
        }
    
        Sample sam2 = new Sample("子类 普通成员 sam2 初始化");
    
        {
            System.out.println("子类 非静态块 2  执行");
        }
    
        static {
            System.out.println("子类 static块2  执行");
        }
    }
    
    class Sample {
        Sample(String s) {
            System.out.println(s);
        }
    
        Sample() {
            System.out.println("Sample默认构造函数被调用");
        }
    }

**运行结果：**

父类 static块 1  执行
    父类 静态成员 staticSam1 初始化
    父类 静态成员 staticSam2 初始化
    父类 static块 2  执行
    子类 静态成员 staticSamSub1 初始化
    子类 静态成员 staticSamSub2 初始化
    子类 static块1  执行
    子类 static块2  执行
    父类 非静态块 1  执行
    父类 普通成员 sam1 初始化
    父类 普通成员 sam2 初始化
    父类 非静态块 2  执行
    父类 默认构造函数被调用
    子类 非静态块 1  执行
    子类 普通成员 sam1 初始化
    子类 普通成员 sam2 初始化
    子类 非静态块 2  执行
    子类 默认构造函数被调用

**由输出结果可知，执行的顺序为：**   
父类静态代码区和父类静态成员  
子类静态代码区和子类静态成员  
父类非静态代码区和普通成员  
父类构造函数  
子类非静态代码区和普通成员  
子类构造函数

与非继承关系中的初始化顺序一致的地方在于，静态代码区和父类静态成员、非静态代码区和普通成员是同一级别的，当存在多个这样的代码块或者成员时，初始化的顺序和它们在程序中申明的顺序一致；此外，静态代码区和静态成员也是仅仅初始化一次，但是在初始化过程中，可以修改静态成员的引用。

**图示：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_15_color_FFFFFF_t_70_g_se_x_16 1][]

### 6.3 类初始化顺序的JVM解释（自我扩展） ###

类初始化顺序受到JVM类加载机制的控制，类加载机制包括加载、验证、准备、解析、初始化等步骤。不管是在继承还是非继承关系中，类的初始化顺序主要受到JVM类加载时机、解析和clinit()初始化规则的影响。

#### 6.3.1 加载时机 ####

加载是类加载机制的第一个阶段，只有在5种主动引用的情况下，才会触发类的加载，而在其他被动引用的情况下并不会触发类的加载。

关于类加载时机和5中主动引用和被动引用详见：  
【深入理解JVM - 类加载机制】：http://blog.csdn.net/u011080472/article/details/51329315

其中3种主动引用的形式为：  
程序启动需要触发main方法的时候，虚拟机会先触发这个类的初始化。  
使用new关键字实例化对象、读取或设置一个类的静态字段（被final修饰、JIT时放入常量池的静态字段除外）、调用一个类的静态方法，会触发初始化。  
当初始化一个类的时候，如果其父类没有初始化，则需要先触发其父类的初始化。

代码1中触发main()方法前，需要触发主类InitialOrderWithoutExtend的初始化，主类初始化触发后，对静态代码区和静态成员进行初始化后，打印”第1个主类对象：”，之后遇到newInitialOrderWithoutExtend ts = new InitialOrderWithoutExtend();，再进行其他普通变量的初始化。

代码2是继承关系，在子类初始化前，必须先触发父类的初始化。

#### 6.3.2 类解析在继承关系中的自下而上递归 ####

类加载机制的解析阶段将常量池中的符号引用替换为直接引用，主要针对的是类或者接口、字段、类方法、方法类型、方法句柄和调用点限定符7类符号引用。  
  
关于类的解析过程详见【深入理解JVM - 类加载机制】：http://blog.csdn.net/u011080472/article/details/51329315

而在字段解析、类方法解析、方法类型解析中，均遵循继承关系中自下而上递归搜索解析的规则，由于递归的特性（即数据结构中栈的“后进先出”），初始化的过程则是由上而下、从父类到子类的初始化顺序。

#### 6.3.3 初始化clinit()方法 ####

初始化阶段是执行类构造器方法clinit() 的过程。clinit() 是编译器自动收集类中所有类变量（静态变量）的赋值动作和静态语句块合并生成的。编译器收集的顺序是由语句在源文件中出现的顺序决定的。JVM会保证在子类的clinit() 方法执行之前，父类的clinit() 方法已经执行完毕。

因此所有的初始化过程中clinit()方法，保证了静态变量和静态语句块总是最先初始化的，并且一定是先执行父类clinit()，在执行子类的clinit()。

### 6.4 代码顺序与对象内存布局（自我扩展） ###

在前面的分析中我们看到，类的初始化具有相对固定的顺序：静态代码区和静态变量先于非静态代码区和普通成员，先于构造函数。

在相同级别的初始化过程中，初始化顺序与变量定义在程序的中顺序是一致的。

而代码顺序在对象内存布局中同样有影响。  
关于JVM对象内存布局详见:【深入理解JVM】：Java对象的创建、内存布局、访问定位:  
http://blog.csdn.net/u011080472/article/details/51321769)。

在HotSpot虚拟机中，对象在内存中存储的布局可以分为3块区域：对象头(Header)、实例数据(Instance Data)和对齐填充(Padding)。而实例数据是对象真正存储的有效信息，也是程序代码中所定义的各种类型的字段内容。

无论是从父类继承还是子类定义的，都需要记录下来，这部分的存储顺序JVM参数和字段在程序源码中定义顺序的影响。HotSpot虚拟机默认的分配策略为longs/doubles、ints、shorts/chars、bytes/booleans、oop，从分配策略中可以看出，相同宽度的字段总是分配到一起。满足这个条件的前提下，父类中定义的变量会出现在子类之前。不过，如果启用了JVM参数CompactFields（默认为true，启用），那么子类中较窄的变量也可能会插入到父类变量的空隙中。

## 七、OOP特征三：多态(Polymorphism) ##

### 7.1 何为多态 ###

从字面意思理解：可以理解为一个事物的多种形态。怎么叫一个事物的多种形态呢？

看代码分析：

public class Person {
    	String name;
    	int age;
    	
    	int id = 1111;
    	
    	public void eat(){
    		System.out.println("人：吃饭");
    	}
    	
    	public void walk(){
    		System.out.println("人：走路");
    	}
    	
    }
    
    public class Man extends Person{
    
        boolean isSmoking;
    
        int id = 2222;
    
        public void earnMoney(){
            System.out.println("男人负责挣钱养家");
        }
    
        public void eat(){
            System.out.println("男人多吃肉，长肌肉");
        }
    
        public void walk(){
            System.out.println("男人霸气的走路");
        }
    
    }
    
    public class Woman extends Person{
    
        boolean isBeauty;
    
        public void goShopping(){
            System.out.println("女人喜欢购物");
        }
    
        public void eat(){
            System.out.println("女人少吃，为了减肥");
        }
    
        public void walk(){
            System.out.println("女人窈窕的走路");
        }
    }
    
    public class PersonTest {
    
        public static void main(String[] args) {
    
            Person p1 = new Person();
            p1.eat();
    
            Man man = new Man();
            man.eat();
            man.age = 25;
            man.earnMoney();
    
            System.out.println("---------------------------");
    
            // 对象的多态性：父类的引用指向子类的对象
            Person p2 = new Man();
            Person p3 = new Woman();
        }
    }

一个人类，既可以是一个男人对象，也可以是一个女人对象；这就是对象的多态性。  
  
多态性，是面向对象中最重要的概念，在Java中的体现：  
对象的多态性：父类的引用指向子类的对象;  
  
注：可以直接应用在抽象类和接口上。

### 7.2 多态的使用 ###

封装隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构，同时也保护了数据。对外界而已它的内部细节是隐藏的，暴露给外界的只是它的访问方法。
    
    	继承是为了重用父类代码。两个类若存在IS-A的关系就可以使用继承。同时继承也为实现多态做了铺垫。
    
    	那么什么是多态呢？多态的实现机制又是什么？
    
    	所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。
    	
    	因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。
    
    	Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简称：编译时，看左边；运行时，看右边。
    		若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)
    		多态情况下，“看左边”：看的是父类的引用（父类中不具备子类特有的方法）
    		多态情况下，“看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）
    
    	一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法。
            示例代码：
                Student m = new Student();
                m.school = “pku”; // 合法,Student类有school成员变量
                Person e = new Student(); 
                e.school = “pku”; // 非法,Person类没有school成员变量
                属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。
    
    	多态的前提：
    		① 类的继承关系  ② 方法的重写
    
    	对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）

public class PersonTest {
    
        public static void main(String[] args) {
            // 对象的多态性：父类的引用指向子类的对象
            Person p = new Man();
    
            // 多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用
            p.eat();
            p.walk();
    		
            // 编译报错
            // p2.earnMoney();
            
            System.out.println(p.id);// 1111
        }
    }

对象的多态 —在Java中,子类的对象可以替代父类的对象使用。  
一个变量只能有一种确定的数据类型。  
一个引用类型变量可能指向(引用)多种不同类型的对象。

示例代码：  
Person p = new Student();  
Object o = new Person();// Object类型的变量o，指向Person类型的对象  
o = new Student(); // Object类型的变量o，指向Student类型的对象

子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting)。

**所以对于多态我们可以总结如下：**

指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法（动态连接、动态调用）。

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

**多态是编译时行为还是运行时行为？**

//证明如下：
    class Animal  {
    
        protected void eat() {
            System.out.println("animal eat food");
        }
    }
    
    class Cat  extends Animal  {
    
        protected void eat() {
            System.out.println("cat eat fish");
        }
    }
    
    class Dog  extends Animal  {
    
        public void eat() {
            System.out.println("Dog eat bone");
        }
    
    }
    
    class Sheep  extends Animal  {
        public void eat() {
            System.out.println("Sheep eat grass");
    
        }
    
    }
    
    public class InterviewTest {
    
        public static Animal  getInstance(int key) {
            switch (key) {
                case 0:
                    return new Cat ();
                case 1:
                    return new Dog ();
                default:
                    return new Sheep ();
            }
    
        }
    
        public static void main(String[] args) {
            int key = new Random().nextInt(3);
    
            System.out.println(key);
    
            Animal  animal = getInstance(key);
    
            animal.eat();
    
        }
    
    }

**理解虚拟方法调用：**

正常的方法调用：  
Person e = new Person();  
e.getInfo();  
Student e = new Student();  
e.getInfo();

虚拟方法调用(多态情况下):  
子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。  
Person e = new Student();  
e.getInfo(); //调用Student类的getInfo()方法

编译时类型和运行时类型  
编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类的getInfo()方法。——动态绑定

### 7.3 多态的意义 ###

定义：子类对象赋值给父类类型的变量，通俗地说就是是将子类对象转为父类对象。

class Person{
        public void print() {
            System.out.println("人类");
        }
    }
    class Student extends Person{
        public void print() {
            System.out.println("我是学生");
        }
    }
    class Teacher extends Person{
        public void print() {
            System.out.println("我是老师");
        }
    }
    public class Test{
        public static void main(String[] args) {
            Person per=new Student();// 对象的多态
            per.print();
        }
    }

**向上转型需要注意的地方**

1. 向上转型后，子类单独定义的方法会丢失（父类并不知道子类定义的新属性与方法）  
2. 父类引用可以指向子类对象，但是子类引用不能指向父类对象（除非强转）  
3. 如果子类中重写了父类的方法，那么调用这个方法的时候，将会调用子类中的方法

**那么重点来了，向上转型的意义究竟是什么？**

减少重复代码  
实例化的时候可以根据不同的需求实例化不同的的对象，实现参数统一化

//多态性的使用举例一：
    public class AnimalTest {
    
        public static void main(String[] args) {
    
            AnimalTest test = new AnimalTest();
            test.func(new Dog());
    
    
            test.func(new Cat());
        }
    
        public void func(Animal animal){//Animal animal = new Dog();
            animal.eat();
            animal.shout();
    
            if(animal instanceof Dog){
                Dog d = (Dog)animal;
                d.watchDoor();
            }
        }
    
        //	public void func(Dog dog){
        //		dog.eat();
        //		dog.shout();
        //	}
        //	public void func(Cat cat){
        //		cat.eat();
        //		cat.shout();
        //	}
    }
    
    
    class Animal{
    
        public void eat(){
            System.out.println("动物：进食");
        }
    
        public void shout(){
            System.out.println("动物：叫");
        }
    
    
    }
    
    class Dog extends Animal{
        public void eat(){
            System.out.println("狗吃骨头");
        }
    
        public void shout(){
            System.out.println("汪！汪！汪！");
        }
    
        public void watchDoor(){
            System.out.println("看门");
        }
    }
    class Cat extends Animal{
        public void eat(){
            System.out.println("猫吃鱼");
        }
    
        public void shout(){
            System.out.println("喵！喵！喵！");
        }
    }
    
    //举例二：
    
    class Order{
    
        public void method(Object obj){
    
        }
    }
    
    //举例三：
    class Driver{
    
        public void doData(Connection conn){//conn = new MySQlConnection(); / conn = new OracleConnection();
            //规范的步骤去操作数据
            // conn.method1();
            // conn.method2();
            // conn.method3();
    
        }
    
    }

简而言之，多态其实是在继承的基础上的。比如说今天我们要去动物园参观动物，那么你说我们去参观兔子、参观绵羊、参观狮子、参观豹子都是对的，但你不能说我们去参观汽车。在这个例子中，子类具有多态性：除了使用自己的身份，还能充当父类。

### 7.4 方法重写和重载对比 ###

1. 二者的定义细节：略

2. 从编译和运行的角度看：  
重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。  
所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；

而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。

引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚绑定，它就不是多态。”

### 7.5 instanceof 操作符 ###

x instanceof A：检验x是否为类A的对象，返回值为boolean型。  
要求x所属的类与类A必须是子类和父类的关系，否则编译错误。  
如果x属于类A的子类B，x instanceof A值也为true。

public class Person extends Object {…}
    public class Student extends Person {…}
    public class Graduate extends Person {…}
    
    public class Test {
    
        public void method(Person e) {
            if (e instanceof Person){
                // 处理Person类及其子类对象
            } 
    
            if (e instanceof Student){
                //处理Student类及其子类对象
            } 
    
            if (e instanceof Graduate){
                //处理Graduate类及其子类对象
            }
    
        }
    }

### 7.6 对象类型转换 ###

基本数据类型的Casting：  
自动类型转换：容量小的数据类型可以自动转换成容量大的数据类型；  
如long g=20; double d=12.0f  
强制类型转换：可以把容量大的数据类型强制转换(casting)成容量小的数据类型；  
如 float f=(float)12.0; int a=(int)1200L

对Java对象的强制类型转换称为造型：  
从子类到父类的类型转换可以自动进行；  
从父类到子类的类型转换必须通过造型(强制类型转换)实现；  
无继承关系的引用类型间的转换是非法的；  
在造型前可以使用instanceof操作符测试一个对象的类型；

**示例代码：**

public class ConversionTest {
        public static void main(String[] args) {
            double d = 13.4;
            long l = (long) d;
            System.out.println(l);
            
            int in = 5;
            // boolean b = (boolean)in;
            
            Object obj = "Hello";
            String objStr = (String) obj;
            System.out.println(objStr);
            
            Object objPri = new Integer(5);
            // 所以下面代码运行时引发ClassCastException异常
            String str = (String) objPri;
        }
    }

public class Test {
        public void method(Person e) { // 设Person类中没有getschool() 方法
            // System.out.pritnln(e.getschool()); //非法,编译时错误
            if (e instanceof Student) {
                Student me = (Student) e; // 将e强制转换为Student类型
                System.out.pritnln(me.getschool());
            }
        }
        public static void main(String[] args){
            Test t = new Test();
            Student m = new Student();
            t.method(m);
        }
    }

public class PersonTest {
    
        public static void main(String[] args) {
            // 对象的多态性：父类的引用指向子类的对象
            Person p = new Man();
    
            // 有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。
    
            // 如何才能调用子类特有的属性和方法？
            // 向下转型：使用强制类型转换符。
            Man m1 = (Man)p2;
            m1.earnMoney();
            m1.isSmoking = true;
    
            //使用强转时，可能出现ClassCastException的异常。所以强转之前，需要通过instanceof进行判断
            // Woman w1 = (Woman)p2;
            // w1.goShopping();
        }
    }

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_19_color_FFFFFF_t_70_g_se_x_16 1][]

### 7.7 多态的笔试题 ###

//考查多态的笔试题目：
    public class InterviewTest1 {
    
        public static void main(String[] args) {
            Base base = new Sub();
            base.add(1, 2, 3);
    
            // Sub s = (Sub)base;
            // s.add(1,2,3);
        }
    }
    
    class Base {
        public void add(int a, int... arr) {
            System.out.println("base");
        }
    }
    
    class Sub extends Base {
    
        public void add(int a, int[] arr) {
            System.out.println("sub_1");
        }
    
        //	public void add(int a, int b, int c) {
        //		System.out.println("sub_2");
        //	}
    
    }

## 八、课后练习题 ##

### 8.1 程序题 ###

**1、创建程序,在其中定义两个类：Person和PersonTest类。**  
定义如下：用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。  
在 PersonTest 类 中实例化 Person 类的对象 b，调 用 setAge() 和getAge()方法，体会Java的封装性。

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_7_color_FFFFFF_t_70_g_se_x_16][]

public class PersonTest {
        public static void main(String[] args) {
            Person b = new Person();
            b.setAge(20);
            System.out.println("b的年龄为:" + b.getAge());
        }
    }
    
    class Person {
        private int age;
    
        public void setAge(int age) {
            if (age < 0 || age > 130) {
                System.out.println("传入的数据非法！");
                return;
            }
            this.age = age;
        }
    
        public int getAge() {
            return age;
        }
    }

**2、结合构造器练习；**  
2.1 在前面定义的Person类中添加构造器，利用构造器设置所有人的age属性初始值都为18。  
2.2 修改上题中类和构造器，增加name属性,使得每次创建Person对象的同时初始化对象的age属性值和name属性值。

public class PersonTest {
        public static void main(String[] args) {
            Person p1 = new Person();
            // p1.age = 1;编译不通过
    
            p1.setAge(12);
    
            System.out.println("年龄为：" + p1.getAge());
    
            Person p2 = new Person("Tom", 21);
            System.out.println("name = " + p2.getName() + ",age = " + p2.getAge());
        }
    }
    
    class Person {
        private int age;
        private String name;
    
        public Person() {
            age = 18;
        }
    
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public void setAge(int age) {
            if (age < 0 || age > 130) {
                // throw new RuntimeException("传入的数据非法！");
                System.out.println("传入的数据非法！");
                return;
            }
            this.age = age;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    }

**3、编写两个类**

TriAngle和TriAngleTest，其中TriAngle类中声明私有的底边长base和高height，同时声明公共方法访问私有变量。此外，提供类必要的构造器。另一个类中使用这些公共方法，计算三角形的面积。

public class TriAngleTest {
        public static void main(String[] args) {
            TriAngle t1 = new TriAngle();
            t1.setBase(2.0);
            t1.setHeight(2.4);
    
            System.out.println("t1面积是:" + t1.getArea());
    
            TriAngle t2 = new TriAngle(5.1, 5.6);
            System.out.println("t2面积是:" + t2.getArea());
        }
    }
    
    
    class TriAngle {
    
        private double base;//底边长
        private double height;//高
    
        public TriAngle() {
    
        }
    
        public TriAngle(double base, double height) {
            this.base = base;
            this.height = height;
        }
    
        public void setBase(double base) {
            this.base = base;
        }
    
        public double getBase() {
            return base;
        }
    
        public void setHeight(double height) {
            this.height = height;
        }
    
        public double getHeight() {
            return height;
        }
    
        public double getArea() {
            return base * height / 2;
        }
    
    }

**4、完成如下要求：**  
(1)定义一个ManKind类，包括:  
成员变量int sex和int salary；  
方法void manOrWoman()：根据sex的值显示“man”(sex==1)或者“woman”(sex==0)；  
方法void employeed()：根据salary的值显示“no job”(salary==0)或者“ job”(salary!=0)。  
(2)定义类Kids继承ManKind，并包括:  
成员变量int yearsOld；  
方法printAge()打印yearsOld的值。  
(3)在Kids中重新定义employeed()方法，覆盖父类ManKind中定义的employeed()方法，输出“Kids should study and no job.”

(4)在Kids中重新定义employeed()方法，在该方法中调用父类ManKind的employeed()方法，然后再输出“but Kids should study and no job.”  
(5)定义类KidsTest，在类的main方法中实例化Kids的对象someKid，用该对象访问其父类的成员变量及方法。

public class ManKind {
        private int sex;//性别
        private int salary;//薪资
    
        public ManKind() {
        }
    
        public ManKind(int sex, int salary) {
            this.sex = sex;
            this.salary = salary;
        }
    
        public void manOrWoman(){
            if(sex == 1){
                System.out.println("man");
            }else if(sex == 0){
                System.out.println("woman");
            }else{
                System.out.println("what?");
            }
        }
    
        public void employeed(){
    		/*if(salary == 0){
    			System.out.println("no job");
    		}else{
    			System.out.println("job");
    		}*/
            //或
            String jobInfo = (salary == 0)? "no job" : "job";
            System.out.println(jobInfo);
        }
    
        public int getSex() {
            return sex;
        }
    
        public void setSex(int sex) {
            this.sex = sex;
        }
    
        public int getSalary() {
            return salary;
        }
    
        public void setSalary(int salary) {
            this.salary = salary;
        }
    }
    
    public class Kids extends ManKind {
        private int yearsOld;
    
        public Kids() {
        }
    
        public Kids(int yearsOld) {
            this.yearsOld = yearsOld;
        }
    
        public void printAge() {
            System.out.println("I am " + yearsOld + " years old.");
    
        }
    
        public int getYearsOld() {
            return yearsOld;
        }
    
        public void setYearsOld(int yearsOld) {
            this.yearsOld = yearsOld;
        }
        /*
         * 在Kids中重新定义employeed()方法，覆盖父类ManKind中定义的employeed()方法，
         * 输出“Kids should study and no job.”
         */
    
        public void employeed() {
            System.out.println("Kids should study and no job.");
        }
    }
    
    public class KidsTest {
        public static void main(String[] args) {
    
            Kids someKid = new Kids(12);
    
            someKid.printAge();
    
            someKid.setSalary(0);
            someKid.setSex(1);
    
            someKid.employeed();
            someKid.manOrWoman();
        }
    }

**5、完成如下练习：**

（1）根据下图实现类。在CylinderTest类中创建Cylinder类的对象，设置圆柱的底面半径和高，并输出圆柱的体积。  
（2）在Cylinder类中覆盖findArea()方法，计算圆柱的表面积。考虑：findVolume方法怎样做相应的修改？

附加题：在CylinderTest类中创建一个Circle类的对象，设置圆的半径，计算输出圆的面积。体会父类和子类成员的分别调用。

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_12_color_FFFFFF_t_70_g_se_x_16 1][]

public class Circle {
        private double radius;//半径
    
        public Circle(){
            radius = 1.0;
        }
    
        public Circle(double radius){
            this.radius = radius;
        }
    
        public double getRadius() {
            return radius;
        }
    
        public void setRadius(double radius) {
            this.radius = radius;
        }
    
        //返回圆的面积
        public double findArea(){
            return Math.PI * radius * radius;
        }
    
    }
    
    public class Cylinder extends Circle{
    
        private double length;//高
    
        public Cylinder(){
            length = 1.0;
        }
    
        public double getLength() {
            return length;
        }
    
        public void setLength(double length) {
            this.length = length;
        }
    
        //返回圆柱的体积
        public double findVolume(){
            // return Math.PI * getRadius() * getRadius() * getLength();
            return super.findArea() * getLength();
        }
    
        @Override
        public double findArea() {//返回圆柱的表面积
            return Math.PI * getRadius() * getRadius() * 2 + 
                2 * Math.PI * getRadius() * getLength();
        }
    
    }
    
    public class CylinderTest {
        public static void main(String[] args) {
    
            Cylinder cy = new Cylinder();
    
            cy.setRadius(2.1);
            cy.setLength(3.4);
            double volume = cy.findVolume();
            System.out.println("圆柱的体积为：" + volume);
    
            //没有重写findArea()时：
            // double area = cy.findArea();
            // System.out.println("底面圆的面积：" + area);
            
            //重写findArea()以后：
            double area = cy.findArea();
            System.out.println("圆柱的表面积：" + area);
    
            System.out.println("--------------------");
            Cylinder cy1 = new Cylinder();
            double volume1 = cy1.findVolume();
            System.out.println("圆柱的体积为：" + volume1);
        }
    }

**6、定义三个类，父类GeometricObject代表几何形状，子类Circle代表圆形，MyRectangle代表矩形。**  
定义一个测试类GeometricTest，编写equalsArea方法测试两个对象的面积是否相等（注意方法的参数类型，利用动态绑定技术），编写displayGeometricObject方法显示对象的面积（注意方法的参数类型，利用动态绑定技术）。

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_15_color_FFFFFF_t_70_g_se_x_16 2][]

public class GeometricObject {//几何图形
    
        protected String color;
        protected double weight;
        
        public String getColor() {
            return color;
        }
        public void setColor(String color) {
            this.color = color;
        }
        
        public double getWeight() {
            return weight;
        }
        public void setWeight(double weight) {
            this.weight = weight;
        }
        
        public GeometricObject(String color, double weight) {
            super();
            this.color = color;
            this.weight = weight;
        }
    
        public double findArea(){
            return 0.0;
        }
    
    }
    
    public class Circle extends GeometricObject {
    
    	private double radius;
    	
    	public Circle(double radius,String color, double weight) {
    		super(color, weight);
    		this.radius = radius;
    	}
    
    	public double getRadius() {
    		return radius;
    	}
    
    	public void setRadius(double radius) {
    		this.radius = radius;
    	}
    	
    	public double findArea(){
    		return Math.PI * radius * radius;
    	}
    
    }
    
    public class MyRectangle extends GeometricObject {
    
    	private double width;
    	private double height;
    	
    	public MyRectangle(double width,double height,String color, double weight) {
    		super(color, weight);
    		this.width = width;
    		this.height = height;
    	}
    
    	public double getWidth() {
    		return width;
    	}
    
    	public void setWidth(double width) {
    		this.width = width;
    	}
    
    	public double getHeight() {
    		return height;
    	}
    
    	public void setHeight(double height) {
    		this.height = height;
    	}
    
    	@Override
    	public double findArea() {
    		return width * height;
    	}
    }
    
    public class GeometricTest {
    
        public static void main(String[] args) {
            GeometricTest test = new GeometricTest();
    
            Circle c1 = new Circle(3.3, "white", 1.0);
            test.displayGeometricObject(c1);
            Circle c2 = new Circle(3.3, "white", 1.0);
            test.displayGeometricObject(c2);
    
            boolean isEquals = test.equalsArea(c1, c2);
            System.out.println("c1 和 c2的面积是否相等：" + isEquals);
    
            MyRectangle rect = new MyRectangle(2.1, 3.4, "red", 2.0);
            test.displayGeometricObject(rect);
    
        }
    
        public void displayGeometricObject(GeometricObject o){//GeometricObject o = new Circle(...)
            System.out.println("面积为：" + o.findArea());
        }
    
        //测试两个对象的面积是否相等
        public boolean equalsArea(GeometricObject o1,GeometricObject o2){
            return o1.findArea() == o2.findArea();
        }
    }

### 8.2 简答题 ###

**1、面向对象三大特征？**  
三大特性是：封装,继承,多态  
所谓封装，就是隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。  
所谓继承，就是子类继承父类‘所有’的特征和行为，使得子类对象（实例）具有父类的成员变量和方法，或类从父类继承方法，使得子类具有父类相同的行为。承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。继承的过程，就是从一般到特殊的过程。  
所谓多态就是程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编译期并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。多态集中体现在方法的重载和重写。  
不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

**2、为什么要使用封装?**  
1、只能通过规定方法访问数据  
2、隐藏类数据的实现细节  
3、方便修改实现  
4、方便加入控制语句　  
5、可以修改属性的读(getter)写(setter)权限

**3、封装的体现？**  
1、属性的封装。  
2、不对外暴露的私有的方法。  
3、构造函数的封装。

**4、为什么要使用继承?**  
1、继承就是为了提高代码的复用性，减少代码的冗余；  
2、便于功能的扩展；  
3、为多态性的使用，提供了前提。

**5、继承的规则？**  
1、一个类可以被多个子类继承。  
2、Java中类的单继承性：一个类只能有一个父类（直接父类）。  
3、子父类是相对的概念。  
4、子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类。  
5、子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法。

**6、四种访问权限修饰符是什么？它们的访问范围分别是什么？**  
Java的四种访问权限修饰符public、protected、 (缺省)、 private；  
public：同一个类、同一包中、不同包中的子类、不同包中的非子类都可以访问。  
protected：同一个类、同一包中、不同包中的子类可以访问。  
缺省：同一个类、同一包中可以访问。  
private：只能在当前类中访问。

**7、为什么要方法重写？**  
从父类继承过来的方法，不满足子类的需求，那么就需要对继承而来的方法进行改造；  
在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。重写以后，在程序执行时，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。

**8、方法重写的规则？**  
1、子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表；  
2、子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型；  
3、子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限；  
4、子类方法抛出的异常不能大于父类被重写方法的异常；

**9、如果现在父类的一个方法定义成private访问权限，在子类中将此方法声明为default访问权限，那么这样还叫重写吗？**  
NO；

**10、成员变量会发生重写吗？**  
不会；

**11、super关键字的作用？**  
super可用于访问父类中定义的属性；  
super可用于调用父类中定义的成员方法；  
super可用于在子类构造器中调用父类的构造器；

**12、super 和 this的异同？**  
super代表父类的内存空间的标识；this代表本类对象的引用。  
super是在子类里面调用父类的成员变量、成员方法、构造函数；this是在当前类里面调用当前对象的成员变量、成员方法、构造函数，this访问本类的属性和方法，如果本类中没有此属性则从父类中继续查找；  
super()调用父类构造函数，this()调用当前类构造函数，必须都写在构造函数的第一行;  
this 和 super 不能同时出现在一个构造函数里面;  
this() 和 super() 都指的是对象，所以，均不可以在 static 环境中使用。

**13、非继承关系中的初始化顺序？**  
static静态代码块和静态成员  
普通成员,构造代码块  
构造函数

**14、继承关系中的初始化顺序？**  
父类静态代码区和父类静态成员  
子类静态代码区和子类静态成员  
父类非静态代码区和普通成员  
父类构造函数  
子类非静态代码区和普通成员  
子类构造函数

**15、为什么要使用多态？**  
减少重复代码；  
实例化的时候可以根据不同的需求实例化不同的的对象，实现参数统一化；

**16、Java实现多态有三个必要条件？**  
Java实现多态有三个必要条件：继承、重写、向上转型。  
继承：在多态中必须存在有继承关系的子类和父类。  
重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。  
向上转型：在多态中需要将父类引用指向子类对象，只有这样该引用才能够具备既能调用父类的方法和子类重写的方法。

**17、方法重写和重载的区别？**  
二者的定义细节：  
重载是指一个类里面（包括父类的方法）存在方法名相同，但是参数不一样的方法，参数不一样可以是不同的参数个数、类型或顺序；子类中存在和父类相同的方法即为覆盖，何谓相同方法请牢记前面的描述，方法名和参数相同，包括参数个数、类型、顺序；  
从编译和运行的角度看：  
重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。  
所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；  
而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。

**18、instanceof 操作符的作用？**  
x instanceof A：检验x是否为类A的对象，返回值为boolean型。

**19、对象类型转换规则？**  
从子类到父类的类型转换可以自动进行；  
从父类到子类的类型转换必须通过造型(强制类型转换)实现；  
无继承关系的引用类型间的转换是非法的；  
在造型前可以使用instanceof操作符测试一个对象的类型；

**20、代码块分类、执行机制、执行顺序?**  
分类：  
普通代码块：在方法或语句中出现的\{\}就称为普通代码块。  
构造块：直接在类中定义且没有加static关键字的代码块称为\{\}构造代码块。  
静态代码块：在java类中使用static关键字声明的代码块。  
执行机制：  
普通代码块和一般的语句执行顺序由他们在代码中出现的次序决定--“先出现先执行”  
构造代码块在创建对象时被调用，每次创建对象都会被调用，并且构造代码块的执行次序优先于类构造函数。  
每个静态代码块只会执行一次。由于JVM在加载类时会执行静态代码块，所以静态代码块先于主方法执行。  
执行顺序：  
静态代码块 > mian方法 > 构造代码块 > 构造方法 > 普通代码块;

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_19_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/80c44ad6651e4156844f478f0365ddf2.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_12_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/fcf32b7c4b4e413c99ebcab8df04f35c.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_16_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/460116a3b5324becb5d2adc093fabfe0.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/a52c0e2a10254db1a89e6e7f36e6ff06.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/61fdfaf0c7bc45df84e81ed9363ae397.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/812874b8f8ff4a219ccbe0b1a503a517.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/72873641272f47d19ea818bd4329c017.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_15_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/be9ff32645004f87ac193b4e5d7b6ee5.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_15_color_FFFFFF_t_70_g_se_x_16 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/2bbc5311720a49849370d420624cc6f8.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_19_color_FFFFFF_t_70_g_se_x_16 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/395a857eb0fb4cb3a3004157dbe0a99a.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_7_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/b93e2cf6c546429aa7bb936546182c1d.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_12_color_FFFFFF_t_70_g_se_x_16 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/44150cb11eab4c60ad711c5aef7cdab4.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_15_color_FFFFFF_t_70_g_se_x_16 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/92ffc659ba8049878f6143694200cbf1.png