【C#】--基础（1）

1、名词解释

   .net/DotNet：一般指.Net Framework 框架，是一种平台，一种技术

    C#：一种编程语言，可以开发基于.net 平台的应用
    Java：既是一种技术，又是一种编程语言
    Winform：.net开发的桌面应用程序
    ASP.Net：.net开发的 Internet 应用程序
    WP7：.net可以用作的手机开发
    IDE：（Integrated Development ）集成开发环境
    ASCII（American Standard Code for Information Interchange，美国信息互换标准代码）
    MSIL：微软中间语言 Microsoft Intermediate Language
    CLR： 公共语言运行时 Common Language Runtime
       包括：CLS、CTS（相当于英语当中的单词和语法），CLR有一项服务称为GC （垃圾收集，Garbage Collector）
        CLS：公共语言规范 Common Language Specification    CTS：公共类型系统 Common Type System
    JIT：即时编译器 Just In Time
    BCL：基类库 Base Class Library
    CIL的术语是IL Intermediate Language
    MFC：微软基础类库 Microsoft Foundation Classes
    COM：组件对象模型 Component Object Model
    FCL：框架类库 Framework
    IDE：集成开发环境
    MSDN：百科全书 Microsoft Developer Network
    C/S：客户机（Client）/服务器模式（Server） 客户需要安装专用的客户端软件 如：qq
    B/S：浏览器（Browser）/服务器模式（Server） 客户机上只要安装一个浏览器
    C/S和B/S都必须要联网
2、数据类型
        int num = 100;//------>存的是整数类型的数据
        double douNum=0.12345;//---->小数类型的数据
        * decimal ：金钱小数，存储金钱，注意格式，如下：
        decimal deciNum=24.1234m;//---->也存小数，是金钱类型，注意数字后面的m
        char ch='A';//---->字符类型，只能存一个字符，不能为空
        string str="哈哈";//------>字符串类型，可以为空
    注意：命名规则   联网
3、常用的转义符
      \\ ：代表一个杠         \ ":代表一个双引号           \n：代表换行              \t：代表制表符，尽量与上面的内容对齐  

      \b：代表占位，如果前面有内容，那么就覆盖前面的内容
      @ ：该符号可以表示不转义，可表示路径
      有以下几种用法：
     （1）换行；（2）加在字符串的前面，使字符串失效；（3）表示路径
4、类型转换
 （1）：类型的自动转换
       参与运算的操作数首先数据类型一定要相同，除非两个操作数的类型相兼容，或者目标类型大于源类型。
       如：int类型和double类型相兼容，并且 double>int ，可以计算的。int 类型可以隐式转换成 double类型。
（2）：强制类型转换（显示转换）
       一定要兼容，但会丢失精度。举例说明为：int num=（int）10.5
       切记：int 转换为double 为隐式转换，多小数；double转换为int 为显示转换，丢精度。
（3）：其他
       程序需要用户输入时，用户输入的内容接收时都是字符串类型，若需要进行计算，可以通过 Convert.ToInt32（该例放入待转换的字符串类型的数字）
       如：int num=Convert.ToInt32(strNum);
       若用户输入的是小数，则：double num=Convert.ToDouble(strNum);
5、算术运算符和复合赋值运算符
 （1）：必须了解自加自减：++、--
           举例讲解：a++ 为先参与运算再进行自身的加1；++a恰好相反，为先进行自身的加1再参与运算。a--和--a的用法是一样的。
           由上可知： 一元运算符的定义：对于像++、--这样的只需一个操作数就可以进行运算的运算符称为一元运算符。
 （2）复合赋值运算符：+=、-=、*=、/=、%=
          举例讲解：int a=22;
          a *= 3; 就相当于 a=a*3； 最终a的结果输出为：66
          对于像如上的需要两个操作数才可以进行运算的运算符称为二元运算符。
         优先级：一元运算符比二元运算符高
      下面做个例题：

        int a,b=6,c=7;
        a=b++ * --c;       //此时a的输出结果为：36
     上题若改为： a=++b * c--;     //此时a的输出结果即为：49
