一、抽象类的基本概念

普通类是一个完善的功能类，可以直接产生实例化对象，并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。

那么什么叫抽象方法呢？在所有的普通方法上面都会有一个“{}”，这个表示方法体，有方法体的方法一定可以被对象直接使用。而抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字abstract做修饰。

而拥有抽象方法的类就是抽象类，抽象类要使用abstract关键字声明。

范例：定义一个抽象类

  1. abstract class A{//定义一个抽象类
  3.     public void fun(){//普通方法
  4.         System.out.println("存在方法体的方法");
  5.     }
  7.     public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
  9. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

二、抽象类的使用

我们先看范例。 
范例：直接实例化抽象类的对象

  1. package com.wz.abstractdemo;
  3. abstract class A{//定义一个抽象类
  5.     public void fun(){//普通方法
  6.         System.out.println("存在方法体的方法");
  7.     }
  9.     public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
  11. }
  13. public class TestDemo {
  15.     public static void main(String[] args) {
  16.         A a = new A();
  17.     }
  18. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

运行：

  1. Exception in thread "main" java.lang.Error: Unresolved compilation problem:
  2.     Cannot instantiate the type A
  4.     at com.wz.abstractdemo.TestDemo.main(TestDemo.java:15)
  • 1
  • 2
  • 3
  • 4
  • 5

从上可知，A是抽象的，无法直接进行实例化操作。为什么不能直接实例化呢？当一个类实例化之后，就意味着这个对象可以调用类中的属性或者放过了，但在抽象类里存在抽象方法，而抽象方法没有方法体，没有方法体就无法进行调用。既然无法进行方法调用的话，又怎么去产生实例化对象呢。

抽象类的使用原则如下： 
（1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public； 
（2）抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理； 
（3）抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类； 
（4）子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）；

范例：

  1. package com.wz.abstractdemo;
  3. abstract class A{//定义一个抽象类
  5.     public void fun(){//普通方法
  6.         System.out.println("存在方法体的方法");
  7.     }
  9.     public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
  11. }
  12. //单继承
  13. class B extends A{//B类是抽象类的子类，是一个普通类
  15.     @Override
  16.     public void print() {//强制要求覆写
  17.         System.out.println("Hello World !");
  18.     }
  20. }
  21. public class TestDemo {
  23.     public static void main(String[] args) {
  24.         A a = new B();//向上转型
  26.         a.fun();//被子类所覆写的过的方法
  27.     }
  28. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

运行结果：

  1. Hello World !
  • 1
  • 2

现在就可以清楚的发现： 
（1）抽象类继承子类里面有明确的方法覆写要求，而普通类可以有选择性的来决定是否需要覆写； 
（2）抽象类实际上就比普通类多了一些抽象方法而已，其他组成部分和普通类完全一样； 
（3）普通类对象可以直接实例化，但抽象类的对象必须经过向上转型之后才可以得到。

虽然一个类的子类可以去继承任意的一个普通类，可是从开发的实际要求来讲，普通类尽量不要去继承另外一个普通类，而是去继承抽象类。

三、抽象类的使用限制

（1）抽象类中有构造方法么？ 
由于抽象类里会存在一些属性，那么抽象类中一定存在构造方法，其存在目的是为了属性的初始化。 
并且子类对象实例化的时候，依然满足先执行父类构造，再执行子类构造的顺序。

范例如下：

  1. package com.wz.abstractdemo;
  3. abstract class A{//定义一个抽象类
  5.     public A(){
  6.         System.out.println("*****A类构造方法*****");
  7.     }
  9.     public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
  11. }
  12. //单继承
  13. class B extends A{//B类是抽象类的子类，是一个普通类
  15.     public B(){
  16.         System.out.println("*****B类构造方法*****");
  17.     }
  19.     @Override
  20.     public void print() {//强制要求覆写
  21.         System.out.println("Hello World !");
  22.     }
  24. }
  25. public class TestDemo {
  27.     public static void main(String[] args) {
  28.         A a = new B();//向上转型
  29.     }
  31. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

执行结果：

  1. *****A类构造方法*****
  2. *****B类构造方法*****
  • 1
  • 2

（2）抽象类可以用final声明么？ 
不能，因为抽象类必须有子类，而final定义的类不能有子类；

（3）抽象类能否使用static声明？ 
先看一个关于外部抽象类的范例：

  1. package com.wz.abstractdemo;
  3. static abstract class A{//定义一个抽象类
  5.     public abstract void print();
  7. }
  9. class B extends A{
  11.     public void print(){
  12.         System.out.println("**********");
  13.     }
  14. }
  15. public class TestDemo {
  17.     public static void main(String[] args) {
  18.         A a = new B();//向上转型
  19.         a.print();
  20.     }
  22. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

执行结果

  1. Exception in thread "main" java.lang.Error: Unresolved compilation problem:
  2.     Illegal modifier for the class A; only public, abstract & final are permitted
  4.     at com.wz.abstractdemo.A.<init>(TestDemo.java:3)
  5.     at com.wz.abstractdemo.B.<init>(TestDemo.java:9)
  6.     at com.wz.abstractdemo.TestDemo.main(TestDemo.java:18)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

再看一个关于内部抽象类：

  1. package com.wz.abstractdemo;
  3. abstract class A{//定义一个抽象类
  5.     static abstract class B{//static定义的内部类属于外部类
  6.         public abstract void print();
  7.     }
  9. }
  11. class C extends A.B{
  13.     public void print(){
  14.         System.out.println("**********");
  15.     }
  16. }
  17. public class TestDemo {
  19.     public static void main(String[] args) {
  20.         A.B ab = new C();//向上转型
  21.         ab.print();
  22.     }
  24. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

执行结果：

  1. **********
  • 1

由此可见，外部抽象类不允许使用static声明，而内部的抽象类运行使用static声明。使用static声明的内部抽象类相当于一个外部抽象类，继承的时候使用“外部类.内部类”的形式表示类名称。

（4）可以直接调用抽象类中用static声明的方法么？ 
任何时候，如果要执行类中的static方法的时候，都可以在没有对象的情况下直接调用，对于抽象类也一样。 
范例如下：

  1. package com.wz.abstractdemo;
  3. abstract class A{//定义一个抽象类
  5.     public static void print(){
  6.         System.out.println("Hello World !");
  7.     }
  9. }
  11. public class TestDemo {
  13.     public static void main(String[] args) {
  14.         A.print();
  15.     }
  17. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

运行结果：

  1. Hello World !
  • 1
  • 2

（5）有时候由于抽象类中只需要一个特定的系统子类操作，所以可以忽略掉外部子类。这样的设计在系统类库中会比较常见，目的是对用户隐藏不需要知道的子类。 
范例如下：

  1. package com.wz.abstractdemo;
  3. abstract class A{//定义一个抽象类
  4.     public abstract void print();
  6.     private static class B extends A{//内部抽象类子类
  8.         public void print(){//覆写抽象类的方法
  9.             System.out.println("Hello World !");
  10.         }
  11.     }
  13.     //这个方法不受实例化对象的控制
  14.     public static A getInstance(){
  15.         return new B();
  16.     }
  18. }
  20. public class TestDemo {
  22.     public static void main(String[] args) {
  24.         //此时取得抽象类对象的时候完全不需要知道B类这个子类的存在
  25.         A a = A.getInstance();
  26.         a.print();
  27.     }
  28. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

运行结果：

  1. Hello World !
  • 1

四、抽象类的应用——模板设计模式

例如，现在有三类事物： 
（1）机器人：充电，工作； 
（2）人：吃饭，工作，睡觉； 
（3）猪：进食，睡觉。 
现要求实现一个程序，可以实现三种不同事物的行为。

先定义一个抽象行为类：

  1. package com.wz.abstractdemo;
  3. public abstract class Action{
  5.     public static final int EAT = 1 ;
  6.     public static final int SLEEP = 3 ;
  7.     public static final int WORK = 5 ;
  9.     public abstract void eat();
  10.     public abstract void sleep();
  11.     public abstract void work();
  13.     public void commond(int flags){
  14.       switch(flags){
  15.         case EAT:
  16.             this.eat();
  17.             break;
  18.         case SLEEP:
  19.             this.sleep();
  20.             break;
  21.         case WORK:
  22.             this.work();
  23.             break;
  24.         case EAT + SLEEP:
  25.             this.eat();
  26.             this.sleep();
  27.             break;
  28.         case SLEEP + WORK:
  29.             this.sleep();
  30.             this.work();
  31.             break;
  32.         default:
  33.             break;
  34.         }
  35.     }
  36. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

定义一个机器人的类：

  1. package com.wz.abstractdemo;
  3. public class Robot extends Action{
  5.     @Override
  6.     public void eat() {
  7.         System.out.println("机器人充电");
  9.     }
  11.     @Override
  12.     public void sleep() {
  14.     }
  16.     @Override
  17.     public void work() {
  18.         System.out.println("机器人工作");
  20.     }
  22. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

定义一个人的类：

  1. package com.wz.abstractdemo;
  3. public class Human extends Action{
  5.     @Override
  6.     public void eat() {
  7.         System.out.println("人吃饭");
  9.     }
  11.     @Override
  12.     public void sleep() {
  13.         System.out.println("人睡觉");
  15.     }
  17.     @Override
  18.     public void work() {
  19.         System.out.println("人工作");
  21.     }
  23. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

定义一个猪的类：

  1. package com.wz.abstractdemo;
  3. public class Pig extends Action{
  5.     @Override
  6.     public void eat() {
  7.         System.out.println("猪进食");
  9.     }
  11.     @Override
  12.     public void sleep() {
  13.         System.out.println("猪睡觉");
  15.     }
  17.     @Override
  18.     public void work() {
  20.     }
  22. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

测试主类：

  1. package com.wz.abstractdemo;
  3. public class AbstractDemo {
  5.     public static void main(String[] args) {
  7.         fun(new Robot());
  9.         fun(new Human());
  11.         fun(new Pig());
  13.     }
  15.     public static void fun(Action act){
  16.         act.commond(Action.EAT);
  17.         act.commond(Action.SLEEP);
  18.         act.commond(Action.WORK);
  19.     }
  21. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

运行结果：

  1. 机器人充电
  2. 机器人工作
  3. 人吃饭
  4. 人睡觉
  5. 人工作
  6. 猪进食
  7. 猪睡觉
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

所有的子类如果要想正常的完成操作，必须按照指定的方法进行覆写才可以，而这个时候抽象类所起的功能就是一个类定义模板的功能。

Java抽象类 详解的更多相关文章

  1. Java 抽象类详解

    在<Java中的抽象方法和接口>中,介绍了抽象方法与接口,以及做了简单的比较. 这里我想详细探讨下抽象类. 一.抽象类的定义 被关键字“abstract”修饰的类,为抽象类.(而且,abx ...

  2. java抽象类详解

    前言 在没讲抽象类之前  我们先来看看 final关键字 final 修饰符 可以修饰 类.属性.方法 修饰类时  表示该类不能被继承   其他特征 跟普通的类一样 修饰 属性时 表示 改属性不能改变 ...

  3. java关键字(详解）

    目录 1. 基本类型 1) boolean 布尔型 2) byte 字节型 3) char 字符型 4) double 双精度 5) float 浮点 6) int 整型 7) long 长整型 8) ...

  4. android java 设计模式详解 Demo

    android java 设计模式详解 最近看了一篇设计模式的文章,深得体会,在此基础我将每种设计模式的案例都写成Demo的形式,方便读者研究学习, 首先先将文章分享给大家: 设计模式(Design ...

  5. Java接口 详解（二）

    上一篇Java接口 详解(一)讲到了接口的基本概念.接口的使用和接口的实际应用(标准定义).我们接着来讲. 一.接口的应用—工厂设计模式(Factory) 我们先看一个范例: package com. ...

  6. Java集合详解1：一文读懂ArrayList,Vector与Stack使用方法和实现原理

    本文非常详尽地介绍了Java中的三个集合类 ArrayList,Vector与Stack <Java集合详解系列>是我在完成夯实Java基础篇的系列博客后准备开始写的新系列. 这些文章将整 ...

  7. 「万字图文」史上最姨母级Java继承详解

    摘要:继承是面向对象软件技术中的一个概念.它使得复用以前的代码非常容易,能够大大缩短开发周期,降低开发费用. 本文分享自华为云社区<「万字图文」史上最姨母级Java继承详解丨[奔跑吧!JAVA] ...

  8. Java 集合详解 | 一篇文章解决Java 三大集合

    更好阅读体验:Java 集合详解 | 一篇文章搞定Java 三大集合 好看的皮囊像是一个个容器,有趣的灵魂像是容器里的数据.接下来讲解Java集合数据容器. 文章篇幅有点长,还请耐心阅读.如只是为了解 ...

  9. Java内部类详解

    Java内部类详解 说起内部类这个词,想必很多人都不陌生,但是又会觉得不熟悉.原因是平时编写代码时可能用到的场景不多,用得最多的是在有事件监听的情况下,并且即使用到也很少去总结内部类的用法.今天我们就 ...

随机推荐

  1. WCF服务的Web HTTP方式

    NET 3.5以后,WCF中提供了WebGet的方式,允许通过url的形式进行Web 服务的访问.现将WCF服务设置步骤记录如下: endpoint通讯协议设置成  webHttpBinding en ...

  2. Guava源码阅读-base-CharMatcher

    package com.google.common.base; (部分内容摘自:http://blog.csdn.net/idealemail/article/details/53860439) 之前 ...

  3. 0《STL源码剖析》简介

    STL源码剖析 ----侯捷 STL主要包括六个组件: 1.配置器:负责空间配置和管理. 2.迭代器:扮演容器和算法之前的胶合剂,所谓“泛型指针”. 3.容器:各种数据结构,如vector,list, ...

  4. 《MIT 6.828 Lab1: Booting a PC》实验报告

    <MIT 6.828 Lab1: Booting a PC>实验报告 本实验的网站链接见:Lab 1: Booting a PC. 实验内容 熟悉x86汇编语言.QEMU x86仿真器.P ...

  5. 利用css 画各种三角形

      #triangle-up {    width: 0;    height: 0;    border-left: 50px solid transparent;    border-right: ...

  6. DEDE调用列表页，前台titlelen显示不全问题解决

    一. 问题描述:{dede:list titlelen='100'}标题长度设为100后,但前台调用显示最长却只有60. 二. 产生原因:经过我多度查找,最终导致标题显示不全的原因是在DEDE生数据库 ...

  7. C++11 bind和function用法

    function是一个template,定义于头文件functional中.通过function<int(int, int)> 声明一个function类型,它是“接受两个int参数.返回 ...

  8. 一、python快速入门(每个知识点后包含练习)

    1. 编程与编程语言 编程的目的是什么? #计算机的发明,是为了用机器取代/解放人力,而编程的目的则是将人类的思想流程按照某种能够被计算机识别的表达方式传递给计算机,从而达到让计算机能够像人脑/电脑一 ...

  9. 怎样使当前cookie只有在加密协议https环境下才能将它发送到服务器

    使用 Secure 属性. 注意, 这个属性基本是"自动"的, 也就是说, 如果当前网页是https请求的, 那里面的各种HTTP请求的cookie都会自定加上这个属性, 如果当前 ...

  10. hdu 1269 入手强连通

    思路待整理 #include<cstdio> #include<iostream> #include<cstring> #include<vector> ...