Java基础 - 11继承和方法重写 - 《JAVA共享》

继承和方法重写

继承和方法重写

1. 继承

继承是Java中实现代码重用的重要手段之一。Java中只支持单根继承，即一个类只能有一个直接父类.。子类与父类是is-a的关系，子类是父类父子类信息编写原则：父类中编写共有的属性和行为子类中编写独有的属性和行为

package com.qfedu.test1;
/**
 *     父类：宠物类
 *     用于记录两个宠物共同有的属性 和 行为
 * 
 *     子类与父类是is-a的关系 子类是父类 (狗是宠物，企鹅是宠物)
 *     父子类信息编写原则：    
 *         父类中编写共有的属性和行为
 *         子类中编写独有的属性和行为
 * @author WHD
 *
 */
public class Pet {
    private String name;
    private int health;
    private int love;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getHealth() {
        return health;
    }
    public void setHealth(int health) {
        this.health = health;
    }
    public int getLove() {
        return love;
    }
    public void setLove(int love) {
        this.love = love;
    }
    public void print() {
        System.out.println("宠物的名字是" + name + "，健康值是" + health + "，爱心值是" + love);
    }
}

package com.qfedu.test1;
/**
 *     狗类
 *         名字
 *         健康值
 *         爱心值
 *         品种
 *     打印狗狗信息
 * @author WHD
 *
 */
public class Dog extends Pet{
    private String strain;
    public String getStrain() {
        return strain;
    }
    public void setStrain(String strain) {
        this.strain = strain;
    }
    public Dog() {}
}

package com.qfedu.test1;
/**
 *     企鹅类
 *         名字
 *         健康值
 *         爱心值
 *         性别
 *     打印信息
 * @author WHD
 *
 */
public class Penguin extends Pet{
    private String sex;
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Penguin() {}
}

package com.qfedu.test1;
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("大黄");// Pet继承而来的
        dog.setHealth(100);// Pet继承而来的
        dog.setLove(100); // Pet继承而来的
        dog.setStrain("哈士奇"); // Dog类编写的
        dog.print();
        // 调用从父类继承而来的print方法打印信息 发现以下两个问题：
        // 1.打印信息身份不准确
        // 2.打印信息不具体
        System.out.println("===============================================");
        Penguin p1 = new Penguin();
        p1.setName("大白");// Pet继承而来的
        p1.setLove(100);// Pet继承而来的
        p1.setHealth(100);// Pet继承而来的
        p1.setSex("雌"); // Penguin类编写的
        System.out.println(p1.getName());
        System.out.println(p1.getHealth());
        System.out.println(p1.getLove());
        System.out.println(p1.getSex());
        p1.print();
    }
}

2. super关键字

super关键字：表示父类对象可以访问，父类访问权限允许的方法属性构造方法

package com.qfedu.test2;
/**
 *     父类：宠物类
 *         名字
 *         健康值
 *         爱心值
 * 
 *     super关键字：表示父类对象
 *     可以访问，父类访问权限允许的
 *         方法
 *         属性
 *         构造方法
 * @author WHD
 *
 */
public class Pet {
    protected String name;
    protected int health;
    protected int love;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getHealth() {
        return health;
    }
    public void setHealth(int health) {
        this.health = health;
    }
    public int getLove() {
        return love;
    }
    public void setLove(int love) {
        this.love = love;
    }
    public void print() {
        System.out.println("宠物的名字是" + name + "，健康值是" + health + "，爱心值是" + love);
    }
}

package com.qfedu.test2;
/**
 *     狗类
 *         品种
 *     打印狗狗信息
 * @author WHD
 *
 */
public class Dog extends Pet{
    private String strain;
    public String getStrain() {
        return strain;
    }
    public void setStrain(String strain) {
        this.strain = strain;
    }
    public Dog() {}
    public void printDog() {
        super.print();
        System.out.println("狗狗的品种是" + strain);
    }
    public Dog(String name,int health,int love,String strain) {
        this.strain = strain;
        super.name = name;
        super.health = health;
        super.love = love;
    }
}

package com.qfedu.test2;
public class Test {
    public static void main(String[] args) {
        Dog dog =  new Dog();
        dog.setName("大黄");
        dog.setHealth(100);
        dog.setLove(100);
        dog.setStrain("金毛");
//        dog.print();
        dog.printDog();
        System.out.println("===========================");
        Penguin p1 = new Penguin();
        p1.setName("大白");
        p1.setLove(100);
        p1.setHealth(100);
        p1.setSex("雌"); 
        p1.printPenguin();
        System.out.println("===========================");
        Dog dog1 = new Dog("小黑", 100, 100, "金毛");
        dog1.printDog();
    }
}

