- （1） 抽象方法和抽象类的定义
- （2） 接口的定义
- 接口是多实现的，一个类可以实现多个接口，但是只能继承一个类。接口之间也可以相互继承
抽象类和接口
面向对象程序设计（OOP）目前已经接近尾声，这个小结我们再介 绍两个重要的概念。
java中除了类，还有抽象类和接口这两个概念，这其中有很多值得我们学习的地方，在理解和思考之前我们先用一个小结给大家看看java中怎么定义抽象类和接口。
（1） 抽象方法和抽象类的定义
一般的方法：
public class Animal { public void eat(){
System.out.println("Animal is eating.");
}
抽象方法：
public abstract class Animal { abstract void eat();
}
abstract void eat(); 去掉方法体，加一个abstract 关键字就是一个抽象方法，如果一个类里有抽象方法，在类的声明上必须也要加上abstract ，变成一个抽象类。我们要注意的是，抽象方法没有方法体，所以不能直接调用，也正是因为抽象方法没有方法体，所以我们不能直接构造一个抽象类。
其实值得我们思考的问题是，一个方法连方法体也没有，这究竟有什么用。答案是【约定】。
我们不能【直接构造抽象类】，但是子类可以继承抽象类，并且必须重写抽象方法，除非子类也是抽象类。这样就会对所有子类有了共同约束，同时父类已经实现的方法也能被所有的子类所复用。
顾名思义：
public abstract class Animal { abstract void eat();
}
这个抽象方法是为了约束子类的，让子类必须实现这个方法。抽象类中除了拥有抽象方法，也可以拥有普通方法。
public abstract class Animal {
abstract void eat();
public void print(){
System.out.println("I'm an Animal!");
}
}
抽象类无法直接进行实例化操作，当一个类实例化之后，就意味着这个对象可以调用类中的属性或者方法了，但在抽象类里存在抽象方法，而抽象方法没有方法体，没有方法体就无法进行调用。既然无法进行方法调用的话，又怎么去产生实例化对象呢。
抽象类里中也可以和其他类一样拥有自己的成员变量：
public abstract class Animal {
private String name;
}
既然有成员变量，我们大致可以猜出抽象类是可以构造的，因为属性必须通过new去内存分配空间才能赋值啊。
那么抽象类中一定存在构造方法，实例化的过程就是属性赋值的过程啊！
看一下下边的例子：
public abstract class Animal {
// 但是我们不能直接new public Animal(){
System.out.println("animal has created!");
}
abstract void eat();
public void print(){
System.out.println("I'm an Animal!");
}
}
public class Cat extends Animal {
public Cat(){
System.out.println("cat has created!");
}
@Override
void eat() {
System.out.println("cat is eating!");
}
public static void main(String[] args) {
new Cat();
}
}
结果：
animal has created!
cat has created!
这个过程说明了，创建子类时，父类依然会被创建，抽象类只有在构建子类的时候才会被构建出实例。
【小问题】：抽象类可以用final声明么？
抽象类存在的目的就是为了让子类去继承，一个类被final修饰了， 就失去了这个能力，结果当然是不行了。
总结一下
1. 抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public；
2. 抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；
3. 抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；
4. 子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）；
（2） 接口的定义
其实接口是比抽象类更高级的抽象，当然抽象类也是比类更高级的抽象。接口中只能有方法的定义，而不能有实现：
public abstract class Animal {
/**
* 呼吸的方法
*/
public abstract void breath();
/**
* 吃的方法
*/
public abstract void eat();
}
我们可以更加优雅的表达出来：
public interface Animal {
/**
* 呼吸的方法
*/
void breath();
/**
* 吃的方法
*/
void eat();
}
abstrac 都不需要了，但是要使用关键字interface ，这种类我们称之为【接口】。
接口中能定义抽象方法，不能有实例字段、不能有方法实现（静态的可以），java8以后在接口中可以定义默认方法，这个我们先放一放以后再讲。编写接口的目的在于对类的某些能力进行约定和规范，接口不能被实例化，没有构造器。
接口中的方法默认是public的，我们也推荐使用默认的，也就是我们定义接口时，不用写它的权限修饰符。但是因为接口是契约、是约定子类必须具备的某些能力，是需要子类去实现的，所以我们在写借口时，推荐使用javadoc的方式给接口加注释。
接口是多实现的，一个类可以实现多个接口，但是只能继承一个类。接口之间也可以相互继承
（1） 深入理解
我们学习了几天的面向对象
继承是 is-a 的关系， dog is an animal。 man is a human。
实现是 can-do的关系， 实现更体现一个类的能力，通过实现多个接口是可以聚合多个能力的。
举一个例子：
【鸟能飞】和【飞机能飞】。它们有功能的特质吗？其实也不太有，当时它们都能飞。
我们在设计上就可以定一个接口，接口有fly的方法定义。
接口是可以多实现的，所以鸟和飞机除了实现飞行的接口还能实现很多其他的接口。这也就意味着它们can-do 很多事情。
抽象类是模板式的设计，而接口是契约式设计。
抽象类设计时往往就是将相同实现方法抽象在父类，由子类独立实现那些实现各自不同的实现。
【做好顶层设计】
中央政府我我们规划蓝图，做好顶层设计，具体的实现具体来，只要跟着党的路线走就好了。
我们再举一个例子，比如食物链，动物会吃其他动物，也会被其他动物吃
//动物
public interface Animal {
/**
* 吃的方法
*/
void eat(Animal animal);
/**
* 获取名字
* @return
*/
String getName();
}
//老虎
public class Tiger implements Animal {
@Override
public void eat(Animal animal) {
System.out.println(this.getName() + "吃了" + animal.getName());
}
@Override
public String getName() {
return "tiger";
}
}
//狼
public class Wolf implements Animal { @Override
public void eat(Animal animal) {
System.out.println(this.getName() + "吃了" + animal.getName());
}
@Override
public String getName() {
return "wolf";
}
}
//羊
public class Sheep implements Animal { @Override
public void eat(Animal animal) {
System.out.println(this.getName() + "吃了" +animal.getName());
@Override
public String getName() {
return "sheep";
}
public static void main(String[] args) {
Animal tiger = new Tiger();
Animal wolf = new Wolf();
Animal sheep = new Sheep();
wolf.eat(sheep); tiger.eat(wolf);
}
}
结果：
//wolf吃了sheep
//tiger吃了wolf
公司里边，牛逼的人写接口。接口更多的是设计的工作，实现更多是搬砖的工作。
