继承

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

  1. classs  类1  extends  类2
  2. {     
  3.        //代码
  4. }

继承的好处：

  1. 提高代码的复用性（减少代码冗余，相同代码重复利用）。

  2. 使类与类之间产生了关系。

    继承中的特点：

  3. Java只支持单继承，不支持多继承

    单继承：一个子类只能有一个父类。支持 多继承：一个子类可以有多个父类。不支持

  1. class C extends A{}     //ok
  2. class C extends A，B...    //error
  1. Java支持多重继承(继承体系)。
    1. class A{}
    2. class B extends A{}
    3. class C extends B{}

    方法重写：

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

  1. 1）旧手机功能：基本的打电话，发信息
  3.     2）新手功功能：基本的打电话下支持视频通话，基本的发信息下支持发送语音和图片。
  5. 定义旧手机类，实现打电话，发信息功能。定义新手机类继承老手机，重写打电话和发信息功能。
  6.   package com.itheima.sh.d_extends_04;//1.定义一个旧手机类public class OldPhone {    //2.在旧手机类中定义打电话    public void call(){        System.out.println("旧手机只能打电话");    }    //和发短信功能    public void sendMessage(){        System.out.println("旧手机只能发短信");    }}package com.itheima.sh.d_extends_04;// 3.定义一个新手机类继承旧手机public class NewPhone extends OldPhone{    //4.在子类即新手机类中对旧手机的打电话和发短信功能进行重写即重新编写    //书写要重写的方法名回车    @Override    public void call() {        //调用的是父类的功能        super.call();        System.out.println("新手机除了打电话还可以视频通话");    }    @Override    public void sendMessage() {        //调用的是父类的功能        super.sendMessage();        System.out.println("新手机除了发短信还可以发图片");    }}package com.itheima.sh.d_extends_04;/*    步骤：    1.定义一个旧手机类    2.在旧手机类中定义打电话和发短信功能    3.定义一个新手机类继承旧手机    4.在子类即新手机类中对旧手机的打电话和发短信功能进行重写即重新编写    5.在测试类中创建子类对象，使用对象调用方法 */public class Test01 {    public static void main(String[] args) {        //5.在测试类中创建子类对象，使用对象调用方法        NewPhone np = new NewPhone();        np.call();        np.sendMessage();    }}

@Override重写注解

  • Override:注解，重写注解校验！
  • 这个注解标记的方法，就说明这个方法必须是重写父类的方法，否则编译阶段报错。
  • 建议重写都加上这个注解，一方面可以提高代码的可读性，一方面可以防止重写出错！

注意事项

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

继承后的特点—构造器

引入

  1. 构造器的名字是与类名一致的。所以子类是无法继承父类构造方法的。
  2. 构造器的作用是初始化对象成员变量数据的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。（先有爸爸，才能有儿子）
  1. 需求：
  3. 根据以下代码画图说明子父类构造函数的特点。
  5. 1）创建一个子类Zi和一个父类Fu,让这个子类来继承这个Fu类；
  7. 2）在Fu类中定义一个成员变量x并赋值为3，然后创建Fu类构造代码块，在这个Fu类代码块中打印x的值；
  9. 3）在Fu类中定义一个一般函数show，也打印x的值；
  11. 4）在Fu类中定义一个无参构造函数，随便打印一句话；
  13. 5）在Zi类中定义一个成员变量y并赋值为10，同样定义一个构造代码块，分别写两个打印语句打印x和y的值；
  15. 6）在子类中复写父类中show函数，并写两句语句，分别打印x和y的值；
  17. 7）在子类中定义一个构造函数，使用super()调用父类无参构造函数，在子类构造函数中打印一句话，调用show函数；
  19. 8）定义一个测试类ConstructorDemo ，在这个类中创建Zi类的对象；
  22. //继承中的构造函数细节
  23. class Fu
  24. {
  25.     int x = 3;
  26.     {
  27.         System.out.println("Fu  构造代码块  x="+x);
  28.     }
  29.     Fu()
  30.     {
  31.         //super();
  32.         System.out.println("Fu的构造函数执行");
  33.     }
  34.     void show()
  35.     {
  36.         System.out.println("Fu show x="+x);
  37.     }
  38. }
  39. class Zi extends Fu
  40. {
  41.     int y = 10;
  42.     {
  43.         System.out.println("Zi 的构造代码块  x="+x);
  44.         System.out.println("Zi 的构造代码块  y="+y);
  45.     }
  46.     Zi()
  47.     {
  48.         super();
  49.         System.out.println("Zi的构造函数执行。。。。。");
  50.         show();
  51.     }
  52.     void show()
  53.     {
  54.         System.out.println("Zi show x="+x);
  55.         System.out.println("Zi show y="+y);
  56.     }
  57. }
  59. class ConstructorDemo 
  60. {
  61.     public static void main(String[] args) 
  62.     {
  63.         Zi z = new Zi();
  64.     }
  65. }

super(…)和this(…)

super和this的用法格式：

this.成员变量 — 本类的 super.成员变量 — 父类的
this.成员方法名() — 本类的
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(..)是根据参数去确定调用父类哪个构造器的。

super(…)案例图解

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

2-1595472214874.jpg

this(…)用法演示

this(…)

  • 默认是去找本类中的其他构造器，根据参数来确定具体调用哪一个构造器。

  • 为了借用其他构造器的功能。 ```java package com.itheima._08this和super调用构造器; class Student{ private String name ; private int age ; private char sex ;

    public Student() { // 很弱，我的兄弟很牛逼啊，我可以调用其他构造器：Student(String name, int age, char sex)

    1.   this("徐干",21,'男');

    }

    public Student(String name, int age, char sex) {

    1.   this.name = name ;
    2.   this.age = age   ;
    3.   this.sex = sex   ;

    }

    public String getName() {

    1.   return name;

    }

    public void setName(String name) {

    1.   this.name = name;

    }

    public int getAge() {

    1.   return age;

    }

    public void setAge(int age) {

    1.   this.age = age;

    }

    public char getSex() {

    1.   return sex;

    }

    public void setSex(char sex) {

    1.   this.sex = sex;

    } }

/**

  • this(…):
  • 默认是去找本类中的其他构造器，根据参数来确定具体调用哪一个构造器。
  • 为了借用其他构造器的功能。 / public class ThisDemo01 { public static void main(String[] args) { Student xuGan = new Student(); System.out.println(xuGan.getName()); // 输出:徐干 System.out.println(xuGan.getAge());// 输出:21 System.out.println(xuGan.getSex());// 输出： 男 } }
  1. ```java
  2. - 子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。
  3. - super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。
  4. - super(..)和this(...)是根据参数去确定调用父类哪个构造器的。
  5. - super(..)可以调用父类构造器初始化继承自父类的成员变量的数据。
  6. - this(..)可以调用本类中的其他构造器。