11：继承

继承

继承的定义

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

继承的格式：

在Java中，使用extends关键字实现继承，extends后跟的是父类名，也就是它从哪个类继承过来的，而用extends的这个类本身称为子类。具体格式如下：

class 父类 {
}
 
class 子类 extends 父类 {
}

例：创建一个父类

package com.itlb.extend;

/**
 * 父类
 */
class Fu {
    //定义变量
    public String s = "这是父类的成员变量";

    //定义方法
    public void say(){
        System.out.println("这是父类的方法");
    };
}
/**
 * 子类
 */
public class Zi extends Fu {    //通过extends继承父类

    public static void main(String[] args) {
        Zi text = new Zi();
        System.out.println(text.s); //调用常量
        text.say();  //调用方法
    }
}

通过创建一个Application类来运行main主方法：

public class Application {
    public static void main(String[] args) {
        Zi text = new Zi();
        System.out.println(text.s); //调用常量
        text.say();  //调用方法
    }
}

运行结果：

这是父类的成员变量
这是父类的方法

继承的特点：

子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类。
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

继承的类型（如下图所示）

super关键字

可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

super有三种用法：

1、直接引用

与this类似，super相当于是指向当前对象的父类，这样就可以用super.xxx来引用父类的成员。

2、子类中的成员变量或方法与父类中的成员变量或方法同名。代码如下：

/**
 * 父类
 */
 class Fu {
    //定义变量
    public String s = "这是Fu的成员变量";

    //定义方法
    public void say(){
        System.out.println("这是Fu的方法");
    };
}
/**
 * 子类
 */
public class Zi extends Fu {
    String s = "这是Zi的成员变量";

    public void say(){
        System.out.println(this.s);   //调用子类常量
        System.out.println(super.s);   //调用父类常量
        System.out.println("这是Zi的方法");
        super.say();  //调用父类方法
    }

    //main方法
    public static void main(String[] args) {
        Zi text = new Zi();
        text.say();  //调用子类方法
    }
}

运行结果：

这是Zi的成员变量
这是Fu的成员变量
这是Zi的方法
这是Fu的方法

3、调用构造方法

/**
 * 父类
 */
 class Fu {
    //定义无参构造方法
    public Fu() {
        System.out.println("父类无参构造方法");
    }
    //定义有参构造方法
    public Fu(String str) {
        System.out.println("父类有参构造方法" + str);
    }
}
/**
 * 子类
 */
public class Zi extends Fu {

    public Zi() {
        super();   //super调用父类无参构造方法
    }

    public Zi(String str) {
        super(str);   //super调用父类有参构造方法
    }

    //main方法
    public static void main(String[] args) {
        Zi text = new Zi();
        text = new Zi(" Hello");


    }
}

运行结果：

父类无参构造方法
父类有参构造方法 Hello

super的注意点：

super 调用父类构造方法时，必须在构造方法的第一句；
super 只能出现在子类的方法或者构造方法中
super 与 this 不能同时使用构造方法

super 与 this 的区别

this 调用的是本类的这个对象；super 代表父类对象的应用
this 不需要继承便可以使用；super 只有在继承条件下在子类进行使用
this 调用的是本类的构造方法；super 调用的是父类的构造方法

重写

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

方法重写的规则：

  方法名称和参数列表必须相同。**可以使用@override检测是否重写成功**

  子类返回值范围必须【小于等于】父类返回值范围

  子类方法的权限必须【大于等于】父类的权限的修饰符

  修饰符权限：public>protected>(default)什么都不写，默认>private

例:

/**
 * 父类
 */
class Fu {
    public void say() {
        System.out.println("Fu类");
    }
}
/**
 * 子类
 */
public class Zi extends Fu {
    @Override  //注释：重写
    public void say() {      //重写只可以在非静态方法中进行
        System.out.println("Zi类");
    }

    //main方法
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.say();
        //父类的引用指向子类
        Fu fu = new Zi();   //子类重写了父类的方法；即子类的方法将父类的方法覆盖
        fu.say();
    }
}

运行结果：

Zi类
Zi类

final关键字

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：

声明类：

final class 类名 {
    //类体
}

声明方法：

修饰符(public/private/default/protected) final 返回值类型 方法名(){
    //方法体
}

注:实例变量也可以被定义为 final，被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final，但是实例变量并不是 final

posted @ 2021-08-01 00:01 Happy*^_^* 阅读(158) 评论(0) 收藏举报

刷新页面返回顶部

Happy^_^

11：继承

继承

继承的定义

super关键字

重写

final关键字

公告