今日内容

  • 复习回顾
    • 定义类。一个Java文件可以定义多个类。但是只有一个类是用public修饰，public修饰的类名必须称为Java文件名。
    • 类中有且仅有5大成分（五大金刚）
      • 成员变量Field：描述类或者对象的属性信息的。
      • 成员方法Method：描述类或者对象的行为的。
      • 构造器（构造方法,Constructor）: 初始化类的一个对象返回。
      • 代码块：还没有学。
      • 内部类：还没有学。
    • 封装
      • 面向对象的三大特征之一：封装，继承，多态。
      • 形成了规范，即使毫无意义还是会这样写代码！
      • 合理隐藏，合理暴露。
      • 封装的规范：成员变量私有，方法一般公开，提供成套的getter和setter方法暴露成员变量的取值和赋值。
      • 封装的作用：提高安全性，提高代码的组件化思想。
      • 封装已经成为Java代码的规范，即使毫无意义，我们也要这样写代码（成员变量私有，方法公开）
    • this关键字
      • this代表了当前对象的引用。
      • this可以出现在构造器和方法中。
      • this出现在构造器中代表构造器正在初始化的对象。
      • this出现在方法中，哪个对象调用方法，this就代表哪个对象。
      • this可以访问对象的成员变量，区分成员变量是局部的还是对象中的成员变量。
  • static关键字.
    • 静态。
    • 修饰方法和变量都是属于类的。没有static修饰的方法和变量是属于每个对象的。
  • 继承
    • 是面向对象的三大特征：封装，继承，多态。

教学目标

  • 能够写出类的继承格式
  • 子类 extends 父类{
  • }
  • 能够说出继承的特点
  • 类是单继承的，可以多层继承，可以有多个子类。
  • 能够区分this和super的作用
  • this代表本类对象引用
  • this.本类成员变量
  • this.本类方法
  • this(…):访问兄弟构造器
  • super代表父类对象引用。
  • super.父类变量
  • super.父类方法
  • super(…):访问父类构造器
  • 能够说出方法重写的概念
  • 方法重写：子类写一个方法覆盖父类的方法，子类以后用自己重写的方法。
  • 能够说出方法重写的注意事项
  • 1.重写方法的名称和形参列表要与父类被重写方法一致。
  • 2.重写方法的权限要与父类一样或者更大。 public > protected > 缺省 > private
  • 能够掌握static关键字修饰的变量调用方式
  • 类名.静态变量
  • 对象.静态变量 （不推荐使用）
  • 能够掌握static关键字修饰的方法调用方式
  • 类名.静态方法
  • 对象.静态方法（不推荐使用）

第一章 复习回顾

1.1 如何定义类

类的定义格式如下:

  1. 修饰符 class 类名{
  2.     // 类中的五大成分。
  3.     // 1.成员变量（属性）
  4.     // 2.成员方法 (行为) 
  5.     // 3.构造器 （初始化类的对象数据的）
  6.     // 4.内部类
  7.     // 5.代码块
  8. }

例如:

  1. public class Student {
  2.     // 1.成员变量
  3.     public String name ;
  4.     public char sex ; // '男'  '女'
  5.     public int age;
  6. }

1.2 如何通过类创建对象

  1. 类名 对象名称 = new 类名();

例如:

  1. Student stu = new Student();

1.3 封装

1.3.1 封装的步骤

1.使用 private 关键字来修饰成员变量。

2.使用public修饰getter和setter方法。

1.3.2 封装的步骤实现

  1. private修饰成员变量
  1. public class Student {
  2.     private String name;
  3.     private int age;
  4. }
  1. public修饰getter和setter方法
  1. public class Student {
  2.     private String name;
  3.     private int age;
  5.     public void setName(String n) {
  6.           name = n;
  7.     }
  9.     public String getName() {
  10.           return name;
  11.     }
  13.     public void setAge(int a) {
  14.         if (a > 0 && a <200) {
  15.             age = a;
  16.         } else {
  17.             System.out.println("年龄非法！");
  18.         }
  19.     }
  21.     public int getAge() {
  22.           return age;
  23.     }
  24. }

1.4 构造器

1.4.1 构造器的作用

通过调用构造器可以返回一个类的对象，构造器同时负责帮我们把对象的数据（属性和行为等信息）初始化好。

1.4.2 构造器的格式

  1. 修饰符 类名(形参列表) {
  2.     // 构造体代码，执行代码
  3. }

1.4.3 构造器的应用

