C#static关键字

静态字段
某些特定数据在内存中只有一份，并且可以被类的所有实例对象共享。(例如某校学生共享一个学校名称，不需要每个学生对象占用内存创建学校名称。)调用方法：类【名.成员名】

代码：

        static void Main(string[] args)
        {
            SchoolName s1 = new SchoolName();//实例化对象
            SchoolName s2 = new SchoolName();
            Console.WriteLine("s1同学毕业于：" + SchoolName.schoolName);//访问成员：【类.成员名】
            Console.WriteLine("s2同学毕业于：" + SchoolName.schoolName);
            Console.ReadKey();
        }
        class SchoolName
        {
            public  static string schoolName="五道口职业技术学院";
            //类中定义public类型的静态字段；不能定义private类型否则无法访问
        }

拓展①：调用static成员不能通过对象来访问，否则会报错。

静态属性
用static修饰的属性被称为静态属性，它可以读写静态字段的值，调用方法：【类名.属性名】

代码：

		static void Main(string[] args)
        {
            Student s1 = new Student();
            Student s2 = new Student();
            Console.WriteLine("s1同学毕业于：" + Student.SchoolName);//通过静态属性调用字段
            Console.WriteLine("s2同学毕业于：" + Student.SchoolName);
            Console.ReadKey();
        }
        class Student
        {
            private static string schoolName = "五道口职业技术学院";//定义private静态字段
            public static string SchoolName//通过get/set属性对字段进行赋值
            {
                get
                {
                    return schoolName;
                }
                set
                {
                    schoolName = value;
                }
            }
        }

静态方法
在不需要实例化对象的情况下可以直接调用类中的方法，能够让对象与方法不绑在一起调用方法：【类名.方法名】

代码：

		static void Main(string[] args)
        {
            Person.Print();
            //static方法调用无需创建对象，直接通过【类.方法名】直接调用
            Console.ReadKey();
        }
        class Person//创建类
        {
            public static void Print()//类中有一个普通方法
            {
                Console.WriteLine("静态方法【类.方法名】直接调用。");
            }
        }

拓展①：在静态方法中可以直接访问静态方法

        static void Main(string[] args)
        {
            Person.Test();
            //static方法调用无需创建对象，直接通过【类.方法名】直接调用
            Console.ReadKey();
        }
        class Person//创建类
        {
            public static void Test()
            {
                Console.WriteLine("Test静态方法");
                Test1();
                //静态方法中访问Test1静态方法
            }
            public  static void Test1()
            {
                Console.WriteLine("Test1静态方法");
            }
        }

拓展②：在非静态方法中可以访问静态方法

		static void Main(string[] args)
        {
            //Person.Test();
            //static方法调用无需创建对象，直接通过【类.方法名】直接调用
            Person p = new Person();
            p.Test2();//通过对象调用类中普通方法
            Console.ReadKey();
        }
        class Person//创建类
        {
            public static void Test()
            {
                Console.WriteLine("Test静态方法");
                //静态方法中访问Test1静态方法
            }
            public  static void Test1()
            {
                Console.WriteLine("Test1静态方法");
            }
            public void Test2()
            {
                Console.WriteLine("Test2非静态方法");
                Test();
                Test1();
                //非静态方法中可以调用静态方法
            }
        }

拓展③：在静态方法中不能访问非静态方法

拓展④：在非静态方法中可以访问非静态方法

		static void Main(string[] args)
        {
            //Person.Test();
            //static方法调用无需创建对象，直接通过【类.方法名】直接调用
            Person p = new Person();
            p.Test2();//通过对象调用类中方法
            Console.ReadKey();
        }
        public void Test2()
           {
               Console.WriteLine("Test2非静态方法");                
               Test3();
               //非静态方法中能够访问非静态方法
           }
        public void Test3()
           {
               Console.WriteLine("Test3非静态方法");
           }

总结：
静态方法能够在非静态方法和静态方法中被访问
非静态方法能够通过非静态方法访问，不能通过静态方法访问

静态类—永远不需要实例化
当类中全部成员为静态时，就可以把这个类声明为静态类
特点：
①：不能实现任何接口
②：内部所有成员均为静态
③：静态类是密封的，不能被继承

格式：

static class 类
        {
            //成员均为静态
        }

代码：

       static void Main(string[] args)
        {
            Student.Print();//直接访问静态方法
            Console.ReadKey();
        }
        static class Student//静态类
        {
            private static string name = "Aucl";//静态字段
            public static void Print()//静态方法
            {
                Console.WriteLine("我的名字叫：" + name);
            }
        }

静态构造方法
与构造方法功能一样，静态构造方法的作用同样是初始化静态成员。调用方法：类名.方法名

代码：

        static void Main(string[] args)
        {
            Person.Print();//调用静态方法
            Console.ReadKey();
        }
        class Person//类
        {
            private static string name;
            private static string tel;
            static Person()//静态构造函数初始化静态成员
            {
                name = "Aucl";
                tel = "001";
            }
            public static void Print()//定义静态方法
            {
                Console.WriteLine("我的名字是：" + name + ",电话号码：" + tel);
            }
        }

注意：
①：一个类只有一个构造方法，否则会报错。

②：该静态构造方法没有任何修饰符，也没有参数。
格式：

static 类名()
{
	//初始化静态成员
}

③：静态构造方法可以在静态类中也可以在非静态类中。
④：程序会在创建第一个实例或者引用任何静态成员之前完成类中静态成员初始化。（？？？）
测试

单例模式
概念：编程过程中一些典型问题，需要特定的代码结构，经过优化后，形成的一种编程风格来解决问题的思想行为：设计模式。单例模式是C#的设计模式，它在设计类时，需要程序运行期间只存在一个实例对象。

单例模式中类的格式：

        //类 对象名 = 类.public方法
		//创建对象
        /*单例模式-->【设计类时，需要保证整个程序运行期间只有一个实例对象】
         class 类名
         {
             private static  类名 变量 = new 类();
             //类内部创建该类的实例对象，使用私有private的静态变量引用
             private 类(){}  
             //创建无参的构造方法
             public static 类名 方法名()
             {
                return 变量;
             }
             //定义静态方法返回实例对象（静态只能访问不能修改）
         }

代码：

        static void Main(string[] args)
        {
            Single a = Single.SingleMethod();
            Single b = Single.SingleMethod();
            //创建对象，★在单例模式的类中已经实例化对象，所以我们直接通过类.方法放回实例化对象即可
            Console.WriteLine(a== b);//最终输出：True
            Console.ReadKey();
        }
        class Single// 单例模式的类名可以随意命名
        {
            private static Single single = new Single();//private的实例对象
            private Single() { }                        //private的无参构造函数
            public static Single SingleMethod()        //public类型的静态方法，返回类内部的实例对象
            {
                return single;
            }
        }

清明时节雨纷纷，路上行人欲断魂