Java抽象类原理与用法实例详解

本文实例讲述了Java抽象类原理与用法。分享给大家供大家参考,具体如下:

一、抽象类的基本概念

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

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

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

范例:定义一个抽象类

abstract class A{//定义一个抽象类
    public void fun(){//普通方法
        System.out.println("存在方法体的方法");
    }
    public abstract void print();//抽象方法,没有方法体,有abstract关键字做修饰
}

二、抽象类的使用

我们先看范例。

范例:直接实例化抽象类的对象

package com.wz.abstractdemo;
abstract class A{//定义一个抽象类
    public void fun(){//普通方法
        System.out.println("存在方法体的方法");
    }
    public abstract void print();//抽象方法,没有方法体,有abstract关键字做修饰
}
public class TestDemo {
    public static void main(String[] args) {
        A a = new A();
    }
}

运行:

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

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

抽象类的使用原则如下:

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

范例:

package com.wz.abstractdemo;
abstract class A{//定义一个抽象类
    public void fun(){//普通方法
        System.out.println("存在方法体的方法");
    }
    public abstract void print();//抽象方法,没有方法体,有abstract关键字做修饰
}
//单继承
class B extends A{//B类是抽象类的子类,是一个普通类
    @Override
    public void print() {//强制要求覆写
        System.out.println("Hello World !");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        A a = new B();//向上转型
        a.print();//被子类所覆写的过的方法
    }
}

运行结果:

Hello World !

现在就可以清楚的发现:

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

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

三、抽象类的使用限制

(1)抽象类中有构造方法么?

由于抽象类里会存在一些属性,那么抽象类中一定存在构造方法,其存在目的是为了属性的初始化。

并且子类对象实例化的时候,依然满足先执行父类构造,再执行子类构造的顺序。

范例如下:

package com.wz.abstractdemo;
abstract class A{//定义一个抽象类
    public A(){
        System.out.println("*****A类构造方法*****");
    }
    public abstract void print();//抽象方法,没有方法体,有abstract关键字做修饰
}
//单继承
class B extends A{//B类是抽象类的子类,是一个普通类
    public B(){
        System.out.println("*****B类构造方法*****");
    }
    @Override
    public void print() {//强制要求覆写
        System.out.println("Hello World !");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        A a = new B();//向上转型
    }
}

执行结果:

*****A类构造方法*****
*****B类构造方法*****

(2)抽象类可以用final声明么?

不能,因为抽象类必须有子类,而final定义的类不能有子类;

(3)抽象类能否使用static声明?

先看一个关于外部抽象类的范例:

package com.wz.abstractdemo;
static abstract class A{//定义一个抽象类
    public abstract void print();
}
class B extends A{
    public void print(){
        System.out.println("**********");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        A a = new B();//向上转型
        a.print();
    }
}

执行结果

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

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

package com.wz.abstractdemo;
abstract class A{//定义一个抽象类
    static abstract class B{//static定义的内部类属于外部类
        public abstract void print();
    }
}
class C extends A.B{
    public void print(){
        System.out.println("**********");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        A.B ab = new C();//向上转型
        ab.print();
    }
}

执行结果:

**********

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

(4)可以直接调用抽象类中用static声明的方法么?

任何时候,如果要执行类中的static方法的时候,都可以在没有对象的情况下直接调用,对于抽象类也一样。

范例如下:

package com.wz.abstractdemo;
abstract class A{//定义一个抽象类
    public static void print(){
        System.out.println("Hello World !");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        A.print();
    }
}

运行结果:

Hello World !

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

范例如下:

package com.wz.abstractdemo;
abstract class A{//定义一个抽象类
    public abstract void print();
    private static class B extends A{//内部抽象类子类
        public void print(){//覆写抽象类的方法
            System.out.println("Hello World !");
        }
    }
    //这个方法不受实例化对象的控制
    public static A getInstance(){
        return new B();
    }
}
public class TestDemo {
    public static void main(String[] args) {
        //此时取得抽象类对象的时候完全不需要知道B类这个子类的存在
        A a = A.getInstance();
        a.print();
    }
}

运行结果:

Hello World !

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

例如,现在有三类事物:

(1)机器人:充电,工作;
(2)人:吃饭,工作,睡觉;
(3)猪:进食,睡觉。

现要求实现一个程序,可以实现三种不同事物的行为。

先定义一个抽象行为类:

package com.wz.abstractdemo;
public abstract class Action{
    public static final int EAT = 1 ;
    public static final int SLEEP = 3 ;
    public static final int WORK = 5 ;
    public abstract void eat();
    public abstract void sleep();
    public abstract void work();
    public void commond(int flags){
     switch(flags){
        case EAT:
            this.eat();
            break;
        case SLEEP:
            this.sleep();
            break;
        case WORK:
            this.work();
            break;
        case EAT + SLEEP:
            this.eat();
            this.sleep();
            break;
        case SLEEP + WORK:
            this.sleep();
            this.work();
            break;
        default:
            break;
        }
    }
}

定义一个机器人的类:

package com.wz.abstractdemo;
public class Robot extends Action{
    @Override
    public void eat() {
        System.out.println("机器人充电");
    }
    @Override
    public void sleep() {
    }
    @Override
    public void work() {
        System.out.println("机器人工作");
    }
}

定义一个人的类:

package com.wz.abstractdemo;
public class Human extends Action{
    @Override
    public void eat() {
        System.out.println("人吃饭");
    }
    @Override
    public void sleep() {
        System.out.println("人睡觉");
    }
    @Override
    public void work() {
        System.out.println("人工作");
    }
}

定义一个猪的类:

package com.wz.abstractdemo;
public class Pig extends Action{
    @Override
    public void eat() {
        System.out.println("猪进食");
    }
    @Override
    public void sleep() {
        System.out.println("猪睡觉");
    }
    @Override
    public void work() {
    }
}

测试主类:

package com.wz.abstractdemo;
public class AbstractDemo {
    public static void main(String[] args) {
        fun(new Robot());
        fun(new Human());
        fun(new Pig());
    }
    public static void fun(Action act){
        act.commond(Action.EAT);
        act.commond(Action.SLEEP);
        act.commond(Action.WORK);
    }
}

运行结果:

机器人充电
机器人工作
人吃饭
人睡觉
人工作
猪进食
猪睡觉

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

更多java相关内容感兴趣的读者可查看本站专题:《Java面向对象程序设计入门与进阶教程》、《Java数据结构与算法教程》、《Java操作DOM节点技巧总结》、《Java文件与目录操作技巧汇总》和《Java缓存操作技巧汇总》

希望本文所述对大家java程序设计有所帮助。

(0)