首先定义一个学生类，代码如下：

  1. public class Student {
  2.     // 1.成员变量
  3.     public String name;
  4.     public int age;
  6.     // 2.构造器
  7.     public Student() {
  8.         System.out.println("无参数构造器被调用")；
  9.     }
  10. }

接下来通过调用构造器得到两个学生对象。

  1. public class CreateStu02 {
  2.     public static void main(String[] args) {
  3.         // 创建一个学生对象
  4.         // 类名 变量名称 = new 类名();
  5.         Student s1 = new Student();
  6.         // 使用对象访问成员变量，赋值
  7.         s1.name = "张三";
  8.         s1.age = 20 ;
  10.         // 使用对象访问成员变量 输出值
  11.         System.out.println(s1.name);
  12.         System.out.println(s1.age); 
  14.         Student s2 = new Student();
  15.         // 使用对象访问成员变量 赋值
  16.         s2.name = "李四";
  17.         s2.age = 18 ;
  18.         System.out.println(s2.name);
  19.         System.out.println(s2.age);
  20.     }
  21. }

1.5 this关键字的作用

1.5.1 this关键字的作用

this代表所在类的当前对象的引用（地址值），即代表当前对象。

1.5.2 this关键字的应用

1.5.2.1 用于普通的gettter与setter方法

this出现在实例方法中，谁调用这个方法（哪个对象调用这个方法），this就代表谁（this就代表哪个对象）。

  1. public class Student {
  2.     private String name;
  3.     private int age;
  5.     public void setName(String name) {
  6.           this.name = name;
  7.     }
  9.     public String getName() {
  10.           return name;
  11.     }
  13.     public void setAge(int age) {
  14.         if (age > 0 && age < 200) {
  15.             this.age = age;
  16.         } else {
  17.             System.out.println("年龄非法！");
  18.         }
  19.     }
  21.     public int getAge() {
  22.           return age;
  23.     }
  24. }

1.5.2.2 用于构造器中

this出现在构造器中，代表构造器正在初始化的那个对象。

  1. public class Student {
  2.     private String name;
  3.     private int age;
  5.     // 无参数构造方法
  6.     public Student() {} 
  8.     // 有参数构造方法
  9.     public Student(String name,int age) {
  10.         this.name = name;
  11.         this.age = age; 
  12.     }
  13. }

第二章 static关键字

2.1 概述

以前我们定义过如下类：

  1. public class Student {
  2.     // 成员变量
  3.     public String name;
  4.     public char sex; // '男'  '女'
  5.     public int age;
  7.     // 无参数构造器
  8.     public Student() {
  10.     }
  12.     // 有参数构造器
  13.     public Student(String  a) {
  15.     }
  16. }

我们已经知道面向对象中，存在类和对象的概念，我们在类中定义了一些成员变量，例如name,age,sex ,结果发现这些成员变量，每个对象都存在（因为每个对象都可以访问）。

而像name ,age , sex确实是每个学生对象都应该有的属性，应该属于每个对象。

所以Java中成员（变量和方法）等是存在所属性的，Java是通过static关键字来区分的。static关键字在Java开发非常的重要，对于理解面向对象非常关键。

关于 static 关键字的使用，它可以用来修饰的成员变量和成员方法，被static修饰的成员是属于类的是放在静态区中，没有static修饰的成员变量和方法则是属于对象的。我们上面案例中的成员变量都是没有static修饰的，所以属于每个对象。

2.2 定义格式和使用

static是静态的意思。 static可以修饰成员变量或者修饰方法。

2.2.1 静态变量及其访问

有static修饰成员变量，说明这个成员变量是属于类的，这个成员变量称为类变量或者静态成员变量。 直接用 类名访问即可。因为类只有一个，所以静态成员变量在内存区域中也只存在一份。所有的对象都可以共享这个变量。

如何使用呢

例如现在我们需要定义传智全部的学生类，那么这些学生类的对象的学校属性应该都是“传智”，这个时候我们可以把这个属性定义成static修饰的静态成员变量。

定义格式

  1. 修饰符 static 数据类型 变量名 = 初始值；

举例

  1. public class Student {
  2.     public static String schoolName = "传智播客"； // 属于类，只有一份。
  3.     // .....
  4. }

静态成员变量的访问:

格式：类名.静态变量

  1. public static void  main(String[] args){
  2.     System.out.println(Student.schoolName); // 传智播客
  3.     Student.schoolName = "黑马程序员";
  4.     System.out.println(Student.schoolName); // 黑马程序员
  5. }

2.2.2 实例变量及其访问

无static修饰的成员变量属于每个对象的， 这个成员变量叫实例变量，之前我们写成员变量就是实例成员变量。

