Java 抽象类和接口

在Java语言中使用abstract class来定义抽象类
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，但可以定义一个引用。抽象类必须被继承，才能被使用。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。
抽象类可包含抽象方法，但抽象类不是必须包含抽象方法。抽象类相当于一个半成品，需要子类继承并覆盖其中的抽象方法，子类才可以实例化，如果子类没有实现父类的抽象方法，那么子类必须定义为抽象类。

抽象方法只有声明没有实现，即只有方法声明没有方法体。有抽象方法就一定有抽象类，有抽象类不一定有抽象方法。
abstract和final不能同时使用，abstract修饰类和方法就是为了继承和重写的，final则是阻止继承和重写。
abstract和private也不能同时修饰方法，因为private阻止方法的重写，而abstract修饰的方法必须重写。
abstract和static也不能同时修饰方法，因为static修饰的方法可以通过类名来调用，抽象方法没有方法体，调用一个没有方法体的方法肯定回出错。
构造方法，类方法（用static修饰的方法）不能声明为抽象方法。
对于抽象方法，不能使用private修饰符（编译出错），不能使用package修饰符（编译正常，但是不合理，后患无穷），可以使用public和protected，大多数情况下都是使用public。
抽象类：

package classTest;

abstract class Parent{
	public abstract void say();

}
class Child extends Parent{
	public void say() {
		System.out.println("子类的say方法");
	}
}

public class TestAbstractClass {
	public static void main(String[] args) {
		Child child = new Child();
		child.say();
	}

}

结果：

子类的say方法

抽象类可以定义构造方法，抽象类仍然使用的是类继承关系。因此，子类在实例化时必须先对抽象类进行实例化（这里抽象类的实例化即子类实例化时仍然会调用抽象类的构造方法）。

package classTest;

abstract class parent1{
	private String name;
	public parent1() {
		System.out.println("抽象类无参构造函数");
	}
	public parent1(String name) {
		this.name = name;
		System.out.println("抽象类有参构造函数" + name);
	}
	public abstract void say();
}

class Child1 extends parent1{
	public Child1() {
		System.out.println("子类无参构造函数");
	}
	public Child1(String name) {
		super(name);
		System.out.println("子类的有参构造函数" + name);
	}
	public void say() {
		System.out.println("say");
	}
}
public class TestAbstractConstructor {
          public static void main(String[] args) {
			new Child1();
			new Child1("hi");
					}
}

结果：

抽象类无参构造函数
子类无参构造函数
抽象类有参构造函数hi
子类的有参构造函数hi

接口
接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过实现接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类（因为接口中所有的方法都是抽象方法，接口中的方法默认的修饰符为public abstract void；同时接口中的属性默认为静态常量，默认修饰符为public static final）。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

package classTest;
 
interface Parent2{
	String name = "a";   // 等价于public static final String name;接口是无法被实例化的，所以接口里边的属性与对象无关，因此属性是静态的；
	void say();        // 等价于public abstract void say();
}
interface Person{
	void work();
}
class Child2 implements Parent2, Person{
	public void say() {
		System.out.println("say");
	}
	public void work() {
		System.out.println("work");
	}
}
public class TestImplements {
         public static void main(String[] args) {
			Child2 c = new Child2();
			c.say();
			c.work();
		}
}

结果：

say
work

接口也是可以继承的，使用extends关键字，接口的继承和类的继承相似的是子接口会获得父接口中的所有抽象方法和全局常量。不同的类只能单继承，接口可以多重继承。
示例：

package classTest;

interface Person2{
	void say();
}
interface Person3{
	void sleep();
}
interface Parent3 extends Person2,Person3{
	void work();
} 
class Child3 implements Parent3{
	public void say() {
		System.out.println("say");
	}
	public void sleep() {
		System.out.println("sleep");
	}
	public void work() {
		System.out.println("work");
	}
}
public class TestInterfaceExtend {
     public static void main(String[] args) {
		Child3 a = new Child3();
		a.say();
		a.sleep();
		a.work();
	}
}

结果：

say
sleep
work

总结：
对比抽象类和接口的组成：
抽象类可以包含的成员：
1、成员变量，和普通类相同，可以有静态变量，直接使用类名调用；
2、成员方法，和普通类相同，可以有静态方法，直接使用类名调用；
3、构造方法，不能用abstract修饰；
4、抽象方法（必须含有），不能被static、private、final修饰；
接口可以包含的成员：
1、全局常量（静态常量），默认使用public static final修饰，必须；
2、抽象方法，默认使用public abstract修饰；