一、Abstract

1，abstract class 抽象类

abstract修饰类，会使该类成为一个抽象类，这个类将不能生成对象实例，但可以做为对象变量声明的类型，也就是编译时类型，抽象类就像当于一类的半成品，需要子类继承并覆盖其中的抽象方法。

注：抽象类，不能生成对象实例的理解：假如抽象类可以生成对象，该对象就能调用抽象类中的任何方法，然而抽象方法是没有方法体的，调用没有任何意义。

public abstract class Person {

public Person() {

System.out.println("Person抽象类，也有构造方法");

}

/**

* 抽象方法(没有具体方法体)，修饰符只能为protected or public

* 因为需要子类实现它，故不能为private...

*/

protected abstract void eat();

/**

* 定义一个 private 非抽象方法

*

*/

private void normalMedthod() {

System.out.println("Person抽象类中的，非抽象方法");

}

}

-------------------------------------------------------------------------

public class Student extends Person{

public Student() {

super();

}

/**

* 子类继承抽象类

* 需要实现该类中的抽象方法

*/

@Override

protected void eat() {

System.out.println("Student中的 eat() 方法");

}

}

-------------------------------------------------------------------------------

public class TestClass {

public static void main(String[] args) {

// 此时 抽象类引用指向子类实例

Person person=new Student();

person.eat();//调用的是Student中的eat()；

}

}

理解：抽象类在java语言中体现了一种继承关系(is - a) 关系，即父类和子类在概念本质上应该是相同的 (这点跟interface不一样，对于interface来说，并不要求interface的实现者和interface定义在概念本质上是一致的， 仅仅是实现了interface定义的规范而已)。

抽象类存在的意义是用来被继承的。一个类继承了一个抽象类，必须实现抽象类里面所有的抽象方法，否则，此类也是抽象类。

二、Interface

1，Interface 关键字

一般在接口中，只定义抽象方法(修饰符只能是public或者不写，默认为public访问权限)，在某种程度上来说，接口是抽象类的特殊化。

实现接口的非抽象类，必须实现该接口中的所有方法，抽象类可以不用实现。

接口没有构造方法，不能被实例化。

一个接口不能实现另一个接口，但是可以多继承其他接口。

2，接口可以用匿名内部类来实现

public interface IPerson {

/**

* 默认会加上 public static final ，全局静态常量(一般不在这里定义)

* 且 在实现类中 不可以重新赋age的值

*/

int age = 9;

void eat(); // 接口中的方法默认就是 abstract方法

void play();

}

---------------------------------------------------------------------

//使用 匿名内部类，实现(具体解释见下面)

testDemo.setIPerson(new IPerson() {

@Override

public void play() {

// TODO Auto-generated method stub

}

@Override

public void eat() {

// TODO Auto-generated method stub

}

});

------------------------------------------------------------------

public void setIPerson(IPerson iperson) {

//伪代码

}

/**

* 匿名内部类实现接口，等同使用一个类，实现该接口

* 创建该接口的对象，并传入 到setIPerson(IPerson iperson);中

* 涉及到向上转型。

* 下面的这种方式，等同于上面的匿名内部类

*/

class Students implements IPerson{

@Override

public void eat() {

// TODO Auto-generated method stub

}

@Override

public void play() {

// TODO Auto-generated method stub

}

}

//setIPerson(IPerson iperson); 本来需要一个IPerson 也可以给它Student的实例，因为该类实现了 IPerson 接口

Students students=new Students();

testDemo.setIPerson(students);

3，匿名内部类的理解

new IPerson() {

@Override

public void play() {

// TODO Auto-generated method stub

}

@Override

public void eat() {

// TODO Auto-generated method stub

}

};

匿名内部类可以继承一个类或实现一个接口，这里的IPerson是匿名内部类所继承的类名或实现的接口名。但匿名内部类不能同时实现一个接口和继承一个类，也不能实现多个接口。如果实现了一个接口，该接口也是Object类的直接子类(这里涉及到向上转型)，匿名类继承一个类或实现一个接口，不需要extends和implements关键字。

IPerson p=new IPerson() {//将其赋值给 p 对象变量。 也可以直接使用

@Override

public void play() {

// TODO Auto-generated method stub

}

@Override

public void eat() {

// TODO Auto-generated method stub

}

};

p.eat();

p.play();

上面是一个表达式，返回的是一个对象的引用，所以可以直接使用或将其复制给一个对象变量。

三、抽象类 和 接口的区别

1，抽象层次不同

抽象类，是对类进行抽象，包括属性和行为。

接口是对局部行为进行抽象。

2，使用范围不同

抽象类，是定义一个规范，在子类中重复出现的行为，抽象到抽象类中，自下而上的设计。

接口 ，自上而下，定义行为和规范。

3，使用对象不同

抽象类，使用的是具有相似特点的类(is - a关系)。

接口 ，并不要求实现的类与该接口是同一本质，只关心有没有该行为。