Java的继承

---

前言

Java的继承是Java面向对象里面尤其重要的部分，它可以大大节省代码的读写量

一、什么是继承？

Java继承是面向对象的最显著的一个特征。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。比如可以分隔符先定义一个类叫车，车有以下属性：车体大小，颜色，方向盘，轮胎，而又由车这个类派生出轿车和卡车两个类，为轿车添加一个小后备箱，而为卡车添加一个大货箱。

类和类之间的继承关系可以用UML符号表示，其中父类又叫超类或基类，子类又叫派生类。父类是子类的一般化，子类是父类的特化（具体化)。[1]

JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个父类，易于管理程序，同时一个类可以实现多个接口，从而克服单继承的缺点。

在面向对象程序设计中运用继承原则，就是在每个由一般类和特殊类形成的一般——特殊结构中，把一般类的对象实例和所有特殊类的对象实例都共同具有的属性和操作一次性地在一般类中进行显式的定义，在特殊类中不再重复地定义一般类中已经定义的东西，但是在语义上，特殊类却自动地、隐含地拥有它的一般类(以及所有更上层的一般类)中定义的属性和操作。特殊类的对象拥有其一般类的全部或部分属性与方法，称作特殊类对一般类的继承。

继承所表达的就是一种对象类之间的相交关系，它使得某类对象可以继承另外一类对象的数据成员和成员方法。若类B继承类A，则属于B的对象便具有类A的全部或部分性质(数据属性)和功能(操作)，我们称被继承的类A为基类、父类或超类，而称继承类B为A的派生类或子类。

继承避免了对一般类和特殊类之间共同特征进行的重复描述。同时，通过继承可以清晰地表达每一项共同特征所适应的概念范围——在一般类中定义的属性和操作适应于这个类本身以及它以下的每一层特殊类的全部对象。运用继承原则使得系统模型比较简练也比较清晰。

上面是比较官方的Java面向对象中对继承的介绍接下来我们来简单理解一下

二、继承的相关特性

，对于Java的继承有哪些特性，我来罗列一下:
1.B类继承A类,则称A类为超类(superclass)、父类、基类,B类则称为子类(subclass)、派生类、扩展类。
2.java 中的继承只支持单继承，不支持多继承，C++中支持多继承，这也是 java 体现简单性的一点，换句话说，java中不允许这样写代码: class Bextends A,C{}。
3.虽然java中不支持多继承，但有的时候会产生间接继承的效果，例如: class Cextends B，class B extends A，也就是说，C直接继承B，其实C还间接继承A。
4.java中规定，子类继承父类，除构造方法和被private修饰的数据不能继承外，剩下都可以继承。
5.java中的类没有显示的继承任何类，则默认继承Object类，Object类是java语言提供的根类（老祖宗类)，也就是说，一个对象与生俱来就有Object类型中所有的特征。
6.继承也存在一些缺点，例如:CreditAccount类继承Account类会导致它们之间的耦合度非常高，Account类发生改变之后会马上影响到CreditAccount类。

三、继承的代码编写

1.继承的代码基本格式

calss a{
}

class b extends a{
}

其中在大括号中可以添加自己需要的方法或者类型

2.代码演示

先来最简单的

package test03;

import org.w3c.dom.ls.LSOutput;

public class super0 {
    public static void main(String[] args) {
    B b=new B();
    b.move();
    }
}

 class A{
    public void move(){
        System.out.println("666牛逼");
    }
 }

 class B extends A{
//    public void speak2(){
//         System.out.println("牛逼666");
//     }
 }

运行一下看看结果

"C:\JetBrains\IntelliJ IDEA 2019.2.4\jbr\bin\java.exe" "-javaagent:C:\JetBrains\IntelliJ IDEA 2019.2.4\lib\idea_rt.jar=55086:C:\JetBrains\IntelliJ IDEA 2019.2.4\bin" -Dfile.encoding=UTF-8 -classpath C:\IdeaProjects\heima169work\out\production\day15 test03.super0
666牛逼

再来更加复杂的

package test02;

public class test01 {
    public static void main(String[] args) {
     cat c=new cat();
     c.a("adasdasds");
     c.move();
    }
}

 class aminal{
    String name;
    public void move(){
        System.out.println(name+"移动");
    }
        public void a(String name){
            this.name=name;
        }
    }
  class cat extends aminal{

  }

在这个代码中，我们将cat继承了aminal的特性，然后在main()函数的主入口中创建了新对象cat c=new cat();接下来通过cat调用aminal中的方法，接下来我们运行一下看看结果如何

"C:\JetBrains\IntelliJ IDEA 2019.2.4\jbr\bin\java.exe" "-javaagent:C:\JetBrains\IntelliJ IDEA 2019.2.4\lib\idea_rt.jar=53599:C:\JetBrains\IntelliJ IDEA 2019.2.4\bin" -Dfile.encoding=UTF-8 -classpath C:\IdeaProjects\heima169work\out\production\day15 test02.test01
adasdasds移动

显而易见的cat这个子类继承的animal中的特性，并且可以通过创建对象的方式利用好父类中的方法，这和我们现实生活中的父子关系类似
儿子的用的父亲的钱，在归根到底父亲的钱到最后依旧是儿子的，父亲的钱就相当于儿子的钱一样

来看下一个案例

package cover;

