abstract 订阅
abstract修饰符可以用于类、方法、事件和索引指示器(indexer),表示其为抽象成员,抽象方法是没有方法体的方法。抽象成员,即抽象类、抽象方法、抽象事件。 展开全文
abstract修饰符可以用于类、方法、事件和索引指示器(indexer),表示其为抽象成员,抽象方法是没有方法体的方法。抽象成员,即抽象类、抽象方法、抽象事件。
信息
外文名
abstract
类    型
抽象成员
不包括
实现代码
中文名
抽象的
性    质
修饰符
abstract说明
抽象的。类似像见微知著、一叶知秋的意思,这是在神秘学里面一个非常重要的概念,就是所有的符号、图像、文字、咒语等等的背后,都还包含有更多、更大、更深、更远的意义,而需要学习者用心去体会、感觉、并思量,才可以深究其意义,并化为自己的一部份,才能好好的来使用它。abstract 不可以和static、virtual、final、native一起使用声明为 abstract 成员可以不包括实现代码,但只要类中还有未实现的抽象成员(抽象方法),那么这个类就是一个抽象类,抽象类的对象不能被实例化,通常作为被强制继承类必须实现某一成员,抽象类必须要有派生子类。并且,如果子类没有实现抽象类的所有方法,则子类也成为一个抽象类。
收起全文
精华内容
下载资源
问答
  • abstract

    2020-03-28 17:40:16
    1.由abstract修饰 2.只有方法的定义,没有方法的实现(大括号都没有) 抽象类 1. 由abstract修饰 2.包含抽象方法的类必须是抽象类,不包含抽象方法的类也可以声明为抽象类 3.抽象类不能被实例化 4.抽象类是需要被...

    抽象方法
    1.由abstract修饰
    2.只有方法的定义,没有方法的实现(大括号都没有)
    抽象类
    1. 由abstract修饰
    2.包含抽象方法的类必须是抽象类,不包含抽象方法的类也可以声明为抽象类
    3.抽象类不能被实例化
    4.抽象类是需要被继承的,子类:
    4.1 重写所有抽象方法–常用
    4.2 也声明为抽象类–不常用
    5.抽象类的意义:
    5.1 包含公共的属性和行为,被子类所共享–代码重用
    5.2 为所有子类提供一种统一的类型–向上造型
    5.3包含抽象方法,为子类提供一个统一的入口
    子类有不同的实现

    找一组图形中的最大面积

    public class ShapeTest {
    	public static void main(String[] args) {
    		//new Shape();//编译错误,抽象类不能被实例化
    		
    		Shape[] shapes=new Shape[4];//创建shape数组对象
    		shapes[0]=new Square(1);
    		shapes[1]=new Square(2);//大
    		shapes[2]=new Circle(1);
    		shapes[3]=new Circle(2);//大
    		maxArea(shapes);
    	}
    	
    	public static void maxArea(Shape[] shapes){//找最大面积
    		double max=shapes[0].area();
    		int maxIndex=0;
    		for(int i=1;i<shapes.length;i++){
    			double area=shapes[i].area();
    			if(area>max){
    				max=area;
    				maxIndex=i;
    			}
    		}
    		System.out.println("最大面积:"+max+",所在下标为:"+maxIndex);
    	}
    
    }
    
    abstract class Shape{//抽象类
    	protected double c;//周长
    	public abstract  double area();//抽象方法
    }
    class Square extends Shape{
    	public Square(double c){
    		this.c=c;
    	}
    	public double area(){//重写抽象方法
    		return 0.0625*c*c;
    	}
    }
    class Circle extends Shape{
    	public Circle(double c){
    		this.c=c;
    	}
    	public double area(){
    		return 0.0796*c*c;
    	}
    }
    
    
    展开全文
  • Design Pattern - Abstract Factory(C#)

    万次阅读 多人点赞 2019-02-02 15:16:02
    /// The 'AbstractFactory' abstract class. /// internal abstract class AbstractFactory { #region Public Methods and Operators /// /// Create product a. /// /// /// The ...

    分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!请点击http://www.captainbed.net 

    Definition

    Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

    Participants

    The classes and/or objects participating in this pattern are:

    • AbstractFactory (ContinentFactory)
      • Declares an interface for operations that create abstract products
    • ConcreteFactory (AfricaFactory, AmericaFactory)
      • Implements the operations to create concrete product objects
    • AbstractProduct (Herbivore, Carnivore)
      • Declares an interface for a type of product object
    • Product (Wildebeest, Lion, Bison, Wolf)
      • Defines a product object to be created by the corresponding concrete factory
      • Implements the AbstractProduct interface
    • Client (AnimalWorld)
      • Uses interfaces declared by AbstractFactory and AbstractProduct classes

    Sample Code in C#


    This structural code demonstrates the Abstract Factory pattern creating parallel hierarchies of objects. Object creation has been abstracted and there is no need for hard-coded class names in the client code.

    /*
     * Structural Abstract Factory Design Pattern.
     */
    
    namespace AbstractFactory.Sample
    {
        using System;
    
        /// <summary>
        /// Startup class for Structural Abstract Factory Design Pattern.
        /// </summary>
        internal static class Program
        {
            #region Public Methods and Operators
    
            /// <summary>
            /// Entry point into console application.
            /// </summary>
            public static void Main()
            {
                // Abstract factory #1.
                AbstractFactory factory1 = new ConcreteFactory1();
                var client1 = new Client(factory1);
                client1.Run();
    
                // Abstract factory #2.
                AbstractFactory factory2 = new ConcreteFactory2();
                var client2 = new Client(factory2);
                client2.Run();
            }
    
            #endregion
        }
    
        /// <summary>
        /// The 'AbstractFactory' abstract class.
        /// </summary>
        internal abstract class AbstractFactory
        {
            #region Public Methods and Operators
    
            /// <summary>
            /// Create product a.
            /// </summary>
            /// <returns>
            /// The <see cref="AbstractProductA"/>.
            /// </returns>
            public abstract AbstractProductA CreateProductA();
    
            /// <summary>
            /// Create product b.
            /// </summary>
            /// <returns>
            /// The <see cref="AbstractProductB"/>.
            /// </returns>
            public abstract AbstractProductB CreateProductB();
    
            #endregion
        }
    
        /// <summary>
        /// The 'ConcreteFactory1' class
        /// </summary>
        internal class ConcreteFactory1 : AbstractFactory
        {
            #region Public Methods and Operators
    
            /// <summary>
            /// Create product a.
            /// </summary>
            /// <returns>
            /// The <see cref="AbstractProductA"/>.
            /// </returns>
            public override AbstractProductA CreateProductA()
            {
                return new ProductA1();
            }
    
            /// <summary>
            /// Create product b.
            /// </summary>
            /// <returns>
            /// The <see cref="AbstractProductB"/>.
            /// </returns>
            public override AbstractProductB CreateProductB()
            {
                return new ProductB1();
            }
    
            #endregion
        }
    
        /// <summary>
        /// The 'ConcreteFactory2' class
        /// </summary>
        internal class ConcreteFactory2 : AbstractFactory
        {
            #region Public Methods and Operators
    
            /// <summary>
            /// Create product a.
            /// </summary>
            /// <returns>
            /// The <see cref="AbstractProductA"/>.
            /// </returns>
            public override AbstractProductA CreateProductA()
            {
                return new ProductA2();
            }
    
            /// <summary>
            /// Create product b.
            /// </summary>
            /// <returns>
            /// The <see cref="AbstractProductB"/>.
            /// </returns>
            public override AbstractProductB CreateProductB()
            {
                return new ProductB2();
            }
    
            #endregion
        }
    
        /// <summary>
        /// The 'AbstractProductA' abstract class.
        /// </summary>
        internal abstract class AbstractProductA
        {
        }
    
        /// <summary>
        /// The 'AbstractProductB' abstract class.
        /// </summary>
        internal abstract class AbstractProductB
        {
            #region Public Methods and Operators
    
            /// <summary>
            /// Interact.
            /// </summary>
            /// <param name="a">
            /// The abstract product a.
            /// </param>
            public abstract void Interact(AbstractProductA a);
    
            #endregion
        }
    
        /// <summary>
        /// The 'ProductA1' class.
        /// </summary>
        internal class ProductA1 : AbstractProductA
        {
        }
    
        /// <summary>
        /// The 'ProductB1' class.
        /// </summary>
        internal class ProductB1 : AbstractProductB
        {
            #region Public Methods and Operators
    
            /// <summary>
            /// Interact.
            /// </summary>
            /// <param name="a">
            /// The abstract product a.
            /// </param>
            public override void Interact(AbstractProductA a)
            {
                Console.WriteLine(GetType().Name + " interacts with " + a.GetType().Name);
            }
    
            #endregion
        }
    
        /// <summary>
        /// The 'ProductA2' class.
        /// </summary>
        internal class ProductA2 : AbstractProductA
        {
        }
    
        /// <summary>
        /// The 'ProductB2' class.
        /// </summary>
        internal class ProductB2 : AbstractProductB
        {
            #region Public Methods and Operators
    
            /// <summary>
            /// Interact.
            /// </summary>
            /// <param name="a">
            /// The abstract product a.
            /// </param>
            public override void Interact(AbstractProductA a)
            {
                Console.WriteLine(GetType().Name + " interacts with " + a.GetType().Name);
            }
    
            #endregion
        }
    
        /// <summary>
        /// The 'Client' class.
        /// Interaction environment for the products.
        /// </summary>
        internal class Client
        {
            #region Fields
    
            /// <summary>
            /// The abstract product a.
            /// </summary>
            private readonly AbstractProductA _abstractProductA;
    
            /// <summary>
            /// The abstract product b.
            /// </summary>
            private readonly AbstractProductB _abstractProductB;
    
            #endregion
    
            #region Constructors and Destructors
    
            /// <summary>
            /// Initializes a new instance of the <see cref="Client"/> class.
            /// </summary>
            /// <param name="factory">
            /// The abstract factory.
            /// </param>
            public Client(AbstractFactory factory)
            {
                _abstractProductA = factory.CreateProductA();
                _abstractProductB = factory.CreateProductB();
            }
    
            #endregion
    
            #region Public Methods and Operators
    
            /// <summary>
            /// Run.
            /// </summary>
            public void Run()
            {
                _abstractProductB.Interact(_abstractProductA);
            }
    
            #endregion
        }
    }
    
    // Output:
    /*
    ProductB1 interacts with ProductA1
    ProductB2 interacts with ProductA2
    
    */

    This real-world code demonstrates the creation of different animal worlds for a computer game using different factories. Although the animals created by the Continent factories are different, the interactions among the animals remain the same.

    /*
     * Real-World Abstract Factory Design Pattern.
     */
    
    namespace AbstractFactory.RealWorld
    {
        using System;
    
        /// <summary>
        /// Startup class for Real-World Abstract Factory Design Pattern.
        /// </summary>
        internal static class Program
        {
            #region Public Methods and Operators
    
            /// <summary>
            /// Entry point into console application.
            /// </summary>
            public static void Main()
            {
                // Create and run the African animal world.
                ContinentFactory africa = new AfricaFactory();
                var world = new AnimalWorld(africa);
                world.RunFoodChain();
    
                // Create and run the American animal world.
                ContinentFactory america = new AmericaFactory();
                world = new AnimalWorld(america);
                world.RunFoodChain();
            }
    
            #endregion
        }
    
        /// <summary>
        /// The 'AbstractFactory' abstract class.
        /// </summary>
        internal abstract class ContinentFactory
        {
            #region Public Methods and Operators
    
            /// <summary>
            /// Create carnivore.
            /// </summary>
            /// <returns>
            /// The <see cref="Carnivore"/>.
            /// </returns>
            public abstract Carnivore CreateCarnivore();
    
            /// <summary>
            /// Create herbivore.
            /// </summary>
            /// <returns>
            /// The <see cref="Herbivore"/>.
            /// </returns>
            public abstract Herbivore CreateHerbivore();
    
            #endregion
        }
    
        /// <summary>
        /// The 'ConcreteFactory1' class.
        /// </summary>
        internal class AfricaFactory : ContinentFactory
        {
            #region Public Methods and Operators
    
            /// <summary>
            /// Create carnivore.
            /// </summary>
            /// <returns>
            /// The <see cref="Carnivore"/>.
            /// </returns>
            public override Carnivore CreateCarnivore()
            {
                return new Lion();
            }
    
            /// <summary>
            /// Create herbivore.
            /// </summary>
            /// <returns>
            /// The <see cref="Herbivore"/>.
            /// </returns>
            public override Herbivore CreateHerbivore()
            {
                return new Wildebeest();
            }
    
            #endregion
        }
    
        /// <summary>
        /// The 'ConcreteFactory2' class.
        /// </summary>
        internal class AmericaFactory : ContinentFactory
        {
            #region Public Methods and Operators
    
            /// <summary>
            /// Create carnivore.
            /// </summary>
            /// <returns>
            /// The <see cref="Carnivore"/>.
            /// </returns>
            public override Carnivore CreateCarnivore()
            {
                return new Wolf();
            }
    
            /// <summary>
            /// Create herbivore.
            /// </summary>
            /// <returns>
            /// The <see cref="Herbivore"/>.
            /// </returns>
            public override Herbivore CreateHerbivore()
            {
                return new Bison();
            }
    
            #endregion
        }
    
        /// <summary>
        /// The 'AbstractProductA' abstract class.
        /// </summary>
        internal abstract class Herbivore
        {
        }
    
        /// <summary>
        /// The 'AbstractProductB' abstract class.
        /// </summary>
        internal abstract class Carnivore
        {
            #region Public Methods and Operators
    
            /// <summary>
            /// Eat.
            /// </summary>
            /// <param name="h">
            /// The herbivore.
            /// </param>
            public abstract void Eat(Herbivore h);
    
            #endregion
        }
    
        /// <summary>
        /// The 'ProductA1' class.
        /// </summary>
        internal class Wildebeest : Herbivore
        {
        }
    
        /// <summary>
        /// The 'ProductB1' class.
        /// </summary>
        internal class Lion : Carnivore
        {
            #region Public Methods and Operators
    
            /// <summary>
            /// Eat.
            /// </summary>
            /// <param name="h">
            /// The herbivore.
            /// </param>
            public override void Eat(Herbivore h)
            {
                // Eat Wildebeest.
                Console.WriteLine(GetType().Name + " eats " + h.GetType().Name);
            }
    
            #endregion
        }
    
        /// <summary>
        /// The 'ProductA2' class.
        /// </summary>
        internal class Bison : Herbivore
        {
        }
    
        /// <summary>
        /// The 'ProductB2' class.
        /// </summary>
        internal class Wolf : Carnivore
        {
            #region Public Methods and Operators
    
            /// <summary>
            /// Eat.
            /// </summary>
            /// <param name="h">
            /// The herbivore.
            /// </param>
            public override void Eat(Herbivore h)
            {
                // Eat Bison.
                Console.WriteLine(GetType().Name + " eats " + h.GetType().Name);
            }
    
            #endregion
        }
    
        /// <summary>
        /// The 'Client' class.
        /// </summary>
        internal class AnimalWorld
        {
            #region Fields
    
            /// <summary>
            /// The carnivore.
            /// </summary>
            private readonly Carnivore _carnivore;
    
            /// <summary>
            /// The herbivore.
            /// </summary>
            private readonly Herbivore _herbivore;
    
            #endregion
    
            // Constructor
    
            #region Constructors and Destructors
    
            /// <summary>
            /// Initializes a new instance of the <see cref="AnimalWorld"/> class.
            /// </summary>
            /// <param name="factory">
            /// The continent factory.
            /// </param>
            public AnimalWorld(ContinentFactory factory)
            {
                _carnivore = factory.CreateCarnivore();
                _herbivore = factory.CreateHerbivore();
            }
    
            #endregion
    
            #region Public Methods and Operators
    
            /// <summary>
            /// Run food chain.
            /// </summary>
            public void RunFoodChain()
            {
                _carnivore.Eat(_herbivore);
            }
    
            #endregion
        }
    }
    
    // Output:
    /*
    Lion eats Wildebeest
    Wolf eats Bison
    
    */

     

    展开全文
  • abstract class和interface的区别

    万次阅读 2017-05-23 14:37:47
    在Java语言中,abstract class和interface是支持抽象类定义的两种机制。正是由于这两种机制的存在,才赋予了Java强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性,...

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

     

     

    Abstract class

    Interface

    实例化

    不能

    不能

    一种继承关系,一个类只能使用一次继承关系。可以通过继承多个接口实现多重继承

    一个类可以实现多个interface

    数据成员

    可有自己的

    静态的不能被修改即必须是static final,一般不在此定义

    方法

    可以私有的,非abstract方法,必须实现

    不可有私有的,默认是publicabstract 类型

    变量

    可有私有的,默认是friendly 型,其值可以在子类中重新定义,也可以重新赋值

    不可有私有的,默认是public static final 型,且必须给其初值,实现类中不能重新定义,不能改变其值。

    设计理念

    表示的是“is-a”关系

    表示的是“like-a”关系

    实现

    需要继承,要用extends

    要用implements

    abstract classinterfaceJava语言中都是用来进行抽象类(本文中的抽象类并非从abstract class翻译而来,它表示的是一个抽象体,而abstract classJava语言中用于定义抽象类的一种方法)定义的,那么什么是抽象类,使用抽象类能为我们带来什么好处呢?

    声明方法的存在而不去实现它的类被叫做抽象类(abstract class),它用于要创建一个体现某些基本行为的类,并为该类声明方法,但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量,其类型是一个抽象类,并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现,否则它们也是抽象类为。取而代之,在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。

    接口(interface)是抽象类的变体。在接口中,所有方法都是抽象的。多继承性可通过实现 这样的接口而获得。接口中的所有方法都是抽象的,没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似,除了该实现类不能从接口定义中继承行为。当类实现特殊接口时,它定义(即将程序体给予)所有这种接口的方法。 然后,它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类,它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到 接口类型或从接口类型转换,instanceof 运算符可以用来决定某对象的类是否实现了接口。

    接口可以继承接口。抽象类可以实现(implements)接口,抽象类是可以继承实体类,但前提是实体类必须有明确的构造函数。接口更关注“能实现什么功能”,而不管“怎么实现的”。

    1.相同点
      A. 两者都是抽象类,都不能实例化。
      B. interface实现类及abstrct class的子类都必须要实现已经声明的抽象方法。

    2. 不同点
      A. interface需要实现,要用implements,而abstract class需要继承,要用extends。
      B. 一个类可以实现多个interface,但一个类只能继承一个abstract class。
      C. interface强调特定功能的实现,而abstract class强调所属关系。
      D. 尽管interface实现类及abstrct class的子类都必须要实现相应的抽象方法,但实现的形式不同。interface中的每一个方法都是抽象方法,都只是声明的 (declaration, 没有方法体),实现类必须要实现。而abstract class的子类可以有选择地实现。
     
    这个选择有两点含义:
        一是Abastract class中并非所有的方法都是抽象的,只有那些冠有abstract的方法才是抽象的,子类必须实现。那些没有abstract的方法,在Abstrct class中必须定义方法体。
        二是abstract class的子类在继承它时,对非抽象方法既可以直接继承,也可以覆盖;而对抽象方法,可以选择实现,也可以通过再次声明其方法为抽象的方式,无需实现,留给其子类来实现,但此类必须也声明为抽象类。既是抽象类,当然也不能实例化。
      E. abstract class是interface与Class的中介。
      interface是完全抽象的,只能声明方法,而且只能声明pulic的方法,不能声明private及protected的方法,不能定义方法体,也 不能声明实例变量。然而,interface却可以声明常量变量,并且在JDK中不难找出这种例子。但将常量变量放在interface中违背了其作为接 口的作用而存在的宗旨,也混淆了interface与类的不同价值。如果的确需要,可以将其放在相应的abstract class或Class中。
      abstract class在interface及Class中起到了承上启下的作用。一方面,abstract class是抽象的,可以声明抽象方法,以规范子类必须实现的功能;另一方面,它又可以定义缺省的方法体,供子类直接使用或覆盖。另外,它还可以定义自己 的实例变量,以供子类通过继承来使用。

    3. interface的应用场合
      A. 类与类之前需要特定的接口进行协调,而不在乎其如何实现。
      B. 作为能够实现特定功能的标识存在,也可以是什么接口方法都没有的纯粹标识。
      C. 需要将一组类视为单一的类,而调用者只通过接口来与这组类发生联系。
      D. 需要实现特定的多项功能,而这些功能之间可能完全没有任何联系。

    4. abstract class的应用场合
      一句话,在既需要统一的接口,又需要实例变量或缺省的方法的情况下,就可以使用它。最常见的有:
      A. 定义了一组接口,但又不想强迫每个实现类都必须实现所有的接口。可以用abstract class定义一组方法体,甚至可以是空方法体,然后由子类选择自己所感兴趣的方法来覆盖。
      B. 某些场合下,只靠纯粹的接口不能满足类与类之间的协调,还必需类中表示状态的变量来区别不同的关系。abstract的中介作用可以很好地满足这一点。
      C. 规范了一组相互协调的方法,其中一些方法是共同的,与状态无关的,可以共享的,无需子类分别实现;而另一些方法却需要各个子类根据自己特定的状态来实现特定的功能。

    展开全文
  • Java中的abstract

    2019-10-28 17:30:39
    abstract

    abstract类

    1. 抽象类是没有具体对象的类。即不能被实例化。

    2. 抽象类是需要继承的,所以abstract与final不能同时修饰同一个类。

    3. 抽象类是它的所有子类的公共属性的集合。
      例如 :

      抽象类Vehicle→子类Train

      子类Track

      两个子类是可以实例化的类。

    4. 抽象类可以继承非抽象类、抽象类,只有非抽象类才能被实例化。抽象类必须有子类,一个子类只能继承一个抽象类;

    5. 抽象类虽然不能用new来实例化,但可以有构适方法,构适方法可以被子类构造函数调用。

    6. 抽象类中可以包含抽象方法,也可以不包含。即使不包含任何抽象方法,也可以将一个类声明为抽象类。

    7. 其中成员变量可以不赋值。

    abstract方法

    1. abstract方法必须位于abstract类中,一旦某个方法被定义成abstract方法,则他所在的类必须声明为抽象类。
    2. 抽象方法只需声明,不需实现
    3. 抽象方法在子类中必须实现,如果不实现,子类仍然是抽象类。即子类继承抽象类的话,必须覆写抽象类的所有抽象方法。

    抽象类可以有构造方法,只是不能直接创建抽象类的实例对象而已。
    在继承了抽象类的子类中通过super(参数列表)调用抽象类中的构造方法
    抽象类虽然不能自己实例化对象,但是在子类新建对象调用子类的构造方法时会先调用抽象类的无参构造方法,这样一来,就可以给抽象类的参数赋值了

    abstract class A{
    	abstract void callme();      //抽象方法
    	abstract void callyou();   //抽象方法
    	void metoo(){
    		System.out.println("inside A's  metoo() method");   //抽象类中的非抽象方法
    		}
    		
    }
    abstract class B extends A{
    	abstract void  callme();          
    	void callyou(){                       //只实现父类中一个抽象方法 这个类还是抽象类
    		System.out.println("inside B's  callyou() method");
    
    	}
    class	class C extends A{     //实现父类中所有抽象方法,为可实例化类
    	void  callme(){
    		System.out.println("inside C's  callme() method");
    
    	}
    	void callyou(){
    		System.out.println("inside C's  callyou() method");
    
    	}
    	}
    }
    

    抽象关键字不能与private,static,final并列修饰同一方法。

    展开全文
  • Java中abstract类和abstract方法

    千次阅读 2020-09-20 14:52:20
    用关键字abstract修饰的类称为abstract类(抽象类)。如: abstract class A { abstract int min(int x,int y); } 用关键字abstract修饰的方法称为abstract方法(抽象方法), 对于abstract方法,只允许声明,...
  • abstract

    2019-06-19 14:41:01
    A abstract类只能用来派生子类,不能用来创建abstract类的对象。 B final类不但可以用来派生子类,也可以用来创建final类的对象。 C abstract不能与final同时修饰一个类。 D abstract类定义中可以...
  • abstract类和abstract方法

    2016-12-22 11:17:58
    可以使用abstract来修饰一个类或者方法。 用abstract修饰的类表示这个类是一个抽象类,用abstract修饰的方法表示这个方法是一个抽象方法。 抽象类不能被实例化。 抽象方法是只有方法声明,而没有方法的实现内容。...
  • c#abstract

    2019-05-28 13:37:44
    using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; ...namespace App_abstract ... abstract class Info ... abstract public voi...
  • abstract关键字

    2020-07-10 11:34:04
    Abstract,即抽象。笼统的描述一类东西。 打个比方: 我们说车子都可以跑(run)。但有几个轮子,怎么跑,对于不同的车有不同的结果。自行车2个轮子需要人踩着跑,三轮车有3个轮子可以人踩、也能电动,汽车发动机推动...
  • Java中的abstract方法和abstract类的问题

    万次阅读 多人点赞 2014-11-20 10:37:07
    当知道一个类的子类将不同的实现某个方法时,把该类声明为抽象类很有用,可以共用相同的父类方法,不必再定义。 抽象类和抽象方法的关系:含有抽象方法的类一定是抽象类,抽象...1:用abstract修饰的类表示抽象类,抽象
  • abstract 类和abstract 方法 (1)用关键字abstract修饰的类称作abstract类(抽象类) //抽象类格式: abstract class A{ ··· }(2)用关键字abstract修饰的方法称作abstract方法(抽象方法),抽象方法没有方法...
  • abstract class

    2018-12-30 11:24:14
    It’s possible to make a class abstract without including any abstract methods. This is useful when you’ve got a class where abstract methods don’t make sense, and yet you want to prevent...
  • abstract

    千次阅读 2018-04-10 23:59:07
    abstract class 机动车 { abstract void 启动(); abstract void 加速(); abstract void 刹车(); } class 手动挡 extends 机动车 { void 启动() { System.out.println("踏下离合器...
  • abstract类和abstract方法(抽象类和抽象方法) 定义:用关键字abstract修饰的类称为abstract类(抽象类) 应用理解:抽象类可以理解为事务的行为标准,提供模板,该行为标准用抽象方法来表示。子类则为是体现事物的...
  • abstract 类和 abstract 方法 (抽象类与抽象方法)

    万次阅读 多人点赞 2018-05-23 22:28:10
    抽象一直以来都是人们所神往的艺术形式,这点从梵高,毕加索等艺术家的身上就可以看出。抽象所代表的是一种形式上的美感,颇有一种... 用关键字abstract修饰的类称为abstract类(抽象类),比如:abstract classA{...
  • 用关键字abstract修饰的类称为abstract类。用关键字abstract修饰的方法称为abstract方法
  • abstract用法

    2019-02-11 11:10:31
    修饰作用关键字,“抽象的”。 1.修饰类时,该类不可被实例化。 2.修饰方法时,该方法所在类必须也...5.abstract关键字不能与private/final/static同时出现。 具体解释见案例注释。 abstract class Person{  St...
  • Java abstract

    千次阅读 2018-08-18 16:25:59
    abstract:是一个修饰符 可以修饰方法,类 1.当我们多个类存在相同的功能,但是功能的主体不同,这时我们进行向上抽取 只抽取功能的定义不抽取功能的主体 抽象类的特点: 1.抽象方法一定要在抽象类中 2.抽象类和抽象...
  • Android Studio 报错 must either be declared abstract or implement abstract method 解决方法 可以单击错误行,在行首出现红色电灯泡,点“implement methods“,就会自动补全缺失的代码 ...
  • abstract 的用法

    万次阅读 2018-02-13 07:59:08
    abstract(抽象)修饰符,可以修饰类和方法1,abstract修饰类,会使这个类成为一个抽象类,这个类将不能生成对象实例,但可以做为对象变量声明的类型,也就是编译时类型,抽象类就像当于一类的半成品,需要子类继承...
  • java 编译报错must either be declared abstract or implement abstract method, 结局:检查父类方法的作用域,最好修改为public
  • 用关键字abstract修饰的类称为abstract类(抽象类)。  对于abstract方法,只允许声明,不允许实现,而且不允许使用final和abstract同时修饰一个方法。  对于abstract类,我们不能用使用new运算符创建该类的对象...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 108,790
精华内容 43,516
热门标签
关键字:

abstract