1、抽象类

(1)抽象类概述

（2）抽象类的定义和实现

```public abstract class Shape {
public int width;
public int length;

public Shape(int width, int length) {
this.length = length;
this.width = width;
}

public Shape() {

}

public abstract double area();
}```

定义Square类，继承抽象类，重写抽象方法：

```public class Square extends Shape{

public Square(int width,int length){
super(width,length);
}

public double area() {
return width*length;
}

}```

```public  class Circle extends Shape {
}
public double area() {
}

}```

```public class Test {
public static void main(String[] args) {
Circle c=new Circle(1);
System.out.println("圆的面积为"+c.area());
Square s=new Square(1,2);
System.out.println("长方形的面积为"+s.area());
}
}```

（3）抽象类的特点

2、接口

（1）接口的特点

```interface Shape {
public static final double pi = Math.PI;

public abstract double getArea();

public abstract double getL();
}```

```public class Circle implements Shape {

}

}

}

public double getArea() {
}

public double getL() {
return 2 * pi * radius;
}

}```

```public class Rectangle implements Shape {
private double width;
private double Length;

public Rectangle(double width, double Length) {
this.width = width;
this.Length = Length;
}

public double getWidth() {
return width;
}

public void setWidth(double width) {
this.width = width;
}

public double getLength() {
return Length;
}

public void setLength(double length) {
Length = length;
}

public double getArea() {
return width * Length;

}

public double getL() {
return 2 * (width + Length);
}

}```

```public class Test {
public static void main(String[] args) {
Circle c = new Circle(2);
System.out.println("圆的面积为" + c.getArea());
System.out.println("圆的周长为" + c.getL());

Rectangle r = new Rectangle(1, 2);
System.out.println("长方形的面积为" + r.getArea());
System.out.println("长方形的周长为" + r.getL());

}
}```

（2）接口的继承

```interface Shape1 {
public static final double pi = Math.PI;

public abstract double getArea();

}```

```interface Shape2 {
public abstract double getL();
}```

```public class Circle implements Shape1, Shape2 {

}

}

}

public double getArea() {
}

public double getL() {
return 2 * pi * radius;
}

}```

```public class Test {
public static void main(String[] args) {
Circle c = new Circle(2);
System.out.println("圆的面积为" + c.getArea());
System.out.println("圆的周长为" + c.getL());
}
}```

（3）接口的好处

实现多重继承。

接口可以降低耦合性（功能能够重复利用）。

3、抽象类和接口的异同

（1）抽象类可以有普通方法，而接口只能为抽象方法，不能有普通方法，但是JDK8以后接口中可以添加使用default或者static修饰的方法（default修饰方法只能在接口中使用，在接口中被default标记的方法为普通方法，可以直接写方法体），例如在Comparator接口中有如下default修饰的方法：

``` default Comparator<T> thenComparing(Comparator<? super T> other) {
Objects.requireNonNull(other);
return (Comparator<T> & Serializable) (c1, c2) -> {
int res = compare(c1, c2);
return (res != 0) ? res : other.compare(c1, c2);
};
}```

（2）一个类可以实现多个接口，但是只能继承一个抽象类

（3）关键字不同：抽象类的继承extends，接口的实现implements

（4）在需要降低代码冗余的时候采用抽象类，否则可以使用接口，面向接口编程能够降低代码的耦合度

（5）抽象类可以有构造⽅方法，接⼝口中不不能有构造⽅方法

（6）抽象类中的抽象⽅方法的访问类型可以是public，protected，但接⼝中的抽象方法只能是public类型的，并且默认即为public abstract类型。

（7）抽象类中可以包含静态方法，接⼝中不能包含静态方法。抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。

4、抽象的（abstract）方法是否可同时是静态的（static）,是否可同时是本地方法（native），是否可同时被synchronized修饰

synchronized和方法的实现细节有关，抽象方法不涉及实现细节，因此也是相互矛盾的。