C# 为什么可以在一个类里声明并实例化自身类的对象

例子1：自身类的对象是静态字段，该字段属于类，而不属于该类的每个对象。

using System;

namespace NewSelfClassObject
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("C:{0}+N:{1}+O:{2}", Atom.C.Radius, Atom.N.Radius, Atom.O.Radius);
            // C# 6 引入了字符串前缀$
            Console.WriteLine($"C:{Atom.C.Radius}+N:{Atom.N.Radius}+O:{Atom.O.Radius}");
            Console.ReadLine();
        }
    }

    public class Atom
    {
        // 静态字段属于类而不属于具体对象（静态成员的地址空间在类的地址空间里，而不在每个对象的地址空间里）
        // 静态字段只可在静态构造函数中被赋值
        public static readonly Atom C; //Atom.C就表示碳原子对象，该对象里包含了碳原子的radius
        public static readonly Atom N; 
        public static readonly Atom O;

        public float Radius { get; set; }

        /// <summary>
        /// 有了自定义的构造函数，就不会自动生成默认无参构造函数，在别处使用Atom atom = new Atom();就会报错
        /// 这是私有的构造函数，说明只能在Atom类里实例化Atom的对象，也就是在静态构造函数中new出对象，
        /// 那么，其他地方要用Atom对象的话，就直接读上面那几个Atom对象就OK，别去每用一次Atom对象就new一次
        /// </summary>
        private Atom(float radius)
        {
            this.Radius = radius;
        }

        /// <summary>
        /// 只能用静态构造函数初始化静态变量，静态构造函数属于类，而不属于具体的对象，
        /// 也就是说这个构造函数只会被执行一次。也就是在创建类的第一个实例或引用类的任何静态成员之前
        /// </summary>
        static Atom()
        {
            C = new Atom(0.1f);
            N = new Atom(0.2f);
            O = new Atom(0.3f);
        }
    }
}

输出：

C:0.1+N:0.2+O:0.3
C:0.1+N:0.2+O:0.3

上述这种用法是OK的，经常用到的也不过是上述这种用法，这样用的目的是减少同一个类型new对象的次数。

例子2：自身类的对象是普通字段，该字段不属于类，而属于该类的每个对象。

// 链表节点类
private sealed class Node
{
    public char m_data;
    public Node m_next; // 是一个引用，指向下一个节点，默认为null

    public Node(char data) : this(data, null) { }

    public Node(char data, Node next)
    {
        m_data = data; 
        m_next = next;
    }

    public override String ToString()
    {
        return m_data.ToString() + ((m_next != null) ? m_next.ToString() : null);
    }
}

private static void SameDataLinkedList()
{
    Node head = new Node('C');
    head = new Node('B', head);
    head = new Node('A', head);
    Console.WriteLine(head.ToString());
}
//在Main中调用SameDataLinkedList()，输出：ABC