【C#】菜鸟教程学习笔记（二）

前言

这部分似乎依然是跟C++差不多的内容，不过鉴于我之前一直在写套着C++外皮的C……这部分内容还是稍微复习一下吧（心虚）

---

十.C#封装

封装：
把一个或多个项目封闭在一个物理的或者逻辑的包中。在面向对象的设计方法论中，封装是为了防止对实现细节的访问。
访问修饰符：
public，private，protected，internal，protected internal
不写明访问修饰符则默认为private。

Public访问修饰符

允许一个类将成员变量和成员函数暴露给其它的函数和对象（可以被外部的类访问）。

Private访问修饰符

允许一个类将其成员变量和成员函数隐藏，只有同一个类中的函数可以访问其死又成员。即使是类的实例也不能访问它的私有成员。

Protected访问修饰符

允许子类访问它的基类的成员变量和成员函数。这样有助于实现继承。（之后再讨论）

Internal访问修饰符

允许一个类将其成员变量和成员函数暴露给当前程序中的其它函数和对象。

Protected Internal 访问修饰符

符允许在本类，派生类或者包含该类的程序集中访问。这也被用于实现继承。

---

十一.C#方法

定义方法，调用方法。

<Access Specifier> <Return Type> <Method Name>(Parameter List)
{
   Method Body
}

参数传递：
值参数，引用参数，输出参数

值参数：

形参不影响实参。

引用参数：

形参改变时实参也会改变。传递的是内存位置。

//用ref表示引用参数
public void swap(ref int x, ref int y)
{
     int temp;
     temp = x; /* 保存 x 的值 */
     x = y;    /* 把 y 赋值给 x */
     y = temp; /* 把 temp 赋值给 y */
}
//...
n.swap(ref a, ref b);

输出参数：

return语句只能从函数中返回一个值，但是可以使用输出参数来从函数中返回两个值。
输出参数会把方法输出的数据赋给自己，其他方面与引用参数相似。

using System;
namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void getValue(out int x )
      {
         int temp = 5;
         x = temp;
      }

      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         //局部变量定义
         int a = 100;

         Console.WriteLine("在方法调用之前，a 的值： {0}", a);

         //调用函数来获取值
         n.getValue(out a);

         Console.WriteLine("在方法调用之后，a 的值： {0}", a);
         Console.ReadLine();
      }
   }
}

提供给输出参数的变量不需要赋值。当需要从一个参数没有指定初始值的方法中返回值时，输出参数特别有用。

using System;
namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void getValues(out int x, out int y )
      {
          Console.WriteLine("请输入第一个值： ");
          x = Convert.ToInt32(Console.ReadLine());
          Console.WriteLine("请输入第二个值： ");
          y = Convert.ToInt32(Console.ReadLine());
      }

      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         //局部变量定义
         int a , b;

         //相当于在函数中获取输入值
         n.getValues(out a, out b);

         Console.WriteLine("在方法调用之后，a 的值： {0}", a);
         Console.WriteLine("在方法调用之后，b 的值： {0}", b);
         Console.ReadLine();
      }
   }
}

---

十二.C#可空类型

C# 提供了一个特殊的数据类型，nullable 类型（可空类型），可空类型可以表示其基础值类型正常范围内的值，再加上一个 null 值。
例如，Nullable< Int32 >，读作”可空的 Int32”，可以被赋值为 -2,147,483,648 到 2,147,483,647 之间的任意值，也可以被赋值为 null 值。

//声明一个nullable 类型
< data_type> ? <variable_name> = null;

//例如：
int? num1 = null;
int? num2 = 45;
double? num3 = new double?();
double? num4 = 3.14157;
//输出的时候显示为空

Null 合并运算符用于定义可空类型和引用类型的默认值。Null 合并运算符为类型转换定义了一个预设值，以防可空类型的值为 Null。Null 合并运算符把操作数类型隐式转换为另一个可空（或不可空）的值类型的操作数的类型。
如果第一个操作数的值为 null，则运算符返回第二个操作数的值，否则返回第一个操作数的值。

double? num1 = null;
num3 = num1 ?? 5.34;
//则num3为5.34

---

十三.C#数组

声明数组：

datatype[] arrayName;
//例如：
double[] balance;

初始化数组：

double[] balance = new double[10];

给数组赋值：

double[] balance = new double[10];
balance[0] = 4500.0;

double[] balance = { 2340.0, 4523.69, 3421.0};

int [] marks = new int[5]  { 99,  98, 92, 97, 95};

int [] marks = new int[]  { 99,  98, 92, 97, 95};

int [] marks = new int[]  { 99,  98, 92, 97, 95};
int[] score = marks;

多维数组：

int [,] a = new int [3,4] {
 {0, 1, 2, 3} ,   /*  初始化索引号为 0 的行 */
 {4, 5, 6, 7} ,   /*  初始化索引号为 1 的行 */
 {8, 9, 10, 11}   /*  初始化索引号为 2 的行 */
};

int val = a[2,3];

交错数组（数组的数组）：

int[][] scores = new int[5][];
for (int i = 0; i < scores.Length; i++) 
{
   scores[i] = new int[4];
}

int[][] scores = new int[2][]{new int[]{92,93,94},new int[]{85,66,87,88}};

---

十四.C#字符串

要用的时候看看那些方法吧，别的好像也没什么……

http://www.runoob.com/csharp/csharp-string.html

---

十五.C#结构体

类和结构有以下几个基本的不同点：
1. 类是引用类型，结构是值类型。
2. 结构不支持继承。
3. 结构不能声明默认的构造函数。

---

十六.C#枚举

//第一个值为0
enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };

//要用的时候：
int WeekdayStart = (int)Days.Mon;

---

十七.C#类

类的默认访问标识符是internal。
构造函数和析构函数同C++。

静态成员static：
当我们声明一个类成员为静态时，意味着无论有多少个类的对象被创建，只会有一个该静态成员的副本。

using System;
namespace StaticVarApplication
{
    class StaticVar
    {
       public static int num;
        public void count()
        {
            num++;
        }
        public int getNum()
        {
            return num;
        }
    }
    class StaticTester
    {
        static void Main(string[] args)
        {
            StaticVar s1 = new StaticVar();
            StaticVar s2 = new StaticVar();
            s1.count();
            s1.count();
            s1.count();
            s2.count();
            s2.count();
            s2.count();         
            Console.WriteLine("s1 的变量 num： {0}", s1.getNum());
            Console.WriteLine("s2 的变量 num： {0}", s2.getNum());
            Console.ReadKey();
        }
    }
}

结果：

s1 的变量 num： 6
s2 的变量 num： 6

静态成员函数：
静态函数在对象被创建之前就已经存在。

---

总结

恩……今天太怠惰了，就看了这么多，感觉主要还是在复习C++的内容。
看了下后面的一些继承之类的东西，似乎也还是C++里学过的……当时我为什么不好好学习（