七、java中的抽象类和抽象方法详解

一、概述：

1、什么是抽象？

提到抽象，人们自然会想到将『抽象』作为其一大特性的『面向对象编程（OOP）』（面向对象的四大特性：抽象、封装、继承、多态）确实，『抽象』这个概念只出现在『面向对象编程』里面——和具象相对应，『抽象』表示某种不确定，即存在潜在的可能性（父类抽象，在子类逐渐具体）。

为了表示『抽象』这一概念，我们使用abstract关键字表示——abstract类是抽象类，abstract方法是抽象方法。

2、什么是抽象类、抽象方法？

类用于描述现实生活中一类事物。类中有属性、方法等成员。

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有 意义，而方法主体则没有存在的意义了。

某种情况下，父类只能知道子类应该具备一个怎样的方法，但是不能够明确知道如何实现该方法。只能在子类中才能确定如何去实现方法体。例如：所有几何图形都应该具备一个计算面积的方法。但是不同的几何图形计算面积的方式不同。

我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法 的类就是抽象类。

3、抽象类、抽象方法总结：

抽象类和抽象方法的产生是为了维护继承链的逻辑，即抽象类相对于那些普通的类处于继承树的根部。抽象方法的产生完全是为了迎合抽象类的存在：抽象方法只能写在抽象类中！抽象类的字段（反正也没有abstract抽象字段一说）只要像正常的继承关系那样使用就好了。被abstract关键字修饰的类叫抽象类。被abstract关键字修饰的方法叫抽象方法。

4、抽象类、抽象方法的核心思想：

抽象类（abstract class）不能被实例化！！抽象类是有构造器的（所有类都有构造器）抽象类以有抽象方法，也可以没有抽象方法；但是抽象方法只能存在于抽象类中。抽象类中的非抽象方法如同在非抽象类中一样，正常继承使用。抽象方法（abstract method）只能存在于抽象类中！！抽象方法所在的类，一定是抽象类（因为抽象方法是没有方法体的，如果所在的类不是抽象类，那么该类可以实例化对象，调用抽象方法，然后无方法体去具体实现功能，则矛盾）不存在所谓的抽象静态方法（abstract static，永远不要这样干！）

关于最后一点，我是这样理解的：因为静态方法总是和一个类相绑定的，也因为这样我们使用类名而不是实例来调用某个类的静态方法；（反证法）如果一个抽象类的抽象方法被修饰为static的，我们推荐使用类名来调用该方法，即调用抽象类的静态方法（在「类」上面划着重号），可是又因为这个方法还被abstract修饰，是没有方法体的，我们不能直接调用（必须要现在子类中具体实现后才能调用），于是矛盾——故不存在所谓的抽象静态方法

二、抽象类、抽象方法的具体表达：

1、抽象方法：

抽象方法 ： 只有方法的声明，没有方法体，即没有{}，以分号 ; 结尾，使用 abstract 关键字修饰：

抽象方法：

修饰符 abstract 返回值类型 方法名(参数列表);

public abstract void run();

非抽象方法：

public abstract void run(){}

抽象方法不能用private、final、static、native修饰。

2、抽象类：

抽象类：包含抽象方法的类。如果一个类包含抽象方法，那么该类必须是抽象类，使用 abstract 关键字修饰。

定义格式：

public abstract class 类名 {

//抽象类中可以包含变量、常量，抽象方法，非抽象方法

}

举例：

public abstract class Person {

public abstract void work()；

}

3、抽象类的使用：

抽象类不能实例化，不能直接创建对象。抽象类是用来被继承的，继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类，使用 abstract 关键字修饰。

抽象类也是类，因此原来类中可以有的成员，抽象类都可以有，那么抽象类不能直接创建对象，为什么还有构造器呢？供子类调用，子类创建对象时，需要为从父类继承的属性初始化。

抽象类不能使用final修饰。

父类：抽象类：

/**

* 抽象类-父类

*/

public abstract class Person {

//抽象类的字段只要正常使用就好了，默认访问权限是package

static String name="大黄";

//非静态字段可以被继承和重写

int age=30;

/**

* 抽象类可以有非抽象非静态方法，在其子类中可以被继承和重写

*/

public void say(){

System.out.println("Hello world!");

}

/**

* 抽象类可以有非抽象静态方法，在其子类中可以被继承和隐藏-子类不能重写该方法，只能继承和隐藏。

*/

public static void eat(){

System.out.println("抽象类中的静态方法");

}

/**

* 抽象方法只能存在于抽象类中，它没有方法体，必须在子类中具体实现：

* 注意：

* 1.抽象类甚至可以没有抽象方法（抽象类的关键是不能实例化而不是抽象方法！）;

* 2.没有所谓的抽象静态方法（abstract static，这样的事情你永远也不要尝试！）

*/

public abstract void printInfo();

}

子类：继承父类，重写方法：

/**

* 子类，继承父类（抽象类）

* 注意：

* 1、子类继承父类（抽象类），必须重写父类所有的抽象方法，否则，子类也要使用 abstract 关键字修饰，变成抽象类；

* 2、父类（抽象类） 中的非抽象非静态方法，可以被重写，也可以不重写，隐藏掉。

* 3、父类（抽象类） 中的非抽象静态方法，不能被重写。

*/

public class Student extends Person{

//自动获得从父类继承来的成员字段

static String name="小明";

int age=12;

/**

* 1、重写父类的抽象方法；

* 2、要想子类不是抽象类，必须重写。

*/

@Override

public void printInfo() {

System.out.println("抽象方法被重写了！！");

}

/**

* 1、重写父类的普通方法-非静态，非抽象方法。

* 2、该方法可重写，可不重写。

*/

@Override

public void say() {

System.out.println("普通方法被重写了！");

}

}

