C# static看了就懂

    /// <summary>
    /// 可以在class前面加static看看里面会有哪些错误和提示
    /// </summary>
    public class Feige
    {
        /// <summary>
        /// 静态变量
        /// </summary>
        public static string hao = "hao";

        /// <summary>
        /// 无参构造函数
        /// </summary>
        public Feige()
        {

        }

        /// <summary>
        /// 多参构造函数
        /// </summary>
        /// <param name="str"></param>
        /// <param name="ii"></param>
        /// <param name="flag"></param>
        public Feige(string str, int ii, bool flag)
        {
            hao = str;
        }

        /// <summary>
        /// 静态构造函数
        /// </summary>
        static Feige()
        {

        }
        
        /// <summary>
        /// 静态方法
        /// </summary>
        /// <returns></returns>
        public static string GetName()
        {
            return "飞哥";
        }

        /// <summary>
        /// 带参数的非静态方法
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public string GetName(string name)
        {
            return name;
        }
    }

    /// <summary>
    /// 测试类，可以继承一下 Feige【加和不加static会有什么效果】
    /// </summary>
    public class Test
    {
        public void MyTest()
        {
            //在这里调用一下Feige中的成员看看那些能实现，那些不能实现，编译无法通过
            Feige feige = new Feige();
            feige.GetName();
            string ss = Feige.hao;
            Feige.GetName();
            static string ss = "";
        }
    }

经过static的反复添加和取消看完代码来总结如下

static称之为静态修饰符，开辟新的内存，调用速度快。

第一、 静态类

静态类：无法从静态类派生子类，无法实现构造方法【也就是说整个类无法实例化】，静态类中的变量和方法全部无法实例化，一切皆静态。

主要特性：

1：仅包含静态成员。

2：无法实例化。

3：是密封的。

4：不能包含实例构造函数。

第二、 静态变量

1.      具有全局性

2.      无论类创建多个对象，其中静态成员的共享一个副本

3.      C#不支持静态局部变量【不支持方法内部的静态变量，使用静态局部变量是无法通过编译的】

第三、 静态方法

1.      类直接调用

2.      不能在内部声明静态变量

3.      不能被实例的对象访问

4.      子类中静态方法即便和父类方法名称相同，也不会覆盖父类，得到的只是一个引用

第四、 静态构造方法

1.      不能使用修饰符，是无法携带参数的。【static后面加类名即可】

2.      不能在内部声明静态变量

3.      一个类只有一个静态构造函数

4.      最多只能运行一次

5.      不能被继承

6.      不声明静态构造方法，编译器会自动默认生成

7.      和构造函数不冲突