目录
1. 如何调用抽象类中的抽象方法？2. 如何调用接口中的抽象方法？
1. 如何调用抽象类中的抽象方法？
抽象类就是不能使用new方法进行实例化的类，即没有具体实例对象的类。抽象类有点类似“模板”的作用，目的是根据其格式来创建和修改新的类。对象不能由抽象类直接创建，只可以通过抽象类派生出新的子类，再由其子类来创建对象。当一个类被声明为抽象类时，要在这个类前面加上修饰符abstract.
在抽象类中的成员方法可以包括一般方法和抽象方法。抽象方法就是以abstract修饰的方法，这种方法只声明返回的数据类型、方法名称和所需的参数，没有方法体，也就是说抽象方法只需要声明而不需要实现。当一个方法为抽象方法时，意味着这个方法必须被子类的方法所重写，否则其子类的该方法仍然是abstract的，而这个子类也必须是抽象的，即声明为abstract.
抽象类中不一定包含抽象方法，但是包含抽象方法的类一定要被声明为抽象类。抽象类本身不具备实际的功能，只能用于派生其子类。抽象类中可以包含构造方法，但是构造方法不能被声明为抽象。
调用抽象类中的方法（抽象方法和非抽象方法），如果方法是static的，直接 抽象类。方法 就可以了；如果是非static的则必须需要一个继承的非抽象类，然后用这个非抽象类的实例来调用方法。
抽象类可以实现接口，接口中的方法 在抽象类中可以不实现，当有子类继承 抽象类时，并且子类不是抽象类时，子类需要将抽象类中的 抽象方法和接口中的方法都实现
抽象类不能用final来修饰，即一个类不能既是最终类又是抽象类。
总结： abstract不能与private、static、final、native并列修饰同一个方法。
注意：子类继承父类方法后，这个子类对象如果执行方法的话，只要子类重写了就执行子类的，不执行父类的。
package xxx.java;
public class AbstractTest {
public static void main(String[] args) {
//一旦Person类抽象了，就不可实例化(不能造对象了)
// Person p1 = new Person();
// p1.eat();
}
}
abstract class Creature{
public abstract void breath();
}
abstract class Person extends Creature{
String name;
int age;
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
//不是抽象方法：有空的方法体
// public void eat(){
//
// }
//抽象方法
public abstract void eat();
public void walk(){
System.out.println("人走路");
}
}
class Student extends Person{
public Student(String name,int age){//父类Person中有构造器，所以子类可以使用父类中的构造器
super(name,age);
}
public Student(){
}
//Student类不能调用父类中的eat方法（抽象方法），要使用eat方法要么额外在子类中把父类Person中的eat方法重写，要么把Student类也弄成抽象类（abstract class Student extends Person）
//即：若子类重写了父类中的所有的抽象方法后，此子类方可实例化；若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰
public void eat(){
System.out.println("学生多吃有营养的食物");
}
@Override
public void breath() {//Student类继承Person类，Person类继承Creature类，Creature类用抽象类修饰了，故Student类要调用Creature类中的breath功能，则要么重写breath方法，要么Student类也抽象化
System.out.println("学生应该呼吸新鲜的没有雾霾的空气");
}
}
在Person类中，抽象方法eat要省略方法体：
public abstract void eat();
我们不能直接通过造Person类的对象调用该eat方法（抽象类不能实例化，无法造抽象类的对象去调用该类中的方法），要调用eat方法，只能造Person类的子类（如Student类），在Student类（不再是抽象类）中重写父类中的所有抽象方法（重写之后的eat方法也不再是抽象方法）
注：若子类重写了父类中的所有的抽象方法后，此子类方可实例化；若子类没有重写父类中的所有的抽象方法则此子类也是一个抽象类，需要使用abstract修饰。即：
class Student extends Person{
public Student(String name,int age){//父类Person中有构造器，所以子类可以使用父类中的构造器
super(name,age);
}
public Student(){
}
public void eat(){
System.out.println("学生多吃有营养的食物");
}
@Override
public void breath() {//Student类继承Person类，Person类继承Creature类，Creature类用抽象类修饰了，故Student类要调用Creature类中的breath功能，则要么重写breath方法，要么Student类也抽象化
System.out.println("学生应该呼吸新鲜的没有雾霾的空气");
}
}
改为：
abstract class Student extends Person{
public Student(String name,int age){//父类Person中有构造器，所以子类可以使用父类中的构造器
super(name,age);
}
public Student(){
}
public void eat(){
System.out.println("学生多吃有营养的食物");
}
@Override
public void breath() {//Student类继承Person类，Person类继承Creature类，Creature类用抽象类修饰了，故Student类要调用Creature类中的breath功能，则要么重写breath方法，要么Student类也抽象化
System.out.println("学生应该呼吸新鲜的没有雾霾的空气");
}
}
但如果Student类又变成抽象类，则Student类又不能能通过造Student类的对象去调用Student类中的方法了。即如果不在Student类中重写父类Person中的全部方法，单纯在Student类前加abstract只能保证程序不出错而已。（本人不成熟的见解，有误望指出）
所以，一般来说，要想调用抽象类中的抽象方法，应该造该抽象类（父类）的子类，然后在子类中重写父类的全部方法，然后就可以通过造子类的对象去调用子类中重写过的方法。
2. 如何调用接口中的抽象方法？
JDK7及以前，接口中的方法一定是抽象方法（那么方法前缀没有abstract，也默认有）。
**接口中不能定义构造器的！**意味着接口不可以实例化（不能通过直接new对象去调用接口中的方法）。要用接口，得通过类去实现(implements)的方式来使用。（即把接口转换成类去使用）：
package xxx.java1;
public class InterfaceTest {
public static void main(String[] args) {
System.out.println(Flyable.MAX_SPEED);
System.out.println(Flyable.MIN_SPEED);
// Flyable.MIN_SPEED = 2;//就算48行省略了public static final，Flyable.MIN_SPEED依然不能赋值
Plane plane = new Plane();//75行开始重写了fly和stop方法，故可以new对象去调用Plane类中的属性方法了。
plane.fly();//通过传入该接口的实现类Plane的对象plane来调用接口Flyable中的方法
}
}
interface Flyable{
//全局常量
public static final int MAX_SPEED = 7900;//第一宇宙速度
int MIN_SPEED = 1;//可以省略了public static final
//抽象方法
public abstract void fly();
//方法中可以省略了public abstract
void stop();
//Interfaces cannot have constructors接口中不能定义构造器的！意味着接口不可以实例化
// public Flyable(){
//
// }
}
class Plane implements Flyable{
//使用接口中的这两个方法时，由于接口中的方法是抽象方法，故在Plane类中要么重新实现一下这两个方法，要么将Plane类抽象化（class前面加abstract）
//下面重新实现一下这两个方法：
//如果实现类覆盖了接口中的所有抽象方(fly,stop)法，则此实现类就可以实例化
//如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
@Override
public void fly() {
System.out.println("通过引擎起飞");
}
@Override
public void stop() {
System.out.println("驾驶员减速停止");
}
}
其中，Flyable接口中的方法是抽象方法，和上面讲的调用抽象方法的手法一样，我们需要在实现类Plane中重写Flyable接口中的所有方法，然后再造实现类Plane的对象plane去调用Flyable接口中的相应的方法（如fly）。
如果只是在class Plane implements Flyableqian前面加上abstract，虽然可避免报错，但还是无法调用Flyable接口中的方法（抽象类无法实例化）。