C#基础必读 修饰符、关键字、数据类型辨析

 

做些技术积累，高手不要见笑。因为C#有点Java和C++杂交的味道，太容易让人记混了。

指定声明的类型和类型成员的可访问性。

public：

                      访问不受限制, 任何地方都可以访问。

protected：

                       访问仅限于类或派生类。

private：

                     访问仅限于类

internal：

                      访问仅限于当前程序集。

protected internal：

                       访问仅限于当前程序集或派生类。

 -----------------------------------------------------------

 

一个成员或类型只能有一个访问修饰符

命名空间上不允许使用访问修饰符。命名空间没有访问限制。

不嵌套在其他类型中的顶级类型的可访问性只能是 internal 或 public。这些类型的默认可访问性是 internal。

类中成员的默认可访问性是private

命名空间中的类型可访问性只能是 internal 或 public。这些类型的默认可访问性是 internal。

 

------------------------------------------------------------

 abstract:

   抽象类

   不能被实例化

   可包含抽象方法和抽象属性

   派生类必须实现抽象基类的所有抽象成员，通过重写抽象成员实现。

 

 ------------------------------------------------------------

Sealed

   密封类         

   不能被继承 , 可防止意外的继承

   abstract 修饰符与密封类一起使用是错误的。

   结构是隐式密封的，因此它们不能被继承。

 

ps：我晕，Java中final关键字的翻版。

-------------------------------------------------------------

static

     静态类：

仅包含静态成员。

不能被实例化。不能使用 new 关键字创建静态类的实例

是密封的。

不能包含实例构造函数, 可包含静态构造函数 

-------------------------------------------------------------

成员修饰符

abstract：

         方法或属性不能实现。都是隐式虚拟，且在派生类中必须实现。       

const

      它指定字段（域）成员或局部变量的值是常数，不能被修改。

       不允许在常数声明中使用 static 修饰符 。

event：

              声明事件。

extern:

              指示方法在外部实现.
virtual:

             指示一个方法或属性可以被派生类改写.

override:  

           对由基类继承的虚（ virtual ）、抽象（abstract）的成员的新实现.

readonly:

           指示一个域成员只能在声明时以及相同类的构造函数中被赋值.

static:

          指示一个成员属于类,而不是属于类的实例.
可用于域成员、方法、属性、操作符、构造函数

-----------------------------------------------------------

此段摘自：

http://www.cnblogs.com/sutengcn/archive/2008/06/13/1219240.html

 

1，整型
    C# 支持九种整型：sbyte、byte、short、ushort、int、uint、long、ulong和 char。
    其中char类型比较特殊。虽然属于整型类别。但是以下两个方面不同于其他整型：
    1）不存在从其他类型到 char类型的隐式转换。具体说来，即使 sbyte、byte和 ushort类型具有完全可以用 char类型来表示的值范围，也不存在从 sbyte、byte或 ushort到 char的隐式转换。
    2）char类型的常数必须写成字符或带有强制转换为类型 char的整数。例如，(char)10与 '"x000A'是相同的。
2，浮点型
    C#的浮点型包括：float和double。
    float类型可表示精度为 7 位、在大约 1.5 × 10−⁴⁵ 到 3.4 × 10³⁸ 的范围内的值。double类型可表示精度为 15 位或 16 位、在大约 5.0 × 10−³²⁴ 到 1.7 × 10³⁰⁸ 的范围内的值。
    浮点型精度较低，不推荐两个浮点型之间比较大小的判断。
3，decimal类型
    decimal 类型是适合财务和货币计算的 128 位数据类型。
    decimal类型可以表示具有 28 或 29 个有效数字、从 1.0 × 10^-28 到大约 7.9 × 10²⁸ 范围内的值。
    decimal类型是采用四舍六入五考虑的银行家舍入法进行计算的。
4，值类型
 

 

PS： 这图不错！

------------------------------------------------------------------

const 、 readonly区别

   const 字段只能在该字段的声明中初始化。

   readonly 字段可以在声明或构造函数中初始化。

   因此，根据所使用的构造函数，readonly 字段可能具有不同的值。

   const 字段为编译时常数

   readonly 字段可用于运行时常数

   const 字段类外通过类名访问

   readonly 字段通过类实例（实例变量）或类（静态变量）访问

------------------------------------------------------------------

 对于那些本质上应该是常量，但是却无法使用const来声明的地方，可以使用static readonly

 

下面是一段关于C#继承与封装的程序，不过我估计这应该是最老的一个写法了，现在C#的语法糖，应该

已经有更方便的实现方式了，只不过我还没接触到。

 

