面向对象【抽象类、接口】

面向对象【抽象类、接口】

思维导图如下：

1、抽象类

1.1、概念

分析事物时，发现了共性内容，就出现向上抽取。会有这样一种特殊情况，就是功能声明相同，但功能主体不同。那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。那么此方法就是一个抽象方法。

当定义了抽象函数的类也必须被abstract关键字修饰，被abstract关键字修饰的类是抽象类。也就是说我们把方法声明抽取，让子类继承后，自己去实现方法体，没有方法体的方法，需要用抽象的关键字abstract标志一下。

1.2、特点

1. 抽象类和抽象方法都需要被abstract修饰。抽象方法一定要定义在抽象类中。
2. 抽象类不可以创建实例（不能被实例化），原因：调用抽象方法没有意义。
3. 只有覆盖了抽象类中所有的抽象方法后，其子类才可以实例化。否则该子类还是一个抽象类。换句话说抽象类不一定有抽象方法，但抽象方法所在的类一定是抽象类。

1.3、抽象类中数据的特点

1. 抽象类中可以有变量，也可以有常量。
2. 抽象类中可以有抽象方法，也可以有非抽象方法。
3. 抽象类是一个类，所以它有构造方法。

1.4、抽象类和一般类的异同点：

相同：

1. 它们都是用来描述事物的。
2. 它们之中都可以定义属性和行为。

​ 不同：

1. 一般类可以具体的描述事物。抽象类描述事物的信息不具体
2. 抽象类中可以多定义一个成员：抽象函数。
3. 一般类可以创建对象，而抽象类一定不能创建对象。

1.5、抽象类中的细节问题

1.5.1、抽象类中是否有构造方法？能不能被实例化？如果不能，构造方法有什么意义？

• 抽象类有构造方法，不能被实例化，抽象类的构造方法供子类实例化调用。

1.5.2、抽象关键字abstract不可以和那些关键字共存？

• private ：是有内容子类继承不到，所以不能重写，但是abstract修饰的方法是要求被重写的；
• final：final修饰的方法不能被重写；
• static：如果一个抽象方法通过static修饰，这个方法可以直接通过类名调用，但是抽象方法是没有方法体的，这样的调用没有意义。

1.5.3、抽象类可不可以没有抽象方法？如果可以，这样的类有什么用吗？

• 抽象类可以没有抽象方法。
• 没有的抽象方法的抽象类的作用是为了不让别的类建立该抽象类对象。

abstract class Employee
{
	private String name;
	private String id;
	private double pay;
	//构造一个员工对象，一初始化就具备着三个属性。
	public Employee(String name,String id,double pay)
	{
		this.name = name;
		this.id = id;
		this.pay = pay;
	}
	//工作行为,由于工作内容不具体，用抽象类描述
	public abstract void work();
}
//具体的子类：程序员。
class Programmer extends Employee
{
	public Programmer(String name,String id,double pay)
	{
		super(name,id,pay);
	}
	public void work()
	{
		System.out.println("code....");
	}
}
//具体的子类：经理。
class Manager extends Employee
{
	//特有属性。
	private double bonus;
	public Manager(String name,String id,double pay,double bonus)
	{
		super(name,id,pay);
		this.bonus = bonus;
	}
	public void work()
	{
		System.out.println("manage");
	}
}

2、接口

2.1、概念

当一个类中的方法都是抽象的时候，java提供了接口。

定义普通的类或者抽象类可以使用class关键字，定义接口必须用interface关键字修饰，类与接口关系用implements表示。

2.2、成员特点

• 成员变量：是常量，固定默认修饰 public static final
• 成员方法：都是抽象的，固定默认修饰public abstract
• 接口中的成员都是公共的。
• 接口不可以创建对象。
• 子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。

2.3、接口与类之间的关系

2.3.1、类与类的关系：

都是抽象的，默认修饰public abstract。

interface Demo//定义一个名称为Demo的接口。
{
	public static final int NUM = 3;
	public abstract void show1();
	public abstract void show2();
}
//定义子类去覆盖接口中的方法。子类必须和接口产生关系，类与类的关系是继承，类与接口之间的关系是 实现。通过 关键字 implements
class DemoImpl implements Demo//子类实现Demo接口。
{
	//重写接口中的方法。
	public void show1(){}
	public void show2(){}
}

2.3.2、类与接口的关系：

是实现关系。类可以多实现接口，使用关键字implements；

interface A
{
	void abstract show1();
}
interface B
{
	void abstract show2();
}
class C implements A,B// 多实现。同时实现多个接口。
{
	public void show1(){}
	public void show2(){}
}

类在继承一个类的同时，可以实现多个接口。

class Fu
{
	public void show(){}
}
interface Inter
{
	public abstract void show1();
}
class Zi extends Fu implements Inter
{
	public void show1()
	{}
}

2.3.3、接口与接口的关系：

是继承关系，接口可以多继承接口。

interface A{
	 abstract void show();
}
interface B{
	abstract void show1();
}
interface C{
	abstract void show2();
}
interface D extends A,B,C{
	 abstract void show3();
}

2.4、接口的特点

• 是对外暴露的规则；
• 是功能的扩展；
• 接口的出现降低了耦合性；
• 接口可以多实现。如：CPU和主板、笔记本的USB接口、插座等。

2.5、与抽象类的区别

抽象类	接口
抽象类只能被单继承	接口可以多实现，接口的出现避免了多继承的局限性
抽象类中定义的是继承体系中的共性功能	接口中定义的是继承体系中的扩展功能
抽象类被继承是“is a ”的关系：xx是yy的一种	接口被实现是“ like a ”的关系：xx像yy的一种
抽象类中的成员变量可以是变量也可以是常量	接口中的成员变量是常量。默认修饰public static final
抽象类的成员方法可以是抽象方法也可以是非抽象方法	接口的成员方法都是抽象方法。都有默认修饰public abstract
抽象类有构造方法	接口没有构造方法