如果你希望某个方法允许子类重写，请加上 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()));
2.一个类继承了一个抽象类和接口怎么来调用抽象修饰类的时候表示是一个抽象类，这个类不能实例化；
抽象类出现的目的就是为了继承；
抽象类一般用在哪里？一个抽象类一般作为工具类；
抽象类中的抽象方法目的就是为了覆盖；
抽象的方法，不能使用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();
}
3.C#中怎样实现类和接口的继承,怎样重写方法using System;
namespace TestInterface
{
public interface Base
{
//方法声明
void Method（)；//无方法体
}
public class Child:Base
{
public void Method()
{
//方法实现
Console.WriteLine("It'r so easy!");
}
}
}
4.C# 抽象类继承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;
}
}
5.C#中的封装,继承,多态,接口希望能给到你些帮助 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() 。
6.接口继承 uml如何表示这个需要你首先明白接口与抽象类的区别！ abstract class和interface有什么区别？它们的区别如下：声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。
不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。
不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。
取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。
接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。
多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。
接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。
当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。
由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。
引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。在Java面向对象的设计中要常做到面向接口编程，面向对象编程。
UML是统一建模语言，那个你自己看下就行了，知道怎么画，如何理解就OK了。
