第6章【面向对象基础—中】

教学目标

• 理解封装的概念
• 掌握权限修饰符的使用
• 掌握成员变量的私有化
• 掌握构造器的声明与使用
• 会声明标准的JavaBean
• 能够写出类的继承格式
• 能够说出继承的特点
• 能够说出方法重写的概念以及和重载的区别
• 能够使用this关键字解决问题
• 能够使用super关键字解决问题
• 能够分析类初始化过程（为面试服务）
• 能够分析实例初始化过程（为面试服务）
• 能够应用多态解决问题
• 理解向上转型与向下转型
• 能够使用instanceof关键字判断对象类型
• 了解native关键字
• 掌握final关键字
• 了解Object类的常用方法
• 会重写Object的常用方法

6.1 封装

6.1.1 封装概述

1、为什么需要封装？

• 我要用洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内部的结构吗？有必要碰电动机吗？
• 我们使用的电脑，内部有CPU、硬盘、键盘、鼠标等等，每一个部件通过某种连接方式一起工作，但是各个部件之间又是独立的
• 现实生活中，每一个个体与个体之间是有边界的，每一个团体与团体之间是有边界的，而同一个个体、团体内部的信息是互通的，只是对外有所隐瞒。

面向对象编程语言是对客观世界的模拟，客观世界里每一个事物的内部信息都是隐藏在对象内部的，外界无法直接操作和修改，只能通过指定的方式进行访问和修改。封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

随着我们系统越来越复杂，类会越来越多，那么类之间的访问边界必须把握好，面向对象的开发原则要遵循“高内聚、低耦合”，而“高内聚，低耦合”的体现之一：

• 高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
• 低耦合：仅对外暴露少量的方法用于使用

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的讲，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

2、如何实现封装呢？

通俗的讲，封装就是把该隐藏的隐藏起来，该暴露的暴露出来。那么暴露的程度如何控制呢？就是依赖访问控制修饰符，也称为权限修饰符来控制。

访问控制修饰符来控制相应的可见边界，边界有如下：

（1）类

（2）包

（3）子类

（4）模块：Java9之后引入

权限修饰符

权限修饰符：public,protected,缺省,private

外部类：public和缺省

成员变量、成员方法、构造器、成员内部类：public,protected,缺省,private

提示：protected修饰非静态成员，跨包时，只能在子类的非静态成员中访问，在静态成员中无论是否创建对象都不能访问。

示例一：本包非子类与子类

package com.atguigu.test01.access1;
public class Father {
    public int a;
    protected int b;
    int c;
    private int d;
    public static int e;
    protected static int f;
    static int g;
    private static int h;
}
class Mother{
    public Mother(){
    }
}

package com.atguigu.test01.access1;
//本包非子类中
public class Other {
    public static void method(){
        Father obj = new Father();
        System.out.println(obj.a);
        System.out.println(obj.b);
        System.out.println(obj.c);
//        System.out.println(obj.d);//跨类不可见
        System.out.println(Father.e);
        System.out.println(Father.f);
        System.out.println(Father.g);
//        System.out.println(h);//跨类不可见
    }
    public void fun(){
        Father obj = new Father();
        System.out.println(obj.a);
        System.out.println(obj.b);
        System.out.println(obj.c);
//        System.out.println(obj.d);//跨类不可见
        System.out.println(Father.e);
        System.out.println(Father.f);
        System.out.println(Father.g);
//        System.out.println(h);//跨类不可见
    }
}

package com.atguigu.test01.access1;
//本包子类中
public class Sub extends Father{
    public static void method(){
        //静态直接访问非静态都不行
/*        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);*/
        Father obj = new Father();
        System.out.println(obj.a);
        System.out.println(obj.b);
        System.out.println(obj.c);
//        System.out.println(obj.d);//跨类不可见
        System.out.println(e);
        System.out.println(f);
        System.out.println(g);
//        System.out.println(h);//跨类不可见
    }
    public void fun(){
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
//        System.out.println(d);//跨类不可见
        System.out.println(e);
        System.out.println(f);
        System.out.println(g);
//        System.out.println(h);//跨类不可见
    }
}

