抽象類和接口的實際應用

一、通過對象的多態性爲抽象類及接口進行實例化

1、抽象類的實例化

package lkp;


abstract class A{
public abstract void print();
}


class B extends A{
public void print(){
System.out.println("lkp");
}
}


class Test{
public static void main(String args[]){
A a = new B();//通過子類爲抽象類實例化
>a.print();
}

2、接口的實例化

package lkp;

interface A{
	public abstract void print();
}

class B implements A{
	public void print(){
		System.out.println("lkp");
	}
}

public class Test{
	public static void main(String args []){
		A a = new B();//通過子類爲接口實例化
		a.print();
	}
}

二、抽象類的實際應用——模板設計

package lkp;
//定義一個抽象類Person
abstract class Person{
	private String name;
	private int age;
	public Person(String name,int age){//屬性的初始化
		this.name = name;
		this.age = age;
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
	public abstract String getContent();//定義一個抽象方法，獲取子類的內容
	public void say(){
		System.out.println(this.getContent());
	}
}

class Student extends Person{
	private float score;
	public Student(String name,int age,float score){
		super(name,age);//調用父類的構造方法
		this.score = score;
	}
	public String getContent(){//覆寫父類中的構造方法
		return "名字" + super.getName()+
				"年齡" + super.getAge() + 
				"分數" + this.score;
	}
}

class Worker extends Person{
	private float salary;
	public Worker(String name,int age,float salary){
		super(name,age);
		this.salary = salary;
	}
	public String getContent(){
		return "名字" +super.getName() + 
				"年齡" + super.getAge() + 
				"工資" + this.salary;
	}
}

public class Test{
	public static void main (String args[]){
		Student stu = new Student("lkp",23,90);
		Worker wor = new Worker("lkp",23,15000);
		System.out.println(stu.getContent());
		System.out.println(wor.getContent());
	}
}

Person類中相當於定義了一個模板，在主方法中調用時，調用的就是普通方法，而子類只需要實現父類中的抽象方法，就可以取得一個人的具體信息。

三、接口的實際應用——制定標準

package lkp;
interface USB{
	public void start();
	public void stop();
}

class Computer{
	public static void plugin(USB usb){
		usb.start();
		System.out.println("---USB設備工作---");
		usb.stop();
	}
}

class Flash implements USB{
	public void start(){
		System.out.println("U盤開始工作");
	}
	public void stop(){
		System.out.println("U盤停止工作");
	}
}

class Print implements USB{
	public void start(){
		System.out.println("打印機開始工作");
	}
	public void stop(){
		System.out.println("打印機停止工作");
	}
}

class Test{
	public static void main(String args []){
		Computer.plugin(new Flash());
		System.out.println();
		Computer.plugin(new Print());
	}
}

由上面的代碼可知，接口是規定了一個標準，計算機認的只是接口，而對於具體的設備計算機本身不關心。

四、抽象類和接口可以互相包含

1、在一個抽象類中包含接口

package lkp;
abstract class A{						//定義一個抽象類
	public abstract void printA();		<span style="white-space:pre">		</span>//定義一個抽象方法printA()
	
	interface B{						//在抽象類A中定義一個接口
		public abstract void printB();	<span style="white-space:pre">		</span>/定義一個抽象方法printB()
	}
}

class X extends A {						//繼承抽象類
	public void printA(){				<span style="white-space:pre">	</span>//覆寫抽象類中方法
		System.out.println("hello--->A");
	}
	
	class Y implements B{				<span style="white-space:pre">	</span>//定義內部類實現內部接口
		public void printB(){			<span style="white-space:pre">	</span>//實現內部接口中的方法
			System.out.println("hello--->B");
		}
	}
}

public class Test{
	public static void main(String args[]){
		A.B b = new X().new Y();		<span style="white-space:pre">	</span>//實例化內部接口對象
		b.printB();						//調用內部接口的方法
	}
}

2、在一個接口中包含抽象類

package lkp;
interface A{
	public abstract void printA();
	
	abstract class B{
		public abstract void printB();
	}
}

class X implements A{
	public void printA(){
		System.out.println("HELLO--->A");
	}
	class Y extends B{
		public void printB(){
			System.out.println("HELLO--->B");
		}
	}
}

public class Test{
	public static void main(String args []){
		A.B b = new X().new Y();
		b.printB();
	}
}

總結：

在抽象類中可以定義接口

在接口中也可以定義抽象類

在抽象類中可以定義多個內部抽象類

在接口中可以定義多個內部接口

五、抽象類和接口的關係