精华内容
下载资源
问答
  • abstract 关键字用于定义抽象方法与抽象类。 抽象方法 抽象方法指没有方法体的方法,具体就是在方法声明的时候没有 {} 括弧以及其中的内容,而是直接在声明时在方法名后加上分号结束。 abstract 关键字用于定义抽象...
  • 抽象类与抽象方法由abstract修饰 abstract的使用注意 抽象方法没有方法体 抽象成员只能存在于抽象类抽象类可以有非抽象成员(侧重族群的概念) 抽象类的子类必须实现抽象方法抽象类you构造函数 抽象类只能...
  • 主要为大家详细介绍了C#抽象类与抽象方法的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • C#类、接口、虚方法和抽象方法-接口与抽象类区别实例 C#类、接口、虚方法和抽象方法-接口与抽象类区别实例
  • C#抽象类与抽象方法

    2011-05-10 16:17:37
    但是一个抽象类里不写抽象方法就没有意义了,既然如此,还不如直接写个普通类? 在一个抽象类里可以不声明抽象方法,这在语法上是没问题的,但实际来说,这样是没有任何意义的。也就是说,你为什么会选择写一个抽象...
  • 本文实例讲述了php抽象方法抽象类。...抽象类中可以有不是抽象的方法和成员属性。 但只要有一个抽象方法,这个类就必须定义为抽象类抽象类怎么用呢?最重要的一点是抽象类,不能产生实例对象!
  • 二、抽象方法抽象类的定义 一个类中至少有一个方法是抽象的,我们称之为抽象类。所以如果定义抽象类首先定义抽象方法。 abstract class class1{ abstract function fun1(); …… } 1、类中至少有一个抽象方法 2...
  • 抽象类不一定有抽象方法,有抽象方法的一定是抽象类吗?如果有抽象方法的一定是抽象类,那么,枚举类可以有抽象方法,这样的话,枚举类是抽象类吗?
  • 1、什么是抽象方法? 我们在类里面定义的没有方法提的方法就是抽象方法。所谓的没有方法体指的是...在抽象类里面可以有不是抽象的方法和成员属性,但只要有一个方法是抽象的方法,这个类就必须声明为抽象类,使用“abs
  • C__抽象类与抽象方法

    2011-10-24 15:13:22
    讲述C抽象类与抽象方法区别,并通过举例详细说明各自的差别
  • 面向对象——抽象类与抽象方法

    千次阅读 2020-04-13 09:26:04
    如果一个类不具体的食物相联系,而只表达一种抽象的概念,仅是作为其派生类的一个基类,这样的类就是派生类,在抽象类中,声明抽象类中声明抽象方法是,如果加上abstract关键字则为抽象方法。abstract 修饰符可...

    如果一个类不与具体的食物相联系,而只表达一种抽象的概念,仅是作为其派生类的一个基类,这样的类就是派生类,在抽象类中,声明抽象类中声明抽象方法是,如果加上abstract关键字则为抽象方法。abstract 修饰符可用于类、方法、属性、索引器和事件。

    在类声明中使用abstract 修饰符以指示某个类只能是其他类的基类。

    标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现。

    通过在类定义前面放置关键字 abstract,可以将类声明为抽象类。例如:

    public abstract class A

    {

        // Class members here.

    }

    抽象类的用途是提供多个派生类可共享的基类的公共定义。

    抽象类具有以下特性:

      • 抽象类不能实例化。
      • 抽象类可以包含抽象方法和抽象访问器。
      • 不能用sealed修饰符修饰抽象类,因为这两个修饰符的含义是相反的。采用sealed 修饰符的类无法继承,而abstract 修饰符要求对类进行继承。
      • 从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实际实现。

    抽象类必须为所有接口成员提供实现。

    实现接口的抽象类可以将接口方法映射到抽象方法上。例如:

    interface I

    {void M();}

    abstract class C : I

    {

    public abstract void M();

    }

    抽象方法是隐式的虚方法。

    由重写方法override提供实现,此重写方法是非抽象类的一个成员。

    只允许在抽象类中使用抽象方法声明。

    在抽象方法声明中使用 static 或 virtual 修饰符是错误的。

    当抽象类从基类继承虚方法时,抽象类可以使用抽象方法重写该虚方法。例如:

    public class D 

    {

    public virtual void DoWork(inti)      {   // Original implementation.    }

    }

    public abstract class E : D

    { public abstract override void DoWork(inti);}

    public class F : E  

    {

    public override void DoWork(inti)  

    {  // New implementation.  }

    }

    如果将 virtual 方法声明为 abstract,则该方法对于从抽象类继承的所有类而言仍然是虚方法。

    继承抽象方法的类不能访问该方法的原始实现。

    在上例中,类F 的DoWork不能调用类D中的DoWork。通过这种方式,抽象类可以强制派生类为虚方法提供新的方法实现。除了在声明和调用语法上不同外,抽象属性的行为与抽象方法一样。在静态属性上使用 abstract 修饰符是错误的。

    在派生类中,通过包括使用 override 修饰符的属性声明,可以重写抽象的继承属性。

    例:自定义抽象类计算圆形面积

    public partial class Form1 : Form

        {

    public Form1()

    {InitializeComponent();}

    private void button1_Click(object sender, EventArgs e)

            {

    CalcAreacalcArea = new CalcArea();//实例化派生类

                Roll roll = calcArea;//使用派生类对象实例化抽象类

                string strNum=textBox1.Text.Trim();//记录TextBox文本框中的内容

    if (strNum != "")//判断是否输入了圆半径

                {

    try

                    {

    roll.R = int.Parse(strNum );//使用抽象类对象访问抽象类中的半径属性

                        textBox2.Text = roll.Area().ToString();//调用自定义方法进行求圆面积

                    }

    catch

                    {

    MessageBox.Show("请输入正确的圆半径!");

                    }

                }

            }

        }

    public abstract class Roll

        {  // 圆半径

    privateint r = 0;

    publicint R

    { get {return r;}set{r = value;}  }

    public abstract double Area();// 抽象方法,用来计算圆面积

        }

        public class CalcArea : Roll//继承抽象类

        {

    public override double Area()   // 重写抽象类中计算圆面积的方法

            {

    returnMath.PI * R * R;

            }

    }

     

    虚拟方法和抽象方法有什么区别?
    抽象方法只有声明没有实现,需要在子类中实现;虚拟方法有声明和实现,并且可以在子类中覆盖,也可以不覆盖使用父类的默认实现
    虚拟方法有实现代码,抽象方法则没有
    并且抽象类不能被实例化,只能实例化实现了全部抽象方法的派生类
    抽象方法是虚拟方法的一种
    抽象方法没有实现,它的存在只是为派生类统一接口;派生类应该实现这个方法
    如果编写一个基类,它永远不会被实现,那么就应该将这个类中的一个或多个方法定义为
    抽象方法。
    抽象方法只存在于抽象类中,有抽象方法的类必须定义为抽象类
    其实大家首先要搞清楚,虚方法与多态性关系密切,虚方法允许派生类完全或部分重写该类的方法,需写方法体。抽象类中可以包含抽象方法与一般的方法,抽象类不可以new,抽象方法只是一个定义,没有方法体,也就是没有{},也不要在里面写内容。它们两个相像的一点是都用override重写

     

    展开全文
  • Python抽象类与抽象方法

    千次阅读 2017-12-22 13:19:55
    抽象方法 抽象方法表示基类的一个方法,没有实现,所以基类不能实例化,子类实现了该抽象方法才能被实例化。 Python的abc提供了@abstractmethod装饰器实现抽象方法,下面以Python3的abc模块举例。 实现In [19]: ...

    抽象方法

    抽象方法表示基类的一个方法,没有实现,所以基类不能实例化,子类实现了该抽象方法才能被实例化。
    Python的abc提供了@abstractmethod装饰器实现抽象方法,下面以Python3的abc模块举例。

    实现

    In [19]: from abc import ABC, abstractmethod
    
    In [20]: class A(object):
        ...:     '''
        ...:     抽象类
        ...:     '''
        ...:     @abstractmethod
        ...:     def fun1(self):
        ...:         pass
        ...:     @abstractmethod
        ...:     def fun2(self):
        ...:         pass
        ...:     
    
    In [21]: a = A()
    
    In [22]: a
    Out[22]: <__main__.A at 0x105cb8198>
    
    In [23]: class B(A):
        ...:     '''
        ...:     继承抽象类
        ...:     '''
        ...:     
        ...:     pass
    
    In [24]: b = B()
    
    In [25]: b
    Out[25]: <__main__.B at 0x105cd1a58>
    • 注意此处抽象方法没有起到作用,因为抽象类没有继承ABC
    In [28]: class A(ABC):
        ...:     '''
        ...:     抽象类
        ...:     '''
        ...:     @abstractmethod
        ...:     def fun1(self):
        ...:         pass
        ...:     @abstractmethod
        ...:     def fun2(self):
        ...:         pass
        ...:     
    
    In [29]: class B(A):
        ...:     pass
        ...: 
    
    In [30]: b = B()
    ---------------------------------------------------------------------------
    TypeError                                 Traceback (most recent call last)
    <ipython-input-30-bb7a6e918aa7> in <module>()
    ----> 1 b = B()
    
    TypeError: Can't instantiate abstract class B with abstract methods fun1, fun2
    
    In [31]: class B(A):
        ...:     def fun1(self):
        ...:         print('fun1')
    
    In [32]: b = B()
    ---------------------------------------------------------------------------
    TypeError                                 Traceback (most recent call last)
    <ipython-input-32-bb7a6e918aa7> in <module>()
    ----> 1 b = B()
    
    TypeError: Can't instantiate abstract class B with abstract methods fun2
    展开全文
  • 主要介绍了Java抽象类和抽象方法定义用法,结合实例形式详细分析了Java抽象类和抽象方法相关原理、定义、使用方法及操作注意事项,需要的朋友可以参考下
  • 抽象类总结 : ① 声明 : 抽象类中使用 abstract 声明 ;...④ 重写 : 抽象类中可以使用抽象方法重写正常方法 , 也可以进行正常的方法重写 ; ⑤ 特征 : 抽象方法只能定义在抽象类中 , 正常类中不能有抽象方法 ;



    I . 抽象类总结



    抽象类总结 :

    ① 声明 : 抽象类中使用 abstract 声明 ;

    ② 成员 : 抽象类中既可以定义正常属性和方法 , 又可以定义抽象的属性和方法 ;

    ③ 继承 : 抽象类可以继承抽象类 , 抽象类也可以继承正常类 , 正常类可以继承抽象类 ;

    ④ 重写 : 抽象类中可以使用抽象方法重写正常方法 , 也可以进行正常的方法重写 ;

    ⑤ 特征 : 抽象方法只能定义在抽象类中 , 正常类中不能有抽象方法 ;



    II . 抽象类声明



    1 . 抽象类简介 : 抽象类不能被实例化 , 在 class 关键字前使用 abstract 修饰 ;


    ① 抽象类默认 open 修饰 : 抽象类 , 默认使用 open 关键字修饰 , 可以直接继承 ;

    ② 抽象方法默认 open 修饰 : 抽象方法 , 默认使用 open 关键字修饰 , 可以直接 override 重写 ;

    //使用 abstract 修饰抽象类 
    abstract class Student {
    }
    


    III . 抽象类中的 ( 正常 / 抽象 ) 的 ( 成员 / 方法 )



    0 . 抽象类内成员总结 : 抽象类中可以定义正常的成员和方法 , 也可以定义抽象的成员和方法 ;


    1 . 定义正常的属性和方法 : 抽象类中可以定义正常的 成员属性 和 成员方法 ;


    ① 正常成员属性 : 该成员属性可以是常量 , 也可以是变量 ;

    ② 正常成员方法 : 正常的方法 , 定义有方法体 ; 如果函数有方法体 , 不能声明为抽象方法 ;

    abstract class Student {
        //抽象类中定义普通常量
        val name: String = "Tom"
    
        //抽象类中定义普通变量
        var age: Int = 18
    
        //抽象类中定义正常方法
        fun say(){
            println("姓名 : ${name} , 年龄 : ${age}")
        }
    }
    

    3 . 定义抽象的属性和方法 : 抽象类中可以定义抽象的 成员属性 和 成员方法 ;


    ① 抽象属性 : 被 abstract 修饰的 常量 var 或 变量 val 属性 , 没有初始化值 , 没有 getter 和 setter 方法 ;

    abstract class Student {
        //抽象类中定义抽象常量 , 没有初始值 , 没有 get set 方法
        abstract val name: String
    
        //抽象类中定义抽象变量 , 没有初始值 , 没有 get set 方法
        abstract var age: Int
    }
    

    ② 抽象方法 : 使用 abstract 修饰的方法 , 没有方法体 ; 如果函数有方法体 , 不能声明为抽象方法 ; 如果类中有抽象函数 , 该类必须声明成抽象类 ;

    abstract class Student {
        //抽象类中定义抽象方法 , 没有方法体
        abstract fun say()
    }
    


    IV . 抽象类继承



    1 . 抽象类可以继承抽象类 :

    abstract class Father{
    }
    
    //抽象类可以继承抽象类
    abstract class Son : Father() {
    }
    

    2 . 抽象类可以继承正常类 : 该正常类必须使用 open 修饰 ;

    open class Father{
    }
    
    //抽象类可以继承正常类 , 该正常类必须使用 open 修饰
    abstract class Son : Father() {
    }
    


    V . 抽象方法的覆盖



    1 . 抽象方法覆盖 : 父类的正常的方法 , 可以在子类中使用抽象方法进行覆盖 ;


    ① 注意父类方法的 open 修饰符 : 抽象类中的正常方法 , 如果想要在子类中设置可以被重写 , 需要使用 open 修饰 ;

    ② 抽象函数与正常函数的继承 : 其抽象函数默认使用 open 修饰 , 可以直接重写 , 正常函数需要使用 open 修饰才能被 override 重写 ;


    2 . 将正常函数覆盖成抽象函数 : 将 Father 类的 open 改成 abstract 也是可以的 , 覆盖操作仍能成立 ;

    //该类可以是正常类 , 也可以是抽象类
    //  此处的示例是正常类 , 将 open 改成 abstract 也成立
    open class Father{
        open fun action(){ println("Father")}
    }
    
    //抽象类可以继承正常类 , 该正常类必须使用 open 修饰
    abstract class Son : Father() {
        override abstract fun action()
    }
    

    3 . 将正常函数覆盖成正常函数 : 正常函数都可以被覆盖成抽象函数 , 那么正常函数的正常覆盖 , 也可以进行 ; 将 Father 类的 open 改成 abstract 也是可以的 , 覆盖操作仍能成立 ;

    //该类可以是正常类 , 也可以是抽象类
    //  此处的示例是正常类 , 将 open 改成 abstract 也成立
    open class Father{
        open fun action(){ println("Father")}
    }
    
    //抽象类可以继承正常类 , 该正常类必须使用 open 修饰
    abstract class Son : Father() {
        //也可以将其重写成正常函数
        override fun action(){ println("Father") }
    }
    


    VI . 抽象方法的实现



    抽象方法实现 :


    ① 正常类子类 : 正常的类继承抽象类必须实现 abstract 抽象方法 ;

    abstract class Father{
        abstract fun action()
    }
    
    //正常类继承抽象类 , 必须实现抽象类中的抽象方法
    class Son : Father() {
        override fun action() {
            println("正常类继承抽象类 , 必须实现抽象类中的抽象方法")
        }
    }
    

    ② 抽象类子类 : 如果抽象类继承抽象类 , 可以不实现父累抽象方法 ;

    abstract class Father{
        abstract fun action()
    }
    
    //抽象类继承抽象类 , 可以不实现抽象方法
    abstract class Son : Father() {
    }
    
    展开全文
  • 抽象类与抽象方法

    2013-08-26 11:43:11
    抽象类和抽象方法:使用abstract关键字修饰的类和方法就成了抽象类和抽象方法,格式普通类和方法类似。   抽象类的特性: ·有抽象类就要有继承的子类去实现抽象类方法。 ·抽象类中可以定义普通类中定义的所有...

    抽象类和抽象方法

    抽象类和抽象方法:使用abstract关键字修饰的类和方法就成了抽象类和抽象方法,格式与普通类和方法类似。

     

    抽象类的特性:

    ·有抽象类就要有继承的子类去实现抽象类中的抽象方法。

    ·抽象类中可以定义普通类中定义的所有成员,并且只有在抽象类中才能定义抽象方法。

    ·抽象类中不能new对象,抽象类中的对象是给子类调用的。

    ·在抽象类中定义的方法,在其普通子类中必须实现所有抽象父类中定义的所有抽象方法,否则这个子类也要申明成抽象类。

    ·抽象类中可以定义构造器,但不能用于创建对象,而是在其子类创建子类的对象时来调用这个构造器来完成抽象类的初始化操作。

    ·抽象类也是类,跟普通类只是稍有差别而已,所以继承它的子类也会继续它的方法和属性等成员。

    ·实现抽象类不需要extends也可以,使用匿名内部类;并且不需要写extends继承关键字。


     

    抽象方法的特性:

    ·抽象方法只有方法声明没有方法实现

    ·抽象方法是准备在子类中实现的,它只是一个模板。

     

    没有抽象属性和抽象变量一说。

     

    注意:

    abstract与final不能同时修饰一个方法或类。因为final修饰的方法不能被重写而abstract修饰的方法需要在子类实现(重写);final修饰的类不能有继承,而abstract修饰的类是抽象类必须要有子类,因此这两个修饰符冲突,不能一起使用。

    abstract与static不能同时修饰一个方法。static修饰方法属于类方法,可以被“类.方法”类直接调用,而abstract修饰的方法是抽象方法,没有方法体,是需要在子类中重写的方法。因此static不能与abstract同时修饰一个方法。

    abstract与private不能同时修饰一个方法。private修饰的方法只能在当前类被调用,而abstract修饰的抽象类必须要在子类中被重写才有意义,如果父类中方法权限是private那么这个方法对子类是透明的。因此private不能同时修饰一个方法。

     

    ·抽象类的作用:

         抽象类就是一个模板,也叫模板设计模式。父类提供了多个子类的通用方法,并且把一个或多个方法留给子类实现,这就是模板模式。

     

    例子:抽象类

    public abstract class SpeedMeter
    {
    	private double trunRate;
    	
    	public abstract double getRadius();
    
    	public void setTruneRate(double trunRate)
    	{
    		this.trunRate = trunRate;
    	}
    
    //计算车速的通用算法,周长 x 转速 = 速度
    	public double getSpeed()
    	{
    		return java.lang.Math.PI * 2 * trunRate * this.getRadius();
    	}
    }
    
    
    public class Car extends SpeedMeter
    {
    	public double getRadius()
    	{
    		return 5.0;
    	}
    
    	public static void main(String[] args)
    	{
    		Car ca = new Car();
    		
    		ca.setTruneRate(10.0);
    
    		System.out.println(ca.getSpeed());
    
    	}
    }
    


    例子:抽象类中定义构造器(这个例子摘自某Java书籍)


    public abstract class Shape
    {
    	{
    		System.out.println("执行Shape的初始化块...");
    	}
    	private String color;
    	
    	public abstract double calPerimeter();
    	
    	public abstract String getType();
    	
    	public Shape(){}
    	public Shape(String color)		//通过多态创建子类的对象,然后同时传入一个参数到这里。
    	{
    		System.out.println("执行Shape的构造器...");
    		this.color = color;
    	}
    	
    	public void setColor(String color)
    	{
    		this.color = color;
    	}
    	public String getColor()
    	{
    		return this.color;
    	}
    }
    
    ---------------------------------------------------------
    
    public class Circle extends Shape
    {
    	private double radius;
    	public Circle(String color , double radius)		//下面创建对象,传入参数
    	{
    		super(color);
    		this.radius = radius;
    	}
    	public void setRadius(double radius)
    	{
    		this.radius = radius;
    	}
    	public double calPerimeter()
    	{
    		return 2 * Math.PI * radius;
    	}
    	
    	public String getType()
    	{
    		return getColor() + "圆形";
    	}
    	public static void main(String[] args)
    	{
    		
    		Shape s2 = new Circle("黄色" , 3);	//多态,创建子类对象。
    	
    		System.out.println(s2.getType());
    		System.out.println(s2.calPerimeter());
    	}
    }
    


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

    千次阅读 2017-03-02 10:47:18
    抽象类:含有抽象方法的类就叫抽象类抽象类中的抽象方法必须被实现!如果一个子类没有实现父类中的抽象方法,则子类也成为了一个抽象类抽象类中的普通方法,可以不必实现。用abstract来修饰一个类时,这个类叫做...
  • 主要介绍了Java的抽象方法抽象类,结合实例形式详细分析了java抽象方法抽象类的相关原理、使用方法及操作注意事项,需要的朋友可以参考下
  •  在Java中用abstract修饰的类是抽象类,用abstract修饰的类的方法是抽象方法抽象类和抽象方法用法总结如下。  1.abstract可以修饰class表示抽象类,可以修饰方法表示抽象方法,但是不能修饰成员变量,也是没有...
  • 抽象类必须要有抽象方法吗?

    万次阅读 2019-07-24 19:05:41
    答案是:不必须 这道题考察的是抽象类的知识: 抽象类必须有关键字abstract来修饰。 抽象类可以不含有抽象方法 如果一个类包含抽象方法,则该类必须是抽象类 ...
  • 抽象类必须要有抽象方法吗?抽象类能使用 final 修饰吗?
  • 抽象类及抽象方法
  • 抽象类和抽象方法、接口抽象类和抽象方法、接口抽象类和抽象方法、接口
  • 抽象类和抽象方法

    千次阅读 2018-08-12 19:46:26
    含有abstract修饰符的class即为抽象类,abstract类不能创建的实例对象。含有abstract方法的类必须定义为abstract class,abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete...
  • 抽象类和抽象方法的定义 抽象方法:就是加上abstract关键字,去掉{},直接;结束 抽象类:抽象方法所在的类,必须是抽象类。在class之前加上abstract即可 package StudyClass; public abstract class Fu { public...
  • 学过C#的人应该都知道抽象方法与虚拟方法,而很多初学者对二者之间的区别并不是很了解。今天本文就来分析一下二者之间的区别。并附上实例加以说明。具体分析如下: 一、主要区别: 对于抽象方法,子类必须实现它。 ...
  • 抽象类: 概念:有时我们表达一些抽象的东西,它是一种概括,不需要它成为一种实体,所以面向对象便有了抽象类。 具体来讲:一个员工,它属于一个公司,但是公司只是一个名称,我们不需要它成为一个实体,所以公司...
  • 抽象类可以有抽象方法,也可以有非抽象方法 抽象方法只允许声明,不允许实现 public abstract class A{ void eat(){ System.out.println("eat"); } abstract int getMax(); } 对于抽象类只能声明,不...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,252,390
精华内容 500,956
关键字:

抽象方法与抽象类的区别