C#委托

函数重载

相同的函数名相同的签名是错误的，但是相同的函数名不同的签名是可行的。

委托

引用存储为函数的类型。生命使用delegate关键字，指定一个函数的签名，包含一个返回类型和参数列表。定义委托后，可以声明该委托类型的变量。初始化该变量使为和该委托有相同函数签名的函数引用使用。就可以使用委托变量来调用这个函数。对该变量的使用就如同使用函数一样。

    有了引用函数变量，可以执行其它方式无法完成的操作。：把委托变量作为参数传递给一个函数。则该函数就可以通过委托调用它引用的函数，而且在运行前不需要知道是哪个函数。

delegate double ProcessDelegate(double param1,double param2);
static double Multiply(double param1,double param2){return param1*param2;}
static double Divide(double param1,double param2){return param1/param2;}
Main(string[] args)
{
    string MainParam1,MainParam2;
    ProcessDelegate process;
    process=new ProcessDelegate(Multiply};
    Console.WriteLine("{0}",process(MainParam1,MainParam2));
    ProcessDelegate process2=new ProcessDelegate(Divide);
    Console.WriteLine("0",process1(MainParam1,MainParam2));
}
在委托引用函数的时候需要给出的是没有双引号的函数名而不是函数内部的参数。
面向对象编程oop
封装了部分应用程序的组件为对象。UMLUniversal Modeling Language语法研究类和对象。属性，字段，方法
对象的生命周期：构造阶段的构造函数，分配内存空间，初始化类的参数。
析构函数，对象占用的资源。
静态和实例类对象，静态成员，静态属性，静态方法，不需要实例化对象。
接口将隐式的公共方法和属性组合，封装成特定功能的一个集合。
继承：C#中的对象只能派生于一个基类。派生类不能访问基类的私有成员。但是派生类和外部代码都可以访问公共成员。派生类可以访问protected，基类和外部代码不可访问。同时，基

类可以定义为抽象类，这样不能实例化，需要通过继承类进行。
多态性：
继承的结果是派生于基类的类在方法和属性上面有一定的重叠。基类Animal有方法EatFood(),从派生类Cow和Chicken进行调用
Animal cow=new Animal();
Animal Chicken=new Animal();
cow.EatFood();
Chicken.EatFodd();
把某个基本类型的变量赋予其派生类型的变量。
Animal myAnimal=mycow;
基本类型的变量转换为派生类的变量，调用派生类的方法。
Cow mycow=(Cow)myAnimal;
mycow.Moo();
System.Object是继承层次的根。所有的对象可以看做为是类Object的一个实例。
接口的多态性：
建立接口类型的变量，可以在支持该接口的对象上，使用这个变量访问该接口提供的方法和属性。
不使用基类的方法EatFood()而是将该方法放入接口的内部，由于接口不提供执行代码，派生类Cow等支持接口，但是要提供接口内部该方法的执行代码：
Cow myCow=new Cow();
Chicken myChicken=new Chicken();
IConsume consumeinterface;
consumeinterface=myCow;
consumeinterface.EatFood();
consumeinterface=myChicken;
consumeinterface.EatFood();
对象之间的包含关系，集合关系，Animal[] animals=new Animal[5];

class myclass{};
internal class myclass{};
public class myclass{};
public abstract myclass{};
public seales myclass{};
规定派生类不能比继承的基类可访问性高：
public class mypubclass{};
internal class myinterclass:mypubclass{};
规定派生类继承时如果有基类要写在接口前面。
public class myclass:MyBase,InterFace1,InterFace2{}
none internal 只能在项目内访问
public 可以在任何地方访问
abstract Or internal abstract 只能在当前项目内访问，不能实例化，只能继承
sealed Or internal sealed 只能在当前项目中访问，不能派生，只能实例化
public sealed 能在任何项目访问，不能派生，只能实例化

namespace swk
{
 public abstract class mybase{}//公共抽象类
 internal class myclass:mybase{}//内部类
 public interface Imybaseinterface{}//公共接口
 internal interface Imybaseinterface2{}//内部接口
 internal interface Imyinterface:Imybaseinterface,Imybaseinterface2{}//内部接口继承了公共接口和内部接口
 internal Sealed class myComplexclass:myclass,Imyinterface{}
 class Class1
 {
  static void main(string[] args)
  {
   MyComplexclass myobj=new MyComplexclass();
   Console.writeLine(myobj.ToString());
  }
 }
 
 
}

