精华内容
下载资源
问答
  • java抽象类和抽象方法
    千次阅读
    2021-02-12 13:58:25

    一、抽象(abstract)的使用

    当父类的某些方法不确定时,可以用abstract关键字来修饰该方法[抽象方法],用abstract来修饰该类[抽象类]。

    我们都知道,父类是将子类所共同拥有的属性和方法进行抽取,这些属性和方法中,有的是已经明确实现了的,有的还无法确定,那么我们就可以将其定义成抽象,在后日子类进行重用,进行具体化。这样,抽象类也就诞生了。

    例如,定义了“动物”父类,其中“动物名称”和“动物年龄”属性已经明确了,但是“动物叫”的方法没有明确,此时就可以将“动物叫”定义为抽象方法。

    所以,抽象类是为了把相同的但不确定的东西的提取出来,为了以后的重用。定义成抽象类的目的,就是为了在子类中实现抽象类。

    packagejavastudy;public classAbstractDemo1 {public static voidmain(String[] args) {//TODO Auto-generated method stub

    }

    }//这就是一个抽象类

    abstract classAnimal {

    String name;intage;//动物会叫

    public abstract void cry(); //不确定动物怎么叫的。定义成抽象方法,来解决父类方法的不确定性。抽象方法在父类中不能实现,所以没有函数体。但在后续在继承时,要具体实现此方法。

    }//抽象类可以被继承//当继承的父类是抽象类时,需要将抽象类中的所有抽象方法全部实现。

    class cat extendsAnimal {//实现父类的cry抽象方法

    public voidcry() {

    System.out.println("猫叫:");

    }

    }

    二、用abstract修饰的类,即抽象类;用abstract修饰的方法,即抽象方法。

    三、抽象方法不能有方法主体。格式如下:

    abstract void xxx();

    四、抽象类不能被实例化。因为抽象类中方法未具体化,这是一种不完整的类,所以直接实例化也就没有意义了。

    五、抽象类中不一定要包含abstrace方法。也就是了,抽象中可以没有abstract方法。

    六、一旦类中包含了abstract方法,那类该类必须声明为abstract类。

    更多相关内容
  • 主要介绍了JAVA抽象类和抽象方法(abstract),结合实例形式分析了java抽象类及抽象方法相关定义、使用技巧与操作注意事项,需要的朋友可以参考下
  • java抽象类和抽象方法

    千次阅读 2021-03-07 00:02:17
    抽象类的使用一般通过继承来实现二、为什么需要抽象类和抽象方法引用抽象方法和抽象类,是java提供的一种语法工具,引导使用者正确的使用它们,减少误用。相当于对子类进行一定限制。三、抽象类和抽象方法的语法规则...

    一、什么是抽象类和抽象方法

    没有具体功能的实现,通过子类继承后重写方法来实现一定约束的类称之为抽象类,抽象类必须被abstract修饰。抽象方法就是只有方法声明,没有方法体的方法。抽象类的使用一般通过继承来实现

    二、为什么需要抽象类和抽象方法

    引用抽象方法和抽象类,是java提供的一种语法工具,引导使用者正确的使用它们,减少误用。相当于对子类进行一定限制。

    三、抽象类和抽象方法的语法规则及其注意事项

    抽象类抽象方法必须被abstract修饰。

    抽象类中可以有普通方法,但是有抽象方法的类必须是抽象类。抽象类中的普通方法因为不能被创建对象,所以不能使用这个普通方法。

    抽象类除了不能实例化对象之外,类的其它功能依然存在。

    抽象方法中可以有被static修饰main方法,并且可以执行。

    一个类在继承抽象类后,必须实现抽象类中定义的所有抽象方法。除非它自己也声明为抽象类。

    抽象方法名后面直接跟一个分号,而不是花括号。

    四、抽象类和抽象方法的实现案例

    1、抽象类中可以有普通方法,但是有抽象方法的类必须是抽象类。

    public abstract class Demo01 {

    public abstract void run();

    public void test(){}

    }

    //编译通过,不报错

    public class Demo01 {

    public abstract void run();

    public void test(){}

    }

    //报错:

    Class 'Demo01' must either be declared abstract or implement abstract method 'run()' in 'Demo01'

    Abstract method in non-abstract class

    2a03c1ce46b001404d74cb483c53dfed.png

    2、抽象类除了不能实例化对象

    public abstract class Demo01 {

    public abstract void run();

    public static void main(String[] args) {

    Demo01 demo01=new Demo01();

    }

    }

    e391d9aa2a3f1229ee45ef3aa8a40ae4.png

    3、抽象方法中可以有被static修饰main方法,并且可以执行。

    public abstract class Demo01 {

    public abstract void run();

    public static void main(String[] args) {

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

    }

    }

    //输出结果:抽象类中的main方法

    4、抽象类的使用一般通继承来实现,且子类中要么对抽象类的方法进行重写,要么声明子类也为抽象类

    public class Demo02 extends Demo01{

    @Override

    public void run() {

    }

    }

    abstract class Demo03 extends Demo01{

    }

    //Demo02和Demo3均能编译通过。

    5、抽象类中的静态方法可以用类名.方法名的方式调用

    e48ac6d43d5525c72074397ed91e40cc.png

    6、抽象的实例:

    有抽象类Father,和抽象方法run()。

    public abstract class Father {

    private String name;

    private int age;

    private char sex='男';

    public int money=100_000;

    public String getName() {

    return name;

    }

    public void setName(String name) {

    this.name = name;

    }

    public int getAge() {

    return age;

    }

    public void setAge(int age) {

    this.age = age;

    }

    public char getSex() {

    return sex;

    }

    public void setSex(char sex) {

    this.sex = sex;

    }

    abstract void run();

    public void say(){

    System.out.println("这是父类普通方法");

    }

    public static void go(){

    System.out.println("这是父类静态方法");

    }

    }

    有子类Son继承了抽象类,重写了父类的抽象方法run

    public class Son extends Father{

    private double salary;

    @Override

    void run() {

    System.out.println("子类重写了父类的方法run");

    System.out.println(super.getSex());

    super.say();

    }

    public static void main(String[] args) {

    Son son=new Son();

    son.run();

    System.out.println(son.getSex());

    //System.out.println(super.getSex()); //错误

    son.setAge(47);

    System.out.println(son.getAge());

    son.setName("ThreePure");

    System.out.println(son.getName());

    //调用父类的公有属性

    System.out.println(son.money);

    //使用继承于父类的方法

    son.say();

    }

    }

    运行结果:

    子类重写了父类的方法run

    这是父类普通方法

    47

    ThreePure

    100000

    这是父类普通方法

    尽管我们不能实例化一个 Father类的对象,但是如果我们实例化一个 Son 类对象,该对象将从 Father 类继承 成员方法,且通过该方法可以设置或获取成员变量。

    五、抽象类的其他补充吗

    抽象类是否有构造器:

    e4dc66d994535459d7bdc270574d7b1e.png

    从图中我们可以知道抽象类也是有构造器的,并别在子类创建对象时被调用。

    public abstract class Demo3 {

    public Demo3() {

    System.out.println("抽象类的构造方法");

    }

    }

    public class Demo4 extends Demo3{

    public static void main(String[] args) {

    Demo4 demo4 =new Demo4();

    }

    }

    //抽象类的构造方法

    2、final与abstract的矛盾

    final关键字可以修饰类、方法、变量。final修饰的类不能被派生;final修饰的方法,禁止子类重写。所以我们可以看出,final和abstract不能一起使用。

    3、构造方法,类方法(用 static 修饰的方法)不能声明为抽象方法。

    ef1db7eeaea5b0eb959f00a80b959e63.png

    展开全文
  • 本文实例讲述了Java抽象类和抽象方法定义与用法。分享给大家供大家参考,具体如下:一、Java抽象类1、抽象类的说明在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象...

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

    一、Java抽象类

    1、抽象类的说明

    在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。

    抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类一样。

    由于抽象类不能实例化对象,所以抽象类必须被继承,才能被使用。也是因为这个原因,通常在设计阶段决定要不要设计抽象类。

    父类包含了子类集合的常见的方法,但是由于父类本身是抽象的,所以不能使用这些方法。

    在Java中抽象类表示的是一种继承关系,一个类只能继承一个抽象类,而一个类却可以实现多个接口。

    在Java语言中使用abstract class来定义抽象类。

    抽象类是为了把相同的但不确定的东西的提取出来,为了以后的重用。定义成抽象类的目的,就是为了在子类中实现抽象类。

    2、抽象类的定义

    abstract class A{//定义一个抽象类

    public void fun(){//普通方法

    System.out.println("存在方法体的方法");

    }

    //不存在方法体的抽象方法

    public abstract void print();//抽象方法,没有方法体,有abstract关键字做修饰

    }

    3、抽象类的使用

    抽象类的使用原则如下:

    (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.fun();//被子类所覆写的过的方法

    }

    }

    (1)抽象类的子类里面有明确的方法覆写要求,而普通类可以有选择性的来决定是否需要覆写;

    (2)抽象类实际上就比普通类多了一些抽象方法而已,其他组成部分和普通类完全一样;

    (3)普通类对象可以直接实例化,但抽象类的对象必须经过向上转型之后才可以得到。

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

    4、抽象类的使用限制

    (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定义的类不能有子类;

    二、Java抽象方法

    用abstract修饰的方法,即抽象方法。并且,抽象方法不能有方法主体。格式如下:

    abstract void xxx();

    说明:

    一旦类中包含了abstract抽象方法,那类该类必须声明为abstract类。

    抽象类中不一定要包含abstrace方法。

    抽象类不能被实例化。因为抽象类中方法未具体化,这是一种不完整的类,所以直接实例化也就没有意义了。

    任何子类必须重写父类的抽象方法,或者声明自身为抽象类

    范例:bstract关键字可以用来声明抽象方法,抽象方法只包含一个方法名,而没有方法体。

    抽象方法没有定义,方法名后面直接跟一个分号,而不是花括号。

    public abstract class Employee

    {

    private String name;

    private String address;

    private int number;

    public abstract double computePay();

    //其余代码

    }

    如果Salary类继承了上面的Employee抽象类,那么它必须实现computePay()方法:

    /* 文件名 : 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;

    }

    //其余代码

    }

    【抽象类总结规定】

    抽象类不能被实例化(初学者很容易犯的错),如果被实例化,就会报错,编译无法通过。只有抽象类的非抽象子类可以创建对象。

    抽象类中不一定包含抽象方法,但是有抽象方法的类必定是抽象类。

    抽象类中的抽象方法只是声明,不包含方法体,就是不给出方法的具体实现也就是方法的具体功能。

    构造方法,类方法(用static修饰的方法)不能声明为抽象方法。

    抽象类的子类必须给出抽象类中的抽象方法的具体实现,除非该子类也是抽象类。

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

    展开全文
  • Java抽象方法和抽象类

    千次阅读 2022-04-22 15:41:00
    1、抽象方法 如果父类的方法本身不需要实现任何功能,仅仅是为了定义方法签名,目的是让子类去...因为这个抽象方法本身是无法执行的,所以Person无法被实例化。并且编译器会报错无法编译Person,因为它包含抽...

    1、抽象方法

            如果父类的方法本身不需要实现任何功能,仅仅是为了定义方法签名,目的是让子类去覆盖它,那么,可以把父类的方法声明为抽象方法

    class Person {    
        // 定义抽象方法
        public abstract void run();
    }

            把一个方法声明为abstract,表示它是一个抽象方法,本身没有实现任何方法语句。因为这个抽象方法本身是无法执行的,所以Person类无法被实例化。并且编译器会报错无法编译Person类,因为它包含抽象方法。

            必须把Person类本身也声明为abstract,才能正确编译它,如:

    // 抽象方法必须定义在抽象类中
      abstract class Person {
         public abstract void run(); 
     }

    2、抽象类

            如果一个class定义了方法,但没有具体执行代码,这个方法就是抽象方法,抽象方法用abstract修饰。因为无法执行抽象方法,因此这个类也必须申明为抽象类(abstract class)。

            使用abstract修饰的类就是抽象类,抽象类无法实例化。

    // 编译报错,Person不能被实例化
    Person p = new Person(); 

            抽象类本身被设计成只能用于被继承,因此,抽象类可以强迫子类实现其定义的抽象方法,否则编译会报错。抽象方法实际上相当于定义了"规范"。

    abstract class Person {  // 定义抽象类Person
        public abstract void run();   // 抽象方法run()
    }
    
    
    class Student3 extends Person {   // 继承抽象类Person
        @Override
        public void run() {   // 必须覆写父类run()方法,否则会报错
            System.out.println("Student.run");
        }
    }
    
    Student p = new Student();
    p3.run();       // 运行结果:Student.run

    3、面向抽象编程

            定义了抽象类Person,以及具体的Student子类的时候,可以通过抽象类Person类型去引用具体的子类实例。

            这种引用抽象类的好处在于,对其进行方法调用,并不关心Person类型变量的具体子类型。

    // Person类型的引用变量s指向Student实例。
    Person s = new Student();
    s.run();

            这种尽量引用高层类型,避免引用实际子类型的方式,称之为面向抽象编程。

            面向抽象编程本质:

            (1)上层代码只定义规范

            (2)不需要子类就可以实现业务逻辑

            (3)具体的业务逻辑由不同的子类实现,调用者并不关心

    4、总结

            通过abstract定义的方法是抽象方法,它只定义没有实现。抽象方法定义了子类必须实现的接口规范。

            定义了抽象方法的class必须被定义为抽象方法,从抽象类继承的子类必须实现抽象方法。

            如果不实现抽象方法,则该子类仍是一个抽象类。

            面向抽象编程使得调用者只关心抽象方法的定义,不关心子类的具体实现。

    展开全文
  • Java抽象类和抽象方法归纳总结

    千次阅读 2020-06-11 12:26:24
    这篇文章从不同角度归纳介绍了抽象类的知识点及其注意事项。文中引用的具体例子在这里:抽象类的一个例子 Triangle类是继承自抽象类GeometriObject的具体子类 GeometriObject中包含两个...抽象方法和抽象类之间的关
  • Java抽象类和抽象方法如何定义

    千次阅读 2020-11-18 23:46:06
    抽象类 具体的类是可以被初始化为对象的,在类的声明前面加上抽象类关键词abstract,则该类就会成为一个抽象类。 abstract public class Canine extends Animal { public void roam () {} } 编译器不会让你初始化...
  • Java抽象类和抽象方法的使用与定义

    千次阅读 2019-10-31 17:06:47
    抽象类和抽象方法的定义 抽象方法:就是加上abstract关键字,去掉{},直接;结束 抽象类:抽象方法所在的类,必须是抽象类。在class之前加上abstract即可 package StudyClass; public abstract class Fu { public...
  • Java中的抽象类和接口

    千次阅读 多人点赞 2022-04-08 15:17:42
    各位铁汁们大家好呀!今天让我们继续学习java,看看java中的抽象类和接口到底是什么? 里面也会讲到多态呀,一起来看看吧
  • Java抽象类和抽象方法详解

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

    千次阅读 2019-06-08 11:43:15
    抽象方法和抽象类必须使用abstract修饰符来定义,有抽象方法的类只能被定义为抽象类抽象类里可以没有抽象方法抽象类和抽象方法的规则: 抽象类必须使用abstract修饰符来修饰,抽象方法必须使用abstract修饰符...
  • 主要介绍了Java抽象类概念与用法,结合实例形式分析了java抽象类的概念、方法、特点及使用方法,需要的朋友可以参考下
  • 你知道java当中的普通类和抽象类之间有什么区别吗?这两者的不同之处究竟是什么呢?下面就小编一起来详细的了解一下吧。一、抽象类和普通类区别抽象类和普通类的区别我们做了以下7点简单的总结,相信看了的朋友应该...
  • Java 抽象类和接口

    千次阅读 热门讨论 2021-11-14 16:09:56
    文章目录一、抽象类1....在Java面向对象当中,所有的对象都是用过类进行描绘的,但是并不是所有的类都是用来描绘对象的,如果一个类没有包含足够多的信息来描述一个具体的对象,这样的类就是抽象类。 1.2抽象方法
  • Java抽象类

    千次阅读 2021-05-30 15:26:05
    java抽象类介绍一、抽象类的基本概念二、抽象类的使用方法三、抽象类的应用 一、抽象类的基本概念   我们都知道在面向对象的领域一切都是对象,同时所有的对象都是通过类来描述的,但是并不是所有的类都是来描述...
  • java抽象类的构造方法和普通类的构造方法一样都是用来初始化类只是抽象类的构造方法不能直接调用 因为抽象类不能实现实例但是一旦一个普通类继承了抽象类 便也可以在构造函数中调用其抽象类的构造函数也可以使用其...
  • Java 抽象类和接口的区别

    千次阅读 2022-03-15 20:06:50
    接口中不能含有静态代码块以及静态方法,而抽象类可以有静态代码块静态方法; 一个类只能继承一个抽象类,而一个类却可以实现多个接口。 二、设计层面上的区别 a.抽象类是对一种事务的抽象,是对整个类进行...
  • 以举例的方式说到如何区分抽象类和接口,这里我们从Java语法谈起,使我们更加了解这两者的内在区别。它们的语法区别:1)接口不能有构造方法抽象类可以有。2)接口不能有方法体,抽象类可以有。3)接口不能有静态方法...
  • Java抽象类 详解

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

    千次阅读 2021-03-08 06:02:32
    关于java抽象类 继承的搜索结果回答抽象类接口的区别:默认的方法实现抽象类可以有默认的方法实现完全是抽象的。接口根本不存在方法的实现。抽象类中可以有已经实现了的方法,也可以有被abstract修饰的方法(抽象...
  • java抽象类详解

    千次阅读 2021-02-25 18:11:57
    final关键字final 修饰符 可以修饰 类、属性、方法修饰类时 表示该类不能被继承 其他特征 跟普通的类一样修饰 属性时 表示 改属性不能改变 并且 必须赋初始值修饰方法时 表示该方法不能被重写什么是抽象类?...
  • Java抽象类中声明静态变量和方法

    千次阅读 2021-02-26 16:08:48
    如果方法声明为静态,则它是类的成员,而不是属于该类的对象。可以在不创建该类的对象的情况下调...它主要用作子类的基础,以扩展实现抽象方法,并覆盖或访问抽象类中已实现的方法。示例abstractclassParent{stati...
  • java抽象类和接口最本质的区别是接口里不能实现方法--接口中的方法全是抽象方法。抽象类中可实现方法--抽象类中的方法可以不是抽象方法,下文给大家简单介绍下,需要的的朋友参考下
  • Java抽象类中是否可以有构造方法

    千次阅读 2021-03-23 10:40:52
    之所以产生这个疑问,是因为Java抽象类本身的要求抽象类是不能被实例化的,抽象类只能作为其他类的父类,或者通过向上转型指向其子类。所以既然抽象类是不允许被实例化的,那么他的构造方法存在是否还有实际意义? ...
  • JAVA 抽象类,抽象方法

    千次阅读 2021-04-22 21:18:22
    如一个抽象类Animal中有一个抽象方法run.public class Animal{public abstract void run();}那么他的子类必须要实现run这个方法。不是实现的话编译就会报错。public class Dog{@Overridepublic void r...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 847,057
精华内容 338,822
关键字:

java抽象类和抽象方法