示例二：跨包子类和非子类

package com.atguigu.test01.access1;
public class Father {
    public int a;
    protected int b;
    int c;
    private int d;
    public static int e;
    protected static int f;
    static int g;
    private static int h;
}

package com.atguigu.test01.other;
import com.atguigu.test01.access1.Father;
public class Another {
    public static void method(){
        Father obj = new Father();
        System.out.println(obj.a);
//        System.out.println(obj.b);//跨包非子类不可见
//        System.out.println(obj.c);//跨包不可见
//        System.out.println(obj.d);//跨类不可见
        System.out.println(Father.e);
//        System.out.println(Father.f);//跨包非子类不可见
//        System.out.println(Father.g);//跨包不可见
//        System.out.println(h);//跨类不可见
    }
    public void fun(){
        Father obj = new Father();
        System.out.println(obj.a);
//        System.out.println(obj.b);//跨包非子类不可见
//        System.out.println(obj.c);//跨包不可见
//        System.out.println(obj.d);//跨类不可见
        System.out.println(Father.e);
//        System.out.println(Father.f);//跨包非子类不可见
//        System.out.println(Father.g);//跨包不可见
//        System.out.println(h);//跨类不可见
    }
}

package com.atguigu.test01.other;
import com.atguigu.test01.access1.Father;
public class Son extends Father{
    public static void method(){
        //静态直接访问非静态都不行
/*        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);*/
        Father obj = new Father();
        System.out.println(obj.a);
//        System.out.println(obj.b);//跨包的静态成员
                        //不能访问非静态的protected
//        System.out.println(obj.c);//跨包不可见
//        System.out.println(obj.d);//跨类不可见
        System.out.println(e);
        System.out.println(f);
//        System.out.println(g);//跨包不可见
//        System.out.println(h);//跨类不可见
    }
    public void fun(){
        System.out.println(a);
        System.out.println(b);
//        System.out.println(c);//跨包不可见
//        System.out.println(d);//跨类不可见
        System.out.println(e);
        System.out.println(f);
//        System.out.println(g);//跨包不可见
//        System.out.println(h);//跨类不可见
    }
}

示例三：缺省的类

package com.atguigu.test01.access1;
class Mother {
}

package com.atguigu.test01.access1;
public class Daughter extends Mother{
}

package com.atguigu.test01.other;
//Mother类是缺省的，跨包不能使用
public class Daughter extends Mother{
}

示例四：公共的类缺省的构造器，跨包使用问题

package com.atguigu.test01.access1;
public class Fu {
    Fu(){
    }
}

package com.atguigu.test01.access1;
public class Zi extends Fu{
}

package com.atguigu.test01.other;
import com.atguigu.test01.access1.Fu;
public class Zi extends Fu{
    Zi() {
        super();
    }
}

package com.atguigu.test01.access1;
public class Neighbor {
    public static void main(String[] args) {
        Fu f = new Fu();
    }
}

package com.atguigu.test01.other;
import com.atguigu.test01.access1.Fu;
public class AnotherNeighbor {
    public static void main(String[] args) {
        Fu f = new Fu();
    }
}

6.1.2 成员变量/属性私有化问题

成员变量（field）私有化之后，提供标准的get/set方法，我们把这种成员变量也称为属性（property）。或者可以说只要能通过get/set操作的就是事物的属性，哪怕它没有对应的成员变量。

1、成员变量封装的目的

• 隐藏类的实现细节
• 让使用者只能通过事先预定的方法来访问数据，从而可以在该方法里面加入控制逻辑，限制对成员变量的不合理访问。还可以进行数据检查，从而有利于保证对象信息的完整性。
• 便于修改，提高代码的可维护性。主要说的是隐藏的部分，在内部修改了，如果其对外可以的访问方式不变的话，外部根本感觉不到它的修改。例如：Java8->Java9，String从char[]转为byte[]内部实现，而对外的方法不变，我们使用者根本感觉不到它内部的修改。

2、实现步骤

1. 使用 private 修饰成员变量

private 数据类型 变量名 ；

代码如下：

public class Chinese {
    private static String country;
    private String name;
      private int age;
    private boolean marry;
}