测试类：

/**

* 测试类

*/

public class Test {

public static void main(String[] args) {

//此句会报错，因为不能实例化一个抽象类

//Person person = new Person();

//实例化抽象类的子类

Student s = new Student();

//向上转型

Person p= new Student();

System.out.println("子类测试====================");

System.out.println("s.name:: "+s.name);

System.out.println("s.age:: "+s.age);

s.say();

s.printInfo();

Person.eat();

System.out.println("向上转型，抽象类测试====================");

System.out.println("p.name: "+p.name);

System.out.println("p.age: "+p.age);

p.say();

p.printInfo();

Person.eat();

}

}

4、抽象类注意事项：

抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。 理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。 理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。抽象类中，可以有成员变量。 理解：子类的共性的成员变量 , 可以定义在抽象父类中。抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。 理解：未包含抽象方法的抽象类，声明为抽象类目的就是不想让使用者创建该类的对象，通常用于某些特殊的类结构设计。抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译报错。除非该子类也是抽象类。 理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

5、abstract关键字：

1、可以用来修饰的结构：类、方法，不能用来修饰变量、代码块、构造器。

2、不能和 abstract 一起使用的修饰符：

外部类可用修饰符：abstract、final ，两种访问修饰符：public和缺省。其中abstract和final不能一起修饰类。方法可用修饰符：4种访问修饰符，static、final、abstract、native。不能共存的：

private，abstract不行 因为private不能被重写

static，abstract不行 因为static不能被重写

final，abstract不行 因为final不能被重写

native，abstract不行 因为都没有方法体，不知道是什么情况，会有歧义

三、抽象类简单案例：

1、案例介绍：

某IT公司有多名员工，按照员工负责的工作不同，进行了部门的划分（研发部员工、维护部员工）。研发部根据所需研发的内容不同，又分为JavaEE工程师、Android工程师；维护部根据所需维护的内容不同，又分为网络维护工程师、硬件维护工程师。

公司的每名员工都有他们自己的员工编号、姓名，并要做它们所负责的工作。

工作内容:

JavaEE工程师： 员工号为xxx的 xxx员工，正在研发淘宝网站；Android工程师：员工号为xxx的 xxx员工，正在研发淘宝手机客户端软件；网络维护工程师：员工号为xxx的 xxx员工，正在检查网络是否畅通；硬件维护工程师：员工号为xxx的 xxx员工，正在修复打印机；

请根据描述，完成员工体系中所有类的定义，并指定类之间的继承关系。进行XX工程师类的对象创建，完成工作方法的调用。

2、案例分析：

根据上述部门的描述，得出如下的员工体系图：

根据员工信息的描述，确定每个员工都有员工编号、姓名、要进行工作。则，把这些共同的属性与功能抽取到父类中（员工类），关于工作的内容由具体的工程师来进行指定。

创建JavaEE工程师对象，完成工作方法的调用。

3、示例代码：

定义员工类(抽象类)：

/**

* 根父类：员工类

*/

public abstract class Employee {

private String id; // 员工编号

private String name; // 员工姓名

public String getId() {

returnid;

}

publicvoid setId(String id) {

this.id = id;

}

public String getName() {

returnname;

}

publicvoid setName(String name) {

this.name = name;

}

//工作方法（抽象方法）：以为具体工作分好几种，不同岗位的工作不一样，所以父类中不能定义具体的方法，

//但是可以定义抽象的方法，然后再具体的类中，具体实现。

public abstract void work();

}

定义研发部员工类Developer 继承 员工类Employee：

/**

*研发部门员工类

*/

public abstract class Developer extends Employee {

}

定义维护部员工类Maintainer 继承 员工类Employee：

/**

*维护部门员工类

*/

public abstract class Maintainer extends Employee {

}

定义JavaEE工程师 继承 研发部员工类，重写工作方法：

/**

*javaEE工程师类

*/

public class JavaEE extends Developer {

@Override

public void work() {

System.out.println("员工号为 " + getId() + " 的 " + getName() + " 员工，正在研发淘宝网站");

}

}

定义Android工程师 继承 研发部员工类，重写工作方法：

/**

*Android工程师类

*/

public class Android extends Developer {

@Override

public void work() {

System.out.println("员工号为 " + getId() + " 的 " + getName() + " 员工，正在研发淘宝手机客户端软件");

}

}

定义Network网络维护工程师 继承 维护部员工类，重写工作方法：

/**

*Network网络维护工程师类

*/

public class Network extends Maintainer {

@Override

public void work() {

System.out.println("员工号为 " + getId() + " 的 " + getName() + " 员工，正在检查网络是否畅通");

}

}

定义Hardware硬件维护工程师 继承 维护部员工类，重写工作方法：

/**

*Hardware硬件维护工程师类

*/

public class Hardware extends Maintainer {

@Override

public void work() {

System.out.println("员工号为 " + getId() + " 的 " + getName() + " 员工，正在修复打印机");

}

}

测试类：

public class Test {

public static void main(String[] args) {

//创建JavaEE工程师员工对象

JavaEE ee = new JavaEE();

//设置该员工的编号

ee.setId("111111");

//设置该员工的姓名

ee.setName("张伟");

//调用该员工的工作方法

ee.work();

}

}

致谢：

参考：https://blog.csdn.net/abc_12366/article/details/79682080 参考：https://www.cnblogs.com/sun10367/p/13552241.html