super关键字：表示父类对象构造方法创建子类对象时，默认调用父类的无参构造方法除非子类显式的调用父类的有参构造方法子类必须调用父类的构造方法无参或者有参必须调用一个

package com.qfedu.test5;
/**
 *     父类：宠物类
 *         名字
 *         健康值
 *         爱心值
 *     
 * @author WHD
 *
 */
public class Pet {
    protected String name;
    protected int health;
    protected int love;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getHealth() {
        return health;
    }
    public void setHealth(int health) {
        this.health = health;
    }
    public int getLove() {
        return love;
    }
    public void setLove(int love) {
        this.love = love;
    }
    public Pet(String name,int health,int love) {
        this.name = name;
        this.health = health;
        this.love = love;
    }
    /**
     *     父类中推荐都提供无参 方便子类使用
     */
    public Pet() {}
    public void print() {
        System.out.println("宠物的名字是" + name + "，健康值是" + health + "，爱心值是" + love);
    }    
}

package com.qfedu.test5;
/**
 *     狗类
 *         品种
 *     打印狗狗信息
 * @author WHD
 *
 */
public class Dog extends Pet{
    private String strain;
    public String getStrain() {
        return strain;
    }
    public void setStrain(String strain) {
        this.strain = strain;
    }
    public void printDog() {
        print();
        System.out.println("狗狗的品种是" + strain);
    }
    /**
     *     因为父类的无参构造被覆盖了 所以Dog子类报错
     *     解决方案：编写有参构造调用父类的有参  不再调用无参
     * @param name
     * @param health
     * @param love
     * @param strain
     */
    public Dog(String name,int health,int love,String strain) {
        super(name, health, love);
        this.strain = strain;
    }
}

package com.qfedu.test5;
/**
 *     企鹅类
 *         性别
 *     打印信息
 * @author WHD
 *
 */
public class Penguin extends Pet{
    private String sex;
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public void printPenguin() {
        super.print(); // 继承自父类的方法 可以使用super加点 或者this加点 或者直接书写 方法名
        System.out.println("企鹅的性别是" + sex);
    }
}

3. 方法重写

1.父子类之间的 2.方法名称相同 3.参数列表相同 4.访问权限不能严于父类不能窄化父类的访问权限 5.返回值相同或者是其子类 6.父类的静态方法可以被继承但是不能被重写非静态方法不能重写为静态方法 7.不能抛出比父类更多的异常

@Override注解此注解可以用于子类的方法上表示此方法为重写父类的方法如果没有符合以上重写的规则那么将编译报错

package com.qfedu.test6;
/**
 *     狗类
 *         品种
 *     打印狗狗信息
 * @author WHD
 *
 */
public class Dog extends Pet{
    private String strain;
    public String getStrain() {
        return strain;
    }
    public void setStrain(String strain) {
        this.strain = strain;
    }
    /**
     *     方法重写
     *     1.父子类之间的
     *     2.方法名称相同
     *     3.参数列表相同
     *     4.访问权限不能严于父类 不能窄化父类的访问权限
     *     5.返回值相同     或者是其子类
     * 
     *     6.父类的静态方法可以被继承 但是不能被重写 非静态方法不能重写为静态方法
     *     7.不能抛出比父类更多的异常
     */
    @Override
    public  void print() {
        super.print();
        System.out.println("狗狗的品种是" + strain);
    }
    public static void m1() {
    }
    public Dog(String name,int health,int love,String strain) {
        super(name, health, love);
        this.strain = strain;
    }
}

4.Object类

Object是所有的类的父类，所有的类将默认继承自此类此类中提供了一些常用的方法，实际开发中我们经常重写这些方法

4.1 重写toString方法

我们直接打印一个对象将默认调用此对象的toString方法，返回值为包名类名+@+哈希值如果我们不想要这个效果，可以重写toString方法

package com.qfedu.test7;
/**
 *     学生类
 *     名字
 *     年龄
 * @author WHD
 *
 */
public class Student{
    private String name;
    private int 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;
    }
    public String toString() {
        String str = super.toString();
        return "Student[name=" + name + ",age=" + age + "]" + str;
    }
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setName("赵四");
        stu.setAge(17);
        System.out.println(stu.getName());
        System.out.println(stu.getAge());
        System.out.println(stu); // 直接打印一个对象将调用从父类继承而来的toString方法
        System.out.println(stu.toString()); 
    }
}