Java学习
Day09
继承
目录
- 继承的概念
- 继承的实现
- 继承中成员访问的特点
- 父类与子类
- 继承的练习
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();
}
}
运行结果:
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("父类方法");
}
}
子类
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);
//就想访问父类的numSystem.out.println(super.num); super.method();
}
}
③
package com.hg.day09.demo06;
public class Demo06Extends {
public static void main (String[] args) {
Zi zi = new Zi();
zi.methodZi();
}
}
运行结果:
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("=============");
}
}
运行结果:
tip:2020080605006