はどう違うの抽象機能をバーチャルに機能しているのでしょうか。

StackOverflow https://stackoverflow.com/questions/391483

質問

はどう違うの抽象機能をバーチャルに機能しているのでしょうか。る場合での使用を推奨仮抄?ある一つのアプローチを考えていますか。

役に立ちましたか？

解決

抽象的に機能していない可能です。 んはっ子クラスでは独自の版では、この方法しかしすぎると一般にも努めの親クラスです。

仮想機能, は、基本的にはい、こちらの機能を示すものではありませんで十分のための子供のクラスです。するおそれがき分け以上を収めれば、このメソッドを使用しない場合には、オーバーライドしてください提供する機能。

他のヒント

抽象関数にはimplementionを持っていないし、それが唯一の抽象クラスで宣言することができます。これは、実装を提供する派生クラスを強制します。

仮想関数は、デフォルトの実装を提供し、それは抽象クラスまたは非抽象クラスのいずれかに存在することができます。

ですから、例えばます：

public abstract class myBase
{
    //If you derive from this class you must implement this method. notice we have no method body here either
    public abstract void YouMustImplement();

    //If you derive from this class you can change the behavior but are not required to
    public virtual void YouCanOverride()
    { 
    }
}

public class MyBase
{
   //This will not compile because you cannot have an abstract method in a non-abstract class
    public abstract void YouMustImplement();
}
  1. のみ abstract 授業で abstract 会員とする。
  2. 非abstract クラスから継承し abstract クラス 必要 override その abstract 会員とする。
  3. An abstract 会員は、暗黙のうちに virtual.
  4. An abstract 会員に提供できず実施abstract と呼ばれ pure virtual 言語).

必ずオーバーライド抽象的な機能です。

このように:

  • 抽象機能 -のとき の継承者を独自に実装
  • 仮想 -のとき その継承者の決定

概要と機能

  1. で宣言される中でのabstractクラスです。
  2. でのみを含む メソッド宣言の実施にはabstractクラスです。
  3. 必ずソッドをオーバーライド由来のクラスです。

仮想関数:

  1. で宣言された内部抽象などの非abstractクラスです。
  2. でcontainsメソッドの実装です。
  3. でオーバーライドになります。

抽象メソッド： クラスは抽象メソッドが含まれている場合、そのクラスは、abstractとして宣言する必要があります。 抽象メソッドは実装を持っていないので、その抽象クラスから派生するクラスは、この抽象メソッドの実装を提供する必要があります。

仮想メソッド： クラスは仮想メソッドを持つことができます。仮想メソッドは実装されています。 あなたは仮想メソッドを持つクラスから継承するときは、<全角> の仮想メソッドをオーバーライドして、追加のロジックを提供する、または独自の実装にロジックを置き換えます。

することができます

ときに何を使用するには： いくつかのケースでは、あなたは、この方法が持つべきものを実装分からない、特定の種類の特定のメソッドを持っている必要があることを知っているが、。
このような場合、あなたはこのシグネチャを持つメソッドを含むインターフェイスを作成することができます。 あなたは、このようなケースを持っていますが、そのインターフェイスの実装者はまた、（あなたがすでに実装を提供することができるため）別の一般的な方法を持っていることがわかっている場合は、あなたは抽象クラスを作成することができます。 この抽象クラスは、抽象メソッド（オーバーライドしなければならない）、および「共通の」ロジックが含まれている別の方法が含まれています。

あなたが直接使用することができるクラスを持っている場合、仮想メソッドを使用する必要がありますが、それは必須ではありませんが、そのためにあなたは、相続が特定の動作を変更することができるようにしたい。

説明:と工夫.期待しないようにしてください.

文脈

働いている21階のビルです。私が被害妄想います。今回、この世界のどこかに、火災で焼するスカイスクレーパー.だが幸いにもては、指導マニュアルのどこかにここにい火災の場合は:

FireEscape()

  1. んの収集荷物
  2. 徒歩火を逃れ
  3. 徒歩行ビル

これは基本的に仮想メソッドを呼 FireEscape()

仮想メソッド

このプランができるのはとても良いし、99%の状況です。この基本計画作品。にあり、1％のエンナーレが詰または損傷の場合は完全に螺んなトーストなんかの激しい行動です。バーチャル手法でいっぱいで仕分けもバッチリです:をオーバーライドすることができ、基礎FireEscape()プランをご自身の版画

  1. 走るウィンドウ
  2. 窓の外にはジャンプ
  3. パラシュートも安心の底

