c# 基础 一些与c++不同的

0

对象（Object）类型

对象（Object）类型 是 C# 通用类型系统（Common Type System - CTS）中所有数据类型的终极基类。Object 是 System.Object 类的别名。所以对象（Object）类型可以被分配任何其他类型（值类型、引用类型、预定义类型或用户自定义类型）的值。但是，在分配值之前，需要先进行类型转换。

当一个值类型转换为对象类型时，则被称为 装箱；另一方面，当一个对象类型转换为值类型时，则被称为 拆箱。

object obj;

obj = 100; // 这是装箱

动态（Dynamic）类型

您可以存储任何类型的值在动态数据类型变量中。这些变量的类型检查是在运行时发生的。

声明动态类型的语法：

dynamic <variable_name> = value;

dynamic d = 20;

1

Console.ReadKey();

Console.ReadLine():

readline 按enter结束

readkey 按任意非功能键（字符） 结束

2

&  |   ^  与或非

~ 按位取反运算符是一元运算符，具有"翻转"位效果，即0变成1，1变成0，包括符号位。

<<   二进制左移运算符。左操作数的值向左移动右操作数指定的位数。

>>  二进制右移运算符。左操作数的值向右移动右操作数指定的位数。

3

Protected：只有该类对象及其子类对象可以访问

Internal：同一个程序集的对象可以访问；

Protected internal：该程序集内的派生类访问，是protected和internal的交集；

4

ref

则方法定义和调用方法都必须显式使用ref关键字。ref是 Reference的缩写。

5

out

使用 输出参数 来从函数中返回两个值。输出参数会把方法输出的数据赋给自己，其他方面与引用参数相似。

public void getValue(out int x )

      {

         int temp = 5;

         x = temp;

      }

int a = 100;

n.getValue(out a);

6

可空类型（Nullable）

可空类型可以表示其基础值类型正常范围内的值，再加上一个 null 值。

< data_type> ? <variable_name> = null;

Null 合并运算符（ ?? ）

如果第一个操作数的值为 null，则运算符返回第二个操作数的值，否则返回第一个操作数的值。

 double? num1 = null;

 num3 = num1 ?? 5.34;  

 Console.WriteLine("num3 的值： {0}", num3);

-----------num3 的值： 5.34

7

声明数组

datatype[] arrayName;

double[] balance;

double[] balance = new double[10];

balance[0] = 4500.0;

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

使用 foreach 循环

在前面的实例中，我们使用一个 for 循环来访问每个数组元素。您也可以使用一个 foreach 语句来遍历数组。

 int []  n = new int[10]; /* n 是一个带有 10 个整数的数组 */

 /* 初始化数组 n 中的元素 */         

 for ( int i = 0; i < 10; i++ )

 {

            n[i] = i + 100;

 }

         /* 输出每个数组元素的值 */

         foreach (int j in n )

  {

            int i = j-100;

            Console.WriteLine("Element[{0}] = {1}", i, j);

    }

j是从n中取得的值，第一个是100，第二个是101.。。第十个是109

Element[0] = 100

Element[1] = 101

Ele
ad98
ment[2] = 102

Element[3] = 103

Element[4] = 104

Element[5] = 105

Element[6] = 106

Element[7] = 107

Element[8] = 108

Element[9] = 109

8

using System;

namespace StringApplication

{

    class Program

    {

        static void Main(string[] args)

        {

           //字符串，字符串连接

            string fname, lname;

            fname = "Rowan";
            lname = "Atkinson";

            string fullname = fname + lname;

            Console.WriteLine("Full Name: {0}", fullname);

            //通过使用 string 构造函数

            char[] letters = { 'H', 'e', 'l', 'l','o' };

            string greetings = new string(letters);

            Console.WriteLine("Greetings: {0}", greetings);

            //方法返回字符串

            string[] sarray = { "Hello", "From", "Tutorials", "Point" };

            string message = String.Join(" ", sarray);

            Console.WriteLine("Message: {0}", message);

            //用于转化值的格式化方法

            DateTime waiting = new DateTime(2012, 10, 10, 17, 58, 1);

            string chat = String.Format("Message sent at {0:t} on {0:D}", 

            waiting);

            Console.WriteLine("Message: {0}", chat);

            Console.ReadKey() ;

        }

    }

}

