黑马程序员全套Java教程_Java基础教程_继承（十七）

黑马程序员全套Java教程_Java基础教程_继承（十七）

1.1 继承概述1.2 继承的好处和弊端1.3 继承中变量的访问特点1.4 super1.5 继承中构造方法的访问特点1.6 继承中成员方法的SEO靠我访问特点1.7 super的内存图1.8 方法重写1.9 方法重写的注意事项1.10 继承的注意事项案例一：老师和学生案例二：猫和狗

1.1 继承概述

在这两个类中，有一部分内容是相同的，包括相同的成员变SEO靠我量和相同的方法，这部分相同的内容我们统称为相同的特征，假如我们把这些相同的特征提取出来，并且也用一个类表示，变成下面这样子。

这个新的类还没有名字，里面有两个成员变量和对应的get/set方法。而另一边SEO靠我，学生类和老师类的效果已经和以前不一样了。有没有一种机制让学生类和老师类拥有这个不知道名字的类的内容，使他们之间产生联系呢？这种机制就是继承。

继承是面向对象三大特征之一，可以使得子类具有父类的属性和方SEO靠我法，还可以在子类中重新定义，追加属性和方法。继承的格式：

（1）格式：public class 子类名extends 父类名{}

（2）范例：public class Zi extends Fu{}

Fu即SEO靠我父类（基类、超类）；Zi即子类（派生类）。继承中子类的特点：

（1）子类可以有父类的内容。

（2）子类还可以有自己特有的内容。Demo.java public class Demo {puSEO靠我blic static void main(String[] args) {Fu fu = new Fu();fu.show();Zi zi = new Zi();zi.method();zi.shoSEO靠我w();} }

Fu.java

public class Fu {public void show(){System.out.println("show方法被调用");} SEO靠我}

Zi.java

public class Zi extends Fu{public void method(){System.out.println("method方法被调用");} SEO靠我}

运行结果

1.2 继承的好处和弊端

继承的好处：

（1）提高了代码的复用性（多个类相同的成员可以放到同一个类中）

（2）提高了代码的维护性（如果方法的代码需要修改，修改一处即可）继承的弊端：继承让类与类之间SEO靠我产生了关系，类的耦合性增加了，当父类发生变化时子类也不得不跟着变化，削弱了子类的独立性。什么时候使用继承：

（1）继承体现的关系：is a，……是……的一种。

（2）假设法：我们有两个类A和B，如果他们满SEO靠我足A是B的一种，或者B是A的一种，说明他们存在继承关系，这个时候就可以考虑使用继承来体现，否则就不能滥用继承。

（3）举例：苹果和水果，猫和动物可以。而猫和狗就不可以。面向对象的四个特征之二——继承

（1SEO靠我）是从已有类得到继承信息（包括已有类相同的属性和相同的方法）创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。

（2）继承的作用：让变化中的软件系统有了一定SEO靠我的延续性，同时继承也是封装程序中可变因素的重要手段（如果不能理解请阅读阎宏博士的《Java与模式》或《设计模式精解》中关于桥梁模式的部分）。

1.3 继承中变量的访问特点

在子类方法中访问一个变量，其查找SEO靠我变量时的查找顺序：

（1）子类局部（方法内部）范围找；

（2）子类成员变量范围找；

（3）父类成员变量范围找；

（4）如果都没有就报错（不考虑父亲的父亲…）。

Demo.java

public class DemSEO靠我o {public static void main(String[] args) {Zi zi = new Zi();zi.show();} }

Fu.java

