一、多态
某一个事物,在不同时刻表现出来的不同状态。
1.多态的前提:
(1)要有继承关系
(2)要有方法重写,没有重写的话就没有意义
(3)要有父类引用指向子类
父类名 对象名=new 子类名();
代码如下(示例):
package com.xupt;
class Demo {
public static void main(String[] args) {
//旧方法
Cat cat = new Cat();
cat.eat();
cat.Catchmouse();
System.out.println("=============");
//多态的方法
Animal an=new Cat();
an.eat();//采用这种方法,子类重写了父类的方法,那么在用父类调用此方法时,会以子类重写后的为准
((Cat) an).Catchmouse();
}
}
class Animal{
public void eat(){
System.out.println("吃饭");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("吃鱼");
}
public void Catchmouse(){
System.out.println("抓老鼠");
}
}
说明:在这个例子中演示了两种方法来执行方法,在用多态的方法时,注意格式
Animal an=new Cat(); 用父类来定义一个新对象,子类会重写父类,包括其中的方法。
用an来执行方法,会先在父类中寻找,父类中有就用父类的,但是这时候父类的方法已经被子类重写,所以相当于是用子类的;如果父类中没有就去子类中找,找到就用;父类子类中都没有的话就 报错。
抽象类
在Java中,一个没有方法体的方法应该定义为抽象方法,而类中如果有抽象方法,该类必须定义为抽象类。
特点:
1.抽象类和抽象方法必须用abstract关键字修饰
抽象类格式: abstract class 类名 {}
抽象方法格式: public abstract void eat();
2.抽象类不一定有抽象方法,有抽象方法的类一定是抽象类
3.抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?
用于子类访问父类数据时的初始化
4.抽象类不能直接实例化那么,抽象类如何实例化呢?
按照多态的方式,由具体的子类实例化。其实这也是多态的一种,抽象类多态。
5.抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法
抽象类举例:
public abstract class Teacher {
public String name;
public int age;
public abstract void teachjava();
}
其中Teacher是一个抽象类,teacherjava()是一个抽象方法
抽象类的成员特点
a:成员变量:既可以是变量,也可以是常量。
b:构造方法:有。用于子类访问父类数据的初始化。
c:成员方法:既可以是抽象的,也可以是非抽象的。
抽象类不能和下列关键字共存
private 冲突
final 冲突
static 不能共存 无意义
二、接口
1.接口特点
a:接口用关键字interface表示 格式: interface 接口名 {}
b:类实现接口用implements表示 格式: class 类名 implements 接口名 {}
c:接口不能实例化
那么,接口如何实例化呢?
按照多态的方式来实例化。
d:接口的子类
(1):可以是抽象类。但是意义不大。
(2):可以是具体类。要重写接口中的所有抽象方法。
三、综合案例
编写java程序,分析如下需求,写出你分析的类有哪些,以及功能。最后写一个测试类,针对每个类的功能进行测试。
共性:
属性:姓名,年龄
功能:讲课。
现在又要针对日语单独开班,
需要部分老师会说日语。
请用所学知识把上面的内容用代码体现。
代码如下(示例):
public abstract class Teacher {
public String name;
public int age;
public abstract void teachEnglish();
}
public interface Japanese {
public void teachJapanese();
}
public class Basicteacher extends Teacher {
@Override
public void teachEnglish() {
System.out.println(“这个老师是教英语的”);
}
}
class A extends Basicteacher implements Japanese{
@Override
public void teachEnglish() {
super.teachEnglish();
}
@Override
public void teachjapanese() {
System.out.println(“这个老师会教日语”);
}
}
class B extends Basicteacher{
@Override
public void teachEnglish() {
super.teachEnglish();
}
}
class Jteacher extends Teacher{
@Override
public void teachEnglish() {
System.out.println(“这个老师是教日语班的”);
}
}
class C extends Jteacher implements Japanese{
@Override
public void teachEnglish() {
super.teachEnglish();
}
@Override
public void teachjapanese() {
System.out.println(“这个老师会教日语”);
}
}
class D extends Jteacher{
@Override
public void teachEnglish() {
super.teachEnglish();
}
}
public class Demo {
public static void main(String[] args) {
A a = new A();
Basicteacher basicteacher=a;
basicteacher.name=“张三”;
basicteacher.age=23;
System.out.println(basicteacher.name+"==="+basicteacher.age);
basicteacher.teachEnglish();
((A) basicteacher).teachjapanese();
System.out.println("================");
B b = new B();
Basicteacher basicteacher1=b;
basicteacher1.name=“李四”;
basicteacher1.age=33;
System.out.println(basicteacher1.name+"==="+basicteacher1.age);
basicteacher1.teachEnglish();
System.out.println("==================");
C c = new C();
Jteacher jteacher=c;
jteacher.name=“王五”;
jteacher.age=44;
System.out.println(jteacher.name+"==="+jteacher.age);
jteacher.teachEnglish();
(© jteacher).teachjapanese();
System.out.println("=====================");
D d = new D();
Jteacher jteacher1 =d;
jteacher.name=“赵六”;
jteacher.age=56;
System.out.println(jteacher.name+"==="+jteacher.age);
jteacher.teachEnglish();
}
结果:
张三===23
这个老师是教英语班的
这个老师会教日语
-------------------------------
李四===33
这个老师是教英语班的
----------------------------------
王五===44
这个老师是教日语班的
这个老师会教日语
-------------------------------
赵六===56
这个老师是教日语班的
下面对这个案例进行讲解:
A,B,C,D都是嵌套继承,而A,C中用到了接口中的方法teachJapanese(),被额外赋予了这个功能 。所以四人虽然都是老师,掌握的功能却不相同,其中teachEnglish()是从最顶层继承下来的公共功能,大家都有。