1. 提供 getXxx方法 / setXxx 方法，可以访问成员变量，代码如下：

public class Chinese {
      private static String country;
    private String name;
      private int age;
    private boolean marry;
    public static void setCountry(String c){
        country = c;
    }
    public static String getCountry(){
        return country;
    }
    public void setName(String n) {
        name = n;
    }
    public String getName() {
        return name;
    }
    public void setAge(int a) {
        age = a;
    }
    public int getAge() {
        return age;
    }
    public void setMarry(boolean m){
        marry = m;
    }
    public boolean isMarry(){
        return marry;
    }
}

3、如何解决局部变量与成员变量同名问题

当局部变量与类变量（静态成员变量）同名时，在类变量前面加“类名.”；

当局部变量与实例变量（非静态成员变量）同名时，在实例变量前面加“this.”

public class Chinese {
      private static String country;
    private String name;
      private int age;
    public static void setCountry(String country){
        Chinese.country = country;
    }
    public static String getCountry(){
        return country;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
}

4、 练习

（1）定义矩形类Rectangle，

声明静态变量sides，初始化为4，表示矩形边长的总数量；
声明实例变量长和宽
全部私有化，并提供相应的get/set方法

（2）在测试类中创建Rectangle对象，并调用相应的方法测试

（2）测试类ObjectArrayTest的main中创建一个可以装3个学生对象的数组，并且按照学生成绩排序，显示学生信息

6.2 构造器（Constructor)

我们发现我们new完对象时，所有成员变量都是默认值，如果我们需要赋别的值，需要挨个为它们再赋值，太麻烦了。我们能不能在new对象时，直接为当前对象的某个或所有成员变量直接赋值呢。

可以，Java给我们提供了构造器。

1、构造器的作用

在创建对象的时候为实例变量赋初始值。

注意：构造器只为实例变量初始化，不为静态类变量初始化

2、构造器的语法格式

构造器又称为构造方法，那是因为它长的很像方法。但是和方法还有有所区别的。

【修饰符】 构造器名(){
    // 实例初始化代码
}
【修饰符】 构造器名(参数列表){
    // 实例初始化代码
}

代码如下：

