抽象类

只约定类所具有的抽象行为，没有具体实现相应的行为

为什么要使用抽象类

有时候子类不需要抽象化

抽象方法时没有方法体的方法

语法格式

abstract class{

常量；
变量
构造（）；
抽象方法；
//
普通方法；
静态方法（）；

}
1
2
3
4
5
6
7
8
9
10
11
12
abstract class TrafficToo{
    int count ;
    //没有具体的行为实现
    public abstract void run();
}
class Car extends TrafficToo{
    //必须实现抽象父类的所有方法
    public void run(){
        System.out.println("公路上行驶");
    }
}

public class Ex1 {

    public static void main(String[] args) {
        //抽象类不能有对象
//      TrafficToo tool = new TrafficToo();
//      tool.run();

        Car car = new Car();
        car.run();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
抽象类的使用场合

不适合创建对象，都是子类的对象
为所有的子类提供了模板
抽象类注意

抽象类不能创建对象
抽象类中可以包含抽象方法，也可以不包含
必须子类继承使用
普通的子类实现抽象父类，必须实现抽象父类中的所有方法（抽象子类除外）
构造器不能是抽象的
abstract 不能与private，static，final一起联用
接口

语法：

访问修饰符 interface 接口名{
    //接口中的所有成员都是public的
    常量； public static final
    抽象方法；  public abstract
    默认方法； default
    静态方法；  static
    静态内部类型 (静态内部 类，接口，枚举)
}
1
2
3
4
5
6
7
8
使用接口注意

接口不能创建对象
用实现类实现使用，普通的实现类必须实现接口的所有抽象方法（抽象实现类除外）
实现类可以实现多个接口的功能
接口之间可以多继承
如何使用接口

示例

//接口
interface MyBank{
    void  webSEvervice();//网上支付 public abstract void
}

//实现类1
class Jingdong implements MyBank{
    //卖东西
    @Override
    public void webSEvervice() {
        System.out.println("京东商城实现了网上支付");

    }

}

//实现类2
class Taobao implements MyBank{
    //卖东西
    @Override
    public void webSEvervice() {
        System.out.println("淘宝商城实现了网上支付");

    }

}
public class Ex3 {

    public static void main(String[] args) {
        Jingdong jingdong = new Jingdong();
        jingdong.webSEvervice();
        Taobao taobao = new Taobao();
        taobao.webSEvervice();

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
多个接口中 同名方法区分：
1. 静态默认方法，用接口名区分
2. 默认方法，实现类必须重写
调用区分：接口名.super.默认方法名
3.抽象方法,统一重写实现，反正都没有方法体

抽象类和接口的异同

相同
1. 都不能创建对象
2. 都有 抽象方法
3. 都是用 子类和实现类 创建对象来使用
4. 普通子类和实现类要实现抽象父类和接口中的所有抽象方法（抽象的除外）

不同
1. 子类只能继承一个抽象父类；（类是单一继承）
2. 实现来说，实现多个接口的功能
3. 接口可以多继承
4. 使用接口可以降低耦合性

多态

一种物质，多种存在形态。

程序中的多态

同一种引用类型，使用不通过的实例而执行不同的操作；

方法重写
父类引用 指向子类对象；接口引用指向实现类的写法
打印机 打印机1 = new 黑白打印机（）；
打印机 打印机2 = new 彩色打印机（）；

网银接口 网银1 = new 京东商城（）；
网银接口 网银2 = new 淘宝商城（）；

多态体现：

屏蔽了子类的差异，子类独特的功能屏蔽了，不能调用了

类多态

接口多态

类型转换

向上类型转换
子类型转为付类型
2. 向下类型转换
父类型转为子类型，需要强制类型转换

转换方式（子类类型）父类对象
1
2
instanceof判断对象属于哪个类或者接口，是此类或此接口返回true，不是返回false

//多态
class Pet{
    private String name;

    public String getName() {
        return name;
    }

    public Pet() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Pet(String name) {
        super();
        this.name = name;
    }
    //空实现
    public void eat(){}

}

class Dog extends Pet{


    public Dog() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Dog(String name) {
        super(name);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void eat() {
        // TODO Auto-generated method stub
        super.eat();
        System.out.println("小狗吃骨头");
    }
    public void run(){
        System.out.println("跑");
    }

}

class Cat extends Pet{

    public Cat() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Cat(String name) {
        super(name);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void eat() {
        // TODO Auto-generated method stub
        super.eat();
        System.out.println("小猫吃鱼");
    }

    public void play(){
        System.out.println("小猫去玩");
    }
}


class PetHospital{
    //看病   Dog -》 Pet  向上类型转换
    public void treatment(Pet pet){
        System.out.println(pet.getName()+"看病");
        pet.eat();
        if(pet instanceof Dog){
            Dog dog =(Dog) pet;//父转子强制类型转换
            dog.run();
        }else if(pet instanceof Cat){
            Cat cat =(Cat) pet;
            cat.play();
        }

    }
/*  public void treatment(Dog dog){

    }

    public void treatment(Cat cat){

    }*/
}
public class TestHospital {

    public static void main(String[] args) {
        Pet dog = new Dog("旺旺 ");
        dog.eat();


        PetHospital  hospital = new PetHospital();
        hospital.treatment(dog);


        Pet cat = new Cat("小花 ");
        cat.eat();

        hospital.treatment(cat);
    }

}
类之间的关系和类图

UML类图
1. 泛化（继承）
2. 实现（接口）
3. 依赖（使用）
4. 拥有（关联）
- 一对一
- 一对多
- 多对多
- 聚集：强关联 整体和局部的关系
局部离开了整体可以独立存在
- 组合：强聚集
局部离开了整体不可以独立存在

优秀