C#父類實現接口，子類繼承父類怎麼寫|c抽象接口繼承怎麼寫

如果你希望某個方法允許子類重寫，請加上 virtual

例如：public class A : infa{

public int add(){}

public int delete(){}

//這個方法是父類自己的

public virtual int update(){}

}

子類重寫時使用 override 關鍵字

public class D:A{

public override int update(){

return 3;

}

}

測試代碼

A a=new A();

B b=new B();

C c=new C();

D d=new D();

MessageBox.Show(String.format("A:{0} B:{1} C:{2}",a.add(),b.add(),c.delete(),d.update()));

抽象修飾類的時候表示是一個抽象類，這個類不能實例化；

抽象類出現的目的就是爲了繼承；

抽象類一般用在哪裏？一個抽象類一般作爲工具類；

抽象類中的抽象方法目的就是爲了覆蓋；

抽象的方法，不能使用private修飾；

接口是一種可以讓類多實現的類型；

接口是爲了提供類的多實現；

實現接口使用關鍵字 implements

實現接口必須實現接口中所有的抽象方法；

abstract class TestAbstractClass{

public void test(){

System.out.println("123");

}

}

abstract class Test1 extends TestAbstractMethod{

public void test(){

System.out.println("Testing");

}

}

interface Animal{

public void run();

}

class Dog implements Animal {

public void run(){

System.out.println（"跑得很快"）；

}

}

public static void main(String args[]){

//TestAbstractClass tac = new TestAbstractClass();

TestAbstractClass tac = new Test();

tac.test();

Animal a = new Dog ();

a.run();

}

using System;

namespace TestInterface

{

public interface Base

{

//方法聲明

void Method（)；//無方法體

}

public class Child:Base

{

public void Method()

{

//方法實現

Console.WriteLine("It'r so easy!");

}

}

}

class Program

{

static void Main(string[] args)

{

Employee em = new Employee();

em.salary = 3000;

em.bonus = 500;

Console.WriteLine(em.CalcSalary());

TechEmployee te = new TechEmployee();

te.salary = 3000;

te.bonus = 500;

te.postSalary = 2000;

Console.WriteLine(te.CalcSalary());

Console.ReadLine();

}

}

abstract class BaseEmployee

{

public int salary;

public abstract int CalcSalary();

}

class Employee : BaseEmployee

{

public int bonus;

public override int CalcSalary()

{

return salary + bonus;

}

}

class TechEmployee : Employee

{

public int postSalary;

public override int CalcSalary()

{

return salary + bonus + postSalary;

}

}

希望能給到你些幫助 C#是一種現代的面向對象的語言. 繼承（inheritance）：繼承是一個面向對象的詞語.說明，一個類（派生類）能分享，其它類（基類）的特徵和行爲.派 生類和基類是"is a"的關係. base classes（基類）：通常基類可以自己實例化，或被繼承.派生類繼承基類中的成員，被標記爲protected或更大 的權限.語法： class (derive class name):(base class name) 例子： //基類 public class Contact { //默認私有的字段 string name; string email; string address； //構造函數 public Contact() { // statements 。

} //屬性 public string Name { get { return name; } set { name = value; } } public string Email { get { return email; } set { email = value; } } public string Address { get { return address; } set { address = value； } } } //派生類 public class Customer : Contact { //自己的私有字段 string gender; decimal income; public Customer() { // statements 。 } } 在上面的例子中，Customer 是 Contact的子類，不但，繼承了父類的成員，name,email,address；還有自己的成員，gender,income. abstract classes（抽象類）：抽象類是一種特殊的基類.除過普通的類成員，它們還有抽象的類成員.抽象類成員， 是不能被實例化的方法和屬性.所有直接從抽象類派生的類，必須實現抽象的方法和屬性.抽象類不能被實例化. 例子： //抽象類 abstract public class Contact { protected string name; public Contact() { // statements。

} //抽象方法 public abstract void generateReport（)； //抽象屬性 abstract public string Name { get; set; }} public class Customer : Contact { string gender; decimal income; int numberOfVisits; public Customer() { // statements } public override void generateReport() { // unique report } public override string Name { get { numberOfVisits++; return name; } set { name = value; numberOfVisits = 0; } } } public class SiteOwner : Contact { int siteHits; string mySite; public SiteOwner() { // statements。 } public override void generateReport() { // unique report } public override string Name { get { siteHits++; return name; } set { name = value; siteHits = 0； } } } 上面的例子，定義了三個類.一個抽象類，兩個派生類.實現了父類的方法和屬性."override"修飾符，實現了抽象 類的方法. Calling Base Class Members（調用基類成員） 派生類能調用基類成員，如果，成員的修飾符是"protected"或更大權限.在適當的上下文條件下，好像調用自己的 成員一樣. 例子： abstract public class Contact { private string address; private string city; private string state; private string zip; public string FullAddress() { string fullAddress = address + 'n' + city + ',' + state + ' ' + zip; return fullAddress; } } public class Customer : Contact { public string GenerateReport() { string fullAddress = FullAddress(); // do some other stuff。

