C#学习笔记（二）—— 实例字段与静态字段

7.05 （实例字段与静态字段）

namespace 第七章_深入理解类_
{
    class D
    {
        int        Mem1;                        //实例字段
        static int Mem2;                        //静态字段

        public void SetVars(int v1, int v2)
        { Mem1 = v1; Mem2 = v2; }

        public void Display( string str)
        {
            Console.WriteLine($"{str}: Mem1 = {Mem1}, Men2 = {Mem2}");
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            D d1 = new D(); D d2 = new D(); D d3 = new D();

            d3.Display("d3");                   //都显示默认值0

            d1.SetVars(4, 5);                   //通过方法给字段赋值
            d1.Display("d1");                   //调用方法打出值,显示4,5   

            d2.SetVars(15, 17);
            d2.Display("d2");                   //显示15,17

            d3.Display("d3");                   //在直接输出字段值时，实例字段是默认值
                                                //而静态字段发生了改变，变成了17.
        }
    }
}

        7.10.04（属性和关联字段）

namespace _7._10._4_属性和关联字段_
{
    class c1                                    //属性属于函数成员
    {
        private int theRealValue = 10;          //后备字段，用于储存属性的数据，修饰词可改

        public  int MyValue                     //定义属性，属性并不分配内存
        {                                       //属性需要访问器，可只定义一个。
            set { theRealValue = value; }       //set为赋值访问器，可以执行任何运算
            get { return theRealValue; }        //get为读取访问器，可以执行任何运算
        }
    }

    internal class Program
    {
        static void Main(string[] args)
        {
            c1 c = new c1();

            Console.WriteLine($"MyValue：{c.MyValue}");  //读取属性的值

            c.MyValue = 20;
            Console.WriteLine($"MyValue：{c.MyValue}");  //读取改变后的属性的值

            c2 c2 = new c2();
            c2.FirstField = 2;
        }
    }
    class c2
    {                                           //后备字段命名约定
        private int firstField;                 //Camel大小写：第一个首字母小写
        public int FirstField                   //Pascal大小写:所有首字母都大写
        {
            set { firstField = value; }         //字段的值同时被改变
            get { return firstField; }          //读取属性，会返回字段的值
        }

        private int _secondField;               //第二种：下划线加Camel大小写
        public int SecondField
        {
            set {_secondField = value; }
            get { return _secondField; }
        }
    }
}

        7.10.05（属性执行其他计算）

namespace _7._10._5_执行其他计算_
{
    class s
    {
        int myValue ;

        public int MyValue
        {
            set { myValue = value > 100 ? 100 : value; }    //在构造器中进行运算，value是隐式参数，相当于形参
            get { return myValue; }
        }
    }

    internal class Program
    {
        static void Main(string[] args)
        {
            s s = new s();
            s.MyValue = 120 + 3;                            //调用属性
            Console.WriteLine(s.MyValue);  
        }
    }
}

        7.10.08（计算只读属性示例）

namespace _7._10._8
{
    internal class Program
    {
        class RightTriangle
        {
            public double A = 3;
            public double B = 4;
            public double Hypotenuse
            {
                get { return A + B; }                   //只读属性
            }
        }
        static void Main(string[] args)
        {
            RightTriangle C = new RightTriangle();
            Console.WriteLine($"{C.Hypotenuse}");
        }
    }
}

        7.10.09（自动实现属性）

namespace _7._10._9_自动实现属性_
{
    internal class Program
    {
        class c1
        {
            public int MyValue
            {
                set;get;                        
            }//自动属性，直接在set与get后加分号，编译器根据属性自动创建隐藏的后备字段
        }
        static void Main(string[] args)
        {
            c1 c1 = new c1();
            c1.MyValue = 1;
            Console.WriteLine($"MyValue: {c1.MyValue}");

            c1.MyValue = 10;
            Console.WriteLine($"MaValue: {c1.MyValue}");
        }
    }
}

        7.10.10（静态属性）

namespace ConsoleTestApp
{
    class Trivial{
        public static int MyValue { get; set; }     //自动静态属性
        public void PrintValue()
        {
            Console.WriteLine("Value form inside:{0}", MyValue);    //从类的内部直接访问静态属性
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Init Value:{0}",Trivial.MyValue);

            MyValue = 10;                                           //使用了using static，所以没有使用类名
            Console.WriteLine("Init Value:{0}", Trivial.MyValue);

            Trivial tr = new Trivial();
            tr.PrintValue();                                        //静态字段与其他静态成员相似
        }
    }
}

        7.11.1（构造函数）

namespace _7._11._1_构造函数_
{
    internal class Program
    {
        class Class
        {
            int ID;
            string Name;

            public Class()             { ID = 28;  Name = "Nemo"; }     //构造函数用于初始化类实例的状态
            public Class(int val)      { ID = val; Name = "Nemo"; }     //通过不同参数的设置，可以被重载
            public Class(String name ) { Name = name; }                 //构造函数必须与类名相同

            public void SoundOff()
            {
                Console.WriteLine($"name: {Name},ID: {ID}");
            }
        }
        static void Main(string[] args)
        {
            Class a = new Class();              //new后加类的某个构造函数，将使用改构造函数创建类的实例
            Class b = new Class(7);
            Class c = new Class("Bill");

            a.SoundOff();
            b.SoundOff();
            c.SoundOff();
        }
    }
}

        7.12（静态构造函数）

namespace program
{
    class RandomClass
    {
        public static int RandomKey = 3;

        static RandomClass()                    /*静态构造函数：在引用任何静态成员前
                                                                在创建任何实例之前被调用作为类级别的成员
                                                                一般是初始化静态字段，只执行一次初始化*/
        {
            RandomKey = 2;
        }

    }

    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine($"{RandomKey}");
            RandomKey = 1000;
            Console.WriteLine($"{RandomKey}");      //第二次调用并没有再次初始化值，显示的是1000而不是2

        }
    }
}