Java(14)继承

Posted 2020-09-23 祝阿明

1.继承（extends）

  1.1 继承：遗传

  1.2 语法

      public class 子类 extends 父类｛

 

｝

     public class Dog extends Pet{

}

 1 public class Pet {
 2     private String name = "无名氏";
 3     private int health = 90;
 4     private int love = 0;
 5     public Pet(){
 6         this.health = 95;
 7         System.out.println("执行宠物的无参构造方法");
 8     }
 9     public Pet(String name){
10         this.name = name;
11     }
12     public String getName(){
13         return name;
14     }
15     public int getHealth(){
16         return health;
17     }
18     public int getLove(){
19         return love;
20     }
21     public void ji(){
22         System.out.println("宠物的自白：\\n我的名字叫"+this.name+",健康值是"+this.health
23                 +",和主人的亲密度是"+this.love+"。");
24     }
25 }

宠物类

 1 public class Dog extends Pet{
 2     private String strain;
 3     public Dog(String name,String strain){
 4         //super(name);
 5         this.strain = strain;
 6     }
 7     public String getStrain(){
 8         return strain;
 9     }
10     public void ji(){
11         super.ji();
12         System.out.println("我是一只"+this.strain);
13     }
14 }

狗狗类继承宠物类

 1 /*
 2  * 继承语法 
 3  * 修饰符 SubClass extends SuperClass{
 4  *         类定义部分
 5  * }
 6  * 继承通过extends关键字来实现，其中SubClass为子类，SuperClass为父类
 7  * 修饰符如果是public,则该类在整个项目中可见，若无public修饰符，则该类只在当前包可见
 8  * 不可以使用private和protected修饰类
 9  */
10 public class Penguin extends Pet {
11     private String sex;
12     //final String home = "南极";
13 //    public void setHome(String home){
14 //        this.home = home; // home不可以再次赋值
15 //    }
16     public Penguin(String name,String sex){
17         super(name);
18         this.sex = sex;
19     } 
20     public String getSex(){
21         return sex;
22     }
23     public void ji(){
24         super.ji();
25         System.out.println("性别是："+this.sex);
26     }
27 }

企鹅类继承宠物类

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

测试类

运行结果为：

 

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修饰，并且抽象方法没有方法体

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

鱼类继承动物类

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

动物抽象类

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

鸟类继承动物类

1 public class TextBFA {
2     public static void main(String[] args){
3         Bird b= new Bird();
4         b.info();
5         Fish f = new Fish();
6         f.info();
7     }
8 }

测试类

运行结果为：

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

　　a.都用abstract修饰

　　b.抽象类不能实例化

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

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

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