その他の言葉 仮想方法を提供す基本計画では、できるオーバーライドが必要な場合.サブクラスでオーバーライドは、親クラスのバーチャル方式の場合はプログラマと判断す。

抽象メソッド

ないすべての組織は掘.一部の団体さんの消防訓練を実施。ない全体的に逃げます。各人は、自分自身への言葉でした。管理に最も人気のあるものをそのような政策など存在しません。

つまり、各人の 強制 開発自FireEscape()メソッドがあります。つね歩き、火を消します。別の男はパラシュート.別の男を使用ロケット推進の技術から離れのビルです。もんまabseilます。管理に注意を払っていない どのよう ま逃げようとしてついての基本的なFireEscape()プランに決めなければならないときは保証され安全衛生来の組織のようなトンの環境です。考査においては、こうした多様なより抽象的な方法です。

の違いについて教えてくださいのか？

抽象メソッド:サブクラス 強制 をFireEscape方法です。仮想メソッドについての基本的な計画を待っていますが、選択でき をご自身の だけでは十分ではありません。

こんなくだったのですか？

抽象メソッドは、具体的なクラスを作るために実施されなければならない方法です。宣言は、抽象クラスである（抽象メソッドを持つ任意のクラスは、抽象クラスでなければならない）、それは具体的なクラスで実装する必要があります。

仮想メソッドはスーパークラスでオーバーライド、の置換の動作を使用して派生クラスでオーバーライドすることができる方法です。あなたがオーバーライドしない場合は、元の動作を取得します。そうした場合、あなたは常に新しい動作を取得します。これは、上書きすることはできませんが、元のメソッドを隠すことができない仮想メソッドに反対しました。これはnew修飾子を使用して行われます。

次の例を参照してください。

public class BaseClass
{
    public void SayHello()
    {
        Console.WriteLine("Hello");
    }


    public virtual void SayGoodbye()
    {
        Console.WriteLine("Goodbye");
    }

    public void HelloGoodbye()
    {
        this.SayHello();
        this.SayGoodbye();
    }
}


public class DerivedClass : BaseClass
{
    public new void SayHello()
    {
        Console.WriteLine("Hi There");
    }


    public override void SayGoodbye()
    {
        Console.WriteLine("See you later");
    }
}
私はDerivedClassをインスタンス化し、SayHello、またはSayGoodbyeを呼び出すと、

、私は「こんにちは」を取得し、「後でお会いしましょう」。私はHelloGoodbyeを呼び出すと、私は「こんにちは」を取得し、「後でお会いしましょう」。 SayGoodbyeが仮想で、派生クラスで置き換えることができるからです。 SayHelloのみが隠されているので、私は私の基本クラスからその呼び出したときに、私は私の元のメソッドを取得します。

抽象メソッドは暗黙的に仮想的です。彼らはより多くのないインターフェイスのように、存在していなければならない動作を定義します。

抽象メソッドは常に仮想です。彼らは、実装を持っていないことができます。

これは主な違いです。

あなたはそれを「デフォルト」の実装を持っているし、子孫はその動作を変更できるようにしたい場合は、

基本的には、仮想メソッドを使用することになります。

抽象メソッドを使用すると、インプリメンテーションを提供するために、子孫を強制ます。

私は（他の回答から）以下のクラスにいくつかの改良を行うことで、この単純なを作っます：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TestOO
{
    class Program
    {
        static void Main(string[] args)
        {
            BaseClass _base = new BaseClass();
            Console.WriteLine("Calling virtual method directly");
            _base.SayHello();
            Console.WriteLine("Calling single method directly");
            _base.SayGoodbye();

            DerivedClass _derived = new DerivedClass();
            Console.WriteLine("Calling new method from derived class");
            _derived.SayHello();
            Console.WriteLine("Calling overrided method from derived class");
            _derived.SayGoodbye();

            DerivedClass2 _derived2 = new DerivedClass2();
            Console.WriteLine("Calling new method from derived2 class");
            _derived2.SayHello();
            Console.WriteLine("Calling overrided method from derived2 class");
            _derived2.SayGoodbye();
            Console.ReadLine();
        }
    }


    public class BaseClass
    {
        public void SayHello()
        {
            Console.WriteLine("Hello\n");
        }
        public virtual void SayGoodbye()
        {
            Console.WriteLine("Goodbye\n");
        }

        public void HelloGoodbye()
        {
            this.SayHello();
            this.SayGoodbye();
        }
    }


    public abstract class AbstractClass
    {
        public void SayHello()
        {
            Console.WriteLine("Hello\n");
        }


        //public virtual void SayGoodbye()
        //{
        //    Console.WriteLine("Goodbye\n");
        //}
        public abstract void SayGoodbye();
    }


    public class DerivedClass : BaseClass
    {
        public new void SayHello()
        {
            Console.WriteLine("Hi There");
        }

        public override void SayGoodbye()
        {
            Console.WriteLine("See you later");
        }
    }

    public class DerivedClass2 : AbstractClass
    {
        public new void SayHello()
        {
            Console.WriteLine("Hi There");
        }
        // We should use the override keyword with abstract types
        //public new void SayGoodbye()
        //{
        //    Console.WriteLine("See you later2");
        //}
        public override void SayGoodbye()
        {
            Console.WriteLine("See you later");
        }
    }
}