public class Student {
    private String name;
    private int age;
    // 无参构造
      public Student() {} 
     // 有参构造
      public Student(String name,int age) {
        this.name = name;
        this.age = age; 
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

注意事项：

1. 构造器名必须与它所在的类名必须相同。
2. 它没有返回值，所以不需要返回值类型，甚至不需要void
3. 如果你不提供构造器，系统会给出无参数构造器，并且该构造器的修饰符默认与类的修饰符相同
4. 如果你提供了构造器，系统将不再提供无参数构造器，除非你自己定义。
5. 构造器是可以重载的，既可以定义参数，也可以不定义参数。
6. 构造器的修饰符只能是权限修饰符，不能被其他任何修饰

3、练习

（1）声明一个员工类，

• 包含属性：编号、姓名、薪资、性别，要求属性私有化，提供get/set，
• 提供无参构造器和有参构造器
• 提供getInfo()

（2）在测试类的main中分别用无参构造和有参构造创建员工类对象，调用getInfo

public class TestEmployee {
    public static void main(String[] args){
        //分别用无参构造和有参构造创建对象，调用getInfo
        Employee e1 = new Employee();
        System.out.println(e1.getInfo());
        Employee e2 = new Employee("1001","张三",110000,'男');
        System.out.println(e2.getInfo());
        e2.setSalary(120000);
        System.out.println(e2.getInfo());
        System.out.println("e1薪资：" + e1.getSalary());
    }
}
class Employee{
    private String id;
    private String name;
    private double salary;
    private char gender;
    //提供无参构造器和有参构造器
    public Employee(){
    }
    public Employee(String id, String name){
        this.id = id;
        this.name = name;
    }
    public Employee(String id, String name, double salary, char gender){
        this.id = id;
        this.name = name;
        this.salary = salary;
        this.gender = gender;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    public char getGender() {
        return gender;
    }
    public void setGender(char gender) {
        this.gender = gender;
    }
    //提供getInfo()
    public String getInfo(){
        return "编号：" + id + "，姓名：" + name + "，薪资：" + salary + "，性别：" +gender;
    }
}

6.3 标准JavaBean

JavaBean 是 Java语言编写类的一种标准规范。符合JavaBean 的类，要求：

（1）类必须是具体的和公共的，

（2）并且具有无参数的构造方法，

（3）成员变量私有化，并提供用来操作成员变量的set 和get 方法。

public class ClassName{
  //成员变量
  //构造方法
      //无参构造方法【必须】
      //有参构造方法【建议】
  //getXxx()
  //setXxx()
  //其他成员方法
}

编写符合JavaBean 规范的类，以学生类为例，标准代码如下：

public class Student {
    // 成员变量
    private String name;
    private int age;
    // 构造方法
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // get/set成员方法
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    //其他成员方法列表
    public String getInfo(){
        return "姓名：" + name + "，年龄：" + age;
    }
}

测试类，代码如下：

public class TestStudent {
    public static void main(String[] args) {
        // 无参构造使用
        Student s = new Student();
        s.setName("柳岩");
        s.setAge(18);
        System.out.println(s.getName() + "---" + s.getAge());
        System.out.println(s.getInfo());
        // 带参构造使用
        Student s2 = new Student("赵丽颖", 18);
        System.out.println(s2.getName() + "---" + s2.getAge());
        System.out.println(s2.getInfo());
    }
}

6.4 继承

6.4.1 继承的概述

生活中的继承

• 财产：富二代

• 样貌：如图所示：
  
  
  

• 才华：如图所示：
  

继承的由来

如图所示：

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类中无需再定义这些属性和行为，只需要和抽取出来的类构成某种关系。如图所示：

其中，多个类可以称为子类，也叫派生类；多个类抽取出来的这个类称为父类、超类（superclass）或者基类。

继承描述的是事物之间的所属关系，这种关系是：is-a 的关系。例如，图中猫属于动物，狗也属于动物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。

继承的好处

• 提高代码的复用性。

• 提高代码的扩展性。

• 类与类之间产生了关系，是学习多态的前提。

6.4.2 继承的格式

通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

【修饰符】 class 父类 {
    ...
}
【修饰符】 class 子类 extends 父类 {
    ...
}

继承演示，代码如下：

/*
 * 定义动物类Animal，做为父类
 */
class Animal {
    // 定义name属性
    String name; 
    // 定义age属性
    int age;
    // 定义动物的吃东西方法
    public void eat() {
        System.out.println(age + "岁的" + name + "在吃东西");
    }
}
/*
 * 定义猫类Cat 继承 动物类Animal
 */
class Cat extends Animal {
    // 定义一个猫抓老鼠的方法catchMouse
    public void catchMouse() {
        System.out.println("抓老鼠");
    }
}
/*
 * 定义测试类
 */
public class ExtendDemo01 {
    public static void main(String[] args) {
        // 创建一个猫类对象
        Cat cat = new Cat()；
        // 为该猫类对象的name属性进行赋值
        cat.name = "Tom";
          // 为该猫类对象的age属性进行赋值
        cat.age = 2;
        // 调用该猫的catchMouse()方法
        cat.catchMouse();
          // 调用该猫继承来的eat()方法
          cat.eat();
    }
}
演示结果：
抓老鼠
2岁的Tom在吃东西

6.4.3 继承的特点一：成员变量

1、父类成员变量私有化（private）

• 父类中的成员，无论是公有(public)还是私有(private)，均会被子类继承。
• 子类虽会继承父类私有(private)的成员，但子类不能对继承的私有成员直接进行访问，可通过继承的get/set方法进行访问。如图所示：

代码如下：

/*
 * 定义动物类Animal，做为父类
 */
class Animal {
    // 定义name属性
    private String name; 
    // 定义age属性
    public int age;
    // 定义动物的吃东西方法
    public void eat() {
        System.out.println(age + "岁的" + name + "在吃东西");
    }
}
/*
 * 定义猫类Cat 继承 动物类Animal
 */
class Cat extends Animal {
    // 定义一个猫抓老鼠的方法catchMouse
    public void catchMouse() {
        System.out.println("抓老鼠");
    }
}
/*
 * 定义测试类
 */
public class ExtendDemo01 {
    public static void main(String[] args) {
        // 创建一个猫类对象
        Cat cat = new Cat()；
        // 为该猫类对象的name属性进行赋值
        //cat.name = "Tom";// 编译报错
          // 为该猫类对象的age属性进行赋值
        cat.age = 2;
        // 调用该猫的catchMouse()方法
        cat.catchMouse();
          // 调用该猫继承来的eat()方法
          cat.eat();
    }
}

如图所示：

eclipse中Debug查看对象成员变量值的情况截图如下：

idea中Debug查看对象成员变量值的情况截图如下：

2、父子类成员变量重名

我们说父类的所有成员变量都会继承到子类中，那么如果子类出现与父类同名的成员变量会怎么样呢？

父类代码：

public class Father {
    public int i=1;
    private int j=1;
    public int k=1;
    public int getJ() {
        return j;
    }
    public void setJ(int j) {
        this.j = j;
    }
}

子类代码：

public class Son extends Father{
    public int i=2;
    private int j=2;
    public int m=2;
}

现在想要在子类Son中声明一个test()方法，并打印这些所有变量的值，该如何实现？

public class Son extends Father{
    public int i=2;
    private int j=2;
    public int m=2;
    public void test() {
        System.out.println("父类继承的i：" + super.i);
        System.out.println("子类的i：" +i);
//        System.out.println(super.j);
        System.out.println("父类继承的j：" +getJ());
        System.out.println("子类的j：" +j);
        System.out.println("父类继承的k：" +k);
        System.out.println("子类的m：" +m);
    }    
}

结论：

（1）当父类的成员变量私有化时，在子类中是无法直接访问的，所以是否重名不影响，如果想要访问父类的私有成员变量，只能通过父类的get/set方法访问；

（2）当父类的成员变量非私有时，在子类中可以直接访问，所以如果有重名时，就需要加“super.”进行区别。

使用格式：

super.父类成员变量名

以上test()调用结果：

public class TestSon{
    public static void main(String[] args){
        Son s = new Son();
        s.test();
    }
}

父类继承的i：1
子类的i：2
父类继承的j：1
子类的j：2
父类继承的k：1
子类的m：2

eclipse中Debug查看对象的成员变量的值截图如下：

idea中Debug查看对象的成员变量的值截图如下：

说明：虽然我们可以区分父子类的重名成员变量，但是实际开发中，我们不建议这么干。

6.4.4 继承的特点二：成员方法

我们说父类的所有方法子类都会继承，但是当某个方法被继承到子类之后，子类觉得父类原来的实现不适合于子类，该怎么办呢？我们可以进行方法重写 (Override)

1、方法重写

比如新的手机增加来电显示头像的功能，代码如下：

class Phone {
    public void sendMessage(){
        System.out.println("发短信");
    }
    public void call(){
        System.out.println("打电话");
    }
    public void showNum(){
        System.out.println("来电显示号码");
    }
}
//智能手机类
class NewPhone extends Phone {
    //重写父类的来电显示号码功能，并增加自己的显示姓名和图片功能
    public void showNum(){
        //调用父类已经存在的功能使用super
        super.showNum();
        //增加自己特有显示姓名和图片功能
        System.out.println("显示来电姓名");
        System.out.println("显示头像");
    }
}
public class ExtendsDemo06 {
    public static void main(String[] args) {
          // 创建子类对象
          NewPhone np = new NewPhone()；
        // 调用父类继承而来的方法
        np.call();
          // 调用子类重写的方法
          np.showNum();
    }
}

小贴士：这里重写时，用到super.父类成员方法，表示调用父类的成员方法。

注意事项：

1.@Override：写在方法上面，用来检测是不是有效的正确覆盖重写。这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。建议保留

2.必须保证父子类之间方法的名称相同，参数列表也相同。
3.子类方法的返回值类型必须【小于等于】父类方法的返回值类型（小于其实就是是它的子类，例如：Student < Person）。

注意：如果返回值类型是基本数据类型和void，那么必须是相同

4.子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示：public > protected > 缺省 > private

5.几种特殊的方法不能被重写

• 静态方法不能被重写
• 私有等在子类中不可见的方法不能被重写
• final方法不能被重写

2、方法的重载

（1）同一个类中

class Test{
    public int max(int a, int b){
        return a > b ? a : b;
    }
    public double max(double a, double b){
        return a > b ? a : b;
    }
    public int max(int a, int b,int c){
        return max(max(a,b),c);
    }
}

（2）父子类中

class Father{
    public void print(int i){
        System.out.println("i = " + i);
    }
}
class Son extends Father{
    public void print(int i,int j){
        System.out.println("i = " + i  ",j = " + j);
    }
}

对于Son类，相当于有两个print方法，一个形参列表是(int i)，一个形参列表(int i, int j)

6.4.5 继承的特点三：构造方法

当类之间产生了关系，其中各类中的构造方法，又产生了哪些影响呢？

首先我们要回忆两个事情，构造方法的定义格式和作用。

1. 构造方法的名字是与类名一致的。
   所以子类是无法继承父类构造方法的。

2. 构造方法的作用是初始化实例变量的，而子类又会从父类继承所有成员变量
   所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个super() ，表示调用父类的实例初始化方法，父类成员变量初始化后，才可以给子类使用。代码如下：

class Fu {
  private int n;
  Fu(){
    System.out.println("Fu()");
  }
}
class Zi extends Fu {
  Zi(){
    // super（），调用父类构造方法
    super();
    System.out.println("Zi（）");
  }  
}
public class ExtendsDemo07{
  public static void main (String args[]){
    Zi zi = new Zi();
  }
}
输出结果：
Fu（）
Zi（）

如果父类没有无参构造怎么办？

public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //其他成员方法省略
}

public class Student extends Person{
    private int score;
}

此时子类代码报错。

解决办法：在子类构造器中，用super(实参列表)，显示调用父类的有参构造解决。

public class Student extends Person{
    private int score;
    public Student(String name, int age) {
        super(name, age);
    }
    public Student(String name, int age, int score) {
        super(name, age);
        this.score = score;
    }
    //其他成员方法省略
}

结论：

子类对象实例化过程中必须先完成从父类继承的成员变量的实例初始化，这个过程是通过调用父类的实例初始化方法来完成的。

• super()：表示调用父类的无参实例初始化方法，要求父类必须有无参构造，而且可以省略不写；
• super(实参列表)：表示调用父类的有参实例初始化方法，当父类没有无参构造时，子类的构造器首行必须写super(实参列表)来明确调用父类的哪个有参构造（其实是调用该构造器对应的实例初始方法）
• super()和super(实参列表)都只能出现在子类构造器的首行

形式一：

class A{
}
class B extends A{
}
class Test{
    public static void main(String[] args){
        B b = new B();
        //A类和B类都是默认有一个无参构造，B类的默认无参构造中还会默认调用A类的默认无参构造
        //但是因为都是默认的，没有打印语句，看不出来
    }
}

形式二：

class A{
    A(){
        System.out.println("A类无参构造器");
    }
}
class B extends A{
}
class Test{
    public static void main(String[] args){
        B b = new B();
        //A类显示声明一个无参构造，
        //B类默认有一个无参构造，
        //B类的默认无参构造中会默认调用A类的无参构造
        //可以看到会输出“A类无参构造器"
    }
}

形式三：

class A{
    A(){
        System.out.println("A类无参构造器");
    }
}
class B extends A{
    B(){
        System.out.println("B类无参构造器");
    }
}
class Test{
    public static void main(String[] args){
        B b = new B();
        //A类显示声明一个无参构造，
        //B类显示声明一个无参构造，        
        //B类的无参构造中虽然没有写super()，但是仍然会默认调用A类的无参构造
        //可以看到会输出“A类无参构造器"和"B类无参构造器")
    }
}

形式四：

class A{
    A(){
        System.out.println("A类无参构造器");
    }
}
class B extends A{
    B(){
        super();
        System.out.println("B类无参构造器");
    }
}
class Test{
    public static void main(String[] args){
        B b = new B();
        //A类显示声明一个无参构造，
        //B类显示声明一个无参构造，        
        //B类的无参构造中明确写了super()，表示调用A类的无参构造
        //可以看到会输出“A类无参构造器"和"B类无参构造器")
    }
}

形式五：

class A{
    A(int a){
        System.out.println("A类有参构造器");
    }
}
class B extends A{
    B(){
        System.out.println("B类无参构造器");
    }
}
class Test05{
    public static void main(String[] args){
        B b = new B();
        //A类显示声明一个有参构造，没有写无参构造，那么A类就没有无参构造了
        //B类显示声明一个无参构造，        
        //B类的无参构造没有写super(...)，表示默认调用A类的无参构造
        //编译报错，因为A类没有无参构造
    }
}

形式六：

class A{
    A(int a){
        System.out.println("A类有参构造器");
    }
}
class B extends A{
    B(){
        super();
        System.out.println("B类无参构造器");
    }
}
class Test06{
    public static void main(String[] args){
        B b = new B();
        //A类显示声明一个有参构造，没有写无参构造，那么A类就没有无参构造了
        //B类显示声明一个无参构造，        
        //B类的无参构造明确写super()，表示调用A类的无参构造
        //编译报错，因为A类没有无参构造
    }
}

形式七：

class A{
    A(int a){
        System.out.println("A类有参构造器");
    }
}
class B extends A{
    B(int a){
        super(a);
        System.out.println("B类有参构造器");
    }
}
class Test07{
    public static void main(String[] args){
        B b = new B(10);
        //A类显示声明一个有参构造，没有写无参构造，那么A类就没有无参构造了
        //B类显示声明一个有参构造，        
        //B类的有参构造明确写super(a)，表示调用A类的有参构造
        //会打印“A类有参构造器"和"B类有参构造器"
    }
}

形式八：

class A{
    A(){
        System.out.println("A类无参构造器");
    }
    A(int a){
        System.out.println("A类有参构造器");
    }
}
class B extends A{
    B（）{
        super();//可以省略，调用父类的无参构造
        System.out.println("B类无参构造器");
    }
    B(int a){
        super(a);//调用父类有参构造
        System.out.println("B类有参构造器");
    }
}
class Test8{
    public static void main(String[] args){
        B b1 = new B();
        B b2 = new B(10);
    }
}

6.4.6 继承的特点四：单继承限制

1. Java只支持单继承，不支持多继承。

//一个类只能有一个父类，不可以有多个父类。
class C extends A{}     //ok
class C extends A，B...    //error

1. Java支持多层继承(继承体系)。

class A{}
class B extends A{}
class C extends B{}

顶层父类是Object类。所有的类默认继承Object，作为父类。

1. 子类和父类是一种相对的概念。
   例如：B类对于A来说是子类，但是对于C类来说是父类

2. 一个父类可以同时拥有多个子类

6.4.7 继承练习

练习1

（1）父类Graphic图形
包含属性：name（图形名），属性私有化，不提供无参构造，只提供有参构造
包含求面积getArea()：返回0.0
求周长getPerimeter()方法：返回0.0
显示信息getInfo()方法：返回图形名称、面积、周长

（2）子类Circle圆继承Graphic图形
包含属性：radius
重写求面积getArea()和求周长getPerimeter()方法，显示信息getInfo()加半径信息

（3）子类矩形Rectange继承Graphic图形
包含属性：length、width
重写求面积getArea()和求周长getPerimeter()方法

public class Graphic {
    private String name;
    public Graphic(String name) {
        super();
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getArea() {
        return 0.0;
    }
    public double getPerimeter() {
        return 0.0;
    }
    /*
     * this对象：调用当前方法的对象，如果是Graphic对象，那么就会执行Graphic的getArea()和getPerimeter()
     * this对象：调用当前方法的对象，如果是Circle对象，那么就会执行Circle的getArea()和getPerimeter()
     * this对象：调用当前方法的对象，如果是Rectangle对象，那么就会执行Rectangle的getArea()和getPerimeter()
     */
    public String getInfo() {
        return "图形：" + name + "，面积：" + getArea() + ",周长：" + getPerimeter();
    }
}

public class Circle extends Graphic {
    private double radius;
    public Circle(String name, double radius) {
        super(name);
        this.radius = radius;
    }
    public double getRadius() {
        return radius;
    }
    public void setRadius(double radius) {
        this.radius = radius;
    }
    @Override//表示这个方法是重写的方法
    public double getArea() {
        return Math.PI * radius * radius;
    }
    @Override//表示这个方法是重写的方法
    public double getPerimeter() {
        return Math.PI * radius * 2;
    }
    /*@Override//表示这个方法是重写的方法
    public String getInfo() {
        return super.getInfo() + "，半径：" + radius;
    }*/
}

public class Rectangle extends Graphic {
    private double length;
    private double width;
    public Rectangle(String name, double length, double width) {
        super(name);
        this.length = length;
        this.width = width;
    }
    public double getLength() {
        return length;
    }
    public void setLength(double length) {
        this.length = length;
    }
    public double getWidth() {
        return width;
    }
    public void setWidth(double width) {
        this.width = width;
    }
    @Override
    public double getArea() {
        return length*width;
    }
    @Override
    public double getPerimeter() {
        return 2*(length + width);
    }
}

public class TestGraphicExer3 {
    public static void main(String[] args) {
        Graphic g = new Graphic("通用图形");
        System.out.println(g.getInfo());
        Circle c = new Circle("圆", 1.2);
        System.out.println(c.getInfo());//调用getInfo()方法的对象是c
        Rectangle r = new Rectangle("矩形", 3, 5);
        System.out.println(r.getInfo());
    }
}

练习2

（1）声明一个银行储蓄卡类，

包含属性：账户，余额
包含取款 public void withdraw(double money)
        存款 pubic void save(double money)
       获取账户信息： public String getInfo() 可以返回账户和余额

（2）声明一个银行信用卡类，继承储蓄卡类

增加属性：可透支额度，最多可透支金额
重写存款 public void withdraw(double money)，可透支
       存款 pubic void save(double money)，需要恢复可透支额度

（3）在测试类中，分别创建两种卡对象，测试

练习3

1、声明父类：Person类
包含属性：姓名，年龄，性别
属性私有化，get/set
包含getInfo()方法：例如：姓名：张三，年龄：23，性别：男

2、声明子类：Student类，继承Person类
新增属性：score成绩
属性私有化，get/set
包含getInfo()方法：例如：姓名：张三，年龄：23，性别：男，成绩：89

3、声明子类：Teacher类，继承Person类
新增属性：salary薪资
属性私有化，get/set
包含getInfo()方法：例如：姓名：张三，年龄：23，性别：男，薪资：10000

public class Person {
    private String name;
    private int age;
    private char gender;
    public Person(String name, int age, char gender) {
        super();
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    public Person() {
        super();
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public char getGender() {
        return gender;
    }
    public void setGender(char gender) {
        this.gender = gender;
    }
    //包含getInfo()方法：例如：姓名：张三，年龄：23，性别：男
    public String getInfo(){
        return "姓名：" + name + "，年龄：" + age +"，性别：" + gender;
    }
}

public class Student extends Person {
    private int score;
    public Student() {
    }
    public Student(String name, int age, char gender, int score) {
        setName(name);
        setAge(age);
        setGender(gender);
        this.score = score;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    //包含getInfo()方法：例如：姓名：张三，年龄：23，性别：男，成绩：89
    public String getInfo(){
        //方式一：
//        return "姓名：" + getName() + "，年龄：" + getAge() + "，成绩：" + score;
        //方法二：
        return super.getInfo() + "，成绩：" + score;
    }
}

public class Teacher extends Person {
    private double salary;
    public Teacher() {
    }
    public Teacher(String name, int age, char gender, double salary) {
        setName(name);
        setAge(age);
        setGender(gender);
        this.salary = salary;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    //包含getInfo()方法：例如：姓名：张三，年龄：23，性别：男，薪资：10000
    public String getInfo(){
        return super.getInfo() + "，薪资：" + salary;
    }
}