Java(14)继承

1.继承（extends）

  1.1 继承：遗传

  1.2 语法

      public class 子类 extends 父类｛

｝

     public class Dog extends Pet{

}

public class Pet {
    private String name = "无名氏";
    private int health = 90;
    private int love = 0;
    public Pet(){
        this.health = 95;
        System.out.println("执行宠物的无参构造方法");
    }
    public Pet(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public int getHealth(){
        return health;
    }
    public int getLove(){
        return love;
    }
    public void ji(){
        System.out.println("宠物的自白：
我的名字叫"+this.name+",健康值是"+this.health
                +",和主人的亲密度是"+this.love+"。");
    }
}

public class Dog extends Pet{
    private String strain;
    public Dog(String name,String strain){
        //super(name);
        this.strain = strain;
    }
    public String getStrain(){
        return strain;
    }
    public void ji(){
        super.ji();
        System.out.println("我是一只"+this.strain);
    }
}

/*
 * 继承语法 
 * 修饰符 SubClass extends SuperClass{
 *         类定义部分
 * }
 * 继承通过extends关键字来实现，其中SubClass为子类，SuperClass为父类
 * 修饰符如果是public,则该类在整个项目中可见，若无public修饰符，则该类只在当前包可见
 * 不可以使用private和protected修饰类
 */
public class Penguin extends Pet {
    private String sex;
    //final String home = "南极";
//    public void setHome(String home){
//        this.home = home; // home不可以再次赋值
//    }
    public Penguin(String name,String sex){
        super(name);
        this.sex = sex;
    } 
    public String getSex(){
        return sex;
    }
    public void ji(){
        super.ji();
        System.out.println("性别是："+this.sex);
    }
}

/*
 * 方法的重写
 * 在子类中可以根据需求对父类继承的方法进行重新编写
 * 要求：重写方法和别重写方法必须具有相同的方法名
 * 必须具有相同的参数列表
 * 重写方法的返回值类型必须和被重写方法的返回值类型相同
 * 重写方法不能缩小被重写方法的访问权限
 */
public class TextDPP {
    public  static void main(String[] args){
        Pet pet = new Pet("吉吉");
        pet.ji();
        Dog dog = new Dog("狗狗","雪狼");
        dog.ji();
        Penguin pgn = new Penguin("胖胖","Q妹");
        pgn.ji();
    }
}

运行结果为：

1.3 继承的特点

  　　 a.子类可以继承父类的非尸用的属性和方法

   　　b.不能继承构造方法

   　　c.继承默认权限修饰符的方法和属性，子类和父类必需在同一包中

  1.4 super(父类)

    　　super.属性名//表示方法父类的属性

    　　super.方法名（参数）;//表示访问父类的方法

    　　super.（参数）;//表示访问父类的构造函数

注意: super（）访问父类构造函数时，必须写在第一行

注意：代码块会执行在构造函数之前

2.重写

　　2.1 重写就是子类重写定义父类的方法

　　2.2 重写规则

 　　　　a.方法名和参数列表相同

　　　　 b.修饰符访问权限子类和父类相同或者比父类大

 　　　　c.返回值类型子类和父类相同(或者是父类返回值类型的子类)

 　　　　d.异常跟父类相同或者范围更小

 一般：重写时，子类的东西都要和父类保持一致

       构造方法不能被重写

       因为不能被继承所以不能被重写

3.抽象类

　　3.2.抽象方法

　　　　语法:public abstract 返回值类型 方法名（参数列表）;

 　　 例:public abstract void print();

注意：抽象方法有abstract修饰，并且抽象方法没有方法体

public class Fish extends Animal{
    int weight = 5;
    int age = 9;
    public void info(){
        System.out.println("我是一只"+weight+"的鱼！");
        System.out.println("今年"+age+"岁了！");
    }
    
}

public abstract class Animal {
        int age;
        String color = "";
        int weight;
        abstract void info(); //抽象这个方法让子类去实现
}

public class Bird extends Animal{
    String color="红色";
    int age = 4;
    public void info(){
        System.out.println("我是一只"+color+"的鸟！");
        System.out.println("今年"+age+"岁了！");
    }

}

public class TextBFA {
    public static void main(String[] args){
        Bird b= new Bird();
        b.info();
        Fish f = new Fish();
        f.info();
    }
}

运行结果为：

4.抽象类和抽象方法的特点

　　a.都用abstract修饰

　　b.抽象类不能实例化

　　并且继承抽象类的子类都必须重写抽象类的所有抽象方法

注意：1）抽象类中不一定有抽象方法

         2）含有抽象方法中的类，一定是抽象类（接口）