結合 のマッピングの名ユニットのコードです。

下旬に結合 この名前が繰り延べのマッピングしました。つまり、作成の名前の最初の、それ以降の工程にマッピングのコードを名前です。

を検討してください。:

  • に比べて、人と機械の好みに合わせて作りの検索とソート
  • に比べて機械、人間は本当に良いで発明

なので、その答えは: virtual が遅いとの結合の機(実行時に abstract との結合指導のための人(プログラマー)

つまり、 virtual おこなうことができ、

"Dear ランタイム, 結んで、適切なコードをこの名前のよい: 検索”

は abstract おこなうことができ、

"Dear プログラマー, くださいbindの適切なコードをこの名前のよい: 発明”

のための完全性、 過負荷 おこなうことができ、

"Dear コンパイラ, 結んで、適切なコードをこの名前のよい: ソート”.

あなたは、彼らがしたい場合は後継が機能を拡張したい場合は、

あなたは基本的に仮想メソッドを使用します。

あなたが相続が機能を実装したいときは、抽象メソッドを使用します（この場合には、彼らは選択肢がない）

私は抽象メソッドは以下のように定義されたいくつかの場所で見てきました。 **

  

の "抽象メソッドは、子クラスで実装する必要がなければなりません"

** 私はそれが似ていると感じます。

子クラスも抽象的である場合は、抽象メソッドは、子クラスで実装する必要があることの必要はありませんの..

1）抽象メソッドのカントのプライベートメソッドです。 2）抽象メソッドのカントの同じ抽象クラスで実装されます。

私たちは抽象クラスを実装している..if言うでしょう、あなたは基本抽象クラスから抽象メソッドをオーバーライドしている必要があります。 ..抽象メソッドを実装すると、仮想メソッドへの上書きのキーワード.Similarであるので。

仮想メソッドは継承されたクラスに実装するために、

のこれは必要ではない。の

                                 ----------CODE--------------

public abstract class BaseClass
{
    public int MyProperty { get; set; }
    protected abstract void MyAbstractMethod();

    public virtual void MyVirtualMethod()
    {
        var x = 3 + 4;
    }

}
public abstract class myClassA : BaseClass
{
    public int MyProperty { get; set; }
    //not necessary to implement an abstract method if the child class is also abstract.

    protected override void MyAbstractMethod()
    {
        throw new NotImplementedException();
    }
}
public class myClassB : BaseClass
{
    public int MyProperty { get; set; }
    //You must have to implement the abstract method since this class is not an abstract class.

    protected override void MyAbstractMethod()
    {
        throw new NotImplementedException();
    }
}

仮想メソッド:

  • 仮想いたしますのでオーバーライドします。

  • 仮想機能が実装されます。時を継承し、クラスまで バーの仮想関数を提供している。

  • を変えることができま戻り値の型の仮想関数が実施さ
    機能をクラスとも言える"をコンセプトとしての
    シャドーイング).

抽象メソッド

  • 概要としなければなオーバーライドします。

  • 抽象的な機能が実装する抽象クラスです。

  • できるだけると宣言しています。この部隊の派生クラスの実装です。

  • 抽象会員が暗黙のうちにvirtualなのです。抽象とすることができよう純粋な仮想の一部です。

    public abstract class BaseClass
{ 
    protected abstract void xAbstractMethod();

    public virtual void xVirtualMethod()
    {
        var x = 3 + 4;
    }
}

