一、抽象类
1、包含抽象方法的类，叫做抽象类
2、抽象方法。一个没有具体实现的方法，被abstract修饰
eg：
abstract class Shape {
public int a;
public void func(){
System.out.println("测试");
}
public abstract void draw();
}·在draw方法前加上abstract，表示这是一个抽象方法，同时抽象方法没有方法体（没有{}，不能执行具体代码）
·对于包含抽象方法的类，必须加上abstract关键字声明这是一个抽象类
3、不可实例化
在main函数中new一个Shape。编译结果如下：
public static void main(String[] args) {
Shape shape = new Shape() {
}
}4、因不能实例化，所以只能被继承
5、抽象类中，可以包含和普通类一样的成员和方法
从第一点的代码中我们可以看出，抽象类中可以包含和普通类一样的成员变量和方法。规则和普通类类似，可以被重写，也可以被子类直接使用。
6、普通类继承抽象类，普通类中需要重写抽象类中的所有抽象方法
class Rect extends Shape{
@Override
public void draw(){
System.out.println("♦");
super.func();
}
}此时我们定义一个类Rect（♦），类Rect通过extengs继承自抽象类Shape。
此时我们就需要重写抽象类当中的draw方法。
7、最大的作用→被继承
8、一个抽象类A，如果继承了一个抽象类B，那么这个抽象类A可以不实现父类的抽象方法
abstract class A extends Shape{
public abstract void funcA();
}此时我们定义一个新的抽象类A，类A继承自抽象类Shape，则类A当中可以不重写Shape中的抽象方法。
9、结合第八点，当A类再次被一个普通类C继承后，那么A和B这两个抽象类当中的抽象方法，C必须重写
class C extends A{
@Override
public void funcA(){
}
@Override
public void draw(){
}
}我们定义一个新的普通类C，类C继承自抽象类A，而类A又是继承自类Shape，那么此时类C中需要重写类A和类Shape中的抽象方法。
10、抽象类不能被final修饰，抽象方法也不能
final修饰代表不可修改、不可继承的，因此，抽象类不能被final修饰，抽象方法也类似。
二、接口
1、使用interface 来修饰
interface Name{
}代码格式如上
2、接口当中的普通方法，不能有具体的实现。非要实现，只能通过关键字default来实现
interface IShape{
public abstract void draw();//默认 public abstract
default public void func(){
System.out.println("默认方法");
}
}
3、接口当中可以有static方法
4、里面的所有方法都是public的
5、抽象方法默认是public abstract的
interface IShape{
void draw();//默认 public abstract
default public void func(){
System.out.println("默认方法");
}
}与第2点的代码相比较，抽象方法前删除public abstract也可编译成功，系统默认抽象方法是public abstract的。
6、接口不可以通过关键字 new 来实例化
public static void main(String[] args) {
IShape iShape = new IShape() {
};
}
7、类和接口之间的关系是通过implements实现的
interface IShape{
public abstract void draw();//默认 public abstract
}
class Flower implements IShape {
@Override
public void draw() {
System.out.println("❀");
}
}
class Triangle implements IShape{
@Override
public void draw(){
System.out.println("△");
}
}此时，我们写一个接口IShape，再写两个类Flower和Triangle，由代码段可以看到，两个类都是通过implements来实现接口的。
8、当一个类，实现了一个接口，就必须重写接口当中的抽象方法
在第7点代码段中，我们可以看到类Flower和类Triangle中都重写了接口IShape中的draw方法。
9、接口当中的成员，默认是public static final修饰的
interface IShape{
public abstract void draw();//默认 public abstract
default public void func(){
System.out.println("默认方法");
}
}10、当一个类实现一个接口之后，重写这个方法的时候，这个方法前必须加public
因为接口里面的方法都是public，并且在实现的时候修饰范围不能缩小，所以只能是public
11、一个类可以通过extends继承一个抽象类或者普通类，但只能继承一个，同时，也可以通过implements实现多个接口
class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
public void eat(){
System.out.println(name+"eat");
}
}
interface IJumping{
void jump();
}
interface ISwimming{
void swim();
}
class Flog extends Animal implements IJumping,ISwimming{
public Flog(String name) {
super(name);
}
@Override
public void jump(){
System.out.println(this.name+"正在跳");
}
@Override
public void swim(){
System.out.println(this.name+"正在游泳");
}
}此时，我们定义了一个Animal类作为父类，定义两个接口→IJumping和ISwimming，此时子类Flog类继承自父类Animal并且实现了IJumping和ISwimming接口。在Flog类中，我们可以看到，重写了两个接口的抽象方法。
12、接口和接口之间存在的关系
接口和接口之间，使用extends来操作，此时意为：拓展
一个接口B通过extends来拓展另外一个接口A的功能，此时当一个类C实现了这个接口B的时候，此时重写的时候，不仅仅是B的抽象方法，还有他从A接口拓展来的功能
interface IJumping{
void jump();
}
interface Irunning extends IJumping{
void run();
}
class Cat extends Animal implements Irunning{
public Cat(String name){
super(name);
}
@Override
public void jump() {
System.out.println(this.name+"正在跳");
}
@Override
public void run() {
System.out.println(this.name+"正在跑");
}
}
public static void runFunc(Irunning irunning){
irunning.jump();
irunning.run();
}
runFunc(new Cat("王一鸣"));此时，Irunning接口继承自IJumping接口，并且在Irunning接口中有其自己的抽象方法，此时来了一个Cat类实现了Irunning接口，那么在Cat类中就需要重写IJumping接口和Irunning接口中的抽象方法。
之后，通过在主函数声明一个静态runFunc方法，通过关键字new一个Cat实例。输出结果如下：
13、扩展知识
final关键字代表最终的、不可改变的
常见的四种用法：
①可以用来修饰一个类
作用：使当前这个类不能有任何子类
②可以用来修饰一个方法
作用：当final关键字用来修饰一个方法的时候，这个方法就是最终方法，不能够被覆盖重写
③可以用来修饰一个局部变量
作用：当fina关键字用于修饰局部变量的时候，这个局部变量就不能更改，“一次赋值，终生不变”。
④可以用来修饰一个成员变量
作用：用final修饰的成员变量不可变