java面向对象之——继承

面向对象的特征之一 ——继承

那什么是继承呢？
    继承是从已有的类中派生出新的类。
继承怎么用？
    在类名后加extends关键字+被继承的类名表示继承关系
继承有什么用吗？
    通俗的来说，子类可以吸收父类类的属性和行为， 并能扩展新的能力。
继承的语法有什么基本要求吗？
   1.JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个 直接父类。
   2.继承之后子类可以调用父类的所有非私有属性和非私有方法

*代码演示：（看不懂没关系，下面有细讲）

public class Animal {//父类：动物
      //私有成员变量，含有封装概念
    private static String name;
    private static int age;
    
     //动物的行为之一：吃食物
    public void eat(){
        System.out.println(name+"会吃");
    }
     //动物的行为之二：睡觉
    public void sleep(){
        System.out.println(name+"会睡觉");
    }
     
     //因为成员变量name和age已经封装起来了，所有内部要有方法来给name与age赋值并返回
    public void setName(String name){
        this.name = name;//this表示当前变量指代的是其成员变量而非局部变量
    }
    public void getName(){
        System.out.println(name);
    }
    public void setAge(int age){
        this.age = age;
    }
    public void getAge(){
        System.out.println(age);
    }
    //这些都是父类的方法，属性
}

class Dog extends Animal{//父类继承子类
    String type;//子类也可以有自己的属性，比如品种
    public void pinzhong(String name){
        System.out.println("旺财是"+type);
    }
    public static void main(String[] args) {
        Dog wc = new Dog();//先实例化对象，接着就可以调用父类没有被private修饰的成员变量、方法
        wc.setName("旺财");
        wc.getName();
        wc.setAge(5);
        wc.getAge();

        wc.eat();
        wc.sleep();

        wc.type = "哈士奇";
        wc.pinzhong();
    }
}

运行结果如下：

那何时使用继承呢？
   继承是代码重用的一种方式，继承是子类继承父类，将子类共有的属性和行为放到父类中。当然，子类与父类要有相同的特征，或者说子类 是 父类的一部分；即符合is-a关系的设计,使用继承。比如说，狗 是 动物 的一部分。

继承的形式
  [访问权限修饰符] [修饰符] 子类名 extends 父类名{子类体}
比如：

public class Animal {
    String name;
    public Animal(){//无参构造方法

    }
    public void eat(){//父类的方法
        System.out.println(name+"会吃");
    }
}
class Dog extends Animal{
    public static void main(String[] args) {
        Dog dog = new Dog();//先实例化Dog的对象
        dog.name ="旺财";
        dog.eat();//在调用父类方法
    }
}
class Cat extends Animal{
    public static void main(String[] args) {
        Cat cat = new Cat();//实例化Cat的对象
        cat.name = "汤姆";
        cat.eat();//调用父类方法
    }
}

如这个代码演示，子类可以继承父类的成员方法、非private修饰的成员变量其结果显而易见，分别是 旺财会吃 和 汤姆会吃

要用专业术语来讲就是：
   Dog类是 Animal类的子类, Animal类是Dog类的父类 ·
  Dog类是 Animal类的派生类, Animal类是Dog类的基类*

继承的传递性

继承的另一个特性就是其具有传递性

java语法是不能一个类继承多个父类，但是可以进行继承传递，比如说C类从B类继承,B类又从A类继承 那么C类就具有B类和A类的所有非私有属性和非私有方法
代码演示：

//继续以动物举例子
public class Animal{//基类（父类）
    String name;
    //父类方法、成员变量
    public void eat(){
        System.out.println("会吃");
    }
}

class Dog extends Animal{//Dog类继承Animal类
    //子类可以继承父类
    int age;
}
class HaShiQi extends Dog{//哈士奇类继承Dog类
//Dog又继承Anima类，所以哈士奇类可以调用DOg和Animal当中的所有成员变量和方法
    public static void main(String[] args) {
        HaShiQi hsq = new HaShiQi();
        hsq.name="旺财";
        hsq.age =5;
        hsq.eat();
    }
}
//这三者关系逐级递减，哈士奇是狗的一种，狗又是动物的一种
//所以，哈士奇会继承Animal和Dog的非私有成员变量，成员变量

当一个没有继承任何一个类时,jvm会默认让类继承Object类 Object是 java为所有类提供的基类

public Animal extends Object{
//extends Object可以默认不写
}

这些都是基类Object类里面可以调用的成员方法，有的会经常用到

继承中的构造方法

继承的最后一个特点就是继承的构造方法和super关键字

子类构造方法总是先调用父类构造方法,默认情况下，调用父类无参构造方法

public class A1 {
    //声明3个依次继承的类，写出无参构造方法
    public A1(){
        System.out.println("A无参构造方法");
    }
}
class A2 extends  A1{
    public A2(){
        System.out.println("A2无参构造方法");
    }
}
class A3 extends A2{
    public A3(){
        System.out.println("A3无参构造方法");
    }

    public static void main(String[] args) {
        A3 a3 = new A3();//实例化对象后，加载构造方法
    }
}

运行结果如下：

如果子类的构造方法中没有显式地调用基类构造方法，则系统默认调用基类无 参数的构造方法

   2.super关键字
super关键字用法之一：
用法很简单，在子类构造方法的第一行，使用super关键字调用父类任意一个构造方法 如果用super,必须写在构造方法的第一句

public class A1 {
    //声明3个依次继承的类，写出无参构造方法
    public A1(){
        super();
        System.out.println("A无参构造方法");
    }
}
class A2 extends  A1{
    public A2(){
        super();
        System.out.println("A2无参构造方法");
    }
}
class A3 extends A2{
    public A3(){
        super();
        System.out.println("A3无参构造方法");
    }

    public static void main(String[] args) {
        A3 a3 = new A3();//实例化对象后，加载构造方法
    }
}

super写在子类构造方法的第一句，作用就是调用任意一个父类的构造方法，这里的代码我只写了无参构造方法，super（）可以默认不写，不写会调用无参构造方法，super（参数）来调用父类任意一个含参数的构造方法，但是必须写在父类构造方法的第一句。

super的用法之二：
  1.用“super.成员变量名”来引用父类成员变量
  2.用“super.方法名（参数列表）”的方式访问父类的方法。

这两个用途其实都是一个道理，在子类中，可以用super关键字来在子类的构造方法中调用父类的变量、方法。
代码演示：

public class A1 {
    //声明3个依次继承的类，写出无参构造方法
    String name = "wang";//父类没有被private修饰的成员变量

    public void m1(){//父类的成员变量
        System.out.println("java牛逼");
    }
    public A1(){
        System.out.println("A无参构造方法");
    }
}
class A2 extends  A1{
    //在子类的构造方法中用super调用父类
    public A2(){//无参构造方法
        super();//可以默认不写
        System.out.println("A2无参构造方法");
        //不用实例化对象就可调用
        System.out.println(super.name);
        super.m1();
    }
    
    public static void main(String[] args) {
        //System.out.println(super.name);
        //写在main方法里面不行，会报错
        //因为main方法时静态方法，main加载的时候其余变量，成员方法都未加载
        A2 a2 = new A2();
        //最后要实例化对象，因为构造方法在实例化对象时才会加载
    }
}

运行结果：

继承剩下的知识点下章发布，感谢您的观看