育才学习网1.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()));
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了。
转载请注明出处育才学习网 » c抽象接口继承怎么写(C#父类实现接口,子类继承父类怎么写)