从头开始学java--抽象类&接口
一.抽象类的定义
抽象类，在类名定义前面加上abstract就成了抽象类。抽象类中包含抽象方法。
抽象方法，在方法前加上abstract就成了抽象方法。只定义了方法，没有实现。
抽象类，因为长得太抽象，java虚拟机都不认识，不能建立对象。只有用子类继承了抽象类，并且将抽象类定义的抽象方法实现了之后，才可以建立子类的对象。
一个例子：
abstract class Person
{
//抽象方法
public abstract void eat();
//abstract void eat(){} 这不是抽象方法，{}也是函数体
//普通方法,抽象类中可以有普通方法，但是只要有一个抽象方法就是抽象类
public void walk()
{
System.out.println("I am person. I can walk");
}
}
class Student extends Person
{
public void eat()
{
System.out.println("I am student. I eat 脑白金") ;
}
}
public class AbstractTest {
public static void main(String[] args)
{
Student student1 = new Student();
student1.eat();//输出为： I am student. I eat 脑白金
}
}
要点：
1.抽象类不能用new创建对象。子类继承抽象类，将抽象类中的抽象方法实现后才可以创建对象，必须保证实现所有的抽象方法，子类如果还有抽象方法也不能创建对象。
2.包含抽象方法的类一定是抽象类。但是抽象类中可以包含非抽象方法。如要一个类不创建对象，可以定义为抽象类，但意义不大，不如构造函数私有化。
3.抽象类的形成：一种是直接定义了一个抽象方法。一种是继承了一个抽象类或者接口，但是没有实现所有的抽象方法。
4.抽象类的作用：强迫子类重写抽象方法，定义子类功能，但是由子类实现。
5.注意，abstract void eat(){}也是有函数体的，{}即函数体。抽象类没有函数体，所以不能有{}。
二.抽象类的使用
抽象类除了被继承之外，也可以使用，但是当然不是建立对象，而是用来引用抽象类的子类对象。即多态的一种表现形式。
abstract class Person
{
//抽象方法
public abstract void eat();
}
class Student extends Person
{
public void eat()
{
System.out.println("I am student. I eat 脑白金") ;
}
}
public class AbstractTest {
public static void main(String[] args)
{
Person person = new Student();
person.eat();//输出为 I am student. I eat 脑白金
}
}
要点：
抽象类使用： 抽象类 抽象类变量 = new 继承抽象类的子类（）；
三.接口的定义
接口可以看成一个特殊的抽象类，但是接口中的方法必须都是抽象的，不涉及任何实现细节。
定义一个接口用关键字interface 实现一个接口用implements关键字。
为什么要用接口呢？
当我们用一个类继承另一个类的时候，继承了类的方法与属性，但是有些属性不是所有类都具有的，在父类中不合适，但是还需要抽象出来，这时候就用到了接口。
接口一般表示类具有某种功能，表示HAS_A而不是IS_A
比如，是Person一定要吃，但是是Person不一定会speakEnglish，所以把这个方法定义在person类中不合适，应该放在接口中，供子类实现。
一个例子：
interface Speak
{
//定义了一个方法，说英语。表示一种能力，供子类实现
public abstract void speakEnglish();
}
class Student implements Speak
{
//Student类实现了speakEnglish()方法，具有了说英语的能力
public void speakEnglish()
{
System.out.println("I am student.I can speak English");
}
}
public class InterfaceTest {
public static void main(String[] args)
{
Student student = new Student();
student.speakEnglish();
}
}
要点：
1.接口不能创建对象，用法大致与抽象类相同。但是接口中不能有非抽象方法。
2.接口中定义方法的修饰符是固定的，public abstract 所以子类实现接口方法的时候必须也用public修饰。
3.java类之间不支持多继承，但是支持多实现，即一个类可以实现多个接口。但是接口可以继承接口，而且可以多继承。
例子：
abstract class Person
{
//定义一个抽象方法，是人就会吃，所以放在父类是合适的。但是吃什么是不一定的，所以定义为抽象方法，由子类具体实现
public abstract void eat();
}
interface Speak
{
//定义了一个方法，说英语。表示一种能力，供子类实现
public abstract void speakEnglish();
}
interface Jump
{
//定义个方法，大跳。表示一种能力，供子类实现
public abstract void jump();
}
class Student extends Person implements Speak,Jump
{
//Student类继承了Person抽象类，实现eat方法
public void eat()
{
System.out.println("I am student. I eat 脑白金");
}
//Student类实现了speakEnglish()方法，具有了说英语的能力
public void speakEnglish()
{
System.out.println("I am student.I can speak English");
}
//Student类实现了jump()方法。具有了大跳的能力
public void jump()
{
System.out.println("I am student.I can jump");
}
}
public class InterfaceTest {
public static void main(String[] args)
{
Student student = new Student();
student.eat();
student.speakEnglish();
student.jump();
}
}
这个类中，Student类继承了Person类，实现了Speak和Jump接口。继承自己父类的方法，同时也具有了接口提供的能力。
输出如下：
四.接口中定义的常量
接口中可以定义常量。接口中的常量和抽象方法都有固定的格式，必须按照格式书写，如果没写全java会给补全，但是不便理解。
例子：
interface Inter
{
//定义在接口中的常量必须初始化
public static final int MAX_VALUE = 100;
public abstract void print();
}
//实现了接口，就可以直接使用接口中定义的常量
class Myclass implements Inter
{
public void print()
{
System.out.println(MAX_VALUE);
}
}
public class InterfaceTest2 {
public static void main(String[] args)
{
Myclass myclass = new Myclass();
myclass.print();//输出结果为 100
}
}
要点：
1.接口中定义常量的格式： public static final 类型 常量名
2.接口中定义抽象方法的格式：public abstract 返回值 方法名
3.实现了接口的类，可以直接使用接口中定义的常量。
4.接口定义常量的时候必须要初始化。
