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("宠物的自白：\n我的名字叫"+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）含有抽象方法中的类，一定是抽象类（接口）