6、判断语句、循环语句
   （1）if - else语句 （其中可以嵌套多个else if语句）
        **注意：if子句中的表达式必须等于布尔值 true 或 false。例如在C#中，常会出现一个编译错误，因为除非在处理bool值，否则“=”不会返回bool
      语法：

if （条件1）
{ //判断条件1是否正确，若正确则执行下面的 else if 语句 
else if （条件2）
{
语句1; //判断条件2是否正确，若正确则执行语句1
}
else 语句2; //若条件2不正确，则执行语句2
}
else 
{
语句3; //若条件1不正确，则执行语句3
}

  （2）switch - case 语句 （其中可以有很多个case的语句）
       语法：

switch （表达式\变量）
{
   case 值1：语句1； break；
   case 值2：语句2； break；
   ...
   default：语句n； break；
}

     执行过程：当程序运行时，先判断 “表达式\变量”，将该值与case语句逐个比较，若和值1匹配，则执行语句1，随后执行break，跳出循环，依次类推，执行所有的case语句；若都不匹配，则执行default下的 语句n ，再break，跳出循环。
（3）while 循环 （为先判断，再执行；至少执行了一次循环体）

int i=0;
while(条件/表达式)-------------------------------ài<某一个数
{
    循环体;
    i++; //若去掉i++ 这一行，则会造成死循环 
}   //若条件/表达式成立，则执行循环体；若不成立，则跳出循环，执行后面的代码

（4）do while 循环 （为先执行，再判断；有可能一次都不执行循环体）

do
{
   循环体;
}while(条件);

     执行过程:当程序运行到do的时候,直接进入里面的循环体;然后在走到while(条件)这行代码,进行判断,如果条件成立,就再一次执行里面的循环体,否则 直接 跳出循环.再执行后面的代码。
（5）for 循环

for(表达式1;表达式2;表达式3) //若去掉“表达式2”或“表达式3”，则造成死循环
{
循环体；
} //先运行“表达式1”，再运行“表达式2”，之后执行“循环体”，接着再运行“表达式3”，然后再运行“表达式2”，再执行“循环体”，以此类推，直至“表达式2”为不满足时，跳出循环，程序结束。

      #####---- break：跳出当前循环；continue：终止本次循环，但不跳出，并判断循环条件，若成立，则进入下一个循环，直至条件不成时退出循环。
7、三元表达式和输出
     语法：表达式1？表达式2：表达式3 例子：bool result=5>3?true:false，意思是判断“result=5>3”是否成立，若成立则输出“true”，否则为“false”。
     输出：int.Parse 等
8、常量、枚举、结构
    （1）常量：固定的始终不变的量
            语法：const 类型 常量名=常量值
            例子：const double Pi=3.14;
                     Pi=3.10; //若运行此语句，则出现错误提示：“赋值号左边必须是变量、属性或索引器”
    （2）枚举：一般把枚举写在命名空间中、类的外面，但是写在类里面是不报错的

enum 枚举名
{
值1,
值2,
... //值是固定的，不能轻易的改变，若改变，则下面的那个枚举值就会加一。枚举值的本质就是数字，但定义时一般不定义为数字
}

####----字符串与枚举的转换
        例子：(Gender)(enum.Parse(typeof(Gender),"male")) 即：（待转换的枚举类型）（Enum.Parse(typeof（待转换的枚举类型），待转换的字符串)）
####----int和枚举的转换，如下：

public enum jijie
{
   春,
   夏,
   秋,
   冬
}
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("请选择您想要的季节，0-春，1-夏，2-秋，3-冬");
        //string str = Console.ReadLine();
        //int num = Convert.ToInt32(str);
        //jijie ji = (jijie)num;
        //Console.WriteLine("您选择的是{0}",ji);
        //Console.ReadKey();
        int num = (int)jijie.夏;
        Console.WriteLine("{0}",num);
        Console.ReadKey();
    }
}

（3）结构（可以解决一次性声明多个不同类型的变量的问题）
       语法： 访问修饰符struct结构名
                {
                    定义结构成员
                 }
   例子：

class Program
{
    public struct Person
    {
        public string name; //前面加上了访问修饰符public之后就不再是变量，而是一个字段
        public int age;
        public char gender;
    }
    static void Main(string[] args)
    {
        Person zsPerson;
        zsPerson.name = "张三";
        zsPerson.age=22;
        zsPerson.gender='男';
    }
}

