一、C#静态和实例概念

静态概念：

公共的、全局的、不属于个别实例的定义。

加载时调用一次，占领内存，不会销毁。

实例概念：

new 出来的具体单个对象。

随着作用域定义，使用，销毁（多数实例，通过垃圾回收机制自动销毁）。

二、C#静态类和实例类

静态类：

1.全局公共封装类，使用 static class定义。

2.使用方式:类名.属性 、类名.方法

3.一般不为静态类，设置构造方法

4.静态资源程序启动时就加载，即可使用

常用的底层基础类库不少是静态类

例如：Syste.Math

实例类：

1.最常用的面向对象编程的类 使用class 定义

2.使用方式 需要 new 出对象后，才能使用。

  FileInfo file = new FileInfo(@"e://one.txt");

三、C#静态成员和实例成员

静态成员：

1.静态成员是属于“类”的或者说属于所有对象共有的

2.静态成员：静态属性，静态方法， 使用static 声明

3.静态成员，从当前类中可以直接使用； 从其他类中，需要通过 类名.静态成员 使用。

4.实例方法中可以访问静态成员，静态发放中不能直接访问实例成员。

实例成员：

1.需要 new 运算执行后才可使用

2.实例成员，可以归垃圾回收机制销毁，可以自定义销毁

举例说明静态成员使用：

static void Test2()
{
    //FileInfo file = new FileInfo(@"e://one.txt");

    Student stu1 = new Student();
    stu1.RealName = "张三";

    Student stu2 = new Student();
    stu2.RealName = "李四";
    Console.WriteLine($"系统中学生总数量：{Student.AllCount}");//打印2
}

public class Student
{
    /// <summary>
    /// 学生总数量
    /// </summary>
    public static int AllCount { get; set; } = 0;

    public string RealName { get; set; }
    public Student()
    {
        //没创建一个对象就累计一下
        AllCount++;
    }
}

更多：

 C# 字符串格式化_C# 字符串格式化整理

 C# 字符串拼接整理_C#字符串拼接方式整理

C# 项目结构整理_.Net 项目结构整理

1.1. 静态成员的声明

 在类定义中，关键字 static 声明 不绑定到类实例的成员( 该成员无需创建对象即可访问)

1.2. 静态数据成员的定义

静态数据成员定义的规则

。。。略； 

静态数据成员的定义规则复杂，在类外定义并初始化且不带static关键字，大部分情况况下不会出错，即使出错咱们也能根据编译器提示的错误信息，快速解决错误点

2. Static member (静态成员)

2.1. 静态数据成员具有静态存储期

2.2. 静态存储期

对象的存储在程序开始时分配，而在程序结束时回收 

(1)      只存在对象的一个实例（只有一份）

(2)      静态存储器对象未明确初始化时会被自动“零初始化（待会程序展示）

3. 实例成员和静态成员

在我下面的例子中，一旦实例化了Square（创建了Square的对象），每个对象中都有各自的side成员。这个side成员就叫做实例成员。 

而numberOfObjects只存在一个，是由所有的Square对象共享的，叫做静态成员。

class Square 
{

private:

  double side;

  static int numberOfObjects;

  // ...

public:

  Square():Square(1.0){}//这是C++11的代理构造

  Square(double side){this->side = side; numberOfObjects++;}

  // ...

};//类的声明，可单放在.h文件中

//xx.cpp文件
int Square::numberOfObjects;//静态成员在类外初始化，不写值，就默认为0，当然可以“ ....= 10；”
int main() {

    Square s1{}, s2{5.0};

}

总结：静态成员函数可以访问静态成员变量

           静态成员函数不可以访问非静态成员变量

           非静态成员函数可以访问静态成员变量

原因:非静态成员函数有this指针所以可访问该类的所有成员（当然包括属于该类的静态成员变量），静态成员函数没有this指针，故只能访问属于该类静态成员

关于总结部分，可自己用简单代码验证，可参考以下代码贴图：

