继承和多态
继承
继承设计原则:对于已经投入使用的类,尽量不要进行修改。
推荐定义一个新的类,来重复利用其中共性内容,并且添加改动新内容。
理解:
继承是多态的前提,如果没有继承,就没有多态。
类比:师父会多少武功,大徒弟也都会,小徒弟也都会。
继承主要解决的问题就是:共性抽取。
父类
也可以叫基类、超类
子类
也可以叫派生类
继承关系当中的特点:
1.子类可以拥有父类的“内容”
2.以拥有自己专有的内容。
特点:
Java语言是单继承的
。一个类的直接父类只能有唯一一个。
class A {}
class B extends A {}//正确
class C{}
class D extends A,C{}//错误
Java语言可以多级继承
。
我有一个父亲,我父亲还有一个父亲,也就是爷爷。
因为:
格式:
在继承的关系中,“子类就是一个父类”。也就是说,子类可以被当做父类看待。
定义父类的格式:(一个普通的类定义)
public class父类名称{
/ / …
}
定义子类的格式:
public cLass 子类名称 extends 父类名称{
//…
}
子类可以调用父类的方法即使子类方法中什么也不写
代码:
//定义一个父类:员工
public class Employee {
public void method() {
System.out.println("方法执行!");
}
}
//定义了一个员工的子类:讲师
public class Teacher extends Employee {
}
public class Demoo1Extends {
public static void main(String[] args) {
//创建了一个子类对象
Teacher teacher = new Teacher();
//Teacher类当中虽然什么都没写,但是会继承来自父类的method方法。
teacher.method();
}
}
继承中成员变量的访问特点
在父子类的继承关系当中,如果成员变量
重名
,则创建子类对象时,访问有两种方式:
直接
通过子类对象访问成员变量:
规则:等号左边是谁,就优先用谁,没有则向上找。
Zi zi = new Zi();
System.out.println(zi.num);
间接
通过成员方法访问成员变量:
该方法属于准,就优先用谁,没有则向上找。
public class Zi extends Fu {
int numZi = 20;
int num = 200;
public void methodzi() {
//因为本类当中有num,所以这里用的是本类的num,而不是父类的num
System.out.println(num);
}
}
区分子类方法中重名的三种变量
局部变量: 直接写成员变量名
本类的成员变量: this.成员变量名
父类的成员变量: super.
成员变量名
在父子类的继承关系当中,创建子类对象,访问重名成员方法
的规则:
创建的对象是谁(看new的是谁),就优先用谁,如果没有则向上找。
new三重名
public class Zi extends Fu {
int num = 20;
public void method() {
int num = 30;
System.out.println(num); // 30,局部变量
System.out.println(this.num); // 20,本类的成员变量
System.out.println(super.num);// 10,父类的成员变量
}
}
继承中方法的覆盖重写
重写( Override)
概念:在继承关系当中,方法的名称一样,参数列表也一样。
重写
(Override):方法的名称一样,参数列表【也一样】。覆盖、覆写。
重载
(OverLoad):方法的名称一样,参数列表【不一样】。
方法覆盖重写的注意事项
;
1.必须保证父子类之间方法的名称相同,参数列表也相同。
@Override:写在方法前面,用来检测是不是有效的正确覆盖重写。这个注解就算不写,只要满足要求,也是正确的方法覆盖重写。
2.子类方法的返回值
必须【小于等于】
父类方法的返回值范围。
小扩展提示。java.Lang.object类是所有类的公共最高父类(祖宗类),java.Lang. string就是object的子类。
3.子类方法的权限
必须【大于等于】
父类方法的权限修饰符。
小扩展提示:public > protected > (default) > private
备注:(default)不是关键字default,而是什么都不写,留空。
//定义一个新手机,使用老手机作为父类
public class NewPhone extends Phone {
//@Override
public void show() {
super.show(); //把父类的show方法拿过来重复利用
//自己子类再来添加更多内容
System.out.println("显示姓名");
System.out.println("显示头像");
}
}
构造方法的访问特点
继承关系中,父子类构造方法的访问特点:
1.子类构造方法当中有一个默认隐含的“super()"调用,所以一定是先调用的父类构造,后执行的子类构造。
package cn.itcast.day09.demo07 ;
public class Fu {
public Fu() {
System.out.println("父类构造方法!");
}
}
package cn.itcast.day09.demo07;
public class Zi extends Fu {
public Zi() {
super(); //在调用父类无参构造方法,不写也照样有
System.out.println("子类构造方法!");
}
}
先输出父类构造
2.子类构造可以通过super关键字来调用父类重载构造
。
public class Fu {
public Fu() {
System.out.println("父类无参构造");
}
public Fu(int num) {
System.out.println("父类构造方法!");
}
}
public class Zi extends Fu {
public Zi() {
//super(); //在调用父类无参构造方法
super(20);//在调用父类重载的构造方法
System.out.println("子类构造方法!");
}
}
3.super的父类构造调用
,必须是子类构造方法的第一个语句。不能在一个子类写两个super
super(); //在调用父类无参构造方法
super(20);//在调用父类重载的构造方法
总结:
子类必须调用父类构造方法,不写则赠送super();写了则用写的指定的super调用,super只能有一个,还必须是第一个。
super关键字
super关键字的用法有三种:
1.在子类的成员方法中,访问父类的成员变量。
2.在子类的成员方法中,访问父类的成员方法。
3.在子类的构造方法中,访问父类的构造方法。
public class Zi extends Fu {
int num = 20;
public Zi(){
super();
}
public void methodZi() {
System.out.println(super.num); //父类中的num
}
public void method() {
super.method(); //访问父类中的method
System.out.println("子类方法");
}
}
this关键字
super关键字用来访问父类内容,而this关键字用来访间本类内容。用法也有三种:
1.在本类的成员方法中,访问本类的成员变量。
2.在本类的成员方法中,访问本类的另—个成员方法。
3.在本类的构造方法中,访问本类的另一个构造方法(注意:this(…)调用也必须是构造方法的第一个语句,也不能写多个。super和this两种构造调用,不能同时使用
)。
public Zi() {
//super(); //这一行不再赠送,赠送的话this就不是第一个了
this(123); //本类的无参构造,调用本类的有参构造
//this(1,2); //错误写法!不能同时写两个this调用
}
public Zi(int n) {
}
public Zi(int n, int m) {
}
}
public class Zi extends Fu {
int num = 20;
public void showNum( ) {
int num = 10;
System.out.println(num); //局部变量
System.out.print1n(this.num);//本类中的成员变量
System.out.println(super.num); //父类中的成员变量
}
public void methodA( ) {
System.out.println("AAA");
}
public void methodB() {
this.methodA();
System.out.println("BBB");
}
}
抽象
一个动物肯定可以吃东西,但是吃什么东西不一定
抽象方法和抽象类
抽象方法:就是加上abstract关键字,然后去掉大括号,直接分号结束。
抽象类:抽象方法
所在的类,必须是抽象类
才行。在cLass之前写上abstract即可。抽象类是__不能实例化
的类____。
如何使用
抽象类和抽象方法:
- 不能直接创建new抽象类对象。
- 必须用一个子类来继承抽象父类。
- 子类必须覆盖重写抽象父类当中所有的抽象方法。
覆盖重写(实现)∶子类去掉抽象方法的abstract关键字,然后补上方法体大括号。 - 创建子类对象进行使用。
public abstract class Animal {
//这是一个抽象方法,代表吃东西,但是具体吃什么(大括号的内容)不确定。
public abstract void eat();
}
public class Cat extends Animal {
public void eat() {
System.out.print1n("猫吃鱼");
}
}
public class MyClass {
public static void main(String[] args) {
Cat cat=new Cat();
cat.eat();
}
}
输出:猫吃鱼
例题:
public class Demo {
public static void main(String[] args) {
Demo demo = new Demo();
demo.show(new Car() {
public void run() {
System.out.println("demo run");
}
});
}
public void show(Car c) {
c.run();
}
}
abstract class Car {
public void run() {
System.out.println("car run...");
}
}
输出:
demo run
注意事项:
关于抽象类的使用,以下为语法上要注意的细节,虽然条目较多,但若理解了抽象的本质,无需死记硬背。
1.抽象类不能创建对象
,如果创建,编译无法通过而报错。只能创建其非抽象子类的对象。
理解:假设创建了抽象类的对象,调用抽象的方法,而抽象方法没有具体的方法体,没有意义。
2.抽象类中,可以有构造方法,是供子类创建对象时,初始化父类成员使用的。
理解:子类的构造方法中,有默认的super(),首先会访问父类构造方法。
3.抽象类中,不一定包含
抽象方法,但是有抽象方法的类必定
是抽象类。
理解:未包含抽象方法的抽象类,目的就是不想让调用者创建该类对象,通常用于某些特殊的类结构设计。
这样没有抽象方法的抽象类,也不能直接创建对象,在一些特殊场景下有用途。
public abstract class MyAbstract {
}
4.抽象类的子类,必须重写
抽象父类中所有的抽象方法
,否则,编译无法通过而报错。除非
该子类也是抽象类。
理解:假设不重写所有抽象方法,则类中可能包含抽象方法。那么创建对象后,调用抽象的方法,没有意义。
接口
生活中的接口举例:电源插座当中的电源接口
接口就是一种公共的规范标准
。
只要符合规范标准,就可以大家通用。
例如:只要符合USB接口的规范,那么各种设备都可以使用:
U盘、打印机、夜读灯、USB小风扇…
接口就是
多个类的公共