Java抽象类与接口的关系

 

 

1.抽象类：

Java可以创建一种类专门用来当做父类，这种类称为“抽象类”。

“抽象类”的作用类似“模板”，其目的是要设计者依据它的格式来修改并创建新的类。但是不能直接由抽象类创建对象，只能通过抽象类派生出新的类，再由它来创建对象。

抽象类的定义及使用规则：

<1>包含一个抽象方法的类必须是抽象类

<2>抽象类和抽象方法都要使用abstract关键字声明

<3>抽象方法只需声明而不需要实现

<4>抽象类必须被子继承、子类（如果不是抽象类）必须覆写抽象类中的全部抽象方法

 

抽象类不能使用final关键字声明，因为使用final关键字声明的类不能被子类所继承

抽象方法不要使用private声明，因为使用private声明了就不能被子类覆写

一个抽象类中可以定义构造方法

 

abstract class A{
	public static final String FLAG = "CHINA";
	private String name = "张三";
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public abstract void print();		//定义一个抽象方法
}

class B extends A{					//继承抽象类，覆写全部的抽象方法
	public void print(){
		System.out.println("FLAG="+FLAG);
		System.out.println("姓名="+super.getName());
	}
}

public class abstract_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		B b = new B();
		b.print();
	}

}

 

假设人分为学生和工人，学生和工人可以说话，但是学生和工人说话的内容不一样，使用抽象类实现这样一个场景

abstract class People{
	private String name;
	private int age;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public People(String name, int age) {	//构造函数
		this.name = name;
		this.age = age;
	}
	
	public void say(){									
		System.out.println(this.getContent());
	}
	
	public abstract String getContent();	//get方法，说话的内容由子类决定
	
}

class Student extends People{
	
	private float score;
	
	public Student(String name, int age,float score) {
		super(name, age);					//调用父类的构造方法
		// TODO 自动生成的构造函数存根
		this.score = score;
	}

	@Override
	public String getContent() {		//覆写父类中的get抽象方法
		// TODO 自动生成的方法存根
		return "学生信息-->姓名："+super.getName()+"年龄："+super.getAge()+"成绩："+this.score;
	}
	
}

class Worker extends People{
	
	private float salary;
	
	public Worker(String name, int age,float salary) {
		super(name, age);					//调用父类的构造方法
		// TODO 自动生成的构造函数存根
		this.salary = salary;
	}

	@Override
	public String getContent() {		//覆写父类中的get抽象方法
		// TODO 自动生成的方法存根
		return "工人信息-->姓名："+super.getName()+"年龄："+super.getAge()+"薪水："+this.salary;
	}
	
}

public class abstract_demo2 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Student stu = new Student("张三",18,99.0f);
		Worker wor = new Worker("张三",18,1000.0f);
		stu.say();
		wor.say();
	}

}

 

2.接口：

Java接口可以理解为一种特殊的类，是由全局常量和公共的抽象方法所组成，定义在接口中的方法默认是public的

接口如果不写public，则也是public访问权限，不是default

与抽象类一样，接口若要使用也必须通过子类，子类通过implements关键字实现接口。

一个子类可以同时实现多个接口，摆脱了Java的单继承局限

 

interface A_1{										//定义接口A_1
	public String AUTHOR = "张三";		//定义全局常量,等价于：public static final String AUTHOR = "张三";	
	public void print();							//定义抽象方法,等价于：public abstract void print();
	public String getInfo();					//定义抽象方法,等价于：public abstract String getInfo();
}

interface B_1{										//定义接口B_1
	public void say();							//定义抽象方法
}

class X implements A_1,B_1{				//子类同时实现两个接口

	@Override
	public void say() {							//覆写B接口中的抽象方法
		// TODO 自动生成的方法存根
		System.out.println("Hello World!");
	}

	@Override
	public void print() {						//覆写A接口中的抽象方法
		// TODO 自动生成的方法存根
		System.out.println("作者:"+AUTHOR);
	}

	@Override
	public String getInfo() {					//覆写A接口中的抽象方法
		// TODO 自动生成的方法存根
		return "HELLO";
	}
	
}

public class interface_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		X x = new X();				//实例化子类对象
		x.say();						//调用被覆写过的方法
		x.print();						//调用被覆写过的方法
	}

}

 

 

同时实现继承和接口

interface A_2{	//定义接口A_1
	public String AUTHOR = "张三";	/定义全局常量
	public void print();	//定义抽象方法
	public String getInfo();	//定义抽象方法
}

abstract class B_2{	//定义一个抽象类
	public abstract void say();	//定义一个抽象方法
}

abstract class B_3 implements A_2{	//定义一个抽象类，并实现接口
	public abstract void say();	//定义一个抽象方法
}

class X_2 extends B_2 implements A_2{	//同时实现继承和接口

	@Override
	public String getInfo() {	//覆写A_2接口中的抽象方法
		// TODO 自动生成的方法存根
		return "HELLO";
	}

	@Override
	public void say() {	//覆写B_2抽象类中的抽象方法
		// TODO 自动生成的方法存根
		System.out.println("Hello World!");
	}				

	@Override
	public void print() {	//覆写A_2接口中的抽象方法
		// TODO 自动生成的方法存根
		System.out.println("作者:"+AUTHOR);
	}
}

class X_3 extends B_3{	//继承抽象类，覆写全部的抽象方法

	@Override
	public void print() {	//覆写B_3抽象类中的抽象方法
		// TODO 自动生成的方法存根
		System.out.println("作者:"+AUTHOR);
	}

	@Override
	public String getInfo() {	//覆写B_3抽象类中的抽象方法
		// TODO 自动生成的方法存根
		return "HELLO";
	}

	@Override
	public void say() {	//覆写B_3抽象类中的抽象方法
		// TODO 自动生成的方法存根
		System.out.println("Hello World!");
	}
	
}

public class extends_implements_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		X_2 x = new X_2();	//实例化子类对象
		x.say();	//调用被覆写过的方法
		x.print();	//调用被覆写过的方法
		X_3 x_1 = new X_3();
		x_1.say();
		x_1.print();
	}

}

 

接口的继承

interface C{	// 定义接口C
	public String AUTHOR = "张三";	//定义全局常量
	public void printC();	//定义抽象方法
}

interface D{	//定义接口D
	public void printD();	//定义抽象方法
}

interface E extends C,D{	// 定义接口E，同时继承接口C和D
	public void printE();	//定义抽象方法
}

class F implements E{

	@Override
	public void printC() {
		// TODO 自动生成的方法存根
		System.out.println("C--Hello World");
	}

	@Override
	public void printD() {
		// TODO 自动生成的方法存根
		System.out.println("D--Hello World");
	}

	@Override
	public void printE() {
		// TODO 自动生成的方法存根
		System.out.println("E--Hello World");
	}							
	
}

public class extends_implements_demo2 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		F f = new F();
		f.printC();
		f.printD();
		f.printE();
	}

}

 

接口的实际应用

接口在实际中更多的作用是用来制订标准，例子USB设备

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{

	@Override
	public void start() {
		// TODO 自动生成的方法存根
		System.out.println("U盘开始工作");
	}

	@Override
	public void stop() {
		// TODO 自动生成的方法存根
		System.out.println("U盘停止工作");
	}
	
}

class Print implements USB{

	@Override
	public void start() {
		// TODO 自动生成的方法存根
		System.out.println("打印机开始工作");
	}

	@Override
	public void stop() {
		// TODO 自动生成的方法存根
		System.out.println("打印机停止工作");
	}
	
}

public class implements_usb_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		computer.plugin(new FLASH());
		computer.plugin(new Print());
	}

}