德仔

<br />C#中使用的关键字是base，但用法不完全相同。<br />1. 调用父类的构造方法<br />// 父类 <br />public class Father <br />{ <br />    public Father(String name) <br />     { <br />        this.name = name; <br />     } <br />    private String name; <br />} <br />// 子类 <br />public cla

<br />接口用来描述一种程序的规定，接口描述可属于任何类或结构的一组相关行为。实现接口的类或结构要与接口的定义严格一致。接口可由方法、属性、事件、索引器或这4种成员类型的任何组合构成。接口不能包含字段。接口成员一定是公共的。<br />定义接口的语法如下:<br /><访问修饰符> interface 接口名<br />{<br />//接口主体<br />}<br />下面定义一个开关的接口，代码如下：<br />public interface IChoose<br />{<br />void On

<br />C#定义了接口后，就要在子类中实现。C#中通常把子类和父类的关系称为继承，子类和接口的关系称为实现。子类可以继承一个父类，可以实现多个接口。接口中不能定义构造函数，所以接口不能实例化。<br />下面我们看例子：<br />using System;<br />public interface IChoose<br />{<br />void On();<br />void Off();<br />}<br />public class TV: IChoose<br />{<br />priva

<br />using System;<br />public interface Iren<br />{<br />void eat();<br />void sleep();<br />}<br />public class Xuesheng: Iren<br />{<br />public void eat()<br />{<br />    Console.WriteLine("我是一个学生，我去食堂吃饭");<br />}<br />public void sleep()<br />{<br />

<br />接口是把隐式公共方法和属性组合起来，以封装特定功能的一个集合。一旦定义了接口，就可以在类中实现它。这样，类就可以支持接口所指定的所有属性和成员。接口不能单独存在；不能进行实例化（因为没有必要实例化）；接口不包括任何实现其成员的代码而只定义了成员本身；成员的实现将在实现接口的类中实现。<br />以上是接口的书本定义，读完基本不知所云。就知道了接口与类不一样，接口与类都需要定义自身的成员，但接口不能实现成员的功能。我觉得可以简单地说：接口是类的更高级抽象（类已经是其所要实现的过程的抽象了），接口定

<br />索引器(Indexer)<br />索引器允许类或结构的实例按照与数据相同的方式进行索引。索引器类似于属性，不同之处在于它们的访问器采用参数。所以索引器也被称为有参属性。<br /><br />示例一：<br />using System ;<br />class ArrClass//没有索引器的类<br />{<br />private readonly string name;<br />public ArrClass(string name)<br />{<br />this.name =

<br />面向对象的程序设计技术引入了继承的概念。一个类从另一个类派生出来时，派生类从基类那里继承特性。C#中，派生类从它的直接基类中继承成员：方法、域、属性、事件、索引指示器。除了构造函数和析构函数，派生类隐式地继承了直接基类的所有成员。<br />一、继承的传递性<br />派生类从基类那里继承特性。派生类也可以作为其它类的基类。从一个基类派生出来的多层类形成了类的层次结构。就像现在中爷爷，爸爸和儿子的关系。儿子不仅可以访问父类爸爸的所有公有属性方法，也可以访问爷爷的所有公有属性和方法，这种关系称为继

<br />1、实例化父类时，可以使用new子类，执行构造函数顺序为：先执行父类构造函数，再执行子类构造函数。<br />2、实例化子类时，只可以new子类，执行顺序同上。<br />3、父类实例化后，只能执行父类的方法，获得父类的属性等。<br />4、实例化子类后，可同时执行子类和父类的方法和属性，如同名方法，则执行子类的方法。<br />我们看以下的代码:<br />    public class A<br />    {<br />        public A(string a) { }<br

<br />构造函数主要用来初始化对象。它又分为静态(static)和实例(instance)构造函数两种类别。大家应该都了解如何来写类的构造函数，这里只说下默认构造函数的作用，以及在类中保留默认构造函数的重要性。实际上，我说错了。正确的说法是：以及在类中保留空参数构造函数的重要性。<br />我们来写一个类A，代码如下：<br />public class A<br />{<br />   public int Number;       //数字<br />   public string Word; 

<br />继承中访问修饰符的区别<br />一、public 类内部可以，子类可以，其他类可以。<br />二、private 类内部可以，子类和其他类都不可以。<br />三、protected 类内部和子类可以，其他类不可以。<br />四、internal 类声明为内部的，即只有当前工程中的代码才能访问它。<br />父类中的成员如果用public修饰，任何类都可以访问；如果用private修饰，它将作为私有成员，只有类本身可以访问，其他任何类都无法访问。在C#中，使用protected修饰符的成员

<br />父类代码如下：<br />public class Person<br />{<br />//父类的构造函数<br />public Person()<br />{<br />Console.WriteLine("Person");<br />}<br />//父类的虚方法<br />public virtual void virFun()<br />{<br />Console.WriteLine("Person's Fun");<br />}<br />}<br />子类代码如下：<br /

<br />子类继承父类的属性和方法，使创建子类变得很简单，实现了代码重用。继承还有一个重要的特性，父类对象可以引用子类实例。也就是子类实例可以赋值给父类的对象变量。<br />这个特性可以这样理解：儿子继承父亲，儿子又把管理自己事务的权利交给父亲，那么父亲就可以代表儿子处理事务，这就是父类对象引用子类实例。现在生活中，父母可以代表儿子处理事务，总公司可以代表子公司生命权利。<br />父类指针要访问子类的成员的情况下，要强制类型转换。<br />父类的对象变量=new 子类类型；   <br />((子类

<br />using System;<br />public class ParentClass<br />{<br />public ParentClass()<br />{<br />    Console.WriteLine("父类构造函数。");<br />}<br />public void print()<br />{<br />    Console.WriteLine("I'm a Parent Class。");<br />}<br />}<br />public class Child

<br />我们看一个例子，假若有一个动物类，类中用方法cry()描述动物的叫声，不同的动物的叫声是不一样的。根据继承的特征，把类中公共部分的内容放在父类中，那么cry()方法就应该放在父类中，根据这样的思路编写程序如下：<br />using System;<br />class Anmial<br />{<br />public void Cry()<br />{<br />Console.WriteLine("这是动物的叫声");<br />}<br />}<br />class Dog: Anmia

<br />如果继承是面向对象设计理论的基石，那么抽象理论和方法就是继承理论的顶梁柱。在汉语词典中抽象是这样解释的：将几个有区别的物体的共同特性或形象抽取出来或孤立地进行考虑的行动或过程。可以看出，抽象就是从事物中提取特征和性质，并不是事物本身。具体应该如何理解呢？<br />大家都知道，学生有一个共同的特征是必须学习，那么学什么，如何学，每一个学生就不一样了。这样可以提取学习这个动作为抽象方法，而不考虑具体内容。动物类都有叫的动作，具体动物如何叫，暂不考虑，先把共性提取出来。简单地说，用来描述这些共性的类

<br />C#规定，抽象类不能实例化，如下代码会发生编译错误：<br />Animal myanimal=new Animal();<br /><br />那么如下代码正确吗？<br /><br />Animal myanimal=new Dog();<br />myanimal.Cry();<br />这段代码是完全正确的。既然抽象类不能实例化，那么这段代码为什么又可以运行呢？首先要明确上面的代码并没有实例化抽象类，只是声明了一个抽象类的对象myanimal，实例化时必须通过构造函数来实现，这里调用的是

<br />C#不支持多重继承，但是客观世界出现多重继承的情况又比较多。为了避免传统的多重继承给程序带来的复杂性等问题，C# 提出了接口的概念。通过接口可以实现多重继承的功能。<br />接口是单纯对事物行为的描述。例如，电器都有“开”和“关”两个行为，开关的作用在于打开或关闭电器，而开关的形式也是不一样的。电灯、电视、电扇，电冰箱各自完成的开关的动作也是不一样的，但是所有的电器都必须具有开和关的功能，这是一个规定，在程序设计中，这个规定就是接口。<br />C#中接口的作用的什么？不是可以继承吗？为什么还

<br />假设我们公司有两种程序员：VB程序员指的是用VB写程序的程序员，用VBpro这个类表示；C程序员指的是用C写程序的程序员，用Cpro这个类来表示。每个类都有一个WriteCode()方法。<br />现在公司来了一个项目，要求派某个程序员写一个程序。<br />using System;<br />//vb程序员<br />class VBpro<br />{<br />public void WriteCode()<br />{<br />    Console.WriteLine("我用vb

<br />虚方法和抽象方法都可以供派生类重写，它们之间有什么区别呢？<br />1. 虚方法必须有实现部分，并为派生类提供了重写该方法的选项。抽象方法没有提供实现部分，抽象方法是一种强制派生类重写的方法，否则派生类将不能被实例化。<br /><br />//抽象方法<br />publicabstractclass Animal<br />{<br />    publicabstractvoid Sleep();<br />    publicabstractvoid Eat();<br />}<br

<br />非抽象类和接口的差别很大，它们的差别主要表现在以下几个方面：<br />1、非抽象类可以有成员变量、常量和构造函数，而接口中不能存在常量、域、操作符、构造函数或析构函数，而且不能包含任何静态成员。<br />2、一个非抽象类可以继承多个接口，而只能继承一个类；<br />3、非抽象类中可以定义具体的方法和实现，而接口只定义方法没有具体的实现；<br />4、接口成员一定是公共的，而且不能声明为虚拟或者是静态的，而非抽象类中是没有这些限制。<br />5、非抽象类可以被实例化，而接口不可以。一般来

<br />1.抽象类可以有实现（包括构造函数），而接口不可以有任何实现。<br />namespace ConsoleApplication1 <br />{ <br />    class Program <br />    { <br />        interface IMyInterface1 <br />        { <br />            void IMethod1(); <br />            void IMethod2(); <br />        }

<br />一、抽象类<br />    (1) 抽象方法只作声明，而不包含实现，可以看成是没有实现体的虚方法<br />    (2) 抽象类不能被实例化<br />    (3) 抽象类可以但不是必须有抽象属性和抽象方法，但是一旦有了抽象方法，就一定要把这个类声明为抽象类<br />    (4) 具体派生类必须覆盖基类的抽象方法<br />    (5) 抽象派生类可以覆盖基类的抽象方法，也可以不覆盖。如果不覆盖，则其具体派生类必须覆盖它们。如：<br />using System;<br />pub

<br />关键字this有两种基本的用法，一是用来进行this访问，二是在声明构造函数时指定需要先执行的构造函数。<br />一、this访问<br />在类的实例构造函数和实例函数成员中，关键字this表示当前的类实例或者对象的引用。this不能用在静态构造函数和静态函数成员中，也不能在其他地方使用。<br />当在实例构造函数或方法内使用了与字段名相同的变量名或参数名时，可以使用this来区别字段和变量或者参数。下面的代码演示了this的用法。<br />public class Dog<br />{

<br />下面举一个生活的例子来理解多态。如果要求3种人——孩子，运动员，音乐演奏者都执行一个动作“play”，会发生什么情况呢？<br />孩子会出去玩耍。<br />运动员会比赛。<br />演员开始演奏。<br />对于同一个命令，不同的人会有不同的反应，执行不同的动作，这就是生活中一个多态。在程序设计中，对于同一个方法，由于执行的对象不同，方法的内容也就不同。执行的结果也是不相同的。<br />同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。<br />多态性通过派生

<br />重载就是在同一个类中，方法名相同，参数列表不同。参数列表不同包括：参数的个数不同，参数类型不同等。<br /><br />重载特征： <br />I.方法名必须相同 <br />II.参数列表必须不相同，与参数列表的顺序无关 <br />III.返回值类型可以不相同<br />用于在给定了参数列表和一组候选函数成员的情况下，选择一个最佳函数成员来实施调用。 <br />public void test(int x,int y){} <br />public void test(int x,ref

<br />数组中的元素可以通过索引进行检索，如果一个类中有很多对象，怎样简单、快速地查找到需要的对象以及对象的特性呢？索引器就是为了实现这样的功能而设计的。索引器允许类或结构的实例按照与数组相同的方式进行索引。可以简单地把索引器理解为书中的目录，字典中提供的检索的索引。<br />索引器(Indexer)是C#引入的一个新型的类成员，它使得对象可以像数组那样被方便，直观的引用。索引器非常类似于我们前面讲到的属性，但索引器可以有参数列表，且只能作用在实例对象上，而不能在类上直接作用。<br />索引器可以重

<br />索引器定义类似于属性，但其功能与属性并不相同。索引器提供一种特殊的方法编写get和set访问器。属性可以像访问字段一样访问对象的数据，索引器可以使用户像访问数组一样访问类成员。定义索引器的语法如下：<br /><访问修饰符>　类型名称 this [类型名称 参数名]<br />{<br />    get{//获得属性的代码}                                                 <br />    set{ //设置属性的代码}<br />}<br /

<br />属性和索引器的差别：一个对象只有一个属性值，所以要存放多个值必须实例化多个对象（通常情况下，实例化一个数组的对象，接着实例化的对象赋给这个数组）。一个对象对应的索引是一个数组，并且可以存放多个数值或字符串，所以只需要实例化一个对象就可以存放以及访问多个存储内容。<br />using System;<br />using System.Collections.Generic;<br />namespace aaa<br />{<br />public class arrClass{ //通过构造

<br />using System;<br />public class Photo //这个类是一个相片类<br />{<br />private string _title; //相片标题<br />//先定义默认构造函数<br />public Photo()<br />{<br />    //初始化相片标题的构造方法<br />    _title = "我是张三";<br />}<br />public Photo(string title)<br />{<br />    //初始化相片标题

转自:http://www.cnblogs.com/bluescreen/archive/2012/02/17/2355731.html public class strorfilepass { /// /// 初始化安全类 /// public strorfilepass() { ///

样式一：protected void Page_Load(object sender, EventArgs e) { if (!Page.IsPostBack) { this.GenImg(this.GenCode(4)); } }

///MD5加密 "8lvbe4kE" public string MD5Encrypt(string pToEncrypt, string sKey) { DESCryptoServiceProvider des = new DESCryptoServiceProvider(); byte[] inputByteArray = Encodi

在处理工时的时候需要这样处理问题.启动时间  结束时间 就需要处理多少小时,多少分钟等写了一个函数处理   protected decimal GetSpanTime(TextBox txtstarttime, TextBox txtendtime) { int year = int.Parse(txtstarttime.Text.ToString().Su

之前的写的自动编码单据流水码是写在存储过程或者函数中的，今天用程序写一个发现TOSTRING可以格式化方便。/// /// 年月日+两位流水码 /// /// public static string AutoCode() { string yearmonthday =Syste

<br />C#中对于接口的实现方式有隐式接口和显式接口两种：<br />隐式地实现接口成员<br />创建一个接口，IChinese，包含一个成员 Speak;我们创建一个类Speaker，实现接口Chinese<br />//隐藏式实现例子<br />public interface IChinese<br />{<br />    string Speak();<br />}<br />public class Speaker : IChinese<br />{<br />    public str

<br />一个类可以同时继承类和接口，或者抽象类和接口，抽象类和类不能在一个类的继承列表中同时出现。如果子类同时继承类，抽象类和接口，一定要把类或者抽象类写在前面，接口写在后面，类名和接口名之是用“,”隔开，接口没有先后顺序。每一种继承要根据各自的规则去实现。<br />如果希望学生都具有姓名、性别、年龄和学号等属性，当可以直接在计算机专业的学生类中创建，但是，如果还有别的专业的学生，那么都要重新写一遍，不符合代码重用的原则。现在把公用代码提取出来创建一个父类，在父类中赋予这些属性就可以。由于学号只有学生

<br />C#抽象类和接口之间在对于抽象类定义的支持方面具有很大的相似性，甚至可以相互替换，因此很多开发者在进行抽象类定义时对于抽象类和接口的选择显得比较随意。其实，两者之间还是有很大的区别的。首先，以抽象类的方式定义一个公共的抽象类Animal如下：<br />public abstract class Animal    <br />{<br />    public abstract void Run();<br />    public abstract void Eat(); <br />} <

<br />1、声明一个抽象方法使用abstract关键字。<br />2、一个类中可以包含一个或多个抽象方法。<br />3、抽象类中可以存在非抽象的方法。<br />4、抽象类不能被直接被实例化。<br />5、实现抽象类用“:”（冒号），实现抽象方法用override关键字。<br />6、抽象类可以被抽象类所继承，结果仍是抽象类。<br />7、抽象方法被实现后，不能更改修饰符。<br />　 using System;　<br />    public abstract class Person<

<br />定义抽象类和抽象方法的目的就是为子类提供一种规定，约束子类的行为。C#通过方法重写来实现抽象方法。当一个抽象基类派生一个子类时，子类将继承基类的所有特征，重新实现所有抽象方法。在子类中实现基类的抽象方法，是使用override关键字来重写基类方法。语法如下：<br />访问修饰符 override 返回类型 方法()<br />{<br />//方法体<br />}<br />重写抽象方法和重写虚拟方法是一样的。不同的是在基类一种是虚拟方法，另一种是抽象方法。通过override关键字可以在子类

<br />C#接口是一个让很多初学C#者容易迷糊的东西，用起来好像很简单，定义接口，里面包含方法，但没有方法具体实现的代码，然后在继承该接口的类里面要实现接口的所有方法的代码，但没有真正认识到接口的作用的时候就觉得用接口是多此一举，当然你这样想那是绝对绝对错误的，比尔盖茨的微软请的员工都是比尔盖茨还聪明的人，他们的C#能添这样的多足吗？<br />可简单的这样理解接口：接口是方法的抽象，如果不同的类有同样的方法，那么就应该考虑使用接口。 <br />例如，人和车都有“跑”的方法，那么就可以定义一个接口IR