Java是一门面向对象的语言：“对象这种观念本身就是 十分方便的工具，使得你可以通过概念将数据和功能封装到一起，因此可以对问题空间的观念给出恰当的表示，而不用受制于必须使用底层及其语言。这些概念用关键字class来表示，它们形成了编程语言中的基本单位”；“复用代码是Java众多引人注目的功能之一”——-这段话引用《Think in Java》。继承的本体就是一个class，而继承的最根本的理解就是复用代码。

目录

前言

继承的语法

继承的特点

访问权限和继承之间的关系

构造器对继承的影响

父类使用默认构造器

父类不使用默认构造器

继承中的向上转型

继承慎用

后言

前言

社会中就有继承的概念（百度百科）：继承是指一个对象直接使用另一对象的属性和方法。也指按照法律或遵照遗嘱接受死者的财产、职务、头衔、地位等。这个解释中的前一句正说明了我们要今天要讲的对象（继承）的大体特性。

在写Java时用到继承的情况有？

当我们准备编写一个类时，发现某个类已有我们所需要的成员变量和方法，假如我们想复用这个类的成员变量和方法，即在所编写类中不用声明成员变量就相当于有了这个成员变量，不用定义方法就相当于有了这个方法，那么我们可以将编写的类声明为这个类的子类即继承。

小知识：

源类，基类，超类或者父类都是一个概念

导出类，继承类，子类也都是同一个概念

继承的语法

在类声明中，使用关键字extends来声明一个类的子类：

class 子类名 extends 父类名 {

  …

}

 注意：如类声明语句中没有extends子句，则该类为java.lang包中的Object的子类。这就说明了java中的代码其实都有一个继承的关系，只不过是继承Object这个java中最根本的父类。

继承的特点

1. 子类拥有父类非private的属性和方法，子类继承的父类方法和成员变量可以当作自己的方法和成员变量一样被子类的实例方法使用。
2. 子类可以有自己属性和方法，即子类可以在父类的基础上对父类进行扩展。
3. 子类可以用自己的方式实现父类的方法。（重写或者覆盖） 

访问权限和继承之间的关系

访问限制修饰符限制对象对成员变量操作和方法调用，也限制继承性

• 当子类和父类在同一个包：父类private成员变量和方法不会被子类继承
• 当子类和父类不在同一个包：父类private和friend（默认）成员变量和方法不会被子类继承                      

构造器对继承的影响

什么是构造器： 

1. 构造器，也称构造方法、构造函数。作用是构造出来一个类的实例，确保对象得到初始化。
2. 构造器的格式： 权限修饰符 类名(无参/有参){}。
3. 根据有无参数，可分为无参构造 和有参构造。  

构造器的特性：

1. 与一般方法名不同的是，构造方法名必须和类名保持一致，并且没有返回值。
2. Java编译器会自动创建无参构造函数，因此在类中，无参构造即使没有，我们也可省略不写。实例化对象时无需赋值。
3. 倘若类中已存在有参构造函数，则编译器不再提供默认无参构造。实例化对象时需赋值，不然报错。
4. 当类实例化一个对象时会自动调用构造方法。

构造器在Java的继承中会产生什么影响呢？

我们虽然继承了父类但是父类的构造器是我们子类继承不了的，我们只能去调用父类的构造器。那么在继承并且编写子类的构造方法的时候就要注意两种情况了：1.父类没有重写了构造函数（即构造函数是Java默认给的一个构造函数）；2.父类重写了构造函数。 

父类使用默认构造器

 package Extends;  public class Father {          Father(){                     //默认的看不出区别所以这边设置个无参构造器效果一样的                                        //当你不定义的时候就是这个构造器           System.out.println("This is Father Constrctor");     } }

 package Extends;  public class Nosuper extends Father{  Nosuper(){                                  //定义子类的构造器   System.out.println("This is Nosuper Constrctor");  }   public static void main(String[] args) {   // TODO Auto-generated method stub   Nosuper no=new Nosuper();  }  }

 OUTPUT： This is Father Constrctor This is Nosuper Constrctor

父类不使用默认构造器

 package Extends;  public class Father {          Father(String name){           System.out.println("This is Father Constrctor,name is "+name);     } }

 package Extends;  public class Nosuper extends Father{  Nosuper(){    super("YYH");                   //必须先调用父类的构造函数否则会报错   System.out.println("This is Nosuper Constrctor");  }  public static void main(String[] args) {   // TODO Auto-generated method stub   Nosuper no=new Nosuper();  } }

 OUTPUT： This is Father Constrctor,name is YYH This is Nosuper Constrctor 

总结：对于继承来说，子类会默认调用父类的构造器，但是如果没有默认的父类构造器，子类必须要调用父类的构造器，而且必须是在子类构造器中做的第一件事(第一行代码)。

继承中的向上转型

当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法，但是它仍然要根据继承链中方法调用的优先级来确认方法，该优先级为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

 package _4_8;  class A {     public String show(D obj) {         return ("A and D");     }     public String show(A obj) {         return ("A and A");     }   }   class B extends A{  //重载       public String show(B obj){         return ("B and B");     }   //重写     public String show(A obj){         return ("B and A");     }   }   class C extends B{} class D extends B{} public class t {     public static void main(String[] args) {         A a1 = new A();         A a2 = new B();                             //1.只能调用子类中重写父类的方法，不可以                                                      //调用重载的方法         B b = new B();         C c = new C();         D d = new D();         System.out.println("1--" + a1.show(b));         System.out.println("2--" + a1.show(c));         System.out.println("3--" + a1.show(d));         System.out.println("--------");         System.out.println("4--" + a2.show(b));         System.out.println("5--" + a2.show(c));         System.out.println("6--" + a2.show(d));         System.out.println("6--" + a2.show(a1));         System.out.println("*");         System.out.println("7--" + b.show(b));         System.out.println("8--" + b.show(c));         System.out.println("9--" + b.show(d));           } }

 OUTPUT: 1--A and A 2--A and A 3--A and D -------- 4--B and A 5--B and A 6--A and D 6--B and A * 7--B and B 8--B and B 9--A and D

 仔细理解一下其中的代码不难理解其中向上转型在继承中的作用。按照this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)这个顺序一步一步的执行就会得到结果。

将子类转换成父类，在继承关系上面是向上移动的，所以一般称之为向上转型。由于向上转型是从一个叫专用类型向较通用类型转换，所以它总是安全的，唯一发生变化的可能就是属性和方法的丢失。

继承慎用

你会感觉当你在编写三四个程序的时候用继承解决了他们公共的部分是很方便的，但是如果你程序很大，class很多而且都继承于一个类中，当你想通过改变父类的一些信息来改变一个子类的信息的时候就会发现其他的子类也会随之改变，有时候会对其他的子类产生不必要的结果。

父类变了其他的子类就会随之全部改变。

继承破坏了封装，对于父类而言，它的实现细节对与子类来说都是透明的。

继承是一种强耦合关系。

“问一问自己是否需要从子类向父类进行向上转型。如果必须向上转型，则继承是必要的，但是如果不需要，则应当好好考虑自己是否需要继承”——《Think in Java》 

后言

这些都是自己翻阅资料或者是查看其他大佬的blog总结的，如有侵权请告知！！！如有错误请指出，谢谢。

希望对你们有所帮助，本人也正在学习Java的路上也是小白一枚，还需要大佬们的多多支持。

                                      

No pains NO results