第九课时

继承
目录

继承的概念
继承的实现
继承中成员访问的特点
父类与子类
继承的练习
1、继承的概念
继承涉及将父类的特征和行为传给子类，所以子类的特征和行为与其父亲非常相似。
在OOP 术语中如果有两个类，它们或多或少地具有一组相同的属性和方法。我们可以创建一个具有两个类共同属性的父亲，再编写两个子类继承父类的全部或部分属性，而不是创建两个单独的类。这样可以确保相同部分的属性和方法只编写了一次，而不是两次，减少了编码量，并提高了代码的可用性。
有多种表示父类和子类的术语，如父类，（parent class )，子类（child class )，超类和子类，基类和派生类等，有一点要注意，即派生类是基类的特化类，因此常常说基类食一般化，而派生类是特殊法。
2、继承的实现
2.1、继承的格式:
在Java中，使用关键字extends来继承类，方法如下:
public class 子类名 extends 父类名{
//程序代码
}
2.2、继承的实现
eg:
题目:

程序代码如下:
①
package com.hg.day09.demo01;
//员工
public class Employee {
String name;
int age;

public void method() {
System.out.println(“我是父类–员工的方法”);
}
②
package com.hg.day09.demo01;
//老师
public class Teacher extends Employee {
public void methodChildren() {
System.out.println(“我是子类–老师的方法”);
System.out.println(“我可以教授知识”);
}
③
package com.hg.day09.demo01;
//助教
public class Assistant extends Employee{
public void methodChildren() {
System.out.println(“我是子类–助教的方法”);
System.out.println(“我要改作业”);
}
④
package com.hg.day09.demo01;

public class Demo01Extends {
public static void main (String[] args) {
Teacher teacher = new Teacher();
teacher.method();
teacher.methodChildren();

Assistant assistant = new Assistant();
assistant.method();
assistant.methodChildren();

}
运行结果如下:

3、继承中成员访问的特点
3.1、继承中变量的访问特点
在子类方法中访问一个变量，采用的是就近原则。
1.子类局部范围找
2.子类成员范围找
3.父类成员范围找
4.如果都没有就报错(不考虑父亲的父亲…)
eg:
①
package com.hg.day09.demo02;

public class Fu {
int numFu=10;
int num=100;

public void methodFu() {
System.out.println(“我是父类的方法:”+num);
}
②
package com.hg.day09.demo02;

public class Zi extends Fu{
int numZi=20;
int numFu=200;
//int num = 200;

public void methodZi() {
//int num = 2000;
System.out.println(“我是子类的方法:”+num);
}
③
package com.hg.day09.demo02;

/*

成员变量的使用
1.直接使用成员变量
2.在类定义里面使用成员变量
*/
public class Demo02Extends {
public static void main (String[] args) {
Fu fu = new Fu();
System.out.println(fu.numFu);
System.out.println("=============");

Zi zi = new Zi();
System.out.println(zi.numFu);
System.out.println(zi.numZi);
System.out.println("=============");

System.out.println(zi.num);
//System.out.println(zi.abc);
//左边new的谁，就先调用谁的成员变量；如果没有，再一次在父类找。
System.out.println("=============");
zi.methodZi();
//zi.methodFu();
}
3.2、super
1.this&super关键字：
this：代表本类对象的引用
super：代表父类存储空间的标识(可以理解为父类对象引用)
2.this和super的使用分别
成员变量：
this成员变量-访问本类成员变量
super成员变量-访问父类成员变量
成员方法：
this成员方法-访问本类成员方法
super成员方法-访问父类成员方法
构造方法:
this(…)-访问本类构造方法
super(…)-访问父类构造方法
eg:
①
package com.hg.day09.demo05;

public class Fu {
public Fu() {
System.out.println(“父类的无参构造”);
}
public Fu(int num){
System.out.println(“父类一个参数的 有参构造方法”);
}
public Fu(int num,String name){
System.out.println(“父类两个参数的 有参构造方法”);
}
②
package com.hg.day09.demo05;
/*

子类方法构造中 有一个默认隐含的super（）调用，所以先调用父类的构造方法，后再执行之类的构造方法。

子类构造方法可以通过super来调用父类的重载构造方法。

子类一定会调用父类的构造方法，如果我们不写，编译器会自己赠送一个super（）;
如果我们写了就可以通过super（）调用父类的重载方法。

*/
public class Zi extends Fu {
public Zi() {
//super(50);
super(20,“精神小伙”);
System.out.println(“子类的无参构造方法”);

}
③
package com.hg.day09.demo05;

public class Demo05Extends {
public static void main (String[] args) {
Zi zi = new Zi();
}
1
2
}
3.3、super内存图
对象在堆内存中，会单独存在一块super区域，用来存放父类的数据

3.4、方法重写
1.方法重写概念
子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）
2.方法重写的应用场景
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容
3.Override注解
用来检测当前的方法，是否是重写的方法，起到【校验】的作用
eg:
①

package com.hg.day09.demo03;

public class Fu {
public void methodFu() {
System.out.println(“我是父类的方法 methodFu”);
}
public void method() {
System.out.println(“我是父类的方法 method”);
}
②
package com.hg.day09.demo03;

public class Zi extends Fu{
public void methodZi() {
System.out.println(“我是子类的方法 methodZi”);
}
//参数不一样 是方法的重载
//子类和父类的方法完全不一样 方法的重写 override
//注解 注释
@Override
public void method() {
System.out.println(“我是子类的方法 method”);
}

③
package com.hg.day09.demo03;

public class Demo03Extends {
public static void main (String[] args) {
Zi zi = new Zi();
zi.methodFu();
zi.methodZi();

zi.method();

Fu fu = new Fu();
//fu.methodZi();

}

4、父类与子类
继承的主要优势在于代码的可重用性，一个类一经定义和调试便可以用来创建新的子类。这样做除了节约大量的时间和精力之外，还无需重新输入相同的代码。另外，父类的数据和方法可用于它的子类。但如果将父类的数据和方法声明为私有使用（关键字为private )。则子类不能访问他们。
eg:
父类:
package com.hg.day09.demo06;

public class Fu {
int num = 100;

public void method() {
System.out.println(“父类方法”);
}
1
2
3
}
子类
package com.hg.day09.demo06;
/*

总结super的三种用法：
1.在子类的成员方法中，访问父类的成员变量。
2.在子类的成员方法中，访问父类的成员方法。
3.在子类的构造方法中，访问父类的构造方法（包括重载方法）

*/
public class Zi extends Fu{
int num = 20;
public Zi() {
super();
}

public void method() {
System.out.println(“子类方法”);
}

public void methodZi() {
System.out.println(num);
//就想访问父类的num

System.out.println(super.num);
super.method();
1
2
}

}
③
package com.hg.day09.demo06;

public class Demo06Extends {
public static void main (String[] args) {
Zi zi = new Zi();

zi.methodZi();

}
1
2
}

5、继承的练习
题目如下:

运行代码如下:
①
package com.hg.day09.demo04;

public class Phone {
public void call(){
System.out.println(“打电话”);
}
public void send(){
System.out.println(“发消息”);
}
public void show(){
System.out.println(“老手机显示号码”);
}
②
package com.hg.day09.demo04;

public class NewPhone extends Phone{
public void show() {
//System.out.println(“显示号码”);

//this
super.show();
System.out.println("显示头像");
System.out.println("显示归属地");

}
③
package com.hg.day09.demo04;

public class Demo04Phone {
public static void main (String[] args) {

Phone phone = new Phone();
phone.call();
phone.send();
System.out.println("=");
phone.show();
System.out.println("===========");

NewPhone newphone = new NewPhone();
newphone.call();
newphone.send();
System.out.println("=");
newphone.show();
System.out.println("===========");
}