using System;

namespace test{

public  class  Student{   
    
    private string student_id;  //学号
    private string student_name;  //姓名
    public static  string  information="---------学生上课情况表----------";
    public  Student(string id,string name)  //构造函数
    {
        student_id=id;
        student_name=name;
    }
    public string StudentID    // 用于访问私有字段 student_id的属性
    { 
        get 
        { return student_id;}
        set  
        {  student_id=value;}
     }
    public string StudentName  //   用于访问私有字段 student_name的属性
    { 
        get 
        { return student_name;}
        set  
        {  student_name=value;}
    }

    public string AddressClass(int i)
    {
        string CAddress;
        if(i==1)
        CAddress="2楼";  //研究生在2楼上课
        else
        CAddress="3楼";  //本科生在3楼上课
        return  CAddress;
    }
}

public class Graduate:Student{

    public  Graduate(string i, string j, string tn): base( i, j )
        {   teacher_name=tn;   }

    public string TeacherName  //   用于访问私有字段 student_name的属性
    { 
        get 
        { return teacher_name;}
        set  
        { teacher_name=value;}
    }
    
    private string teacher_name; //导师名
}

class AppStudent
{

    public static void Main(){

        Console.WriteLine("{0}",Student.information);
        Graduate gs=new Graduate("2007480***","哈哈","施杨");
        Console.WriteLine("研究生学号＝{0}",gs.StudentID);  //调用属性StudentID
        Console.WriteLine("研究生姓名＝{0}",gs.StudentName);  //调用属性StudentName
        Console.WriteLine("研究生上课地点＝{0}",gs.AddressClass(1));  //调用方法
        Console.WriteLine("教师姓名＝{0}",gs.TeacherName);
        Console.ReadLine();
    }

}

}

 

----------------------------------------------------------------------------------

  base关键字

         base 关键字用于从派生类中访问基类的成员

----------------------------------------------------------------------------------

方法的覆写与调用

 

 

using System;

namespace test{

 class  BaseClass{ 
  public void TestMethod(){
   Console.WriteLine("BaseClass:: TestMethod");
  }
 }
 class  DerivedClass:BaseClass{
  new public void TestMethod(){
   base. TestMethod();  //base访问基类中被隐藏的方法
   Console.WriteLine("DerivedClass:: TestMethod");
  }
 }

 class App
 {
   public static void Main(){

    DerivedClass  t =new DerivedClass();
    t.TestMethod();     //调用DerivedClass:: TestMethod（） 
    ((BaseClass)t). TestMethod();     //调用BaseClass:: TestMethod（）
    Console.ReadLine();
   }
 }

}

 

-------------------------------------------------------------------------------

引用参数：

      ref修饰符声明，不创建新的存储位置

      变量被作为实参传递前，自身必须被明确赋值。

      引用参数被认为是初始化过的。

 

      out修饰符声明,不创建新的存储位置

      变量被作为实参传递前，自身不需要明确地赋值。

      调用后，实参变量被认为已被明确赋值

      输出参数被认为是未初始化过的。

      返回之前，必须为每一个输出参数明确地赋值。

      实现多值返回

 

 

参量参数：

    params修饰符声明

    一个参量参数必须是形式参数列表中的最后一个

    参量参数的类型必须是一个单维数组类型。

    例如，类型int[]可以被用作参量参数类型，但是类型int[,]不能用。

 

using System;

namespace test{

class Test{
    static void F(params int[] args){
    Console.WriteLine("# of arguments: {0}", args.Length);
    for (int i = 0; i < args.Length; i++)
        Console.WriteLine("\t args[{0}] = {1}", i, args[i]);
    }
    static void Main(){
        F( ); 
        F(1, 2);
        F(1, 2, 3);
        F(new int[] {1, 2, 3, 4});
        Console.ReadLine();
    }
}
}

 

PS:Java里没有，个人觉得有点多余。

--------------------------------------------------------------------------------

 多态上要强于Java，因为Java中的子类中如果有与父类同名同参的方法，必须覆写，否则报错，而C#可以new一个方法，从而实现

在不改变父类方法的同时，新开辟一块内存空间，保存子类的同名同参方法。但是同样Java中的继承机制也没有C#复杂，但是也不失

简练，子类不用重写父类方法，就可以用super调用。Java中的接口对应C#中的虚函数。相对而言，比较习惯用Java的接口。

 

as运算符的功能与强制类型转换类似。

        可将一个对象强制转换为另一类型。

        如果源类型无法转换为目标类型，则首先将其置为null，然后再转换为目标类型