public class test02 {
    public static void main(String args[]) {
        Student stu = new Student(); // 实例化的是子类
        stu.setName("张三"); // Person类定义
        stu.setAge(20); // Person类定义
        System.out.println("姓名：" + stu.getName() + "，年龄：" + stu.getAge());
    }
}
    class Person {
        private String name;
        private int age;

        public void setName(String name) {
            this.name = name;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public String getName() {
            return this.name;
        }

        public int getAge() {
            return this.age;
        }
    }

    class Student extends Person { // Student类继承了Person类
    }

在这里面我们将person里面的属性全部私有化，再用student继承person中的属性，这次在主函数中我们就需要建立特定的方法来通过子类来调用父类的方法，说明子类可以调用父类中的私有方法，但是不能直接访问父类的私有方法
接下来我们运行看看

"C:\JetBrains\IntelliJ IDEA 2019.2.4\jbr\bin\java.exe" "-javaagent:C:\JetBrains\IntelliJ IDEA 2019.2.4\lib\idea_rt.jar=53963:C:\JetBrains\IntelliJ IDEA 2019.2.4\bin" -Dfile.encoding=UTF-8 -classpath C:\IdeaProjects\heima169work\out\production\day15 cover.test02
姓名：张三，年龄：20

很显然结果和我们预期的一样，通过子类确实可以调用父类的私有方法并且修改，但是必须在父类中定义set和get的方法才能，但是要记住，子类并非继承到父类的私有属性，子类只是继承了父类的非私有属性

接下来看另一个实例

package cover;

public class test {
    public static void main(String[] args) {
        chinesepeople c = new chinesepeople();
        c.setName("周浩");
        c.speak();
        englishpeople e = new englishpeople();
        e.setName("zhouhao");
        e.speak();
    }
}
    class People{
        private String name;

        public People(String name) {
            this.name = name;
        }

        public People() {
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
        public void speak(){
            System.out.println(name+"......");
        }
    }

    class chinesepeople extends People{
        public void speak(){
            System.out.println(this.getName()+"正在说汉语");
        }
    }

    class englishpeople extends People{
        public void speak(){
            System.out.println(this.getName()+"正在说英语");
        }
    }

这其实也是一种方法的重写，在下面我们会介绍
运行一下试试

"C:\JetBrains\IntelliJ IDEA 2019.2.4\jbr\bin\java.exe" "-javaagent:C:\JetBrains\IntelliJ IDEA 2019.2.4\lib\idea_rt.jar=54659:C:\JetBrains\IntelliJ IDEA 2019.2.4\bin" -Dfile.encoding=UTF-8 -classpath C:\IdeaProjects\heima169work\out\production\day15 cover.test
周浩正在说汉语
zhouhao正在说英语

可以见的，在子类继承了父类后，我们依旧可以通过新创建一个对象来调用并且修改父类中的方法和属性

四、继承的方法重写

1.定义

在java中方法的重写是建立在java类的三大特性之一：继承性的基础之上的，没有继承性也就不能谈方法的重写。方法的重写是当程序中父类的某一个方法并不能满足子类的需求时，子类可以重新定义该方法的内容与功能来满足子类的需求的一种操作。

2.要求

1.子类重写的方法必须和父类重写的方法具有相同的方法名称、参数列表

2.子类重写的方法返回值类型不能大于父类被重写的方法返回值类性

3.子类重写的方法访问权限不能小于父类被重写的方法的权限;子类不能重写父类中声明的private 权限的方法

4.子类方法抛出的异常不能大于父类被重写方法时异常

3.优势

方法重写的主要优点是，类可以将自己的特定实现提供给继承的方法，而无需修改父类代码。

当一个类具有多个子类时，这很有用，因此，如果一个子类需要使用父类方法，则可以使用它，而其他想要实现不同的类可以使用重写功能进行更改，而无需接触父类

4.实例

package Super;

public class test01 {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.yiDong();
    }
}

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

    class Cat{
        //对move进行重写
        public void move(){
            System.out.println("cat move");
        }
        public void yiDong(){
            this.move();
           move();
        }
    }

在这段代码中，我们在子类中重写了父类的方法，又在子类中重新写了一个方法利用子类覆盖父类写的方法，从而达到调用两次的作用，接下里我们运行一下试试

"C:\JetBrains\IntelliJ IDEA 2019.2.4\jbr\bin\java.exe" "-javaagent:C:\JetBrains\IntelliJ IDEA 2019.2.4\lib\idea_rt.jar=54976:C:\JetBrains\IntelliJ IDEA 2019.2.4\bin" -Dfile.encoding=UTF-8 -classpath C:\IdeaProjects\heima169work\out\production\day14 Super.test01
cat move
cat move

可以看见结果和我想象中一样，覆盖就是在子类中创造自己想要的并且依旧保存父类的方法属性

上面的这个代码其实也是一种重写

package cover;

public class test {
    public static void main(String[] args) {
        chinesepeople c = new chinesepeople();
        c.setName("周浩");
        c.speak();
        englishpeople e = new englishpeople();
        e.setName("zhouhao");
        e.speak();
    }
}
    class People{
        private String name;

        public People(String name) {
            this.name = name;
        }

        public People() {
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
        public void speak(){
            System.out.println(name+"......");
        }
    }

    class chinesepeople extends People{
        public void speak(){
            System.out.println(this.getName()+"正在说汉语");
        }
    }

    class englishpeople extends People{
        public void speak(){
            System.out.println(this.getName()+"正在说英语");
        }
    }

5.注意

a:父类中私有方法子类不能被重写，因为父类私有方法子类根本就无法继承。
b:子类重写父类方法时，访问权限不能更低，最好就一致
c:父类静态方法，子类也必须通过静态方法进行重写，其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中，子类重写父类方法的时候，最好声明一模一样。
d:构造方法不参与重写（构造方法无法继承）
e:final修饰的方法，子类不能重写，只能继承

总结

以上便是我对继承的浅薄了解，以后有时间会抓紧补充