面向对象三大特征（二）继承

目录

1.什么是继承：

2.继承的作用：

3.如何实现继承

4.继承中的构造方法

5.super关键字

6.方法的重写( override)

代码实现：

运行结果：

---

1.什么是继承：

子类继承父类的属性和行为，使得子类具有父类相同的行为。

2.继承的作用：

代码重用：子类继承父类后，子类可以使用父类中地功能，不需重复定义

代码扩展：在自己的类中扩展自己特有的功能，不影响其他类

3.如何实现继承

extends关键字可以声明类的继承关系

当一个类没有显示的继承其他类时,那么默认继承自Object(是java中所有类的父类/基类)

如：

public class Dog extends Object{
    String name;
    public void play(){
    
        System.out.println("狗会玩");

    }

}
public class XiaoTianQuan extends Dog{


//XiaoTianQuan 类继承了Dog类    


}

注意：

Java不支持多重继承，但可以多层继承

构造方法不可以被子类继承，但可以调用

继承之后子类可以调用父类的所有非私有属性和非私有方法

4.继承中的构造方法

（1）子类继承父类时，先调用父类的构造方法

[构造方法的作用是用来为对象中的属性进行赋值操作的.
因为子类拥有父类中成员,所以需要对父类中的成员也要进行初始化]

（2）通过super关键字调用父类中任意一个构造方法，且必须写在子类构造方法的第一行；先要确保父类进行初始化.

若子类构造方法中没有显示地调用父类构造方法【即没有将super()显示地写出来】，系统会默认调用父类地无参构造方法。

5.super关键字

使用super关键字访问父类成员

• 用super.成员变量名来引用父类成员变量

• 用super.方法名（参数列表）访问父类的方法

• 用super.构造方法(参数列表)访问父类构造方法

注意：

不要把super误认为是父类对象.

在创建子类对象时, 不会创建父类对象.

只会将父类中的信息加载到子类对象中存储

6.方法的重写( override)

（1）为什么重写

当父类的方法实现不能满足子类需求时,可以对方法进行重写.

（2）方法重写的规则

• 方法名相同、参数列表相同；

• 返回值类型相同；

• 访问权限不能小于父类权限

注意：构造方法,静态方法不能重写,成员变量不存在重写

代码实现：

 // 基类/父类  定义大家共有的属性和行为
public class Animal extends  Object{

    private String name;
    private int age;

    //Animal类中的无参构造
    public Animal(){
        super();
        System.out.println("Animal类中的无参构造");
    }

    public Animal(String name, int age) {
         super();
        System.out.println("Animal有参构造方法");
        this.name = name;
        this.age = age;
    }

    /*
      吃东西
     */
     void eat(){
        System.out.println("动物吃东西");
     }

    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;
    }
}

/*
  子类  extends 继承父类
  拥父类中的行为和属性,  但是不能直接对父类中的私有成员进行访问
 */
public class Dog  extends Animal{

        private String type;//品种

        public Dog(){
            super();//调用父类无参构造方法
            System.out.println("Dog类中无参构造方法");
        }

        public Dog(String name, int age) {
            super(name, age);//调用的是父类中有参构造方法
        }

       /*
               狗会玩
               是狗类自己特有的功能
       */
        public void play(){
            System.out.println("狗会玩耍");
        }

        public String getType() {
            return type;
        }

        public void setType(String type) {
            this.type = type;
        }
}

public class XiaoTianQuan extends Dog{

       private String  color;//颜色

       public XiaoTianQuan(){
           super();//必须放在第一行
           System.out.println("XiaoTianQuan类中的无参构造方法");
       }

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

       /*
          哮天犬是神犬,与其他动物吃东西的方式不同,
          那么我们就将Animal类中的eat方法,原封不动(方法结构)的在子类中进行定义
          称为在子类中重写/覆盖父类中的方法
          @Override 注解标签,表示此方法是从父类中重写而来的,在编译期间就会进行语法上的校验
        */
       @Override
       public  void eat(){
           super.play();//调用父类中方法
           System.out.println("哮天犬坐着吃东西");
           this.fly();//调用自己类中方法
       }

       public void fly(){
                System.out.println("哮天犬会飞");
       }
}

public class Test {

    public static void main(String[] args) {
          Dog dog =  new  Dog();
          dog.setName("旺财");
          dog.setAge(3);
          dog.eat();
          //dog.name="" 子类不能访问父类中私有的
          XiaoTianQuan xtq =  new XiaoTianQuan();
          xtq.setName("哮天");
          xtq.setAge(500);
          xtq.eat();//调用的是父类中eat()
          xtq.play();
          xtq.fly();//自己的扩展功能

    }
}

运行结果：

Animal中的无参构造方法  //
dog中无参构造方法
动物会吃
Animal中的无参构造方法
dog中无参构造方法
XiaoTianQuan类中的无参构造方法
哮天犬坐着吃
狗会玩
哮天犬坐着吃
哮天犬会飞