显示

Full Name: RowanAtkinson

Greetings: Hello

Message: Hello From Tutorials Point

Message: Message sent at 17:58 on Wednesday, 10 October 2012

9 

结构体与类

1、类是引用类型，结构是值类型。（既然class是引用类型，class可以设为null。但是我们不能将struct设为null,因为它是值类型。）

2、结构不支持继承。

3、结构不能声明默认的构造函数。

10  

enum  枚举

enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };

默认情况下，第一个枚举符号的值是 0.

Days.Mon  1

Days.Fri  5

11 

类的 构造函数 是类的一个特殊的成员函数，当创建类的新对象时执行。
析构函数用于在结束程序（比如关闭文件、释放内存等）之前释放资源。析构函数不能继承或重载。

静态成员和静态函数

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

也可以把一个成员函数声明为 static。这样的函数只能访问静态变量。静态函数在对象被创建之前就已经存在。

using System;

namespace StaticVarApplication

{

    class StaticVar

    {

       public static int num;

        public void count()

        {

            num++;

        }

        public static int getNum()

        {

            return num;

        }

    }

    class StaticTester

    {

        static void Main(string[] args)

        {

            StaticVar s = new StaticVar();

            s.count();

            s.count();

            s.count();                   

            Console.WriteLine("变量 num： {0}", StaticVar.getNum());

            Console.ReadKey();

        }

    }

}

变量 num： 3

12 继承

基类 Person 和派生类 Employee 都有一个名为 Getinfo 的方法。通过使用 base 关键字，可以从派生类中调用基类的 Getinfo 方法。

using System;

public class Person

{

    protected string ssn = "444-55-6666";

    protected string name = "John L. Malgraine";

    public virtual void GetInfo()

    {

        Console.WriteLine("Name: {0}", name);

        Console.WriteLine("SSN: {0}", ssn);

    }

}

class Employee : Person

{

    public string id = "ABC567EFG";

    public override void GetInfo()

    {

        // Calling the base class GetInfo method:

        base.GetInfo();

        Console.WriteLine("Employee ID: {0}", id);

    }

}

class TestClass

{

    static void Main()

    {

        Employee E = new Employee();

        E.GetInfo();

    }

}

本示例显示如何指定在创建派生类实例时调用的基类构造函数。

using System;

public class BaseClass

{

    int num;

    public BaseClass()

    {

        Console.WriteLine("in BaseClass()");

    }

    public BaseClass(int i)

    {

        num = i;

        Console.WriteLine("in BaseClass(int i)");

    }

    public int GetNum()

    {

        return num;

    }

}

public class DerivedClass : BaseClass

{

    // This constructor will call BaseClass.BaseClass()

    public DerivedClass() : base()

    {

    }

    // This constructor will call BaseClass.BaseClass(int i)

    public DerivedClass(int i) : base(i)

    {

    }

    static void Main()

    {

        DerivedClass md = new DerivedClass();

        DerivedClass md1 = new DerivedClass(1);

    }

}

13

abstract class是抽象类.比如说,圆形和三角形都是形状.圆形和三角形有具体的表现方式,可以说是具体类.而形状没办法具体表现出来,就是抽象类.抽象类可以有自己的属性,可以有非abstract 的方法.

请注意，下面是有关抽象类的一些规则：

您不能创建一个抽象类的实例。

您不能在一个抽象类外部声明一个抽象方法。

通过在类定义前面放置关键字 sealed，可以将类声明为密封类。当一个类被声明为 sealed 时，它不能被继承。抽象类不能被声明为 sealed。

当有一个定义在类中的函数需要在继承类中实现时，可以使用虚方法。虚方法是使用关键字 virtual 声明的。虚方法可以在不同的继承类中有不同的实现。对虚方法的调用是在运行时发生的。

动态多态性是通过 抽象类 和 虚方法 实现的。

interface是接口.相当于某些具体对象的交叉点,这个点本身不能做什么,只能把操作传达给各个具体的对象,让对象自己去执行.接口的数据成员必须是静态且不能修改的(static final),所有的方法都是虚方法.