一、继承问题的引出
继承性是面向对象的第二个主要特征。
首先，编写Person类、Student类两个程序。
个人等级：
class Person { private String name； 私有输入； 公共void set name (string name ) { this.name=name； }publicvoidsetage(intage ) { this.age=age； }公共字符串getname () { return this.name； } public int getAge () { return this.age； }} Student类：
类字符串{ private string name； 私有输入； 私有字符串； 公共void set name (string name ) { this.name=name； }publicvoidsetage(intage ) { this.age=age； } publicvoidsetschool (stringschool ) { this.school=school； }公共字符串getname () { return this.name； } public int getAge () { return this.age； } public String getSchool () { return this.school； }以上两个程序，通过代码的比较可以明显看出，代码中存在重复，正如以前学到的那样，无法消除该重复。
在所有代码中，具有最重复含义的是链接列表类，它为简单的Java类和其他任何类编写链接列表程序，代码量大，不容易维护。
二、继承的概念
继承是面向对象的最明显的特性。 继承从现有类派生新类，新类吸收现有类的数据属性和行为，扩展新能力。
在Java中，要实现继承关系，请使用以下语法：
class子类extends父类{}子类也称为派生类； 父类也称为超类(Super Class )。
观察继承的基本实现：
package com.wz.extendsdemo； class Person { private String name； 私有输入； 公共void set name (string name ) { this.name=name； }publicvoidsetage(intage ) { this.age=age； }公共字符串getname () { return this.name； } public int getAge () { return this.age； } classtudentextendsPerson {//student类为person类} public class test demo { publicstaticvoidmain (string args ) studeng ////Person类定义stu.setage(20； //Person类为System.out.println (名称： ' stu.getName )，年龄： ' stu.getAge ' )； }运行结果：
名称：彩色手机，年龄： 20代码可以看出，子类(Student )没有定义任何操作，主类使用的所有操作都由Person类定义。 这是子类即使不扩充父类，也能维持父类的操作。
在子类中扩展父级
类的功能： package com.wz.extendsdemo;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类 private String school; // 子类的属性 public void setSchool(String school) { this.school = school; } public String getSchool() { return this.school; }}public class TestDemo { public static void main(String args[]) { Student stu = new Student(); // 实例化的是子类 stu.setName("彩色的手机"); // Person类定义 stu.setAge(20); // Person类定义 stu.setSchool("清华大学"); // Student类扩充方法 System.out.println("姓名：" + stu.getName() + "，年龄：" + stu.getAge() + "，学校：" + stu.getSchool()); }}运行结果:
姓名：彩色的手机，年龄：20，学校：清华大学以上的代码，子类对于父类的功能进行了扩充（扩充了一个属性和两个方法）。但是思考一下：子类从外表看是扩充了父类的功能，但是对于以上的代码，子类还有一个特点：子类实际上是将父类定义的更加的具体化的一种手段。父类表示的范围大，而子类表示的范围小。
三、继承的限制
虽然继承可以进行类功能的扩充，但是其在定义的时候也是会存在若干种限制的。
限制一：一个子类只能够继承一个父类，存在单继承局限。
错误的写法：
以上操作称为多重继承，实际上以上的做法就是希望一个子类，可以同时继承多个类的功能，但是以上的语法不支持而已，但是可以换种方式完成同样的操作。
正确的写法：
class A {}class B extends A {}class C extends B {}C实际上是属于（孙）子类，这样一来就相当于B类继承了A类的全部方法，而C类又继承了A和B类的方法，这种操作称为多层继承。
结论：Java之中只允许多层继承，不允许多重继承，Java存在单继承局限。
限制二：在一个子类继承的时候，实际上会继承父类之中的所有操作（属性、方法），但是需要注意的是，对于所有的非私有（no private）操作属于显式继承（可以直接利用对象操作），而所有的私有操作属于隐式继承（间接完成）。
package com.wz.extendsdemo;class A { private String msg; public void setMsg(String msg) { this.msg = msg; } public String getMsg() { return this.msg; }}class B extends A { public void print() { //System.out.println(msg); // 错误: msg定义为private，不可见 }}public class TestDemo { public static void main(String args[]) { B b = new B(); b.setMsg("彩色的手机"); System.out.println(b.getMsg()); }}此时对于A类之中的msg这个私有属性发现无法直接进行访问，但是却发现可以通过setter、getter方法间接的进行操作。
限制三：在继承关系之中，如果要实例化子类对象，会默认先调用父类构造，为父类之中的属性初始化，之后再调用子类构造，为子类之中的属性初始化，即：默认情况下，子类会找到父类之中的无参构造方法。
package com.wz.extendsdemo;class A { public A() { // 父类无参构造 System.out.println("*************************") ; }}class B extends A { public B() { // 子类构造 System.out.println("#########################"); }}public class TestDemo { public static void main(String args[]) { B b = new B() ; // 实例化子类对象 }}运行结果:
*************************#########################这个时候虽然实例化的是子类对象，但是发现它会默认先执行父类构造，调用父类构造的方法体执行，而后再实例化子类对象，调用子类的构造方法。而这个时候，对于子类的构造而言，就相当于隐含了一个super()的形式:
class B extends A { public B() { // 子类构造 super(); // 调用父类构造 System.out.println("#########################"); }}现在默认调用的是无参构造，而如果这个时候父类没有无参构造，则子类必须通过super()调用指定参数的构造方法:
package com.wz.extendsdemo;class A { public A(String msg) { // 父类构造 System.out.println("*************************"); }}class B extends A { public B() { // 子类构造 super("Hello"); // 调用父类构造 System.out.println("#########################"); }}public class TestDemo { public static void main(String args[]) { B b = new B(); // 实例化子类对象 }}运行结果：
*************************#########################在任何的情况下，子类都逃不出父类构造的调用，很明显，super调用父类构造，这个语法和this()很相似：super调用父类构造时，一定要放在构造方法的首行上。