抽象类
为什么要有抽象类？
假设我有一个父类：Animal类
1 //创建一个动物类
2 public class Animal {
3 //动物有名字
4 public String name;
5 //动物有年龄
6 public String age;
7
8 //动物有吃的功能
9 public void eat(){
10 System.out.println("动物在吃东西");
11 }
12 }
子类：Cat类和Dog类
1 public class Dog extends Animal{
2 @Override
3 public void eat() {
4 System.out.println("小狗吃骨头");
5 }
6 }
7 class Cat extends Animal{
8 @Override
9 public void eat() {
10 System.out.println("小猫吃鱼");
11 }
12 }
发现每个子类都需要重写父类eat()方法，而且Animal类中eat()方法无法具体的写出动物吃什么，是无法确定的，因为动物是一个抽象的概念，无法具体为某种动物，所以这里需要用到抽象类。
抽象类和抽象方法的定义
抽象类的定义：需要用到abstract关键字来修饰。
抽象方法的定义：当不确定方法体的内容时，就需要用到抽象方法，需要用到abstract关键字修饰，而抽象方法不能有方法体,连{}都不能有。
语法：
abstract class 类名{
代码块;
}
举个例子：（而上面的例子就可以使用抽象类和抽象方法实现）
父类：Animal类
1 //创建一个动物类，父类可以写成一个抽象类
2 public abstract class Animal {
3 //动物有名字
4 public String name;
5 //动物有年龄
6 public String age;
7
8 //动物有吃的功能,但无法确定方法的具体实现，所以使用抽象方法
9 public abstract void eat();
10 }
子类：Dog类和Cat类
1 public class Dog extends Animal{
2 //子类继承抽象类后，必须重写抽象类中的抽象方法
3 //如果不实现抽象方法，则也需要定义成抽象类
4 @Override
5 public void eat() {
6 System.out.println("小狗吃骨头");
7 }
8 }
9 class Cat extends Animal{
10 //子类继承抽象类后，必须重写抽象类中的抽象方法
11 //如果不实现抽象方法，则也需要定义成抽象类
12 @Override
13 public void eat() {
14 System.out.println("小猫吃鱼");
15 }
16 }
注意：
①如果一个类继承抽象类时，必须实现抽象类中的所有抽象方法，否则该类也要是一个抽象类
②抽象类中可以抽象方法，也可以有普通的方法
③抽象类不能被实例化，但是有构造方法（是类就一定有构造方法）
④抽象方法必须使用abstract修饰，并且不能有方法体
⑤含有抽象方法的类一定是抽象类
接口
接口的理解
接口的本质是标准，规范，大家都要遵守的规则，比如现实中type-c接口，你想要充电就必须是圆口才可以插进去充电。
接口在jdk1.8以前接口中的所有方法都是抽象方法，所有的属性都是静态常量，而接口也能解决类中的局限性(单继承)
接口中的方法都是用 public abstract 修饰
接口中的属性都是用 public static final修饰
如何定义接口
语法：
public interface 接口名{
//成员-1.8以后
//1.静态常量成员
//2.抽象方法成员
}
举个例子：
1 //定义接口
2 public interface Animal {
3 //定义常量，只能赋值一次
4 //而接口中的属性都是静态常量，所以默认属性添加public final static修饰
5 public final static String name = "旺财";
6
7 //定义抽象方法
8 //而接口中的方法都是抽象方法，所以默认方法添加public abstract
9 public abstract void eat();
10 }
接口与接口之间继承关系
一个接口可以继承多个接口
语法：
interface 接口名 extends 接口名1，接口名2，.....，接口名n{
//代码内容
}
举个例子：
interface A{
//代码内容
}
interface B{
//代码内容
}
interface C extends A,B{
//代码内容
}
接口与类之间实现关系
使用implements关键字
语法：
public class 类名 implements 接口1，接口2，接口3，...... ，接口n{
//代码内容
}
举个例子：
1 //定义接口
2 public interface Animal {
3 //定义常量，只能赋值一次
4 //而接口中的属性都是静态常量，所以默认属性添加public final static修饰
5 public final static String name = "旺财";
6
7 //定义抽象方法
8 //而接口中的方法都是抽象方法，所以默认方法添加public abstract
9 public abstract void eat();
10 }
11 //类实现接口
12 class Cat implements Animal{
13 //需要重写接口中所有抽象方法
14 @Override
15 public void eat() {
16 System.out.println("小猫吃鱼");
17 }
18 }
接口的知识点：
（1）接口中声明的静态方法只能被接口调用，不能被其他实现类进行调用
（2）接口中声明的默认方法可以被实现类继承，实现类在没有重写方法的情况下，默认调用接口中声明的方法，如果实现类重写方法，则调用的是自己重写的方法。
（3）类实现两个接口，而两个接口中定义了同名同参的默认方法。则实现类在没有重写此两个接口默认方法下会报错---------->接口冲突
那如何继承父类，并实现接口呢？子类的格式要如何写呢？
很简单，先继承后实现接口。
举个例子：
class A extends SuperA implement B,C {
//代码内容
}
A相较于SuperA来讲是子类，A相较于B,C来讲叫做实现类。
总结一下：
①同类型之间使用继承，类与接口使用实现
②类与类之间，只允许单继承，使用extends关键字
③接口与接口之间：允许多继承，使用extends关键字
④类与接口之间：允许多实现。使用implements关键字
标签：接口,抽象,Animal,抽象类,方法,public From： https://www.cnblogs.com/gzyhrc/p/17823524.html