抽象機能 できない体になオーバーライドによる児童の授業

仮想機能 して体を示すものではありませんオーバーライドによる児童の授業

一番上の例で使用のコードによって非常に良いです。私は必要な追加したいと考えているが、以下の簡単な説明を利用した工夫ではなくコード/技術。

簡単な説明-説明を工夫

抽象メソッド

思いのジョージ-W-ブッシュ.彼は彼の兵士:"Go戦イラク".ことになるのです。すべての彼は、指定される戦闘が必要です。彼が指定されていない どのよう このことが起こると思います。もうだけではできない、"fight":いるということね！い戦いるB-52やっderringer?その詳細は左かったのですが、自分以外の誰か.これは抽象的な方法です。

仮想メソッド

David Petraeusが高いのを書いてみたいと思います。そう戦いをおこなうことができ、

  1. の敵
  2. を相殺した。
  3. てその後ビール

の問題であるとの一般的な方法です。この方法がることもない特定です。とっても良いことPetraeusは受注してゆとりと範囲-その許可等を変更する定義の"戦い"によると、特定の条件です。

私の仕事Bloggsを読み込みPetraeusめて与えられた許可の実施自身の版の戦いによると、彼の特定の要件:

  1. 見しました。
  2. 撮影したのです。
  3. 帰
  4. しています。

Nouri al Malikiを受けてまかなわれています。同受注からPetraeus.ために戦います。でも彼は政治家ではなく、歩兵。明らかにできないので一周の撮影彼politican敵のです。でPetraeusは与えていると言っているが、仮想メソッド、Malikiを実装する独自の戦い方法によれば、彼の特定の状況:

  1. 見しました。
  2. いただくとともに逮捕されたあとBS trumped上げます。
  3. 帰
  4. しています。

つまり、仮想法定型の指示で一般的に指導できることがわかった特定の人々に軍の階層に分かれ、特定の状況です。

二つの違い

  • ジョージブッシュしないことを証明ず実施。これによって提供されなければならないます。これは抽象的な方法です。

  • Petraeusの は を実施内容がその許可のために部下をオーバーライド氏の注文を自分の版できない場合だってありますか？

い役立っています。

の抽象関数（メソッド）：

は、抽象メソッド●キーワード抽象と宣言されている方法である。

これは、ボディを持っていません●ます。

これは、派生クラスで実装する必要があり●ます。

●メソッドが抽象的であれば、クラスべき抽象ます。

仮想関数（メソッド）：

仮想方法●キーワード仮想で宣言され、それは、overrideキーワードを使用して、派生クラスのメソッドによりオーバーライドすることができる。

の方法であります

●それは、それを上書きするかどうかまで派生クラスにいます。

答えは回数が、それぞれが、設計時の決定で使用するときについて質問が提供されています。私は明確なインタフェースに共通するメソッドの定義をバンドルしようとすると、適切な抽象化レベルでクラスにそれらを引くために良い練習としてそれを見るでしょう。クラスに抽象仮想メソッド定義の共通セットをダンプすることは、簡潔なインターフェースのセットを実装する非抽象クラスを定義するのが最良であり得るクラスunistantiableをレンダリングします。いつものように、それはあなたのアプリケーションの特定のニーズに合ったものを最高に依存します。

一般からのオブジェクト指向の眺望：

に関する抽象メソッド:がありますので、抽象メソッドは、親クラスを実際にご言っていることの児童クラスこんにちはおいてメソッドシグニチャー。ばねが利用でき実施するべきである。

に関する仮想関数:また、下記のいずれかに該当する仮想メソッドは、親クラスごとの派生クラスこんにちはがある機能のことをどうにかしなきゃいます。場合に便利ですただけます。場合、このメソッドをオーバーライドをコードも利用できる私の実施コード!

これは一部の哲学をめざすとこの二つの概念を一般OO

あな話仮想クラスのクライアントまで、フルのC#.

のための機能

  1. 抄録のみで機能して署名のみのクラスによるオーバーライドが付可能です。
  2. 仮想機能の一部の機能ドライブのクラスはありませんオーバーライドによって、要求

できるかを決めてます。

implementation.Itを持っているdoesntの

抽象メソッドは、親クラスで宣言されています。子クラスはそのメソッドを実装するためのresposibleです。

仮想メソッドは、親クラスの実装を持っている必要があり、それが親クラスの実装を使用するか、子クラスでそのメソッドのために自分自身のための新しい実装を持っているかどうかの選択をするために子クラスを容易にします。

