Java 类的继承

类的继承

继承的特点

1.减少你的代码量

2.让类与类之间 产生关联(产生 父子的关系)

继承使用关键字: extends

注意:

1. 继承时 可以把多个类中 相同的功能或方法 抽取出来

重新构造一个类出来 把这些类 建立继承关系

2.建立继承关系的同时 一定要符合逻辑(切记不要为继承而继承)

继承的写法

class 子类 extend 父类{

}

举例

/*
 * 猫类
 * 姓名 颜色 种类 会睡觉 会抓老鼠 
 *
 * 狗类
 * 姓名 颜色 种类 会睡觉 会啃骨头
 *
 * 抽取出 相同的部分 组成 动物类
 */

class Animal{
    String name;
    String color;
    String kind;

    // 会睡觉
    public void sleep() {
        System.out.println("睡觉");
    }
}

class Cat extends Animal{
    // 抓老鼠
    public void hitMouse() {
        System.out.println("会抓老鼠");
    }

}
class Dog extends Animal{
    // 啃骨头
    public void eat() {
        System.out.println("会啃骨头");
    }   
}

// 测试一下
public class Demo {
    public static void main(String[] args) {
        // 创建一个猫
        // 子类继承了父类 方法 和 属性
        Cat cat = new Cat();
        cat.name = "汤姆";
        cat.kind = "灰猫";
        cat.hitMouse();
        cat.sleep();


    }
}

Java中的继承

注意:

1. java 只允许 单继承 (多继承可以使用接口来间接实现)

2. java 中 允许 多层继承

---

java中 最顶层父类(最基础类)Object类

如果我这个类 没有写 继承哪个父类 默认就是继承Object类

---

1. 如果我要使用 这些类中 共有的方法(属性) 使用哪个类 ?

创建 当前继承中 最顶端类 去使用

2. 如果我要使用 这些类中 特有的方法(属性) 使用哪个类 ?

创建 当前继承中 最底端类 去使用

构造方法

构造方法不能被继承

为了保证继承完整性 在你创建子类对象的时候

如果你不调用父类的构造方法 那么

系统会默认帮你调用 父类无参构造方法

super 关键字

super 代表是 父类的对象

super 调用对象 super点对象

调方法 super点方法();

super(); 调用的父类构造方法

this(); 调用的是本类的构造方法

---

思考: 如果父类 和 子类的方法 能不能重名?

可以 (方法重写)

注意:

1.方法声明完全一致的 叫方法重写

2.方法的重写 建立在 类与类之前有继承关系(子类重写父类的方法)

---

Override(重写)和Overload(重载) 的区别

1.重写前提: 需要继承关系

重载: 在同一个类中

2.重写 需要方法的声明 完全一致

重载 只能参数 有关

public class Phone {
    public static void main(String[] args) {
        IOS8 ios8 = new IOS8();
        ios8.siri();
        // 如果直接打印对象 相当于 系统会帮你
        // 在打印时 调用toString()方法
        // 希望能直接打印出来 对象属性值
        System.out.println(ios8);
        System.out.println(ios8.toString());
    }
}
class IOS7 extends Object{
    public void call() {
        System.out.println("打电话");
    }
    public void siri() {
        System.out.println("说英文");
    }

}

class IOS8 extends IOS7 {

    @Override
    public void siri() {
        super.siri();
    }


    /*
    // 方法的重写:对父类的方法 进行一个功能上的升级
    public void siri() {
        // 中英文 都会说
        super.siri(); // 调用父类的方法
        System.out.println("说中文");
    }
    */

    // 重写toString()方法
    // 利用toString方法 来写 介绍自己的方法
    @Override
    public String toString() {

        return "haha";
    }

}

---

举例 :

/*
 * 老师类 学生类  
 * 无参 有参构造 set/get方法 成员变量私有化 介绍自己的方法
 *  属性:姓名,年龄
 * 行为:吃饭
 * 老师有特有的方法:讲课
 * 学生有特有的方法:学习
 */

public class Demo {
    public static void main(String[] args) {
        // 创建一个学生
        Student student = new Student("张三", 12, 3);
        System.out.println(student);

        Teacher teacher = new Teacher("李四", 32);
        System.out.println(teacher);
    }
}
class People{
    // 继承中 private 修饰的变量 是不能直接访问的
    private String name; // 姓名
    private int age; // 年龄

    // 无参 有参
    public People(){
    }
    public People(String name,int age) {
        this.age = age;
        this.name = name;
    }

    // set/get
    public String getName() {
        return this.name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return this.age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    // 吃饭
    public void eat() {
        System.out.println("吃饭");
    }

    // 介绍
    public String toString() {
        return "姓名: " + name+ " 年龄: " + age;
    }
}

class Teacher extends People{

    public Teacher() {}
    public Teacher(String name,int age) {
        super(name, age);
    }   



}

class Student extends People{
    private int num = 0 ;

    public Student() {

    }
    public Student(String name,int age ,int num) {
        // 直接调用父类的构造方法 完成初始化
        // 为了保证继承的完整性 在子类的构造方法中
        // 第一行 必须调用父类的构造方法(无参有参都行)
        super(name, age);
        // 特有属性 直接赋值就行
        this.num = num;
    }
    // 介绍自己的方法
    @Override
    public String toString() {
        // 可以在父类的基础上 添加直接特有的属性去打印
        return super.toString() + " 学号:" + num;
    }
}