一.抽象类

在某些情况下，父类知道其子类应该包含哪些方法，但是无法确定这些子类如何实现这些方法。这种有方法签名但是没有具体实现细节的方法就是抽象方法。有抽象方法的类只能被定义成抽象类，抽象方法和抽象类必须使用abstract修饰。抽象类里可以没有抽象方法。

1.1 抽象类和抽象方法

      抽象类和抽象方法的规则如下：

      1.抽象类和抽象方法都必须使用abstract修饰符修饰，抽象方法不能有方法体

      2.抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器创建抽象类的实例。即使这个抽象类里不包含抽象方法。

      3.抽象类可以包含成员变量，方法（普通方法、抽象方法），构造器，初始化块，内部类（接口，枚举类）5中成分。抽象类的构造器不能用于创建实例，主要是用于被子类调用。

      4.含有抽象方法的类（直接定义了一个抽象方法；继承了一个父类，没有完全实现父类包含的抽象方法；或实现一个接口，但没有完全实现接口包含的抽象方法）只能被定义成抽象类。

    定义抽象方法只需在普通方法上加上abstract修饰符，并把普通方法的方法体全部去掉，并在方法后增加分号即可

    定义抽象类只需在普通类上增加abstract修饰符即可。

   抽象类不能用于创建实例，只能当作父类被其他子类继承。

package com.company2;

abstract class Shape{
    private String color;
    //定义一个计算周长的方法
    public abstract  double calPerimeter();
    //定义一个返回形状的方法
    public abstract  String getType();

    public Shape(String color) {
        this.color = color;
    }

    public Shape() {
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

public class Triangle extends Shape{
    
    private double a;
    private double b;
    private double c;

    public Triangle(String color, double a, double b, double c) {
        super(color);
        setSides(a,b,c);
    }
    
    public void setSides(double a, double b, double c)
    {
        if(a+b > c || a+c > b || b+c > a){
            this.a = a;
            this.b = b;
            this.c = c;
        }
        System.out.println("三角形两边之和必须大于第三边");
    }
    @Override
    public double calPerimeter() {
        return a+b+c;
    }

    @Override
    public String getType() {
        return "三角形";
    }
}

        当使用abstract修饰类时，表明这个类只能被继承；当使用abstract修饰方法时，表明这个方法必须有子类提供实现（重写）。而final修饰的方法不能被重写，final修饰的类不能被继承。因此final

和abstract永远不能同时使用。static和abstract不能同时修饰某个方法，没有类抽象方法的说法，但可以同时修饰内部类。abstract也不能修饰变量和构造器。

       利用抽象类和抽象方法的优势，可以更好地发挥多态的优势，使得程序更加灵活。

1.2 抽象类的作用

    从语义的角度来看，抽象类是从多个具体类中抽象出来的父类，它具有更高层次的抽象，它体现的是一种模板模式的设计。抽象类作为多个子类的通用模板，子类在抽象类的基础上进行

拓展，改造，避免了子类设计的随意性。

抽象类的普通方法可依赖与抽象方法，抽象方法则推迟到子类中提供实现

package com.company2;

abstract class Speedmeter
{
    private double turnRate;//转速

    public Speedmeter() {
    }
    //把返回车轮半径的方法定义成抽象方法
    public abstract double getRadius();
    public void setTurnRate(double turnRate){
        this.turnRate = turnRate;
    }
    public double getSpeed()
    {
        return Math.PI*2*getRadius()*turnRate;
    }
}
public class CarSpeedmeter extends Speedmeter{

    @Override
    public double getRadius() {
        return 0.28;
    }

    public static void main(String[] args)
    {
        CarSpeedmeter csm = new CarSpeedmeter();
        csm.setTurnRate(15);
        System.out.println(csm.getSpeed());
    }
}

模板模式在面向对象的软件中很常用，其原理简单，实现也简单。下面是使用模板模式的一些简单规则：

1.抽象父类可以只定义需要使用的某些方法，把不能实现的部分抽象成抽象方法，留给其子类实现。

2.父类中可能包含需要调用其他系列方法的方法。这些被调用方法既可以由父类实现，也可以由子类实现。父类提供的方法只是定义了一个通用算法，其实现也许并不完全由自身实现，必须

   依赖于其子类的帮助。

二. Java 8改进的接口（interface）

2.1 接口的概念

      接口是多个相似类中抽象出来的一组公共行为规范，接口不提供任何实现，它体现的是规范和实现分离的哲学。

     规范和实现分离正是接口的好处，它让软件系统各组件之间面向接口耦合，可以为软件系统提供很好的松耦合设计，从而降低个模块间的耦合，为系统提供更好的可拓展性和可维护性。

     接口可以有多个直接父接口，但接口只能继承接口，不能继承类

2.2 接口的定义规则

      1.由于接口定义的是一种规范，用interface跟class区分，因此接口里不能包含构造器和初始化块定义。接口里可以包含成员变量（只能