java中的接口和抽象类

1.抽象类

如果一个类含有抽象方法，则称这个类为抽象类。抽象方法用关键字abstract修饰，只有声明，而没有具体的实现。

定义一个抽象类：

abstract class AbstractTest{
	//抽象类中的成员变量默认为default,也可以被public,protected,private修饰，可以不用赋初值。
	int a=2;
	public int b;
	protected int d;
	private int c;
	//抽象类中的方法不可以被default修饰
	abstract void m1();
	public void m2(){
		//方法体
	}
	protected void m3(){
		//方法体
	};
	private void m4(){
		//方法体
	}
}

• 抽象类中的成员变量默认为default，也可以被public，protected，private修饰，可以不用赋初值，这些成员变量可以在子类中被重新定义，也可以重新赋初值。
• 抽象类中除了有抽象方法之外（抽象方法的权限修饰符只能为public和protected），也可以含有被public，protected，private修饰的成员方法。抽象类中的成员方法不能被default修饰。
• 子类继承抽象类时，必须重写抽象类中的抽象方法。如果子类没有实现父类中的抽象方法，则必须将子类也定义为abstract类。

抽象类就是为了继承而存在的，对于一个父类，如果它的某个方法在父类中实现出来没有任何意义，必须根据子类的实际需要来进行不同的实现，就可以将这个方法声明为abstract方法，包含abstract方法的类也就是抽象类了。

2.接口

接口用关键字interface修饰，定义接口：

interface Interface1{                                                                                                                    
	//成员变量字段修饰符public static final,必须初始化且其值不能被改变。
	public static final int a=3;
	//成员变量修饰符可以省略public static final;
	int b=10;
	//接口中的方法修饰为public和abstract,且没有方法体。
	abstract void print(String str);
	public void add(int n1,int n2);
}

• 接口中可以有成员变量与成员方法，成员变量隐式指定为public static final，只能是public static final修饰，使用private修饰会报错，并且可以省略，但是一般情况下不在接口中定义变量。
• 接口中的成员方法可以修饰为public或abstract，且没有具体的实现。
• 子类实现接口时必须实现接口中的所有方法。

3.接口不可以被实例化，但是接口引用可以指向一个实现该接口的对象,抽象类同理。

package zhishidian;

import org.junit.Test;

abstract class AbstractTest{
	//抽象类中的成员变量默认为default,也可以被public,protected,private修饰，可以不用赋初值。
	int a=2;
	public int b;
	protected int d;
	private int c;
	//抽象类中的成员方法不可以被default修饰，抽象方法的权限修饰符为public和protected;
	public abstract void m1();
	protected abstract void m5();
	public void m2(){
		//方法体
	}
	protected void m3(){
		//方法体
	};
	private void m4(){
		//方法体
	}
}

//接口修饰符关键字interface
interface Interface1{                                                                                                                    
	//成员变量字段修饰符public static final,必须初始化且其值不能被改变。
	public static final int a=3;
	//成员变量修饰符可以省略public static final;
	int b=10;
	//接口中的方法修饰为public或abstract,且没有方法体。
	abstract void print(String str);
	public void add(int n1,int n2);
}

public class InterfaceTest extends AbstractTest implements Interface1{
	public static final int a=4;
	@Test
	public void test(){
		//接口不可以被实例化，但是接口引用可以指向一个实现该接口的对象,抽象类同理。
		Interface1 a1=new InterfaceTest();
		AbstractTest at=new InterfaceTest();
		a1.print("hello");
		a1.add(2,3);
		InterfaceTest it=new InterfaceTest();
		System.out.println("本类中的变量a:"+it.a);
		System.out.println("接口中的变量a:"+Interface1.a);
		System.out.println("父类中的变量a:"+super.a);
	}
	//实现接口的类必须实现接口中定义的方法，继承抽象类时必须实现抽象类中的抽象方法。
	@Override
	public void print(String str) {
		System.out.println(str);
	}
	@Override
	public void add(int n1, int n2) {
		System.out.println(n1+n2);
	}
	@Override
	public void m1() {
		//方法体
	}
	@Override
	protected void m5() {
		//方法体
	}
}