C#基础知识

C#
一.如何编译cs文件：
 打开VS编译工具，通过cd+空格+文件路径，切换到指定编译地方。通过命令csc+空格+文件名.cs来编译，编译后可以直接运行生成的.exe文件。也可以在VS命令工具中键入文件名来查看运行结果。
二.C#变量：
 1.值类型：int,double,byte,float,enum,struct,char,bool.值类型都有一个引用类型与之相对应。
 2.引用类型：string,数组,类，接口，delegate.
三.类型转换：
 1.把小类型的数据赋值给大类型数据时候，系统自动进行隐式转换。反之则需要进行显式转换
 1强制转换：类型A a = (类型A) b;
 一般用于值类型与值类型间的转换或者引用类型间的转换。
 2通过Convert.ToType()进行转换；
 值类型与引用类型间的相互转换最好使用Convert转换。
四.string类型的字符拼接：
 通过@来全部转义，也可以通过斜杠"\"来转义
 

public static void Main()
 {
  //{"name":"小强","age":22,"book":"钢铁是怎样炼成的"}
  Console.WriteLine(@"{""name"":""小强"",""age"":22,""book"":""钢铁是怎样炼成的""}");
  string name = "小强";
  int age = 22;
  Console.WriteLine(@"{""name"":"""+name+@""",""age"":"+age+@",""book"":""钢铁是怎样炼成的""}");
  // insert into emp values(1001,'小强',34,89);
  // deletefrom emp where sid = var;
  int sid = 1001;
  Console.WriteLine("insert into emp values(1001,'小强',34,89)");
  Console.WriteLine(@"deletefrom emp where sid = "+sid+"");
 }

五.数组的定义
 1.Type[] 数组名 = new Type[size];
 2.Type[] 数组名 = {元素,……,元素};
 3.Type[] 数组名 = new Type[]{元素,……,元素};
 new操作符是在内存中开辟一段连续的空间。获取数组长度：数组名.Length。
六.C#函数
 [访问修饰符] [static] 返回值 函数名([参数列表])
 {
  //方法体
 }
 函数即方法即功能
 1.函数作用：1封装代码块，提高代码重用性2一个函数就是一个方法，实现一个功能。
 2.函数参数的传递：
 1.值传递(传递a,b变量中的值)
 

public static void Main()
 {
  int b = 7;
  Console.WriteLine(b);
 }
 public static void TestRef(int a)
 {
  a = 9;
 }

 2.址传递(传递的时变量的地址)
 

public static void Main()
 {
  int b = 7;
  TestRef(ref b);
  Console.WriteLine(b);
 }
 public static void TestRef(ref int a)
 {
  a = 9;
 }

 3.out传递(址传递，要求变量没有初值)

 public static void Main()
 {
  int b;
  TestOut(out b);
  Console.WriteLine(b);
 }
 public static void TestOut(out int a)
 {
  a = 24;
 }

  4.param可变长变量
  

public static void Main()
 {
  TestParams("1",2,3,4);
 }
 public static void TestParams(string a,params int[]a)
 {
  foreach(int i in a)
  {
   Console.WriteLine(i);
  }
 }

   注意：params变量类型是数组类型，在传递的时候可以传入一系列元素。一般情况可变长的params变量放到参数类表的最后面。
七.C#面向对象
 1.类：具有公共属性和方法的抽象和封装。
 [访问修饰符] class 类名
 {
 //类体;
 }
 类包含：成员变量、成员属性、成员方法。
 变量：成员变量一般是Private类型，在类外部使用通常需要把变量封装成属性。
 属性：对成员的变量进行的封装，使它具有读写权利。
 方法：成员变量即为成员函数亦等于成员功能
 [访问修饰符] 返回值 函数名([参数列表])
 {
 }
 2.对象：类实例化的具体成员。在程序中一切运行的基本单位都为对象。
 创建对象的过程就是把类中所有变量、属性、方法复制一份赋给对象的内存空间。
 对象即为成员即为实例
 3.构造函数：
 构造函数是用来创造函数的，能开辟出一个内存空间，放在堆里面。创造的对象指向堆的内存空间。构造函数没有返回值。
 [访问修饰符] 类名(构造函数名)
 {
 
 }
 构造函数名必须和类名一样。
 作用：1创建对象2初始化成员变量3实现对象的多元化
 默认情况下，系统会为类提供一个空的构造函数。自己增写构造函数后，默认的构造函数消失。
 4.函数的重载：
 具有相同方法名，但是参数类型、顺序、个数不同的函数互为重载。互为重载的函数必须位于一个类里面。
 5.this关键字：
 this关键字指得是当前对象。使用this关键字可以区别成员变量和参数，起到明确使用对象的作用。
 6.static关键字：
 通过static关键字修饰的方法、变量、属性是属于类的，不能通过对象来访问。(是谁的谁调用)。但是成员的方法可以直接调用static修饰的方法和变量，建议用类调用static修饰的方法和变量。static创建的变量和方法直至程序退出，内存空间才会释放。
      

public class StudyStatic
       {
  public static void Main()
  {
   People.sing();
  }
        }
 public class People
 {
  public static string name = "人类";
  public static void sing()
  {
   Console.WriteLine("这是类的方法");
   People p = new People();
   p.Test();
  }
  public void Test()
  {
   Console.WriteLine("这是成员方法");
  }
 }

 7.readonly关键字：
 由readonly修饰的关键字不能再赋值：public static readonly string name = "小强";
 8.新特性：
  1.属性
  可以直接写属性，不需要定义成员变量，也不需要具体实现get set 方法
 

 public class StudyNewProperty
  {
   public static void Main()
   {
    People p = new People();
    p.Name = "小强";
    p.Age = 1;
    p.Print();
   }
  }
  public class People
  {
   public string Name
   {
    get;set;
   }
   public int Age
   {
    get;set;
   }
   public void Print()
   {
    Console.WriteLine(Name + "今年" + Age + "岁了。");
   }
  }

        2.创建对象：
  可以直接给属性赋值，属性之间用逗号隔开。
 

 public class StudyNewProperty
  {
   public static void Main()
   {
    People p = new People(){Name = "小强",Age = 1};
    p.Print();
   }
  }
  public class People
  {
   public string Name
   {
    get;set;
   }
   public int Age
   {
    get;set;
   }
   public void Print()
   {
    Console.WriteLine(Name + "今年" + Age + "岁了。");
   }
  }

        3.var关键字和匿名对象
  可以通过var关键字标识任何类型的变量。
   通过new关键字来创建匿名对象，这个对象没有类型，属性可以随意定义，只能通过var关键字定义的变量来接收对象。

  public class StudyNewProperty
  {
   public static void Main()
   {
    var p = new People(){Name = "小强",Age = 1};
    p.Print();
    //匿名对象
    var a = new{forcolor = "yellow",leg = 4};
    Console.WriteLine(a.leg);
   }
  }
  public class People
  {
   public string Name
   {
    get;set;
   }
   public int Age
   {
    get;set;
   }
   public void Print()
   {
    Console.WriteLine(Name + "今年" + Age + "岁了。");
   }
  }

八.继承：
 继承是用来扩展自身功能，通过":"来实现继承。
 c#中只支持单继承，即一个类只能有一个直接父类。
 父类=基类=超类
 子类=sub类=派生类
 1继承中的构造函数：
  默认情况，子类中的构造函数调用的是父类默认的空的构造函数。
  父类中自定义了构造函数，则子类中必须显式的调用父类中任意一个构造函数(:base())
 

public class StudyExtend
 {
  public static void Main()
  {
   People p = new People("小强");
  }
 }
 public class WuDang
 {
  private string name;
  public WuDang()
  {
   Console.WriteLine("i'm first");
  }
  public WuDang(string str)
  {
   Console.WriteLine("i'm first");
  }
  public WuDang(string str,int i)
  {
   Console.WriteLine("i'm first");
  }
  public WuDang(int i )
  {
   Console.WriteLine("i'm first");
  }
  public string Name
  {
   get{return this.name;}
   set{this.name = value;}
  }
  public void Taiji()
  { 
  }
 }
 public class People : WuDang
 { 
  public People(string name) :base("aaa")
  {
   Console.WriteLine("I'm second");
  }
 }

 2方法的重写：
  当父类方法不能实现某功能，但却调用了此方法，则可以通过子类方法的重写，完善其功能。
  父类被重写的方法前面加上virtual关键字修饰。重写的子类方法前面加上override关键字。
  重写要求存在继承关系，而且重写的方法与被重写方法类型一致。
 3多态
  不同环境下充当不同的角色
    1上转型：子类对象赋值给父类对象；此时父类对象调用的是自己的属性、方法、变量或者是子类重写过的方法。
    用途：指定标准。根据具体实现不同，调用不同的方法，继而实现不同功能和样式。
 

public class StudyExtend
 {
  public static void Main()
  {
   //上转型
   WuDang w = new People();
   w.sing();
  }
 }
 public class WuDang
 {
  public virtual void sing()
  {
   Console.WriteLine("father");
  }
 }
 public class People : WuDang
 {  
  public override void sing()
  {
   Console.WriteLine("son");
  }
 }

    2下转型：把已经上转型的父类对象赋值给子类对象(需要强制转换)例如：People p =(People) w;
 

public class StudyExtend
 {
  public static void Main()
  {
   //上转型
   WuDang w = new People();
   w.sing();
   //下转型
   People p =(People) w;
   p.Test();
  }
 }
 public class WuDang
 {
  public virtual void sing()
  {
   Console.WriteLine("father");
  }
  public virtual void Print()
  {
   Console.WriteLine("fffff");
  }
 }
 public class People : WuDang
 {
  public override void sing()
  {
   Console.WriteLine("son");
  }
  public void Test()
  {
   Console.WriteLine("sssss");
  }
 }

 4抽象类：
  [访问修饰符] abstract class 抽象类名
 {
  //不能有构造函数
  //可以定义像普通类一样的变量、属性、方法
  //可以有抽象函数
 }
  

 public class StudyAbstract
 {
  public static void Main()
  {
   God.Say();
   YeSu y = new YeSu();
   y.sing();
   //抽象方法的调用
   y.Fun();
   //可以把子类的对象给抽象类变量，从而实现抽象方法调用。
   God g = new YeSu();
   g.Fun();
  }
 }
 public abstract class God
 {
  //类方法可以由抽象类直接调用
  public static void Say()
  {
   Console.WriteLine("Hello");
  }
  //抽象类没有构造函数，即不能通过new关键字创建对象，
  //无法直接调用成员方法。可以通过继承抽象类，实现
  //方法的调用。
  public void sing()
  {
   Console.WriteLine("哈利路亚");
  }
 //----------------抽象方法-----------------------//
  //抽象方法没有只有方法的定义，没有实现。
  public abstract void Fun();
  public abstract void Fun1();
  public abstract void Fun2();
 }
 //继承抽象类的子类必须实现抽象类中的全部抽象方法
 public class YeSu : God
 {
  public override void Fun()
  {
   Console.WriteLine("fly");
  }
  public override void Fun1()
  {
  }
  public override void Fun2()
  {
  }
 }

 5  sealed关键字 
  1如果sealed修饰类，这类不能被继承(绝育类)  pblic sealecd class(){}
  2如果sealed修饰方法，则方法不能被重写 public sealed void sing(){}
 6 interface

 为解决多继承问题而产生的特殊"类"。
 public interface 接口名
 {
  //只能写方法的定义和属性的定义（不能在接口里去实现方法或属性）
 }
 接口定义方法前面不能家public等修饰符
 在实现接口的时候不能在方法前加override关键字
 要继承类也要实现接口时候，必须把父类写前面，接口写在后面，中间都好隔开
 

public class StudyInterface
 {
  public static void Main()
  {
   //上转型
   UStorage u = new UStorage();
   Phone p = new Phone();
   KnowUSB(u);
   KnowUSB(p);
  }
  public static void KnowUSB(IUSB usb)
  {
   usb.know();
  }
 }
 public class A
 {
 }
 public interface IUSB
 {
  //只能编写方法或属性的定义，不能在接口中实现
  void know();
 }
 public class UStorage : A,IUSB
 {
  public void know()
  {
   Console.WriteLine("识别U盘");
  }
 }
 public class  Phone : IUSB
 {
  public void know()
  {
   Console.WriteLine("识别手机");
  }
 }