从头开始学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.接口定义常量的时候必须要初始化。