抽象機能は実装せずに、「単に」署名です。 クラスを使用することができますどのように宣言するためのインタフェースで使用されています。 これは、派生クラスのいずれかで実装されている必要があります。

仮想関数（実際の方法）、あなたが同様に宣言する機能であり、継承階層クラスのいずれかで実装する必要があります。

そのようなクラスの継承されたインスタンスは、あなたは下の階層のクラスで、それを実装していない限り、同様の実装を継承します。

C ++背景から、C ++仮想のC＃仮想対応する、C＃抽象メソッドがC ++純粋仮想関数に対応している

を抽象関数やメソッドのクラスによって公開されるパブリック「操作の名前」で、その目的は、抽象クラスと一緒に、主に構造ANに対するオブジェクトのデザインに制約のフォームを提供していますオブジェクトが実装する必要があります。

実際にはその抽象クラスから継承するクラスは、一般的にそうでない時にエラーを発生させるコンパイラ、このメソッドに実装を提供する必要があります。

抽象クラスとメソッドを使用すると、クラスを設計する際に、実装の詳細に焦点を当てることによって、クラスの構造は非常にそれらの間での共同作業クラス間の依存関係との結合を作成し、実装にあまりにも関連することを避けるために、主に重要である。

を仮想関数やメソッドは、単にそのモデルクラスのパブリック振る舞いをする方法ですが、私たちは、子クラスが持つことができると思うので、我々は、継承チェーンでそれを変更すること自由に残すことができますその行動のためのいくつかの特定の拡張機能を実装する必要があります。

これらの両方は、オブジェクト指向パラダイムでの polymorpfhismするの形式を表します。

私たちは、優れた継承モデルをサポートするために一緒に抽象メソッドおよび仮想関数を使用することができます。

私たちは、当社のソリューションの主なオブジェクトの良い抽象的構造を設計し、さらに特化しやすいもの配置することにより、基本的な実装を作成し、我々はvirtualsを、これらのものを作り、最終的に私たちは私たちの基本的な実装を専門とし、eventyually「オーバーライド」の仮想のものを継承ます。

ここで私は、これは非常に基本的なレベルでのインターフェイス、抽象クラスと普通のクラスの振る舞いを参照するには、むしろ有形一例であってよい期待していくつかのサンプルコードを書いています。 ます。https：// githubのデモとしてそれを使用したい場合は、プロジェクトとしてのGitHubでこのコードを見つけることができます.COM / usavas / JavaAbstractAndInterfaceDemoする 

public interface ExampleInterface {

//    public void MethodBodyInInterfaceNotPossible(){
//    }
    void MethodInInterface();

}

public abstract class AbstractClass {
    public abstract void AbstractMethod();

    //    public abstract void AbstractMethodWithBodyNotPossible(){
    //
    //    };

    //Standard Method CAN be declared in AbstractClass
    public void StandardMethod(){
        System.out.println("Standard Method in AbstractClass (super) runs");
    }
}

public class ConcreteClass
    extends AbstractClass
    implements ExampleInterface{

    //Abstract Method HAS TO be IMPLEMENTED in child class. Implemented by ConcreteClass
    @Override
    public void AbstractMethod() {
        System.out.println("AbstractMethod overridden runs");
    }

    //Standard Method CAN be OVERRIDDEN.
    @Override
    public void StandardMethod() {
        super.StandardMethod();
        System.out.println("StandardMethod overridden in ConcreteClass runs");
    }

    public void ConcreteMethod(){
        System.out.println("Concrete method runs");
    }

    //A method in interface HAS TO be IMPLEMENTED in implementer class.
    @Override
    public void MethodInInterface() {
        System.out.println("MethodInInterface Implemented by ConcreteClass runs");

    //    Cannot declare abstract method in a concrete class
    //    public abstract void AbstractMethodDeclarationInConcreteClassNotPossible(){
    //
    //    }
    }
}

私の理解するには：

抽象メソッド：

だけ抽象クラスは、抽象メソッドを保持することができます。また、派生クラスがメソッドを実装する必要がない実装がクラスに設けられていない。

仮想方法：

クラスは、これらを宣言し、同じの実装を提供することができます。また、派生クラスはそれをオーバーライドする方法を実装する必要があります。

ライセンス： CC-BY-SA と 帰属
所属していません StackOverflow
scroll top