抽象类和接口的实际应用

一、通过对象的多态性为抽象类及接口进行实例化

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();
	}
}

总结：

在抽象类中可以定义接口

在接口中也可以定义抽象类

在抽象类中可以定义多个内部抽象类

在接口中可以定义多个内部接口

五、抽象类和接口的关系