需要注意的是：实例成员变量属于每个对象，必须创建类的对象才可以访问。

格式：对象.实例成员变量

2.2.3 静态方法及其访问

有static修饰成员方法，说明这个成员方法是属于类的，这个成员方法称为类方法或者静态方法**。 直接用 类名访问即可。因为类只有一个，所以静态方法在内存区域中也只存在一份。所有的对象都可以共享这个方法。

与静态成员变量一样，静态方法也是直接通过类名.方法名称即可访问。

举例

  1. public class Student{
  2.     public static String schoolName = "传智播客"； // 属于类，只有一份。
  3.     // .....
  4.     public static void study(){
  5.         System.out.println("我们都在黑马程序员学习");   
  6.     }
  7. }

静态成员变量的访问:

格式：类名.静态方法

  1. public static void  main(String[] args){
  2.     Student.study();
  3. }

2.2.4 实例方法及其访问

无static修饰的成员方法属于每个对象的， 这个成员方法叫实例方法。

需要注意的是：实例方法是属于每个对象，必须创建类的对象才可以访问。

格式：对象.实例方法

示例：

  1. public class Student {
  2.     // 实例变量
  3.     private String name ;
  4.     // 2.方法：行为
  5.     // 无 static修饰，实例方法。属于每个对象，必须创建对象调用
  6.     public void run(){
  7.         System.out.println("学生可以跑步");
  8.     }
  9.     // 无 static修饰，实例方法
  10.     public  void sleep(){
  11.         System.out.println("学生睡觉");
  12.     }
  13.     public static void study(){
  15.     }
  16. }
  1. public static void main(String[] args){
  2.     // 创建对象 
  3.     Student stu = new Student ;
  4.     stu.name = "徐干";
  5.     // Student.sleep();// 报错，必须用对象访问。
  6.     stu.sleep();
  7.     stu.run();
  8. }

2.3 小结

1.当 static 修饰成员变量或者成员方法时，该变量称为静态变量，该方法称为静态方法。该类的每个对象都共享同一个类的静态变量和静态方法。任何对象都可以更改该静态变量的值或者访问静态方法。但是不推荐这种方式去访问。因为静态变量或者静态方法直接通过类名访问即可，完全没有必要用对象去访问。

2.无static修饰的成员变量或者成员方法，称为实例变量，实例方法，实例变量和实例方法必须创建类的对象，然后通过对象来访问。

3.static修饰的成员属于类，会存储在静态区，是随着类的加载而加载的，且只加载一次，所以只有一份，节省内存。存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。它优先于对象存在，所以，可以被所有对象共享。

4.无static修饰的成员，是属于对象，对象有多少个，他们就会出现多少份。所以必须由对象调用。

第三章 继承

3.1 概述

3.1.1 引入

假如我们要定义如下类:
学生类,老师类和工人类，分析如下。

  1. 学生类
    属性:姓名,年龄
    行为:吃饭,睡觉
  2. 老师类
    属性:姓名,年龄，薪水
    行为:吃饭,睡觉，教书
  3. 班主任
    属性:姓名,年龄，薪水
    行为:吃饭,睡觉，管理

如果我们定义了这三个类去开发一个系统，那么这三个类中就存在大量重复的信息（属性:姓名，年龄。行为：吃饭，睡觉）。这样就导致了相同代码大量重复，代码显得很臃肿和冗余，那么如何解决呢？

假如多个类中存在相同属性和行为时，我们可以将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。如图所示：
1.jpg

其中，多个类可以称为子类，单独被继承的那一个类称为父类、超类（superclass）或者基类。

3.1.2 继承的含义

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

继承：就是子类继承父类的属性和行为，使得子类对象可以直接具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

3.1.3 继承的好处

  1. 提高代码的复用性（减少代码冗余，相同代码重复利用）。
  2. 使类与类之间产生了关系。

3.2 继承的格式

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

  1. class 父类 {
  2.     ...
  3. }
  5. class 子类 extends 父类 {
  6.     ...
  7. }

需要注意：Java是单继承的，一个类只能继承一个直接父类，跟现实世界很像，但是Java中的子类是更加强大的。

3.3 继承案例

3.3.1 案例

请使用继承定义以下类:

  1. 学生类
    属性:姓名,年龄
    行为:吃饭,睡觉
  2. 老师类
    属性:姓名,年龄，薪水
    行为:吃饭,睡觉，教书
  3. 班主任
    属性:姓名,年龄，薪水
    行为:吃饭,睡觉，管理

3.3.2 案例图解分析

