七、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、抽象类注意事项:

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

 
 

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、案例分析:

  • 根据上述部门的描述,得出如下的员工体系图:
    七、java中的抽象类和抽象方法详解_第1张图片

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

  • 创建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

你可能感兴趣的:(java基础)