将枚举和结构合起来可以这样用：

public enum g
{ 
     男,
     女
}
public struct Person
{
    public string name;
    public int age;
    public g gender;
}
class Program
{ 
    static void Main(string[] args)
    {
       Person zsPerson;
       zsPerson.name = "张三";
       zsPerson.age=22;
       zsPerson.gender=g.男;
    }
}

9、数组
<1> 四种声明数组的类型：
    （1）int[] num1=new int[10]; //只声明长度为“10”的数组
    （2）int[] num2=new int[3]{11,24,55}; //声明长度为3的数组，且里面有对应个数的元素
    （3）int[] num3=new int[]{12,45,643,456,34}; //在声明数组时直接添加了元素，由元素的个数决定数组的长度
    （4）int[] num4={13,243,54,67}; //声明数组时直接添加元素，默认的数组长度就是元素的个数
<2> 存值：通过下标或者索引来存值、赋值。

        int[] nums=new int[10]; nums[0]=2; nums=[6]=5;
        取值：通过下标或者索引来取值。 Console.WriteLine(nums[5]);
<3> 数组的排序       Array.Sort(nums); Array.Reverse(nums);
     //自己查下冒泡排序法，挺简单的，这里不写了
10、try...catch 的简单用法

try
{
  //  有可能出现错误的代码
}
catch
{
  //  如果try中的代码出现异常，则转入catch中的代码
}

  try...catch 是让程序员看的，便于修改可能出现异常的代码
**11、方法
  作用：减少代码量，将很多重复的代码放在一起，用时直接调用就ok。（函数就是将一堆代码进行重用的一种机制）
        一个方法就是完成一个功能。
（1）方法的命名规则：
        <1>方法名开头大写，参数名开头小写，参数名、变量名要有意义。
（2）语法：
       [访问修饰符] static 返回值类型 方法名([参数列表]) ---->[]代表着可有可无，当前默认为：public
      {
           方法体;
　    }
     

   public static void Show()
　　{
　　    Console.WriteLine("如果你想要改变这个世界，那么你才能改变这个世界");　　
　　}

（3）方法的调用
       对于静态方法的调用，有两种方式： “类名.方法名();” 或者 如果在同一个类中，可以直接写“方法名();”
（4）静态方法 （只要在方法中看到static，那么这个方法就是静态方法）
（5）如果方法的返回值类型是 void ，则这个方法没有返回值；
            如果这个方法可以给变量赋值，我们就说这个方法有返回值，接受这个方法的变量决定了该方法的返回值类型。
            ruturn 返回变量的值并直接退出方法。
（6）方法的重载
           方法的重载就是说方法名可以相同，但是里面的参数个数不能相同，还有类型也不能相同。或者是参数个数可以相同，但是类型不能相同。
12、类
      语法：[访问修饰符]class类名
              {
                  成员；.....
              }
        类中可以包含变量的定义、方法
        类的实例化，用关键字new。 语法：类 实例名=new 类（）;
        类的成员访问 语法：实例名.属性 实例名.方法名（）;
        访问修饰符：public private(internal protected)
（1）属性
       字段用 public        修饰的问题...用 private
       属性的定义 get，set
       属性是为了保护与之相对应的字段，保证对字段的读取和赋值符合要求
       属性可以分为：读写、只读、只写 （属性中的get和set分别代表读和写）
       允许外部访问的变量一定要声明为属性
***** 给name的属性赋值，就相当于给字段赋值。类不占内存，但对象占内存
（2）类的构造函数
       构造方法用来创建对象，并且可以再构造函数汇总对对象进行初始化。构造函数可以重载，也就是有多个参数不同的构造函数。
（3）析构函数
           1> 不能再结构中定义析构函数，只能对类使用析构函数。
           2>一个类只能有一个析构函数
           3>无法继承或重载析构函数
           4>无法调用析构函数，因为它本身是被自动调用的
           5>析构函数没有修饰符，也没参数  

 --后记：这是我自己重新系统性的学习C#时做的小笔记，大多内容是基础性的理论知识，供自己参考，也分享给朋友们喽，@_@