老师类，学生类，还有班主任类，实际上都是属于人类的，我们可以定义一个人类，把他们相同的属性和行为都定义在人类中，然后继承人类即可，子类特有的属性和行为就定义在子类中了。

如下图所示。

360截图20181202211331250.jpg

3.3.3 案例代码实现

1.父类Human类

  1. public class Human {
  2.   // 合理隐藏
  3.   private String name ;
  4.   private int age ;
  6.   // 合理暴露
  7.   public String getName() {
  8.       return name;
  9.   }
  11.   public void setName(String name) {
  12.       this.name = name;
  13.   }
  15.   public int getAge() {
  16.       return age;
  17.   }
  19.   public void setAge(int age) {
  20.       this.age = age;
  21.   }
  22. }

2.子类Teacher类

  1. public class Teacher extends Human {
  2.   // 工资
  3.   private double salary ;
  5.   // 特有方法
  6.   public void teach(){
  7.       System.out.println("老师在认真教技术！")；
  8.   }
  10.   public double getSalary() {
  11.       return salary;
  12.   }
  14.   public void setSalary(double salary) {
  15.       this.salary = salary;
  16.   }
  17. }

3.子类Student类

  1. public class Student extends Human{
  3. }

4.子类BanZhuren类

  1. public class Teacher extends Human {
  2.     // 工资
  3.     private double salary ;
  5.        // 特有方法
  6.     public void admin(){
  7.         System.out.println("班主任强调纪律问题！")；
  8.     }
  10.     public double getSalary() {
  11.         return salary;
  12.     }
  14.     public void setSalary(double salary) {
  15.         this.salary = salary;
  16.     }
  17. }

5.测试类

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Teacher dlei = new Teacher();
  4.         dlei.setName("播仔");
  5.         dlei.setAge("31");
  6.         dlei.setSalary(1000.99);
  7.         System.out.println(dlei.getName());
  8.         System.out.println(dlei.getAge());
  9.         System.out.println(dlei.getSalary());
  10.         dlei.teach();
  12.         BanZhuRen linTao = new BanZhuRen();
  13.         linTao.setName("灵涛");
  14.         linTao.setAge("28");
  15.         linTao.setSalary(1000.99);
  16.         System.out.println(linTao.getName());
  17.         System.out.println(linTao.getAge());
  18.         System.out.println(linTao.getSalary());
  19.         linTao.admin();
  21.         Student xugan = new Student();
  22.         xugan.setName("播仔");
  23.         xugan.setAge("31");
  24.         //xugan.setSalary(1000.99); // xugan没有薪水属性，报错！
  25.         System.out.println(xugan.getName());
  26.         System.out.println(xugan.getAge());
  30.     }
  31. }

3.3.4 小结

1.继承实际上是子类相同的属性和行为可以定义在父类中，子类特有的属性和行为由自己定义，这样就实现了相同属性和行为的重复利用，从而提高了代码复用。

2.子类继承父类，就可以直接得到父类的成员变量和方法。是否可以继承所有成分呢？请看下节！

3.4 子类不能继承的内容

3.4.1 引入

并不是父类的所有内容都可以给子类继承的：

子类不能继承父类的构造器，因为子类有自己的构造器。

值得注意的是子类可以继承父类的私有成员（成员变量，方法），只是子类无法直接访问而已，可以通过getter/setter方法访问父类的private成员变量。

3.4.1 演示代码

  1. public class Demo03 {
  2.     public static void main(String[] args) {
  3.         Zi z = new Zi();
  4.         System.out.println(z.num1);
  5. //        System.out.println(z.num2); // 私有的子类无法使用
  6.         // 通过getter/setter方法访问父类的private成员变量
  7.         System.out.println(z.getNum2());
  9.         z.show1();
  10.         // z.show2(); // 私有的子类无法使用
  11.     }
  12. }
  14. class Fu {
  15.     public int num1 = 10;
  16.     private int num2 = 20;
  18.     public void show1() {
  19.         System.out.println("show1");
  20.     }
  22.     private void show2() {
  23.         System.out.println("show2");
  24.     }
  26.     public int getNum2() {
  27.         return num2;
  28.     }
  30.     public void setNum2(int num2) {
  31.         this.num2 = num2;
  32.     }
  33. }
  35. class Zi extends Fu {
  36. }

3.5 继承后的特点—成员变量

当类之间产生了继承关系后，其中各类中的成员变量，又产生了哪些影响呢？

3.5.1 成员变量不重名

