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;
writeline方法属于类}
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

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。