C# 常量，变量，字段，属性，方法

常量：指在程序编译时已经存在且在程序生命周期内不会发生改变的值，用const定义一个常量。

 

           private class TestA     --定义一个类时后边不加（）

            {

                 private const double Pi=3.14;

                 private double GetPi()   --输出pi值得方法，后边带（）

                {

                   double t=pi;

                   return t;

                }

            }

变量：

           变量本身被用来存储特定类型的数据，可以根据需要随时改变变量中所存储的数据值。变量具有名称、类型和值。变量名是变量在程序源代码中的标识。变量类型确定它所            代表的内    存的大小和类型，变量值是指它所代表的内存块中的数据。在程序的执行过程中，变量的值可以发生变化。使用变量之前必须先声明变量，即指定变量的类型和            名称。 

           变量可以存储值类型，也可以存储引用类型

           值类型变量：直接存储其数据值，主要包括整数类型，浮点类型和布尔类型。

           值类型变量在堆栈中进行分配，因此效率很高，使用值类型主要目的是为了提高性能，主要分为以下3种值类型。   

          （1）整数类型     

          （2）浮点类型    

          （3）布尔类型   

           引用类型变量:存储的是其数据值得引用，引用类型变量可以引用同一对象，这种情形下，对一个变量的操作会影响另一个变量所引用的同一对象。  u引用类型被赋值前的            值都是null。

   值类型和引用类型的区别:

          public class Test

          {

              public int a=3;   --值类型变量

             string ss="1234455":

              public string sq=ss;   --引用类型变量

          }   

   在变量类型后添加“?”表示可空值类型。
   例如:
    into a=null;

         以上代码VS会提示错误：无法将 Null 转换成 “int” ，因为它是一种不可以为 null 值的类型。

        但写成以下格式就不会报错了：

           int? a=null;

       值类型直接存储其值，而引用类型存储对其值得引用。值类型存储在内存的栈中，而引用类型在内存的堆中存在对值得引用地址。

 

      字段，属性

字段是构成类结构的一种元素，它不仅可以用C#内置类型进行声明，也可以用任意的自定义类型进行声明，很明显，它不仅可以保存一个值类型的实例，也可以保存一个引用类型的地址引用。字段可以直接定义在类或结构中。相比常量，它就多了一些特性，它不仅可以是类的状态数据，也可以是实例的状态数据，它默认并不是static，而是对象级的成员，除非明确指定其修饰符为static。字段可以使用的修饰符为： public、private、protected、internal 或 protected internal。另外，readonly也可以用于字段，如果再加上satic，此时它就相当于常量了，只不过对象级的字段初始化是在构造函数中进行的，类级的字段初始化是在静态构造函数中进行的。如下代码：

    public class Code_03
    {
        public const double PAI = 3.14;
        double radius = 20;
        static int a = 10;
        static readonly int b = 30;
    }

常量是在编译时计算，字段是在运行时计算，

const常量在声明处进行初始化，编译时直接将值编译进元数据，运行时不能进行值更改（如下面代码中的PAI）。

实例字段可在定义处和构造函数内进行初始化。可在任意处进行更改，如果其可访问性允许（如下面代码中的radius）。

static 字段声明为类级的字段，它属于类的状态数据。可在任意处进行更改，如果其可访问性允许（如下面代码中的a）。

readonly 字段声明只读字段，只能在构造函数内对其进行更改（如下面代码中的b）。

static readonly 字段声明静态只读字段，它属于类级且只读。只能在静态构造函数内对其更改（如下面代码中的c）。

 public class Code_03
    {
        public const double PAI = 3.14;
        double radius = 20;
        static int a = 10;
        readonly int b = 0;
        static readonly int c = 30;

        static Code_03()
        {
            a = 100;
            c = 1000;
            //错误 非静态的字段、方法或属性“ConsoleApp.Example03.Code_03.c”要求对象引用    
            //radius = 1;
            //b = -1;
        }
        public Code_03()
        {
            radius = 1;
            a = -1;
            b = -1;
            //错误 无法对静态只读字段赋值(静态构造函数或变量初始值中除外)
            //c = -1;
        }
        public void MyMethod()
        {
            radius = 1;
            a = -1;
            //错误 无法对静态只读字段赋值(静态构造函数或变量初始值中除外)
            //b = -1;
            //c = -1;
        }
    }

属性：

字段通常保存着类或对象本身的状态，我们当然可以将其公开为public让外界对其进行读、写修改。从某种意义上来讲，我们更希望在类本身内部对自己的状态进行维护，并不希望外界对自己的状态进行直接更改，以防止破坏这些数据，所幸的是还有一个数据成员可供使用，它就是属性。

如果在外部要访问某一个类的内部成员（私有字段），可以使用方法来达到目的，但如果对每一个字段都去编写一个方法来进行读写操作似乎又麻烦了些。属性以灵活的方式实现了对私有字段的访问，它是一种“访问器”方法，包括get方法和set方法，更明确地说，属性就是方法的精简写法的实现，隐藏了实现和验证的代码。它有两个访问器：

get访问器用于获取属性的值。

set访问器用于设定属性的值。既然它是方法，且是要在方法内对私有字段用新值进行更改替换，那么它就是可以（或者说是应该）接收参数的， value 关键字就是用于定义由 set 取值函数分配的值。假如有如下一个属性的定义：

public class Code_03_2
    {
        string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
    }

这个定义是通过属性Name对私有字段_name进行访问

我们已经看出来，属性是方法的实现，既然是方法，那方法就可以被访问修饰符定义，如public、private等，来限定方法的可访问性，很显然，我们也可以对属性的可访问性进行限定，这里是对访问器set和get进行访问限定的

属性还有一种更简洁的写法如下：

        public int Age { get; set; }
        public string Address { get; set; }

在编译的时候，编译器会自动生成对应的私有字段_age和_address，同样也会生成相应的get_方法和set_方法。

方法，函数

在了解方式之前我们应该先了解一下类和对象

  类：具有共同属性和行为的的同一类事物的集合，如人类，电脑类

  对象：对类的实例化成为对象，如人类中的张三，就是类的一个对象

 

定义一个人类，有Name和age属性
public class Person
{
     public string _name;
     pbublic string Name
    {
      get{this.Name=_name;}
      set{_name=value;}
    }
    public string _age;
    public string Age
   {
      get{this.Age=_age;}
      set{_age=value;}
    }

}

上边的代码是定了一个人类，有姓名和年龄这两个属性

那么张三是怎么出来的呢？

实例化：

Person person =New Person（）;

person.Name='张三';

person.Age=20;

(也可以简写为:Person person=new Person(){Name='张三',Age=20};)

这样就实话化出了一个人类的对象，张三

而方法 就是这些人类的可以做的行为，定义在类的内部，如张三可以喝水，生孩子

public class Person
{
    // 属性和字段的简写 在编译时声称Name的字段和get set 方法
   public string Name{get;set;}
   public int Age{get;set;}
   
   public string Heshui（）
  {
      string Name=this.Name;  
     return Name+"可以喝水";
  }
  

}

Person person=new Person(){Name='张三',Age=20};

person.heshui();

heshui就是Person类的一个方法，实例化一个对象之后就可以调用heshui()这个方法了。

 

 

 

常量，变量，方法等一般都有访问修饰符来限制访问权限

常用的访问修饰符有：

private:私有成员，在类的内部可以访问

public:公共成员，完全公开，没有访问限制

protected:保护成员，在类的内部和继承类中可以访问

internal：在同一命名空间内可以访问