如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。代码如下：

  1. class Fu {
  2.     // Fu中的成员变量
  3.     int num = 5;
  4. }
  5. class Zi extends Fu {
  6.     // Zi中的成员变量
  7.     int num2 = 6;
  9.     // Zi中的成员方法
  10.     public void show() {
  11.         // 访问父类中的num
  12.         System.out.println("Fu num="+num); // 继承而来，所以直接访问。
  13.         // 访问子类中的num2
  14.         System.out.println("Zi num2="+num2);
  15.     }
  16. }
  17. class Demo04 {
  18.     public static void main(String[] args) {
  19.         // 创建子类对象
  20.         Zi z = new Zi(); 
  21.           // 调用子类中的show方法
  22.         z.show();  
  23.     }
  24. }
  26. 演示结果：
  27. Fu num = 5
  28. Zi num2 = 6

3.5.2 成员变量重名

如果子类父类中出现重名的成员变量，这时的访问是有影响的。代码如下：

  1. class Fu1 {
  2.     // Fu中的成员变量。
  3.     int num = 5;
  4. }
  5. class Zi1 extends Fu1 {
  6.     // Zi中的成员变量
  7.     int num = 6;
  9.     public void show() {
  10.         // 访问父类中的num
  11.         System.out.println("Fu num=" + num);
  12.         // 访问子类中的num
  13.         System.out.println("Zi num=" + num);
  14.     }
  15. }
  16. class Demo04 {
  17.     public static void main(String[] args) {
  18.           // 创建子类对象
  19.         Zi1 z = new Zi1(); 
  20.           // 调用子类中的show方法
  21.         z1.show(); 
  22.     }
  23. }
  24. 演示结果：
  25. Fu num = 6
  26. Zi num = 6

子父类中出现了同名的成员变量时，子类会优先访问自己对象中的成员变量。如果此时想访问父类成员变量如何解决呢？我们可以使用super关键字。

3.5.3 super访问父类成员变量

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用super 关键字，修饰父类成员变量，类似于之前学过的 this 。

需要注意的是：super代表的是父类对象的引用，this代表的是当前对象的引用。

使用格式：

  1. super.父类成员变量名

子类方法需要修改，代码如下：

  1. class Fu {
  2.     // Fu中的成员变量。
  3.     int num = 5;
  4. }
  6. class Zi extends Fu {
  7.     // Zi中的成员变量
  8.     int num = 6;
  10.     public void show() {
  11.         int num = 1;
  13.         // 访问方法中的num
  14.         System.out.println("method num=" + num);
  15.         // 访问子类中的num
  16.         System.out.println("Zi num=" + this.num);
  17.         // 访问父类中的num
  18.         System.out.println("Fu num=" + super.num);
  19.     }
  20. }
  22. class Demo04 {
  23.     public static void main(String[] args) {
  24.           // 创建子类对象
  25.         Zi1 z = new Zi1(); 
  26.           // 调用子类中的show方法
  27.         z1.show(); 
  28.     }
  29. }
  31. 演示结果：
  32. method num=1
  33. Zi num=6
  34. Fu num=5

小贴士：Fu 类中的成员变量是非私有的，子类中可以直接访问。若Fu 类中的成员变量私有了，子类是不能直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员变量呢？对！可以在父类中提供公共的getXxx方法和setXxx方法。

3.6 继承后的特点—成员方法

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

3.6.1 成员方法不重名

如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。代码如下：

  1. class Fu {
  2.     public void show() {
  3.         System.out.println("Fu类中的show方法执行");
  4.     }
  5. }
  6. class Zi extends Fu {
  7.     public void show2() {
  8.         System.out.println("Zi类中的show2方法执行");
  9.     }
  10. }
  11. public  class Demo05 {
  12.     public static void main(String[] args) {
  13.         Zi z = new Zi();
  14.          //子类中没有show方法，但是可以找到父类方法去执行
  15.         z.show(); 
  16.         z.show2();
  17.     }
  18. }

3.6.2 成员方法重名

如果子类父类中出现重名的成员方法，则创建子类对象调用该方法的时候，子类对象会优先调用自己的方法。

代码如下：

  1. class Fu {
  2.     public void show() {
  3.         System.out.println("Fu show");
  4.     }
  5. }
  6. class Zi extends Fu {
  7.     //子类重写了父类的show方法
  8.     public void show() {
  9.         System.out.println("Zi show");
  10.     }
  11. }
  12. public class ExtendsDemo05{
  13.     public static void main(String[] args) {
  14.         Zi z = new Zi();
  15.          // 子类中有show方法，只执行重写后的show方法
  16.         z.show();  // Zi show
  17.     }
  18. }

