面向对象、多态、抽象类、接口

---

一、多态

某一个事物，在不同时刻表现出来的不同状态。

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（）是从最顶层继承下来的公共功能，大家都有。