JAVA的修饰词（3）----abstract 抽象类

1.引入概念：

狼和狗，两个类，抽取他们所属的共性：犬科。

犬科都有吼叫行为，具体是汪汪汪还是嗷嗷嗷，是不确定的，需要子类明确。

这些犬科不具体的功能，需要在类中标识出来，通过java中的关键字abstract（抽象）

定义了抽象函数的类也要被abstract修饰，即抽象类。

用法和继承类似。

举例：

abstract class 犬科(){
abstract void 叫()；
//用abstract修饰抽象函数
}

class Dog extends 犬科{
void 叫(){
System.out.println("汪汪汪")；
}
}

class Wolf extends 犬科{
void 叫(){
System.out.println("嗷嗷嗷")；
}
}

2.抽象类的特点

1）抽象类和抽象方法都需要被abstract修饰。抽象方法一定定义在抽象类中。

2）抽象类不可以创建实例，因为调用抽象方法是没有意义的。

3）只有覆盖了抽象类的所有抽象方法后子类才可以实例化，否则这个子类还是一个抽象类。

3.抽象类的常见问题

1）抽象类一定是父类吗？

答：

是的，因为抽象类是不断抽取而来的

2）抽象类有构造函数吗？

答：

有的，虽然能不能给自己的对象初始化，但是可以给自己的子类初始化。

3）抽象类和一般类有什么不同？

答：

4000
抽象类和一般类都是用来描述事物的，并且都可以定义属性和功能，但是：

一般类可以描述具体的描述事物，可以创建对象；

抽象类描述事物的信息不具体，不能创建对象，能够定义抽象函数。

4）抽象类里一定要定义抽象方法吗？

答：

不一定，抽象类的另一个作用就是可以利用抽象类的特性使该类不能创建对象

5）abstract不能哪些关键字一起用？

答：

1 final ：最终不能更改，抽象肯定得定义抽象方法

2 private ：明显….你都私有了不让别人用还抽象干嘛

3 static : 静态直接能被类名调用，对抽象类来说是没有意义的

4.抽象类简单应用

需求：

公司中程序员有姓名，工号，薪水，工作内容

项目经理有姓名，工号，薪水，工作内容，奖金 进行建模。

解决步骤：

1）寻找涉及的对象

程序员：
属性：姓名，工号，薪水
行为:工作内容
项目经理：
属性：姓名，工号，薪水，奖金
行为：工作内容

两个对象具有共性，没有子父类关系。将他们的共性抽取，共同类型：worker

员工:
属性：姓名，工号，薪水
行为:工作内容

员工的工作内容是不具体的，所以是抽象的，应该由子类实现

可以写出员工类：

abstract class Worker{
private String name;
private String id;
private double pay;

// 构造函数，员工的3个属性
public worker(String name,String id,double pay){
this.name = name;
this.id = id;
this.pay = pay;
}

// 抽象行为：工作
public abstract void work();
}

写出子类：程序员

class Programmer extends Worker{
// 构造函数
public programmer(String name,String id,double pay){
// 引用父类
super(name,id,pay);
}

// 工作行为：代码
public void work(){
System.out.println("I'm coding");
}
}

写出子类：经理

class Manager extends Worker{
// 特有属性：奖金
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("I'm manageing");
}
}

5.补充

对于上面3.4问题，举例说明

有一个接口

interface Inter{
public void show1();
public void show2();
public void show3();
}

现在需要分别单独使用show1和show2

//使用1方法
class InterDemo1 implements Inter{
public void show1(){
xxxx;
}
// 如果不覆盖其他方法，这就是一个抽象类
// 所以需要写，即使用不到
public void show2(){}
public void show3(){}
}

//同上，使用2
class InterDemo2 implements Inter{
public void show2(){
xxxx;
}
public void show1(){}
public void show3(){}
}

这样做的话很费劲，复用性差

所以可以设置一个类，把四个方法覆盖，再让子类继承

class InterImpl implements Inter{
public void show1();
public void show2();
public void show3();
}
// 继承InterImpl中的方法，直接使用show1就行了，简化了很多
class InterDemo1 extends InterImpl{
public void show1(){
xxxx;
}
}
// 同上，使用show2
class InterDemo1 extends InterImpl{
public void show2(){
xxxx;
}
}

可是这样做又出现问题了，这个InterImpl类 创建对象是没有意义的，所以令其抽象化。

// 抽象化
abstract class InterImpl implements Inter{
public void show1();
public void show2();
public void show3();
}

这就是没有抽象方法的抽象类。

思想很重要。之所以使用继承，是为了在对共性类型操作时更为简单。