3.7 方法重写

3.7.1 概念

方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

3.7.2 使用场景与案例

发生在子父类之间的关系。
子类继承了父类的方法，但是子类觉得父类的这方法不足以满足自己的需求，子类重新写了一个与父类同名的方法，以便覆盖父类的该方 法。

例如：我们定义了一个动物类代码如下：

  1. public class Animal  {
  2.     public void run(){
  3.         System.out.println("动物跑的很快！");
  4.     }
  5.     public void cry(){
  6.         System.out.println("动物都可以叫~~~");
  7.     }
  8. }

然后定义一个猫类，猫可能认为父类cry()方法不能满足自己的需求

代码如下：

  1. public class Cat extends Animal {
  2.     public void cry(){
  3.         System.out.println("我们一起学猫叫，喵喵喵！喵的非常好听！");
  4.     }
  5. }
  7. public class Test {
  8.     public static void main(String[] args) {
  9.           // 创建子类对象
  10.           Cat ddm = new Cat()；
  11.         // 调用父类继承而来的方法
  12.         ddm.run();
  13.           // 调用子类重写的方法
  14.           ddm.cry();
  15.     }
  16. }

3.7.2 @Override重写注解

  • @Override:注解，重写注解校验！
  • 这个注解标记的方法，就说明这个方法必须是重写父类的方法，否则编译阶段报错。
  • 建议重写都加上这个注解，一方面可以提高代码的可读性，一方面可以防止重写出错！
    加上后的子类代码形式如下： 
    1. public class Cat extends Animal {
    2.   // 声明不变，重新实现
    3.  // 方法名称与父类全部一样，只是方法体中的功能重写写了！
    4.  @Override
    5.  public void cry(){
    6.      System.out.println("我们一起学猫叫，喵喵喵！喵的非常好听！");
    7.  }
    8. }

3.7.3 注意事项

  1. 方法重写是发生在子父类之间的关系。
  2. 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
  3. 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。

3.8 继承后的特点—构造器

3.8.1 引入

当类之间产生了关系，其中各类中的构造器，又产生了哪些影响呢？
首先我们要回忆两个事情，构造器的定义格式和作用。

  1. 构造器的名字是与类名一致的。所以子类是无法继承父类构造方法的。
  2. 构造器的作用是初始化对象成员变量数据的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。（先有爸爸，才能有儿子）

继承后子类构造器特点:子类所有构造器的第一行都会先调用父类的无参构造器，再执行自己

3.8.2 案例演示

按如下需求定义类:

  1. 人类
    成员变量: 姓名,年龄
    成员方法: 吃饭
  2. 学生类
    成员变量: 姓名,年龄,成绩
    成员方法: 吃饭

代码如下：

  1. class Person {
  2.     private String name;
  3.     private int age;
  5.     public Person() {
  6.         System.out.println("父类无参");
  7.     }
  9.     // getter/setter省略
  10. }
  12. class Student extends Person {
  13.     private double score;
  15.     public Student() {
  16.         //super(); // 调用父类无参,默认就存在，可以不写，必须再第一行
  17.         System.out.println("子类无参");
  18.     }
  20.      public Student(double score) {
  21.         //super();  // 调用父类无参,默认就存在，可以不写，必须再第一行
  22.         this.score = score;    
  23.         System.out.println("子类有参");
  24.      }
  26. }
  28. public class Demo07 {
  29.     public static void main(String[] args) {
  30.         Student s1 = new Student();
  31.         System.out.println("----------");
  32.         Student s2 = new Student(99.9);
  33.     }
  34. }
  36. 输出结果：
  37. 父类无参
  38. 子类无参
  39. ----------
  40. 父类无参
  41. 子类有参

3.8.3 小结

  • 子类构造器执行的时候，都会在第一行默认先调用父类无参数构造器一次。
  • 子类构造器的第一行都隐含了一个super()去调用父类无参数构造器，super()可以省略不写。

3.9 super(…)和this(…)

3.9.1 引入

请看上节中的如下案例：

  1. class Person {
  2.     private String name;
  3.     private int age;
  5.     public Person() {
  6.         System.out.println("父类无参");
  7.     }
  9.     // getter/setter省略
  10. }
  12. class Student extends Person {
  13.     private double score;
  15.     public Student() {
  16.         //super(); // 调用父类无参构造器,默认就存在，可以不写，必须再第一行
  17.         System.out.println("子类无参");
  18.     }
  20.      public Student(double score) {
  21.         //super();  // 调用父类无参构造器,默认就存在，可以不写，必须再第一行
  22.         this.score = score;    
  23.         System.out.println("子类有参");
  24.      }
  25.       // getter/setter省略
  26. }
  28. public class Demo07 {
  29.     public static void main(String[] args) {
  30.         // 调用子类有参数构造器
  31.         Student s2 = new Student(99.9);
  32.         System.out.println(s2.getScore()); // 99.9
  33.         System.out.println(s2.getName()); // 输出 null
  34.         System.out.println(s2.getAge()); // 输出 0
  35.     }
  36. }

