java抽象类 订阅
Java语言中,用abstract 关键字来修饰一个类时,这个类叫作抽象类。抽象类是它的所有子类的公共属性的集合,是包含一个或多个抽象方法的类。抽象类可以看作是对类的进一步抽象。在面向对象领域,抽象类主要用来进行类型隐藏。 展开全文
Java语言中,用abstract 关键字来修饰一个类时,这个类叫作抽象类。抽象类是它的所有子类的公共属性的集合,是包含一个或多个抽象方法的类。抽象类可以看作是对类的进一步抽象。在面向对象领域,抽象类主要用来进行类型隐藏。
信息
外文名
java abstract class
关键字
abstract
作    用
将许多有关的类组织在一起
含    义
使用了关键词abstract声明的类
所属领域
计算机科学技术
中文名
java抽象类
java抽象类产生背景
人们往往用建立抽象类的方法为一组类提供统一的界面。抽象类的概念来源于现实生活之中。这就使我们能在一个更高、更抽象的级别上考虑问题,从而简化了问题的复杂性。在Java程序中用抽象类(abstract class)来实现自然界的抽象概念。抽象类的作用在于将许多有关的类组织在一起,提供一个公共的类,而那些被组织在一起的具体的类作为其子类而派生出来。抽象类刻画了公有行为的特征,并通过继承机制传送给它的派生类。抽象类是它的所有子类的公共属性的集合,是包含一个或多个抽象方法的类。抽象类可以看作是对类的进一步抽象。首先从现实世界中的对象可以抽象出软件系统中的对象(保留主要属性和行为,去掉次要属性和行为),然后从软件系统中的对象可以抽象出软件系统中的类(去掉属性值,把具体的对象变成了抽象的概念),而抽象类则是对多个类的抽象结果,抽象类进一步描述了多个具体类的共同特征和行为。从系统分析的角度,使用抽象类可以更好地刻画自然界的抽象概念,更有效地完成软件系统与自然行为系统的映射,从系统设计实现的角度,使用抽象类可以更好地利用这些共同属性和操作,避免代码的重复编写,从而减少出错的几率,提高程序的开发效率。 [1] 
收起全文
精华内容
下载资源
问答
  • java抽象类

    千次阅读 2018-11-14 11:24:48
    java抽象类

    分享一下我老师大神的人工智能教程!零基础,通俗易懂!http://blog.csdn.net/jiangjunshow

    也欢迎大家转载本篇文章。分享知识,造福人民,实现我们中华民族伟大复兴!

                   
    JAVA抽象类的理解:
    1、普通的JAVA类也可以在CLASS前加ABSTRACT声明为抽象,只不过此时的该类不再可以实例化。
    2、如果一个类里有一个以上的抽象方法,则该类必须声明为抽象类,该方法也必须声明为抽象。
    3、抽象类不能被实例化,但不代表它不可以有构造函数,抽象类可以有构造函数,备继承类扩充
    用 abstract 修饰的类是抽象类。
    抽象类是不完整的,并且它只能用作基类。它与非抽象类的不同:   1、抽象类不能直接实例化,并且对抽象类使用 new 运算符是编译时错误。虽然一些变量和值在编译时的类型可以是抽象的,但是这样的变量和值必须或者为 null,或者含有对非抽象类的实例的引用(此非抽象类是从抽象类派生的)。   2、允许(但不要求)抽象类包含抽象成员。   3、抽象类不能被密封。   当Congo抽象类派生非抽象类时,这些非抽象类必须具体实现所继承的所有抽象成员,从而重写哪些抽象成员。在下边的示例中:    abstract class A{ public abstract void F();}   abstract class B: A{ public void G() {}}   class C: B{ public override void F() { // actual implementation of F }}    抽象类 A 引入抽象方法 F。类 B 引入另一个方法 G,但由于它不提供 F 的实现,B 也必须声明为抽象类。类 C 重写 F,并提供一个具体实现。由于 C 中没有了抽象成员,因此可以(但并非必须)将 C 声明为非抽象类。   抽象类与接口紧密相关。然接口又比抽象类更抽象,这主要体现在它们的差别上:1)类可以实现无限个接口,但仅能从一个抽象(或任何其他类型)类继承,从抽象类派生的类仍可实现接口,从而得出接口是用来解决多重继承问题的。2)抽象类当中可以存在非抽象的方法,可接口不能且它里面的方法只是一个声明必须用public来修饰没有具体实现的方法。3)抽象类中的成员变量可以被不同的修饰符来修饰,可接口中的成员变量默认的都是静态常量(static final)。4)这一点也是最重要的一点本质的一点"抽象类是对象的抽象,然接口是一种行为规范"。   以上是它们本身的异同,下面再来从实际应用讲讲它们的异同!   不同之处:

    定义  抽象类表示该类中可能已经有一些方法的具体定义,但是接口就仅仅只能定义各个方法的界面(方法名,参数列表,返回类型),并不关心具体细节。

    用法  1)在继承抽象类时,必须覆盖该类中的每一个抽象方法,而每个已实现的方法必须和抽象类中指定的方法一样,接收相同数目和类型的参数,具有同样的返回值,这一点与接口相同。   2)当父类已有实际功能的方法时,该方法在子类中可以不必实现,直接引用的方法,子类也可以重写该父类的方法(继承的概念)。   3)而实现 (implement)一个接口(interface)的时候,是一定要实现接口中所定义的所有方法,而不可遗漏任何一个。   4)另外,抽象类不能产生对象的,但可以由它的实现类来声明对象。   有鉴于此,在实现接口时,我们也常写一个抽象类,来实现接口中的某些子类所需的通用方法,接着在编写各个子类时,即可继承该抽象类来使用,省去在每个都要实现通用的方法的困扰。
               

    给我老师的人工智能教程打call!http://blog.csdn.net/jiangjunshow

    这里写图片描述
    展开全文
  • Java 抽象类

    千次阅读 多人点赞 2019-01-28 09:16:52
    Java 抽象类 在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类抽象类除了不能实例...

    Java 抽象类

    在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。
    抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类一样。
    由于抽象类不能实例化对象,所以抽象类必须被继承,才能被使用。也是因为这个原因,通常在设计阶段决定要不要设计抽象类。
    父类包含了子类集合的常见的方法,但是由于父类本身是抽象的,所以不能使用这些方法。
    在Java中抽象类表示的是一种继承关系,一个类只能继承一个抽象类,而一个类却可以实现多个接口。
    抽象类
    在Java语言中使用abstract class来定义抽象类。如下实例:

    Employee.java 文件代码:
    /* 文件名 : Employee.java */

    public abstract class Employee
    {
       private String name;
       private String address;
       private int number;
       public Employee(String name, String address, int number)
       {
          System.out.println("Constructing an Employee");
          this.name = name;
          this.address = address;
          this.number = number;
       }
       public double computePay()
       {
         System.out.println("Inside Employee computePay");
         return 0.0;
       }
       public void mailCheck()
       {
          System.out.println("Mailing a check to " + this.name
           + " " + this.address);
       }
       public String toString()
       {
          return name + " " + address + " " + number;
       }
       public String getName()
       {
          return name;
       }
       public String getAddress()
       {
          return address;
       }
       public void setAddress(String newAddress)
       {
          address = newAddress;
       }
       public int getNumber()
       {
         return number;
       }
    }
    
    注意到该 Employee 类没有什么不同,尽管该类是抽象类,但是它仍然有 3 个成员变量,7 个成员方法和 1 个构造方法。 现在如果你尝试如下的例子:

    AbstractDemo.java 文件代码:
    /* 文件名 : AbstractDemo.java */

    public class AbstractDemo
    {
       public static void main(String [] args)
       {
          /* 以下是不允许的,会引发错误 */
          Employee e = new Employee("George W.", "Houston, TX", 43);
     
          System.out.println("\n Call mailCheck using Employee reference--");
          e.mailCheck();
        }
    }
    
    当你尝试编译AbstractDemo类时,会产生如下错误:
    Employee.java:46: Employee is abstract; cannot be instantiated
          Employee e = new Employee("George W.", "Houston, TX", 43);
                       ^
    1 error
    
    继承抽象类
    我们能通过一般的方法继承Employee类:

    Salary.java 文件代码:
    /* 文件名 : Salary.java */

    public class Salary extends Employee
    {
       private double salary; //Annual salary
       public Salary(String name, String address, int number, double
          salary)
       {
           super(name, address, number);
           setSalary(salary);
       }
       public void mailCheck()
       {
           System.out.println("Within mailCheck of Salary class ");
           System.out.println("Mailing check to " + getName()
           + " with salary " + salary);
       }
       public double getSalary()
       {
           return salary;
       }
       public void setSalary(double newSalary)
       {
           if(newSalary >= 0.0)
           {
              salary = newSalary;
           }
       }
       public double computePay()
       {
          System.out.println("Computing salary pay for " + getName());
          return salary/52;
       }
    }
    
    尽管我们不能实例化一个 Employee 类的对象,但是如果我们实例化一个 Salary 类对象,该对象将从 Employee 类继承 7 个成员方法,且通过该方法可以设置或获取三个成员变量。

    AbstractDemo.java 文件代码:
    /* 文件名 : AbstractDemo.java */

    public class AbstractDemo
    {
       public static void main(String [] args)
       {
          Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
          Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
     
          System.out.println("Call mailCheck using Salary reference --");
          s.mailCheck();
     
          System.out.println("\n Call mailCheck using Employee reference--");
          e.mailCheck();
        }
    }
    
    以上程序编译运行结果如下:
    Constructing an Employee
    Constructing an Employee
    Call mailCheck using  Salary reference --
    Within mailCheck of Salary class
    Mailing check to Mohd Mohtashim with salary 3600.0
    
    Call mailCheck using Employee reference--
    Within mailCheck of Salary class
    Mailing check to John Adams with salary 2400.
    
    抽象方法
    如果你想设计这样一个类,该类包含一个特别的成员方法,该方法的具体实现由它的子类确定,那么你可以在父类中声明该方法为抽象方法。
    Abstract 关键字同样可以用来声明抽象方法,抽象方法只包含一个方法名,而没有方法体。
    抽象方法没有定义,方法名后面直接跟一个分号,而不是花括号。
    public abstract class Employee
    {
       private String name;
       private String address;
       private int number;
       
       public abstract double computePay();
       
       //其余代码
    }
    
    声明抽象方法会造成以下两个结果:
    如果一个类包含抽象方法,那么该类必须是抽象类。
    任何子类必须重写父类的抽象方法,或者声明自身为抽象类。
    继承抽象方法的子类必须重写该方法。否则,该子类也必须声明为抽象类。最终,必须有子类实现该抽象方法,否则,从最初的父类到最终的子类都不能用来实例化对象。
    如果Salary类继承了Employee类,那么它必须实现computePay()方法:

    Salary.java 文件代码:
    /* 文件名 : Salary.java */

    public class Salary extends Employee
    {
       private double salary; // Annual salary
      
       public double computePay()
       {
          System.out.println("Computing salary pay for " + getName());
          return salary/52;
       }
     
       //其余代码
    }
    

    抽象类总结规定:

    1. 抽象类不能被实例化(初学者很容易犯的错),如果被实例化,就会报错,编译无法通过。只有抽象类的非抽象子类可以创建对象。
    2. 抽象类中不一定包含抽象方法,但是有抽象方法的类必定是抽象类。
    3. 抽象类中的抽象方法只是声明,不包含方法体,就是不给出方法的具体实现也就是方法的具体功能。
    4. 构造方法,类方法(用 static 修饰的方法)不能声明为抽象方法。
    5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现,除非该子类也是抽象类。
    展开全文
  • java 抽象类

    千次阅读 2020-02-07 10:40:58
    1.java抽象类的基本概念 普通类就是完善的功能类,直接生产对象并使用,其中的方法都已经实现完整(带有方法体"{}").抽象类的最大特点包含了抽象方法,抽象方法是只声明(没有方法体)的方法,抽象方法定义时使用abstract...

    1.java抽象类的基本概念
    普通类就是完善的功能类,直接生产对象并使用,其中的方法都已经实现完整(带有方法体"{}").抽象类的最大特点包含了抽象方法,抽象方法是只声明(没有方法体)的方法,抽象方法定义时使用abstract关键字完成,并且抽象方法一定要在抽象类中,抽象类要使用abstract关键字声明.

    2.下面程序可以了解到,由于类中存在了一个抽象方法get(),所以A类就必须使用abstract定义为抽象类,但是抽象类毕竟不是完整的类,所以不能像以前那样,直接实例化对象.

    abstract class A{
         private String in = "芷若 张无忌";
        public void print(){
                     System.out.print(in);
                     }
            public  abstract void get();                    //抽象方法:只有声明没有方法体         
         }
    

    错误使用----直接实例化
    一个类对象实例化后,可以调用类中的属性和方法,但是抽象类中的抽象方法没有方法体,所以这样肯定不合理.

    public  class Test{
          public static void main(String args[]){
             A a =new A()            //错误:Cannot instantiiate the type A
              }
          }
    

    在实际开发中,抽象类使用原则如下.
    1.抽象类必须有子类,使用extends继承,一个子类只能继承一个抽象类;
    2.子类(如果不是抽象类)必须覆写抽象中的全部抽象方法;
    3.抽象类对象可以使用对象的向上转型,通过子类来进行实例化操作.

    3.使用抽象类
    与之前类的继承不一样的是,抽象类定义出子类必须要覆写的方法,而之前的类可以选择性地决定是否需要覆写,并且,抽象类实际上就比普通类多了一些抽象方法而已,其他定义和普通类一样.
    在这里插入图片描述
    运行结果
    在这里插入图片描述
    结论:
    1.抽象类不能使用final定义,final定义的类不能有子类.
    2.抽象方法可以有构造方法,抽象类除了包含抽象方法外,还包含了普通方法和属性,而属性一定要在构造方法执行完毕后才可以进行初始化操作.
    3.抽象类可以没有抽象方法,但是如果有抽象方法,则一定是抽象类,即使抽象类没有抽象方法,也不能够被直接实例化.
    4.抽象类使用static有两种情况:
    情况一:直接使用static,肯定无法定义一个抽象类
    情况二:在内部类定义可以直接使用static,就表示定义了一个内部抽象类.

    4.定义内部抽象类
    定义抽象内部类,同时使用static声明,这就表示一个外部类,即抽象类的名称为"A.B".
    在这里插入图片描述
    运行结果
    在这里插入图片描述
    5.看下面程序
    在这里插入图片描述
    运行结果
    输出结果为"0",要解释这个结果,参考之前讲过构造方法给出的问题:“一个类只有执行了构造方法后,才可以为类中的属性初始化,而在属性没有初始化前,类中所有的属性都是对应数据类型的默认值”.
    主类实例化的是子类对象,根据对象的实例化流程,子类对象实例化前首先调用父类构造,为父类中的属性初始化,这时候子类对象由于没有被实例化,所以Po2类中的x属性就是其对应数据类型的默认值0,在父类构造中,又调用了print()方法,而此时实例化的是子类对象,所以调用的肯定是被覆写过得方法,所以结果为"x=0".
    在这里插入图片描述

    展开全文
  • Java抽象类

    千次阅读 2021-04-23 19:02:34
    文章目录抽象类1.1 概述由来定义1.2 abstract使用格式抽象方法定义格式:抽象类抽象的使用1.3 注意事项 抽象类 1.1 概述 由来 父类中的方法,被它的子类们重写,子类各自的实现都不尽相同。那么父类的方法声明和方法...

    抽象类

    1.1 概述

    由来

    父类中的方法,被它的子类们重写,子类各自的实现都不尽相同。那么父类的方法声明和方法主体,只有声明还有
    意义,而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定,包含抽象方法
    的类就是抽象类。

    定义

    抽象方法 : 没有方法体的方法。
    抽象类:包含抽象方法的类。

    1.2 abstract使用格式

    抽象方法

    使用 abstract 关键字修饰方法,该方法就成了抽象方法,抽象方法只包含一个方法名,而没有方法体。

    定义格式:

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

    代码举例:

    public abstract void run()

    抽象类

    如果一个类包含抽象方法,那么该类必须是抽象类。
    定义格式:

    abstract class 类名字 {
    }
    

    代码举例:

    public abstract class Animal {
        public abstract void run()}
    

    抽象的使用

    继承抽象类的子类必须重写父类所有的抽象方法。否则,该子类也必须声明为抽象类。最终,必须有子类实现该父类的抽象方法,否则,从最初的父类到最终的子类都不能创建对象,失去意义。

    代码举例:

    public class Cat extends Animal {
        public void run (){
            System.out.println("小猫在墙头走~~~")}
    }
    public class CatTest {
        public static void main(String[] args) {
            // 创建子类对象
            Cat c = new Cat();
            // 调用run方法
            c.run();
        }
    }
    

    输出结果:

    小猫在墙头走~~~
    

    此时的方法重写,是子类对父类抽象方法的完成实现,我们将这种方法重写的操作,也叫做实现方法。

    1.3 注意事项

    关于抽象类的使用,以下为语法上要注意的细节,虽然条目较多,但若理解了抽象的本质,无需死记硬背。

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

    万次阅读 多人点赞 2016-10-05 00:06:35
    一、抽象类的基本概念普通类是一个完善的功能类,可以直接产生实例化对象,并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。...
  • java基础-java抽象类

    2017-06-20 19:01:42
    java抽象类 (1)基本属性 java抽象类中不一定抽象方法,但是有抽象方法的类一定是java 抽象类;抽象类的抽象方法必须使用abstract修饰;抽象类不可以被实例化,需要依靠继承该抽象类的子类来完成实例化操作. (2)...
  • java抽象类详解

    千次阅读 2018-06-27 10:55:13
    1、Java抽象类存在的意义,为什么要使用抽象类? 利于代码的维护和复用。把相同的方法或者属性抽象出来放在一个抽象类中,让类去继承,则实现了复用。 2、什么是抽象类? 加上abstract关键字的类即为抽象类。 3、...
  • Java抽象类和抽象方法例子

    千次阅读 2017-09-17 23:56:59
    转自Java抽象类用法示例详解  Java抽象类的定:java抽象类体现数据抽象的思想,是实现程序多态性的一种手段。也提到抽象类与抽象方法的限制,下面我们会通过一下java抽象类小示例来给你介绍抽象类的用法。希望对你...
  • java抽象类和普通类的区别 1.抽象类不能被实例化。 2.抽象类可以有构造函数,被继承时子类必须继承父类一个构造方法,抽象方法不能被声明为静态。 3.抽象方法只需申明,而无需实现,抽象类中可以允许普通方法有主体...
  • 1 继承抽象类 和继承普通类 有声明区别啊? as:当然有区别了,继承抽象类必须重写或说实现抽象类里的所有抽象方法,普通类看情况而定比较随意。...2 java 抽象类java接口类有什么区别 抽象类( abstract meth
  • Java接口和Java抽象类

    2013-04-23 08:36:36
    Java接口和Java抽象类有太多相似的地方,又有太多特别的地方,究竟在什么地方,才是它们的最佳位置呢?把它们比较一下,你就可以发现了。 1、Java接口和Java抽象类最大的一个区别,就在于Java抽象类可以提供某些...
  • 标签: java抽象类概念理解抽象类与接口区别抽象类与普通类区别 2017-05-04 16:26 1029人阅读 评论(0) 收藏 举报  分类: Java(17)  版权声明:本文为博主csdn_aiyang原创文章,未经博主...
  • Java抽象类和抽象方法详解

    千次阅读 2018-02-24 02:03:51
    Java抽象类和抽象方法详解一 . 由来 当编写一个类时,常常会给这个类定义一些方法来描述这个类的行为方式,通常这些方法都有相应的具体的方法体,但是,在某些情况下,某个基类只是知道其子类应该包含怎样的方法,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 79,022
精华内容 31,608
关键字:

java抽象类

java 订阅