return fullAddress； } } 上面的例子中，派生類調用基類的方法：FullAddress（)； 基類的構造函數，可以被派生類調用，用base（). 例子： abstract public class Contact { private string address; public Contact(string address) { this.address = address; } } public class Customer : Contact { public Customer(string address) : base(address) { } } 例子中，派生類沒有address成員，可以調用基類的構造函數. Hiding Base Class Members（隱藏基類成員） 派生類可以和基類有同樣名字的成員.這時，就會隱藏基類的成員. 例子： abstract public class Contact { private string address; private string city; private string state; private string zip; public string FullAddress() { string fullAddress = address + 'n' + city + ',' + state + ' ' + zip; return fullAddress; } } public class SiteOwner : Contact { public string FullAddress() { string fullAddress; // create an address。 return fullAddress； } } 在例子中，派生類和基類有同樣的成員，FullAddress（)，當調用時，基類的方法會被隱藏. 儘管基類的成員被隱藏，仍然可以訪問基類的成員，透過，base關鍵字，調用基類的引用. 例子： abstract public class Contact { private string address; private string city; private string state; private string zip; public string FullAddress() { string fullAddress = address + 'n' + city + ',' + state + ' ' + zip; return fullAddress; } } public class SiteOwner : Contact { public string FullAddress() { string fullAddress = base.FullAddress(); // do some other stuff。

return fullAddress； } } 在例子中，派生類調用基類的成員，用base引用. visioning（版本） 例子： using System; public class WebSite { public string SiteName; public string URL; public string Description; public WebSite() { } public WebSite( string strSiteName, string strURL, string strDescription ) { SiteName = strSiteName; URL = strURL; Description = strDescription; } public override string ToString() { return SiteName + ", " + URL + ", " + Description; } } public class Contact { public string address; public string city; public string state; public string zip; public string FullAddress() 。

這個需要你首先明白接口與抽象類的區別！ abstract class和interface有什麼區別？它們的區別如下：聲明方法的存在而不去實現它的類被叫做抽象類（abstract class），它用於要創建一個體現某些基本行爲的類，併爲該類聲明方法，但不能在該類中實現該類的情況。

不能創建abstract 類的實例。然而可以創建一個變量，其類型是一個抽象類，並讓它指向具體子類的一個實例。

不能有抽象構造函數或抽象靜態方法。Abstract 類的子類爲它們父類中的所有抽象方法提供實現，否則它們也是抽象類爲。

取而代之，在子類中實現該方法。知道其行爲的其它類可以在類中實現這些方法。

接口（interface）是抽象類的變體。在接口中，所有方法都是抽象的。

多繼承性可透過實現這樣的接口而獲得。接口中的所有方法都是抽象的，沒有一個有程序體。

接口只可以定義static final成員變量。接口的實現與子類相似，除了該實現類不能從接口定義中繼承行爲。

當類實現特殊接口時，它定義（即將程序體給予）所有這種接口的方法。然後，它可以在實現了該接口的類的任何對象上調用接口的方法。

由於有抽象類，它允許使用接口名作爲引用變量的類型。通常的動態聯編將生效。

引用可以轉換到接口類型或從接口類型轉換，instanceof 運算符可以用來決定某對象的類是否實現了接口。在Java面向對象的設計中要常做到面向接口編程，面向對象編程。

UML是統一建模語言，那個你自己看下就行了，知道怎麼畫，如何理解就OK了。