抽象类和接口

一、抽象类和抽象方法

abstract修饰的类是抽象类，修饰的方法时抽象方法；

抽象方法没有方法体，如果一个类中含有抽象方法，这个类 一定是抽象类，也就是抽象类中可以有抽象方法和非抽象方法，抽象类不能实例化。

//抽象类
public abstract class Shape {
    String name;
    //抽象方法
    public abstract double area() ;
    //非抽象方法
    public void show() {
    }
    //游离块
    {
        System.out.println("游离块");
    }
    //构造器
    public Shape(String name) {
        this.name = name;
    }
}

public static void main(String[] args) {
    Shape s = new Shape("图形"); //错误，抽象类不能实例化
}

一个类继承抽象类，子类可以是抽象类也可以是非抽象类，抽象类不必一定重写抽象方法；非抽象类一定要重写抽象方法。就可以实例化子类对象了

//正确的，因为子类也是抽象类，允许继承的抽象方法存在
public abstract class GuizeShape extends Shape{

}

 非抽象类继承抽象类，一定要重写抽象方法！

public class Rect extends Shape{
    private double height;
    private double width;
    //非抽象类中 不允许有继承的抽象方法，对抽象方法进行重写(实现)
    @Override
    public double area() {
        return height*width;
    }
}

为什么要定义抽象类？

模板设计模式

        通过定义一个抽象类，包含了抽象方法和非抽象方法，在非抽象方法中调用了抽象方法，整个抽象类就相当于一个模板，程序员必须要继承抽象类，重写抽象方法，才能使用模板类中的非抽象方法功能。

//模板设计模式
//银行存款
public abstract class BankRate {
    public abstract double getBenjin();
    public abstract double getRate();
    //利息 = 本金*利率
    public double lixi() {
        return getBenjin()*getRate();
    }
}

public class TestRate extends BankRate{
    @Override
    public double getBenjin() {
        // TODO Auto-generated method stub
        return 10000;    //存入本金10000
    }
    @Override
    public double getRate() {
        // TODO Auto-generated method stub
        return 0.03;    //存款利率3%
    }
    public static void main(String[] args) {
        TestRate tr = new TestRate();
        System.out.println(tr.lixi());    //300.0
    }
}

二、接口(interface)

定义接口

使用interface关键字 ，接口是interface，类是class。

接口中只能定义常量、抽象方法（但是在JDK8之后，接口中可以定义默认方法和静态方法）

//接口
public interface IFirst {
    //自动在所有的属性前面加 public static final ;也可以自己加
    String name = "TESTNAME";
    //public static final String name = "TESTNAME"; //定义常量
    //接口中的所有方法默认有abstract修饰的
    public void sayHello(); //定义抽象方法
}

定义一个类，实现(implements)接口 ，其实实现就是继承，只是类和类的继承用extends，类和接口的继承叫实现  用implements

实现类的名字 以Impl结尾的

public class FirstImpl implements IFirst{
    @Override
    public void sayHello() {
        System.out.println("Hello");
    }
}

注意事项

1. 一个类可以实现多个接口，implements后面写多个接口，用逗号隔开

public class FirstImpl implements IFirst,ISecond{
    @Override
    public void sayHello() {
        System.out.println("Hello");
    }
    @Override
    public void sayWorld() {
        System.out.println("world");
    }
}

2. 一个类既要实现接口，又要继承类 ，先写extends继承，再写implements实现

public class FirstImpl extends Animal implements IFirst,ISecond{
    @Override
    public void sayHello() {
        System.out.println("Hello");
    }
    @Override
    public void sayWorld() {
        System.out.println("world");
    }
}

3. 接口和接口之间也可以继承，可以是多继承 

public interface IFirst extends IA,IB{

}

类和类、类和接口以及接口和接口之间的关系

 接口的作用：

1. 制定标准规范

2. 设计

3. 降耦合 一个类调用了另一个类的功能，两个类具有耦合度的，可以使用接口降低类和类的耦合度

三、在设计中类的分类

1. 实体类

        实体类的对象，主要是存储数据的，也就是实体类只有 属性 和 getter/setter方法

2. 过程类

        过程类的对象，主要是对业务过程的描述。

3. 事件类

        主要是处理事件过程的。

四、类和类的关系

1. 继承关系：子类和父类的关系

关系图

        

2. 依赖关系：体现的是调用关系，理解为 use a

3. 关联关系：是一种强依赖关系，

4. 聚合关系：体现的是整体与部分的关系，理解为has-a

5. 组合关系：体现的是一种contains-a的关系，这种关系比聚合更强，也称为强聚合，整体与部分是不可分的

   

五、类和接口之间的关系：

实现关系：类实现interface接口，可以实现多个

关系图：

                

 六、接口和抽象类的区别？

1. 定义接口使用interface；定义类使用class

2. 接口中只能定义常量；抽象类中可以定义常量和变量

3. 接口只能定义抽象方法；抽象类中可以定义抽象方法和非抽象方法

4. 一个类实现了接口，要实现接口中所有的抽象方法，一个类可以实现多个接口；

    一个类继承了抽象类，要实现抽象类中的所有抽象方法，类和类是单继承

5. 接口和接口是多继承

6. 接口不能有构造方法，抽象类可以有构造方法。