class myclass
{
 public myclass(){};//构造函数
 public ~myclass(){};//析构函数
}

构造函数的队列
class mybaseclass
{
 public mybaseclass(){}
 public mybaseclass(int i){}
}
class myclass:mybaseclass
{
 public myclass(){}
 public myclass(){int i}
 public myclass(){int i,int j}
}

myclass myobj=new myclass();
构造队列：
System.object.Object();
mybaseclass.mybaseclass();
myclass.myclass();

myclass myobj=new myclass(4);
构造队列：
System.Object().Object();
mybaseclass.mybaseclass(int i);
myclass.myclass(int i);

myclass myobj=new myclass*3,5);
构造队列：
System.Object.Object();
mybaseclass.mybaseclass();
myclass.myclass(int i,int j);

public class mybase
{
 public mybase(){}
 public mybase(){int i}
}
public class myclass:mybase
[
 public myclass():base(i);
 public myclass(int i);
 public myclass(int i,int j);
}

myclass myobj=new myclass();
构造对列：
System.Object.Object();
mybase.mybase(int i);
myclass.myclass();

public class mybase
{
 public mybase(){};
 public mybase(int i){};
}
public class myclass:mybase
{
 public myclass():this(5,6){}
 public myclass(int i){};
 public myclass(int i,int j){}
}
myclass myobj=new myclass();
构造队列：
System.Object.Object();
mybase.mybase();
myclass.myclass(5,6);
myclass.myclass();

派生类只能继承于一个基类，只能直接继承于一个抽象类，可以通过继承链来继承多个抽象类。
类可以有多个接口。
 抽象类可以拥有抽象成员（没有代码体，必须在派生类中执行，否则派生类本身必须也是抽象的）和非抽象成员（它们拥有代码体，可以是虚拟的，可以在派生类中重写）。
 接口成员必须都在使用接口的类上执行，它们没有代码体。接口成员定义为公共的，倾向于外部使用，抽象类的成员可以是私有的，受保护的，内部的或受保护的内部成员（其中受保护的内部成员只能在应用程序的代码或派生类中访问），接口不能包含字段、构造函数、析构函数、静态成员或常量。

namespace
{
 public class myclass{public int myclassint;}
 struct mystruct{public int mystruct;}
 class class1
 {
  static void Main(string[] args)
  {
   myclass mc1=new myclass();
   myclass mc2=mc1;
   mc1.myclassint=10;
   mc2.myclassint=20;
   mystruct mys1=new mystruct();
   mystruct mys2=mys1;
   mys1=10;
   mys2=20;
  }
 }
}
myc1=20;
myc2=20;
mys1=10;
mys2=20;

public 认可代码可以访问
private 由类中的代码访问
internal 项目内部的代码访问
protected 类中的代码或者派生类可以访问

public readonly 公共只读 readonly说明只能在构造函数里面给初值

Class myclass
{
 public string getString()
 {
  return "hear is a string";
 }
}
virtual 可以重写
abstract 方法必须重写
override 重写了以个基类的方法，当方法被重写，必须使用该关键字
extern 方法定义在其它地方

public class myclass
{
 public virtual DoSomething()
 {
  //base implementation
 }
}
public class mysecondclass:myclass
{
 public override DoSomething()
 {
  //SecondClass implenmentation,overrides base implementation
 }
}

可以使用Sealed关键字，说明方法不能在派生类中进一步的修改
public class mysecondclass:myclass
{
 public Sealed DoSomething()
 {
  //SecondClass implenmentation,overrides base implementation
 }
}

对于属性的定义：get set
public class myclass
{
 private int myint;
 public int MyintPop
 {
  get{return myint;}
  set{if(value<10&&value>3)myint=value;else throw(new ArgumentOutOfRangeException("MyintPop",value,"MyintPop值要在0~10之间"));}
 }
}

using System;

namespace Try
{
 ///

  }
  public int ValIntPop//公共属性
  {
   get
   {
    return valint;//读取属性
   }
   set
   {
    if(value>=0&value<=10){valint=value;}//设置属性，超出范围输出异常
    else{throw(new ArgumentOutOfRangeException("MyValInt",value,"ValIntPop定义在10～0之间"));}
   }
  }
  public override string ToString()//重写ToString()
  {
   return "value:"+valint+"Name:"+name;
  }

 }
}