本文主要向大家介绍了JAVA语言面向对象三大特性讲解之继承，通过具体的内容向大家展示，希望对大家学习JAVA语言有所帮助。

前言：

继承，既是对现有类的复用。如果子类继承了父类，那么子类就拥有了父类的能力了。除此之外，子类还能加入自己新加入的方法，功能，或是重新定义从父类继承的某项功能。这样，就可以在现有的功能上开发新的功能，这样能大大减少开发的周期.

|继承的优点|

现在我们来构建一个Cat的类 

package Test.practice.thinking_in_java.extend_test;

/**

 * @Author 7aY

 * @Description: TODO()

 * @Date :Create in 13:202018/3/12

 */

/**

 * 猫类

 */

public class Cat {

    private int age;//年龄

    private int weigth;//体重

    private String name;//名字

    public int getAge() {

        return age;

    }

    public Cat(int age,int weigth,String name){

        this.age=age;

        this.weigth=weigth;

        this.name=name;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public int getWeigth() {

        return weigth;

    }

    public void setWeigth(int weigth) {

        this.weigth = weigth;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public void printMessage(){

        System.out.println("name:"+getName()+" weigth:"+getWeigth()+"kg  age:"+getAge());

    }

    public  Cat(){}

}

这个Cat类包含体重 名字 身高等信息，但现在我想要在这个Cat的基础上创建一个EgyptianCat的类，我要重新把之前的代码重新再写一次然后再添加新的东西下去吗？很显然这会十分的麻烦且无用，所以这时候extend 这个关键字发挥了他的用处了

public class EgyptianCat extends Cat {

    private  String color;

    public String getColor() {

        return color;

    }

    public void setColor(String color) {

        this.color = color;

    }

    public EgyptianCat(int height,int weigth,String name,String color){

        super(height,weigth,name);

        this.color=color;

    }

    @Override

    public void printMessage() {

        System.out.println("name:"+getName()+" weigth:"+getWeigth()+"kg  age:"+getAge()+"color:"+getColor());

    }

}

和Cat相比，EgyptianCat就多了个一个私用属性color，通过extend继承，我们的类构建可以简洁很多，并且可以在继承的基础上重新构建一个属于我们新类的方法，这种方法叫做重写方法（PS：重写方法会调用上一层继承的被重写方法）

这里我们重写了父类的printMessage()方法，在打印信息中新加入了color属性

现在我们来new下父类和子类并且调用他们的printMessage方法查看下结果

public static void main(String[] args) {

       Cat cat = new Cat(2,10,"jay");

       cat.printMessage();

       EgyptianCat egyptianCat = new EgyptianCat(3,5,"lois","black");

       egyptianCat.printMessage();

   }

输出结果为：

name:jay weigth:10kg  age:2

name:lois weigth:5kg  age:3 color:black

|成员的继承|

如果子类继承了父类，则：

1.子类继承父类的所有public与protect成员，无论子类是否与父类在同一个包中；

2.如果子类与父类在同一个包中，那么子类也会继承父类包访问权限

3.子类不能继承父类的私有成员，但是子类可以通过父类的public或protect方法间接访问父类的私有成员 

package Test.practice.thinking_in_java.extend_test;

/**

 * @Author 7aY

 * @Description: TODO()

 * @Date :Create in 22:212018/3/13

 */

public class SuperClass {

    public int public_value;

    protected  int protect_value;

    private int private_value;

    public SuperClass(){

        public_value=1;

        protect_value=2;

    }

    public int getPrivate_value() {

        return private_value;

    }

    public void setPrivate_value(int private_value) {

        this.private_value = private_value;

    }

}

在SuperClass这个类中我们声明三种访问权限的变量，让我们看下他的子类是怎么继承成员变量的

package Test.practice.thinking_in_java.extend_test;

/**

 * @Author 7aY

 * @Description: TODO()

 * @Date :Create in 22:242018/3/13

 */

public class ExtendClass extends SuperClass {

    public void printMessage() {

        System.out.println("public value:"+public_value);

        System.out.println("protect value"+protect_value);

        // System.out.println("private value"+private_value); 并不能直接访问私有属性

        System.out.println("private value:"+getPrivate_value());

    }

    public static void main(String[] args) {

        ExtendClass extendClass = new ExtendClass();

        extendClass.setPrivate_value(3);

        extendClass.printMessage();

    }

}

我们新创建了一个ExtendClass类，其中声明了一个printMessage打印出成员变量的信息，让我们看下结果吧

public value:1

protect value2

private value:3

结果说明，子类能直接继承父类的public和protect成员变量，但并不能直接继承私有变量，但能通过setter和getter方法来访问private变量

|继承的向上转型和向下转型|

如果子类继承了父类，那么我们可以认为子类是父类的其中一种，是父类的特殊拓展版，例如Cat类继承于Animal类，那么我们可以把Cat看做为Animal,Cat具有Animal的所有特征，但并不能把Animal看做为Cat，因为并不是所有的Animal都是Cat.

在Java中，我们可以把父类的引用赋值给子类的对象，然后通过父类的引用来进行操作，这种操作被称为向上转型，但是，子类的新增方法并不能进行使用和操作。我们不能把子类的引用赋值给父类的对象，就像前面所说的，可以把Cat看做为Animal,Cat具有Animal的所有特征，但并不能把Animal看做为Cat，因为并不是所有的Animal都是Cat.

package Test.practice.thinking_in_java.extend_test;

/**

 * @Author 7aY

 * @Description: TODO()

 * @Date :Create in 22:432018/3/13

 */

public class Animal {

    public void walk(){

        System.out.println("Animal walk!!");

    }

    public void sleep(){

        System.out.println("Animal sleep!!");

    }

    public void eat(){

        System.out.println("Animal eat!!");

    }

}

我们现在创建一个Animal类，然后我们再创建一个Cat类继承于Animal类

package Test.practice.thinking_in_java.extend_test;

/**

 * @Author 7aY

 * @Description: TODO()

 * @Date :Create in 13:202018/3/12

 */

/**

 * 猫类

 */

public class Cat extends Animal {

    private int age;//年龄

    private int weigth;//体重

    private String name;//名字

    public int getAge() {

        return age;

    }

    public Cat(int age,int weigth,String name){

        this.age=age;

        this.weigth=weigth;

        this.name=name;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public int getWeigth() {

        return weigth;

    }

    public void setWeigth(int weigth) {

        this.weigth = weigth;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public void printMessage(){

        System.out.println("name:"+getName()+" weigth:"+getWeigth()+"kg  age:"+getAge());

    }

    public  Cat(){}

     public void  Meow(){

         System.out.println("meow!!!!");

     }

}

其中Cat类中新增了一个Meow的猫叫方法

现在我们来测试一下：

package Test.practice.thinking_in_java.extend_test;

/**

 * @Author 7aY

 * @Description: TODO()

 * @Date :Create in 22:492018/3/13

 */

public class Test {

    public static void main(String[] args) {

        Animal cat = new Cat();

        cat.eat();

        cat.sleep();

        cat.walk();

        //但是不能调用Meow这个方法，现在我们把cat引用转为Cat

        cat=(Cat) cat;

        ((Cat) cat).Meow();

        //Cat animal = new Animal(); 编译器报错，并不能向下转型！

    }

}

结果：

Animal eat!!

Animal sleep!!

Animal walk!!

meow!!!!

正如之前所说的一样，父类引用指向子类对象不能使用子类自己新增的方法，而且如果向下转型的话编译器会报错，那么向下转型有什么作用呢？之后我们会提到.

|多态的实现|

现在我们要编写一个动物园类，检查传入的动物是什么动物

package Test.practice.thinking_in_java.extend_test;

/**

 * @Author 7aY

 * @Description: TODO()

 * @Date :Create in 0:212018/3/15

 */

public class Zoo {

    //动物园检查动物

    public void check(Animal animal){

        System.out.println("this is animal!");

    }

    public void check(Cat cat){

        System.out.println("this is cat!");

    }

    public void check(EgyptianCat egyptianCat){

        System.out.println("this is egyptianCat!");

    }

    public static void main(String[] args) {

        Zoo zoo = new Zoo();

        Animal animal = new Animal();

        Cat cat = new Cat();

        EgyptianCat egyptianCat = new EgyptianCat();

        zoo.check(animal);

        zoo.check(cat);

        zoo.check(egyptianCat);

    }

}

结果：

this is animal!

this is cat!

this is egyptianCat!

以上的代码是check方法的重载,看上去没有任何问题.但只要我们稍加修改，用到上面的向上转型，结果则会出人意料

  public static void main(String[] args) {

        Zoo zoo = new Zoo();

        Animal animal = new Animal();

        Cat cat = new Cat();

        Animal egyptianCat = new EgyptianCat();

        zoo.check(animal);

        zoo.check(cat);

        zoo.check(egyptianCat);

    }

}

输出结果：

this is animal!

this is cat!

this is animal!

这是因为方法重载是静态的，传入参数类型是看类型的引用，前面cat的引用类型是Animal，所有编译器自动把cat传到Animal的重载方法中。

现在我们稍加修改

public class Zoo {

    //动物园检查动物

    public void check(Animal animal){

        animal.printInfo();

    }

    public static void main(String[] args) {

        Zoo zoo = new Zoo();

        Animal animal = new Animal();

        Cat cat = new Cat();

        Animal egyptianCat = new EgyptianCat();

        zoo.check(animal);

        zoo.check(cat);

        zoo.check(egyptianCat);

    }

}

结果为：

this is Animal

this is cat

this is EgyptianCat

这里说明一下，Animal 、Cat、EgyptianCat类中都有一个printInfo方法打印出自身的信息

从结果可以看出，虽然是向上转型，但是仍能准确输出类的信息，并且在Zoo类中并不需要重载方法，试想一下每当有一个新的类出现就重载一次，那么这个Zoo类的重载方法是不是太多了，以后管理起来也不方便，但使用多态的话，这需要在子类中重写方法即可，十分的方便。

【总结】

使用继承这个关键字extend 能减少我们代码编写的工作量，但在重写的时候要注意，例如重写，类的变量继承等

因为有了继承，使得代码的复用有了千变万化的机会

本文由职坐标整理并发布，希望对同学们有所帮助。了解更多详情请关注编程语言JAVA频道！