public classSEO靠我 Fu {//年龄public int age = 40; }

Zi.java

public class Zi extends Fu {//身高public int height = 17SEO靠我5;//年龄public int age = 20;public void show(){int age = 30;System.out.println(age);System.out.printlnSEO靠我(height);} }

输出结果：30，如果没有int age = 30则输出结果为20。

1.4 super

super关键字的用法和this关键字的用法相似：

（1）this：代表本类对SEO靠我象的引用（this关键字指向调用该方法的对象，一般我们是在当前类中使用

this关键字，所以我们常说this代表本类对象的引用）；

（2）super：代表父类存储空间的标识（可以理解为父类对象引用）。 SEO靠我 关键字访问成员变量访问构造方法访问成员方法thisthis.成员变量，访问本类成员变量this(…)，访问本类构造方法this.成员方法(…)，访问本类成员方法supersuper.成员SEO靠我变量，访问父类成员变量super(…)，访问父类构造方法super.成员方法(…)，访问父类成员方法 public class Zi extends Fu {//身高public iSEO靠我nt height = 175;//年龄public int age = 20;public void show(){int age = 30;System.out.println(age);SystSEO靠我em.out.println(height);//如果要访问本类的成员变量age，怎么办呢？System.out.println(this.age);//如果要访问父类的成员变量age，怎么办呢？SySEO靠我stem.out.println(super.age);} }

1.5 继承中构造方法的访问特点

public class Demo {public static void main(StSEO靠我ring[] args) {//创建对象Zi zi = new Zi();} } public class Fu {public Fu(){System.out.prSEO靠我intln("Fu中无参构造方法被调用");}public Fu(int age){System.out.println("Fu中带参构造方法被调用");} } puSEO靠我blic class Zi extends Fu {public Zi(){System.out.println("Zi中无参构造方法被调用");}public Zi(int age){System.SEO靠我out.println("Zi中带参构造方法被调用");} }

运行结果一：父类和子类的无参构造方法都被调用了

public class Demo {public static void SEO靠我main(String[] args) {//创建对象Zi zi = new Zi();Zi zi2 = new Zi(20);} }

运行结果二：父类中的无参构造方法被调用了一次，子类SEO靠我中的有参、无参构造方法都被调用了一次

两个运行结果引出两个问题：（1）创建子类对象的时候为什么会访问父类的方法？（2）为什么访问的都是父类的无参构造方法？

子类中所有的构造方法默认都会访问父类中无参的构造SEO靠我方法，原因：

（1）子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，而访问父类的构造方法，就是为了完成父类数据的初始化。——解决第一个问题

（2）每一个SEO靠我子类构造方法的第一条语句默认都是：super()，这是自带的不管我们自己有没有写。——解决第二个问题如果父类中只有带参构造方法而没有无参构造方法，子类的构造方法第一条语句super()无法执行，就会报SEO靠我错。在不手写无参构造方法的情况下，怎么解决？

解决方法：直接手写super的带参构造方法。 public class Zi extends Fu {public Zi(){super(2SEO靠我0);System.out.println("Zi中无参构造方法被调用");}public Zi(int age){super(20);System.out.println("Zi中带参构造方法被调用SEO靠我");} }

1.6 继承中成员方法的访问特点

public class Demo {public static void main(String[] args) {Zi zi = newSEO靠我 Zi();zi.method();zi.show();} } public class Fu {public void show(){System.out.prinSEO靠我tln("Fu中show()方法被调用");} } public class Zi extends Fu {public void method(){System.oSEO靠我ut.println("Zi中的method()方法被调用");}public void show(){super.show();System.out.println("Zi中show()方法被调用"SEO靠我);} }

运行结果：

通过子类对象访问一个方法，其查找方法时的查找顺序：

（1）子类成员方法范围找；

（2）父类成员方法范围找；

（3）如果都没有就报错（不考虑父亲的父亲…）

1.7 superSEO靠我的内存图

public class Demo {public static void main(String[] args) {Zi zi = new Zi();zi.show();zi.method(SEO靠我);} }

首先程序从main方法开始执行，main方法加载到栈内存。

接着执行main方法里面的第一句：Zi z = new Zi()：左边的动作“Zi z”会加载到main方法里面。

而SEO靠我右边的“new Zi()”，首先会在堆内存申请一个空间，并进行子类数据的初始化，得age的值为20。空间的起始地址001最终赋值给main方法中的变量zi。public class Zi extendSEO靠我s Fu{public int age = 20;public Zi(){System.out.println(age);}public void show(){int age = 30;SystemSEO靠我.out.println(age);System.out.println(this.age);System.out.println(super.age);} }

接下来我们调用Zi类的构SEO靠我造方法Zi()，构造方法就会加载到栈内存。

进入到构造方法内，由于子类中所有的构造方法默认都会访问父类中无参的构造方法（每一个子类构造方法的第一条语句默认都是super()），所以我们看到Fu类里面。

调SEO靠我用Fu的无参构造方法前，要先进行Fu类内容的初始化，在堆内存申请一个super空间用于存储父类初始化的数据，空间内age的值为40。public class Fu{public int age = 4SEO靠我0;public Fu(){System.out.println("Fu类无构造方法被调用");}public void method(){System.out.println("Fu类method方SEO靠我法被调用");} }

接着我们调用Fu类的构造方法，构造方法加载到栈内存。在控制台输出“Fu类无参构造方法被调用”。Fu类无参构造方法执行完毕后从栈内存消失。

接着我们回到Zi类里面，ZiSEO靠我的构造方法访问完父类的无参构造方法之后接着往下执行，在控制台输出“Zi类无参构造方法被调用”。Zi类无参构造方法执行完毕后栈内存消失。

接着执行main方法的第二个语句：zi.show()。我们看到ZiSEO靠我类里面的show方法。show()方法加载到栈内存，

此时shou()的调用者的地址是001，则this的地址也是001。在show()方法里面定义了一个age=30，这个age就会在栈内存的show(SEO靠我)方法中存在。此时直接输出show方法的值，会输出30；通过this访问age的值，会访问地址为001的age的值20；通过super方法age的值，首先会找到调用者，通过调用者找到super，通过sSEO靠我uper访问下面age的值得40。

show方法执行完毕，从栈内存消失。

接下来回到主函数，执行第三个语句：zi.method()，首先我们发现Zi类中并没有method方法，所以我们其继承的Fu类中去找SEO靠我，将父类的method方法加载到栈内存。在控制台输出“Fu类method方法被调用”。method方法从栈内存消失。main方法执行完毕，从栈内存中消失。

1.8 方法重写

方法重写：子类中出现了和父类中SEO靠我一模一样的方法声明。方法重写的应用：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。练习：手机类和新手机类

Phone.jaSEO靠我va public class Phone {public void call(String name){System.out.println("给" + name + "打电话");SEO靠我} }

NewPhone.java

public class Phone {public void call(String name){System.out.println("给" + nSEO靠我ame + "打电话");} }

PhoneDemo.java

public class PhoneDemo {public static void main(String[] args)SEO靠我 {Phone phone = new Phone();phone.call("林青霞");NewPhone newPhone = new NewPhone();newPhone.call("林青霞"SEO靠我);} } @Override是一个注解（后面会学），可以帮助我们检查重写方法声明的正确性。

1.9 方法重写的注意事项

私有方法不能被重写（父类私有成员子类是不能继承的SEO靠我）子类方法访问权限不能更低（public>默认>私有）

1.10 继承的注意事项

Java中类只支持单继承，不支持多继承，如下列写法会报错： public class Son exSEO靠我tends Father, Mother{ } Java中类支持多层继承，如下列写法为正确的：

Granddad.java publicSEO靠我 class Granddad(){public void drink(){System.out.println("爷爷爱喝酒");} } public class SEO靠我Father extends Granddad(){public void somke(){System.out.println("爸爸爱抽烟");} } publiSEO靠我c class Son extends Father(){ }

案例一：老师和学生

需求：定义老师类和学生类，然后写代码测试；最后找到老师类和学生类当中的共性内容，抽取出一个父类，用继承的SEO靠我方式改写代码，并进行测试。实现思路：

（1）定义老师类（姓名，年龄，教书()）

（2）定义学生类（姓名，年龄，学习()）

（3）定义测试类，写代码测试

（4）共性抽取父类，定义人类（姓名，年龄）

（5）定义老师SEO靠我类，继承人类，并给出自己特有的方法：教书()

（6）定义学生类，继承人类，并给出自己特有的方法：学习()

（7）定义测试类，写代码测试前三步略

Person.java public clasSEO靠我s Person {private String name;private int age;public Person() {}public Person(String name, int age) SEO靠我{this.name = name;this.age = age;}.......

Teacher.java

public class Teacher extends Person {public TeaSEO靠我cher() {}public Teacher(String name, int age) {super(name, age);}public void teach(){System.out.prinSEO靠我tln("开始上课");} }

Student.java

public class Student extends Person {public Student() {}public StSEO靠我udent(String name, int age) {super(name, age);}public void study(){System.out.println("开始学习");} SEO靠我 }

Demo.java

public class Demo {public static void main(String[] args) {Teacher teacher1 = new TeacSEO靠我her();teacher1.setName("林青霞");teacher1.setAge(30);System.out.println(teacher1.getName() + "," + teacSEO靠我her1.getAge());teacher1.teach();Teacher teacher2 = new Teacher("风清扬", 33);System.out.println(teacherSEO靠我2.getName() + "," + teacher2.getAge());teacher2.teach();} }

值得注意的是，若要使用有参数的构造方法，我们要在Teacher类和SEO靠我Student类里面另写。

案例二：猫和狗

需求：请采用继承的思想实现猫和狗的案例，并在测试类中进行测试分析：

（1）猫

成员变量：姓名，年龄

构造方法：无参，带参

成员方法：get/set方法，抓老鼠()

（2）SEO靠我狗

成员变量：姓名，年龄

构造方法：无参，带参

成员方法：get/set方法，看门()

（3）共性

成员变量：姓名，年龄

构造方法：无参，带参

成员方法：get/set方法实现：

（1）定义动物类（Animal）

成员SEO靠我变量：姓名，年龄

构造方法：无参，带参

成员方法：get/set方法 public class Animal {private String name;private int age;puSEO靠我blic Animal() {}public Animal(String name, int age) {this.name = name;this.age = age;}..........

（2）定SEO靠我义猫类，继承动物类

构造方法：无参，带参

成员方法：抓老鼠()public class Cat extends Animal{public Cat() {}public Cat(String name, SEO靠我int age) {super(name, age);}public void seize(){System.out.println(this.getName() + "找Jerry玩");} SEO靠我 }

（3）定义狗类，继承动物类

构造方法：无参，带参

成员方法：看门()public class Dog extends Animal{public Dog() {}public Dog(StriSEO靠我ng name, int age) {super(name, age);}public void guard(){System.out.println("EDG NB！");} }

（4SEO靠我）定义测试类（AnimalDemo），写代码测试

public class AnimalTest {public static void main(String[] args) {Cat tom = nSEO靠我ew Cat("Tom", 2);tom.seize();Cat catKing = new Cat();catKing.setName("猫皇");catKing.setAge(25);catKinSEO靠我g.seize();} }