我们发现，子类有参数构造器只是初始化了自己对象中的成员变量score，而父类中的成员变量name和age依然是没有数据的，怎么解决这个问题呢，我们可以借助与super(…)去调用父类构造器，以便初始化继承自父类对象的name和age.

3.9.2 super和this的用法格式

super和this完整的用法如下，其中this，super访问成员我们已经接触过了。

  1. this.成员变量        --    本类的
  2. super.成员变量        --    父类的
  4. this.成员方法名()      --    本类的    
  5. super.成员方法名()   --    父类的

接下来我们使用调用构造器格式：

  1. super(...) -- 调用父类的构造器，根据参数匹配确认
  2. this(...) -- 调用本类的其他构造器，根据参数匹配确认

3.9.3 super(….)用法演示

代码如下：

  1. class Person {
  2.     private String name ="凤姐";
  3.     private int age = 20;
  5.     public Person() {
  6.         System.out.println("父类无参");
  7.     }
  9.     public Person(String name , int age){
  10.         this.name = name ;
  11.         this.age = age ;
  12.     }
  14.     // getter/setter省略
  15. }
  17. class Student extends Person {
  18.     private double score = 100;
  20.     public Student() {
  21.         //super(); // 调用父类无参构造器,默认就存在，可以不写，必须再第一行
  22.         System.out.println("子类无参");
  23.     }
  25.      public Student(String name ， int age，double score) {
  26.         super(name ,age);// 调用父类有参构造器Person(String name , int age)初始化name和age
  27.         this.score = score;    
  28.         System.out.println("子类有参");
  29.      }
  30.       // getter/setter省略
  31. }
  33. public class Demo07 {
  34.     public static void main(String[] args) {
  35.         // 调用子类有参数构造器
  36.         Student s2 = new Student("张三"，20，99);
  37.         System.out.println(s2.getScore()); // 99
  38.         System.out.println(s2.getName()); // 输出 张三
  39.         System.out.println(s2.getAge()); // 输出 20
  40.     }
  41. }

注意：

子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。

super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

super(..)是根据参数去确定调用父类哪个构造器的。

3.9.4 super(…)案例图解

父类空间优先于子类对象产生

在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造七调用时，一定先调用父类的构造器。理解图解如下：

继承练习分析.jpg

3.9.5 this(…)用法演示

this(…)

  • 默认是去找本类中的其他构造器，根据参数来确定具体调用哪一个构造器。
  • 为了借用其他构造器的功能。
  1. package com.zsy._08this和super调用构造器;
  2. /**
  3.  * this(...):
  4.  *    默认是去找本类中的其他构造器，根据参数来确定具体调用哪一个构造器。
  5.  *    为了借用其他构造器的功能。
  6.  *
  7.  */
  8. public class ThisDemo01 {
  9.     public static void main(String[] args) {
  10.         Student xuGan = new Student();
  11.         System.out.println(xuGan.getName()); // 输出:徐干
  12.         System.out.println(xuGan.getAge());// 输出:21
  13.         System.out.println(xuGan.getSex());// 输出： 男
  14.     }
  15. }
  17. class Student{
  18.     private String name ;
  19.     private int age ;
  20.     private char sex ;
  22.     public Student() {
  23.   // 很弱，我的兄弟很牛逼啊，我可以调用其他构造器：Student(String name, int age, char sex)
  24.         this("徐干",21,'男');
  25.     }
  27.     public Student(String name, int age, char sex) {
  28.         this.name = name ;
  29.         this.age = age   ;
  30.         this.sex = sex   ;
  31.     }
  33.     public String getName() {
  34.         return name;
  35.     }
  37.     public void setName(String name) {
  38.         this.name = name;
  39.     }
  41.     public int getAge() {
  42.         return age;
  43.     }
  45.     public void setAge(int age) {
  46.         this.age = age;
  47.     }
  49.     public char getSex() {
  50.         return sex;
  51.     }
  53.     public void setSex(char sex) {
  54.         this.sex = sex;
  55.     }
  56. }

