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() {
		//方法体
	}
}

posted on 2019-05-06 15:33  BlueTree2  阅读(156)  评论(0编辑  收藏  举报

导航