Java知识总结-抽象类和接口

说明：接口中容易混淆的是成员的隐式修饰，并且犯过以为抽象方法不需要写返回值类型的错误。这里特意写篇关于抽象类和接口的文章加深记忆。

一、抽象类

抽象方法：只有功能定义，没有功能主体的方法。抽象不可以被直接调用。

具有抽象方法的类一定要定义为抽象类，注：抽象类中可以不定义抽象方法。

下面为简单的抽象类和抽象方法定义：

abstract class Demo{    //抽象类
	abstract void show();  //抽象方法
}

注意：抽象方法具有返回值类型。

1.抽象类不可以被创建对象：

abstract class Demo{
	abstract void show();
}
public class Test {
	public static void main(String[] args) {
     Demo d=new Demo();
	}
}

结果：编译失败，无法创建抽象类对象。

2.当抽象类中不定义抽象方法时，其目的仅仅是为了不让该类创建对象。例：

abstract class Demo{
	void show(){
		System.out.println("show");
	}
}

3.抽象类中的抽象方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象后调用子类的复写方法。例：

abstract class People{  //抽象类
	abstract void say();//抽象方法
}
class Chinese extends People{  //抽象类的子类
	public void say(){   // 复写父类的抽象方法
		System.out.println("中文");
	}
}
public class Test {
	public static void main(String[] args) {
	 Chinese s=new Chinese();//创建子类对象
     s.say();//调用子类对象的复写方法
	}
}

运行结果：

中文

4.如果子类子覆盖了一个抽象类的部分抽象方法（还有一部分抽象没有被覆盖），那么该子类还是一个抽象类。例：

abstract class People{  //抽象类
	abstract void say();//抽象方法
	abstract void eat();//抽象方法
}
abstract class Chinese extends People{  //子类仍然为抽象类
	public void say(){   // 只复写父类的部分抽象方法
		System.out.println("中文");
	}
}

5.抽象类中可以定义成员变量，并且不用被abstract关键词所修饰。例：

abstract class People{  //抽象类
	abstract void say();//抽象方法
	int x=5;//抽象类中的成员变量
}
class Chinese extends People{  //子类仍然为抽象类
	public void say(){   // 只复写父类的部分抽象方法
		System.out.println("中文");
	}
}
public class Test {
	public static void main(String[] args) {
	 Chinese s=new Chinese();//创建子类对象
     s.say();//调用子类对象的复写方法
     System.out.println(s.x);
	}
}

运行结果：

中文
5

二、接口
接口中常见定义：常量，抽象方法。

接口中的成员都有固定修饰符。
常量：public static final

方法：public abstract

注：因为接口中抽象方法被public修饰，所以当子类实现接口复写抽象方法时，复写方法也必须用public修饰。否则会因为权限小于接口中抽象方法而无法实现覆盖。

且这些修饰符都是默认隐式存在的，当没有手动添加的时候，java会隐式地添加这些修饰符。

下面是一个简单的接口：

interface Demo{  //接口
	public abstract void show(); //常量
	public static final int NUM=3;//抽象方法
}

1.与抽象类一样，接口是不可以创建对象的，因为接口中也有抽象方法，例：

interface Demo{
	public abstract void show();
	public static final int NUM=3;
}
public class Test {
	public static void main(String[] args) {
	 Demo d=new Demo();
	}
}

结果编译失败，无法为接口创建对象。

2。可以通过一个子类实现该接口，子类需要覆盖接口中的全部抽象方法，才可以创建子类对象。例：

interface People{//定义接口
	public abstract void say();//抽象方法
	public abstract void eat();//抽象方法
}
class Chinese implements People{//定义子类实现接口
	public void say(){ //复写抽象方法
		System.out.println("中文");
	}
	public void eat(){//复写抽象方法
		System.out.println("中餐");
	}
}
public class Test {
	public static void main(String[] args) {
	 Chinese c=new Chinese();//创建子类对象
	 c.eat(); //调用子类复写方法
	 c.say();//调用子类复写方法
	}
}

运行结果;

中餐
中文

3.当子类实现接口时，如果没有将全部抽象方法覆盖（还有部分抽象方法没有覆盖），那么子类就是一个抽象类，

interface People{//定义接口
	public abstract void say();//抽象方法
	public abstract void eat();//抽象方法
}
abstract class Chinese implements People{//子类为抽象类
	public void say(){ //复写抽象方法
		System.out.println("中文");
	}
	/*
	 * 该抽象方法没有被覆盖
	  public void eat(){//复写抽象方法
	
		System.out.println("中餐");
	}
	*/
}

4.接口与接口是继承关系.例：

interface People{//定义接口
	public abstract void say();//抽象方法
	public abstract void eat();//抽象方法
}
interface Chinese extends People{//子接口
	public abstract void gongfu();//抽象方法
}

注：接口继承接口也使用关键词extends.

5.接口可以同时继承都多个接口，实现多继承特性。

interface A{
	
}
interface B{
	
}
interface C extends A,B{
	
}