3.9.6 小结

  • 子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。
  • super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。
  • super(..)和this(…)是根据参数去确定调用父类哪个构造器的。
  • super(..)可以调用父类构造器初始化继承自父类的成员变量的数据。
  • this(..)可以调用本类中的其他构造器。

3.10 继承的特点

  1. Java只支持单继承，不支持多继承。
  1. // 一个类只能有一个父类，不可以有多个父类。
  2. class A {}
  3. class B {}
  4. class C1 extends A {} // ok
  5. // class C2 extends A, B {} // error
  1. 一个类可以有多个子类。
  1. // A可以有多个子类
  2. class A {}
  3. class C1 extends A {}
  4. class C2 extends  A {}
  1. 可以多层继承。
  1. class A {}
  2. class C1 extends A {}
  3. class D extends C1 {}

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

第四章 引用类型使用小结(重点)

  1.     实际的开发中，引用类型的使用非常重要，也是非常普遍的。我们可以在理解基本类型的使用方式基础上，进一步去掌握引用类型的使用方式。基本类型可以作为成员变量、作为方法的参数、作为方法的返回值，那么当然引用类型也是可以的。在这我们使用两个例子 , 来学习一下。

4.1 引用类型作为方法参数和返回值

  1. public class Person{
  2.   public void eat(){
  3.     System.out.println("吃饭");
  4.   }
  5. }
  6. public class Test{
  7.   public static void main(String[] args){
  8.         method(new Person());
  9.            Person p = createPerson();
  10.   }
  12.   //引用类型作为方法参数,在前面笔记本案例中我们也使用了接口类型作为方法参数
  13.   pubic static void method(Person p){
  14.        p.eat();
  15.   }
  17.   //引用类型作为返回值
  18.   public static Person createPerson(){
  19.         return new Person();
  20.   }
  21. }

4.2 引用类型作为成员变量

  1. 我们每个人(Person)都有一个身份证(IDCard) , 为了表示这种关系 , 就需要在Person中定义一个IDCard的成员变量。定义Person类时，代码如下：
  1. class Person {
  2.     String name;//姓名
  3.     int age;//年龄
  4. }
  1. 使用使用`String` 类型表示姓名 , `int` 类型表示年龄。其实，`String`本身就是引用类型，我们往往忽略了它是引用类型。如果我们继续丰富这个类的定义，给`Person` 增加身份证号 , 身份证签发机关等属性，我们将如何编写呢？这时候就需要编写一个IDCard类了

定义IDCard(身份证)类，添加身份证号 , 签发地等属性：

  1. class IDCard {
  2.     String idNum;//身份证号
  3.     String authority;//签发地
  5.       //getter和setter方法
  6.       //...
  8.       //toString方法
  9.       //...
  10. }

修改Person类：

  1. public class Person {
  2.     String name;//姓名
  3.     int age;//年龄
  5.     IDCard idCard;//表示自己的身份证信息
  7.     //name和age的getter、setter方法
  8.     //...
  10.     public IDCard getIdCard() {
  11.         return idCard;
  12.     }
  14.     public void setIdCard(IDCard idCard) {
  15.         this.idCard = idCard;
  16.     }
  18.     @Override
  19.     public String toString() {
  20.         return "Person{" +
  21.                 "name='" + name + '\'' +
  22.                 ", age=" + age +
  23.                 ", idCard=" + idCard +
  24.                 '}';
  25.     }
  26. }

测试类：

  1. public class TestDemo {
  2.     public static void main(String[] args) {
  3.         //创建IDCard对象
  4.         IDCard idCard = new IDCard();
  5.         //设置身份证号
  6.         idCard.setIdNum("110113201606066666");
  7.         //设置签发地
  8.         idCard.setAuthority("北京市顺义区公安局");
  10.         //创建Person对象
  11.         Person p = new Person();
  12.         //设置姓名
  13.         p.setName("小顺子");
  14.         //设置年龄
  15.         p.setAge(2);
  16.         //设置身份证信息
  17.         p.setIdCard(idCard);
  19.         //打印小顺子的信息
  20.         System.out.println(p);
  21.     }
  22. }
  23. 输出结果:
  24. Person{name='小顺子', age=2, idCard=IDCard{idNum='110113201606066666', authority='北京市顺义区公安局'}}

类作为成员变量时，对它进行赋值的操作，实际上，是赋给它该类的一个对象。同理 , 接口也是如此 , 例如我们笔记本案例中使用usb设备。在此我们只是通过小例子 , 让大家熟识下引用类型的用法 , 后续在咱们的就业班学习中 , 这种方式会使用的很多。