相关推荐

  • 简单理解Java的抽象类

    在自上而下的继承层次结构中,位于上层的类更具有通用性,甚至可能更加抽象.从某种角度看,祖先类更加通用,它只包含一些最基本的成员,人们只将它作为派生其他类的基类,而不会用来创建对象.甚至,你可以只给出方法的定义而不实现,由子类根据具体需求来具体实现. 这种只给出方法定义而不具体实现的方法被称为抽象方法,抽象方法是没有方法体的,在代码的表达上就是没有"{}".包含一个或多个抽象方法的类也必须被声明为抽象类. 使用 abstract 修饰符来表示抽象方法和抽象类. 抽象类除了包含抽象方法外,

  • JAVA 继承基本类、抽象类、接口介绍

    封装:就是把一些属性和方法封装到一个类里. 继承:就如子类继承父类的一些属性和方法. 多态:就如一个父类有多个不同特色的子类. 这里我就不多讲解,下面我主要说明一个继承.继承是OOP(面向对象)的一个特色,java只支持单继承(如果继承两个有同样方法的父类,那么就不知道继承到那个父类的,所以java只支持单继承).继承是java的一个特色,我们用的所以类都继承Objict类,所以就要Object类的方法,如toString().getClass().wait()--所以我们建立的类都有父类. J

  • Java接口和抽象类用法实例总结

    本文实例讲述了Java接口和抽象类用法.分享给大家供大家参考,具体如下: 接口 1 因为java不支持多重继承,所以有了接口,一个类只能继承一个父类,但可以实现多个接口,接口本身也可以继承多个接口. 2 接口里面的成员变量默认都是public static final类型的.必须被显示的初始化. 3 接口里面的方法默认都是public abstract类型的.隐式声明. 4 接口没有构造方法,不能被实例化. 5 接口不能实现另一个接口,但可以继承多个接口. 6 类如果实现了一个接口,那么必须实现

  • 简单学习Java抽象类要点及实例

    使用抽象类应该注意的几个要点: 包含一个或者多个抽象方法的类必须被声明为抽象类. 将类声明为抽象类,不一定含有抽象方法.通常认为,在抽象类中不应该包括具体方法,建议尽量将通用的域和方法放在超类中.抽象类不可以被实例化.即不能创建这个类的对象 实例代码: 复制代码 代码如下: import java.util.*; /** * This program demonstrates abstract classes. * @version 1.01 2004-02-21 * @author Cay H

  • java中抽象类、抽象方法、接口与实现接口实例详解

    前言 对于java中的抽象类,抽象方法,接口,实现接口等具体的概念就不在这里详细的说明了,网上书本都有很多解释,主要是我懒,下面通过一个例子来说明其中的精髓要点,能不能练成绝世武功,踏上封王之路,就看自己的的啦(不要误会,我指的只是我自己啦啦) 用接口实现一个简单的计算器 1.利用接口做参数,写个计算器,能完成+-*/运算 (1)定义一个接口Compute含有一个方法int computer(int n,int m); (2)设计四个类分别实现此接口,完成+-*/运算 (3)设计一个类UseCo

  • Java基础教程之接口的继承与抽象类

    在实施接口中,我们利用interface语法,将interface从类定义中独立出来,构成一个主体.interface为类提供了接口规范. 在继承中,我们为了提高程序的可复用性,引入的继承机制.当时的继承是基于类的.interface接口同样可以继承,以拓展原interface. 接口继承 接口继承(inheritance)与类继承很类似,就是以被继承的interface为基础,增添新增的接口方法原型.比如,我们以Cup作为原interface: 复制代码 代码如下: interface Cup

  • Java接口和抽象类实例分析

    本文实例讲述了Java的接口和抽象类.分享给大家供大家参考.具体分析如下: 对于面向对象编程来说,抽象是它的一大特征之一.在Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类.这两者有太多相似的地方,又有太多不同的地方.很多人在初学的时候会以为它们可以随意互换使用,但是实际则不然.今天我们就一起来学习一下Java中的接口和抽象类. 若有不正之处,请多多谅解并欢迎批评指正,不甚感激. 一.抽象类 在了解抽象类之前,先来了解一下抽象方法.抽象方法是一种特殊的方法:它只有声明,而没有具体的实

  • Java中接口和抽象类的区别与相同之处

    1. 抽象类: (1).概念:抽象类是对一种事物的抽象,即对类抽..抽象类是对整个类整体进行抽象,包括属性.行为.Java抽象类和Java接口一样,都用来声明一个新的类型.并且作为一个类型的等级结构的起点. (2).格式: 复制代码 代码如下: public abstract class abstractDemo{             /**属性*/             private String name;             /**方法*/             public

  • 详细解析Java中抽象类和接口的区别

    在Java语言中, abstract class 和interface 是支持抽象类定义的两种机制.正是由于这两种机制的存在,才赋予了Java强大的 面向对象能力.abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性,甚至可以相互替换,因此很多开发者在进 行抽象类定义时对于abstract class和interface的选择显得比较随意.其实,两者之间还是有很大的区别的,对于它们的选择甚至反映出对 于问题领域本质的理解.对于设计意图的理解是否正确.合理

  • JAVA抽象类和抽象方法(abstract)实例分析

    本文实例讲述了JAVA抽象类和抽象方法(abstract).分享给大家供大家参考,具体如下: 一.抽象(abstract)的使用 当父类的某些方法不确定时,可以用abstract关键字来修饰该方法[抽象方法],用abstract来修饰该类[抽象类]. 我们都知道,父类是将子类所共同拥有的属性和方法进行抽取,这些属性和方法中,有的是已经明确实现了的,有的还无法确定,那么我们就可以将其定义成抽象,在后日子类进行重用,进行具体化.这样,抽象类也就诞生了. 例如,定义了"动物"父类,其中&qu

  • 深入解析Java编程中的抽象类

    Java程序用抽象类(abstract class)来实现自然界的抽象概念.抽象类的作用在于将许多有关的类组织在一起,提供一个公共的类,即抽象类,而那些被它组织在一起的具体的类将作为它的子类由它派生出来.抽象类刻画了公有行为的特征,并通过继承机制传送给它的派生类.在抽象类中定义的方法称为抽象方法,这些方法只有方法头的声明,而用一个分号来代替方法体的定义,即只定义成员方法的接口形式,而没有具体操作.只有派生类对抽象成员方法的重定义才真正实现与该派生类相关的操作. 在各子类继承了父类的抽象方法之后,

  • java 抽象类与接口的区别总结

    java 抽象类与接口的区别总结 abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制,正是由于这两种机制的存在,才赋予了Java强大的面向对象能力. abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性,甚至可以相互替换,因此很多开发者在进行抽象类定义时对于 abstract class和interface 选择显得比较随意. 其实,两者之间还是有很大的区别的,对于它们的选择甚至反映出对于问题领域本质的 理解

随机推荐