JavaSE(14)-继承

继承

概念：

• 继承就是子类继承父类，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

生活中的继承：

图解：

• 奶牛和驴属于食草动物类，狮子和老虎属于食肉动物类。
• 食草动物类和食肉动物类又属于动物类。
• 所以继承需要符合的关系是：is-a，父类更通用，子类更具体。

继承类型：

• 单继承

public class A{
	······
}
public class B extends A{
	······
}

• 多重继承

public class A{
	······
}
public class B extends A{
	······
}
public class C extends B{
	······
}

• 不同类继承同一个类

public class A{
	······
}
public class B extends A{
	······
}
public class C extends A{
	······
}

• Java不支持多继承

继承的特性：

• 子类拥有父类非private的属性和方法。
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
• 子类可以用自己的方法实现父类的方法。
• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

不继承：

非继承代码演示：

• Tiger类

package oop.demo04;

/**
 * @author CodePigPig
 * @date 2021/2/2 8:23 下午
 * @Email 1399203705@qq.com
 */
public class Tiger {
    private String name;
    private int age;

    public Tiger(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println(name+"正在吃");
    }
    public void sleep(){
        System.out.println(name+"正在睡觉");
    }
    public void selfIntroduction(){
        System.out.println("大家好！我是"+name+",我今年"+age+"岁了");
    }
}

• MilkCow类

package oop.demo04;

/**
 * @author CodePigPig
 * @date 2021/2/2 8:23 下午
 * @Email 1399203705@qq.com
 */
public class MilkCow {
    private String name; //姓名
    private int age; //年龄

    public MilkCow(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println(name+"正在吃");
    }
    public void sleep(){
        System.out.println(name+"正在睡觉");
    }
    public void selfIntroduction(){
        System.out.println("大家好！我是"+name+",我今年"+age+"岁了");
    }
}

说明：

• 从Tiger类和MilkCow类可以看出，同样的属性和同样的方法，代码存在重复了，导致后果就是代码量大且臃肿。
• 维护性不高，如果需要修改同样的属性和方法，需要更改多处代码，容易出错。

继承：

• 通过将同样的属性和方法进行提取出来，设置为公共类，让子类Tiger类和MilkCow类继承父类Animal类
• 减少了重复代码，代码更加简洁，提高代码的复用性。

继承的代码演示：

• Animal类（公共类）

package oop.demo04;

/**
 * @author CodePigPig
 * @date 2021/2/2 8:22 下午
 * @Email 1399203705@qq.com
 */
public class Animal {
    private String name; //姓名
    private int age; //年龄

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println(name+"正在吃");
    }
    public void sleep(){
        System.out.println(name+"正在睡觉");
    }
    public void selfIntroduction(){
        System.out.println("大家好！我是"+name+",我今年"+age+"岁了");
    }
}

• Tiger类

public class Tiger extends Animal{

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

• MilkCow类

public class MilkCow extends Animal{

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

• Application类

package oop.demo04;

/**
 * @author CodePigPig
 * @date 2021/2/2 8:39 下午
 * @Email 1399203705@qq.com
 */
public class Application {
    public static void main(String[] args) {

        MilkCow milkCow = new MilkCow("奶小牛", 22);
        milkCow.eat();
        milkCow.sleep();
        milkCow.selfIntroduction();

        System.out.println("==============分割线=============");

        Tiger tiger = new Tiger("虎大王",3);
        tiger.eat();
        tiger.eat();
        tiger.selfIntroduction();
    }
}

输出：
奶小牛正在吃
奶小牛正在睡觉
大家好！我是奶小牛,我今年22岁了
==============分割线=============
虎大王正在吃
虎大王正在吃
大家好！我是虎大王,我今年3岁了  

继承中的关键字

概述：

• 继承可以使用extends和implements这两个关键字来实现继承。
• 所有类都继承于java.lang.Object，当一个类没有继承其他类时，默认继承object类（祖先类）。

关键字：

• extend关键字
• 类的继承时单一继承，一个子类只能拥有一个父类，所以extends只能继承一个类。

public class Animal { 
    private String name;   
    private int id; 
    public Animal(String myName, String myid) { 
        //初始化属性值
    } 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
 
public class Penguin  extends  Animal{ 
}

• implements关键字
• 使用implements关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同事继承多个接口

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

• this关键字：指向自己的引用
• super关键字：我们可以用过super关键字来实现对父类成员的访问，用来引用当前对象的父类

package oop.demo05;

/**
 * @author CodePigPig
 * @date 2021/2/2 9:07 下午
 * @Email 1399203705@qq.com
 */

class Animal{
    public void eat(){
        System.out.println("animal ： eat");
    }
}

class Cat extends Animal{
    public void eat(){
        System.out.println("cat : eat");
    }

    public void eatTest(){
        this.eat();
        super.eat();
    }
}

public class Application {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.eat();

        Cat cat = new Cat();
        cat.eat();
        System.out.println("=========分割线=========");
        cat.eatTest();
    }
}
package oop.demo05;

/**
 * @author CodePigPig
 * @date 2021/2/2 9:07 下午
 * @Email 1399203705@qq.com
 */

class Animal{
    public void eat(){
        System.out.println("animal ： eat");
    }
}

class Cat extends Animal{
    public void eat(){
        System.out.println("cat : eat");
    }

    public void eatTest(){
        this.eat();
        super.eat();
    }
}

public class Application {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.eat();

        Cat cat = new Cat();
        cat.eat();
        System.out.println("=========分割线=========");
        cat.eatTest();
    }
}

输出：
animal ： eat
cat : eat
=========分割线=========
cat : eat
animal ： eat

• final关键字
• final关键字声明类可以把类定义为不能被继承，即最终类；或者用于修饰方法，该方法不能被子类重写。

声明类：
final class 类名{
	·····
}

声明方法：
修饰符(public/private/default/protected) final 返回值类型 方法名(){
	······
}