前言：我们都知道，类是对象的抽象，对象是类的实例，对象有自己的属性和方法，万物皆对象，不可避免的，类也是一种对象，也有它自己的方法和属性，类的成员称为静态成员，包括静态数据和静态方法，而类实例化出的对象的成员称为实例成员。下面让我们来了解一下C#中的静态成员和实例成员。
　　静态成员（static member）：又叫类成员，指的是在成员类型或返回值类型前用static关键字修饰的变量或方法，包括静态数据和静态方法；
　　实例成员（instance member）：又称非静态成员、对象成员，是没有用static修饰的变量或方法，包括实例数据和实例方法。
　　不同点：表面看就是有没有被static修饰，其次是在内存分配上，类加载时，静态成员只只分配一次，有且只有一份存储空间。而对于实例成员，每产生一个实例都要重新分配一个存储空间。
　　特点之静态成员：
　　1）静态成员（包括静态数据和静态方法）必须由类名调用，不能使用对象调用（静态数据可以由实例方法调用）。
　　2）静态数据属于类的级别，当类加载时，一个静态数据在内存只分配一个存储空间，无论new出多少个实例，它也只是有那一个空间。
　　3）静态方法只能调用静态数据，不能调用对象。

特点之实例成员：
　　1）实例成员（包括实例数据和实例方法）必须通过对象来调用，不能使用类名调用。
　　2）类的实例数据属于类的实例级别，每新创建一个对象，都会在内存中为实例成员开辟一块新的存储空间。
　　3）实例方法可以调用实例数据和静态数据。
　　附：我们在C#中经常使用的WriteLine等方法都是静态成员，是直接调用类名Console来使用的。
　　让我们来用代码来说明方法对数据的调用情况：

class Demo
 
{
    int a;                // 实例数据
    static int b;         // 静态数据
    void A()              // 实例方法
 
    {
        a = 1;             // 正确：实例方法可以调用实例数据
        b = 1;             // 正确：实例方法可以调用静态数据
    }
 
    static void B()       // 静态方法
 
    {
        a = 1;             // 错误：静态方法不能调用实例数据
        b = 1;             // 正确：静态方法可以调用静态数据
    }
 
    static void Main()        // 静态方法
    {
        Demo d = new Demo();  // 实例化对象
        d.a = 1;              // 正确：实例可以调用实例数据
        d.b = 1;              // 错误：实例不能调用静态数据
        Demo.a = 1;           // 错误：类名不能调用实例数据
        Demo.b = 1;           // 正确：类名可以调用静态数据
        d.A();                // 正确：实例可以调用实例方法
        d.B();                // 错误：实例不能调用静态方法
        Demo.A();             // 错误：类名不能调用实例方法
        Demo.B();             // 正确：类名可以调用静态方法
    }
}

另外，让我们来用代码说明一下，静态数据只使用一块内存空间：

public class Demo
 
{
    static int count=0;  //定义静态数据count
    int number=0;        //定义实例数据number
    public Demo()
    {
	number =number+ 1;
        count = count + 1;        
    }
 
    public void show()
    {
        Console.WriteLine("number={0} : count={1}", number, count);
    }
}
 
class Test
{
    public static void Main()
    {
        Demo a = new Demo();
        a.show();
        Console.WriteLine("***************");
        Demo b = new Demo();
        b.show();
        Console.WriteLine("***************");
        Demo c = new Demo();
        c.show();
    }
}

输出结果为：
　　　　number=1 : count=1
　　　　********************
　　　　number=1 : count=2
　　　　********************
　　　　number=1 : count=3

可以看出：静态数据的值是随着实例化出的对象数目而改变的，每增加一个实例化对象都会使静态数据值+1，所以所有的对象都是使用的同一个静态数据，即证明了静态数据公用一块内存空间，而每个对象的实例数据都相同，说明每实例化一次都会开辟一块新的内存空间。