C# 静态static 嵌套类 分部类

/*static的相关内容:静态字段,静态属性,静态方法,,静态构造,静态类,readonly,const,嵌套类,分部类
 * static可以理解为全局的,共享同一块内存
 * 可以通过default(类型名)得到每个类型的默认值
 * 静态字段不从属于字段而是从属与类,而实例字段都是从属于每个字段,针对于每个字段都有不同的值
 * 类和对象都能关联数据;
 * this是用于实例的访问方法,所以你能用this.静态成员进行访问
 * 要想在静态方法中获得实例成员的访问,就必须先获得对字段或方法所从属于的那个特定的实例的引用,Main()就是静态方法
 * 静态构造器是用于对类(No is instance of Class)进行初始化,没有静态终结器的说法
 * 静态构造器不现实调用,相反,CLR在首次访问类的时候自动调用静态构造器,记住,静态构造函数是在运行时调用的,
 * 静态构造函数在编译成IL语言是变成.cctor(),而实例静态构造函数是.ctor()
 * 规范:应尽量使用内联(inline),不要使用静态构造函数进行初始化,也避免在声明是进行初始化
 * 静态构造函数是private 自己写的话不允许有修饰符
 * 由于静态构造器不允许显示调用,所以不允许任何参数
 * 有的类不包含任何实例成员,所以这种类就要declare为静态的类,也就是说静态类里面不包含instance成员,跟前面的学习可以知道,实例类可以包含静态成员
 * 静态类被编译成IL时会被标记为abstract和sealed表示不可扩展,不能从它派生出任何类
 * 静态类被编译曾CIL时,没有实例构造,静态构造是在CLR里面的
 * 学习英语:generated生成,via 通过,invoke调用,derived衍生的,nested嵌套的,literal字面的
 * 要将永恒不变的值声明为const常量,以后有可能要改变的declare为readonly(只能用于字段,不能用于据不变量)
 * readonly fileds cannot be set outside the costrustor.要不就直接在声明时设初值(只有两种情况下可以为readonly设置值:声明时,构造函数中)
 * 在类中可以定义一个类,称为嵌套类,在类中定义的类可以用private,但是在命名空间中只能定义internal和public;
 * 避免使用公共类型的嵌套类
 * 分部类是将一个类的定义划分到多个文件夹下,分布方法只能在分布类中,在编译的时候直接弄成一个类了
 * 分布方法不能有访问修饰符或virtual,abstract,override,new,sealed,huo extern修饰符
 * User: YuanWei
 * Date: 2015/1/15
 * Time: 16:30
 *
 *
 */
using System;

namespace LearningStatic
{
//    private class Person
//    {
//        //会报错:在命名空间中定义的元素无法显示的声明为private,protected或protected internal,但是可以声明为public和internal
//    }
    /*分部类:的主要作用是一个类的定义划分到多个文件中,常用于代码生成器,但也可以在同一个类中定义多个分部类
     *
     */
    public partial class Person
    {
        public string Name{get;set;}
        public double Height{set;get;}
        partial void Talk()//分布方法不能有访问修饰符或virtual,abstract,override,new,sealed,huo extern修饰符
        {}//私有的
    }
    public partial class Person
    {
        partial void Talk();
        public DateTime Birthday{get;set;}
    }
//    public class Program
//    {
//        //会报错,命名空间下已经包含了Program的定义,也就是说同一个明明空间下是不能包含出分部类以外的相同的类
//    }
    class Program
    {
        public static void Main(string[] args)
        {
            /*有一个灵感:如果想给某个类的实力成员做一个标记的话。可以定义一个static字段,构造函数里每次将这个值赋值给一个字段,然后进行自增
             * 那么这每个对象都有特定的标签了
             *
             */

            // TODO: Implement Functionality Here
            Person person=new Person();
//            person能够点出来所有的public成员;
            Employee employee=new Employee();
            Console.WriteLine(employee.PI.ToString());
            Console.WriteLine(Employee.ID.ToString());
            //Console.WriteLine(default(int));
            Console.WriteLine(Employee.Sex);
            Console.WriteLine(Employee.Name);
            Math.Abs(-1);
            Console.ReadKey(true);
        }
    }
    public class Employee
    {
        public readonly double PI=3.1415926;//实例只读字段,readonly 的值可以在构造函数中修改,而const不可以
        public readonly static int ID=23;//静态只读字段有两种写法,readonly的static可以交换,只能在静态构造函数和声明初始化的时候set value.
        public static readonly int Num=45;//正规的写法
        public const string Sex="female";//会自动转换成静态字段,所以可以通过类型名.Sex进行访问,所以通过实例是不能进行访问的
        public static string Name;
        public int Height;
        public static int Age{get;set;}//静态属性,封装了静态字段,安全度提高
        public static void Add()
        {
//            this.Name="YuanWei";//错误。不能用this访问静态成员
//            用this点不出来静成员
            Employee.Name="HongLi";//用类名能访问的是静态成员
//            this.Height=180;//,错误,用this(instance)访问的是实例成员,所以要想在静态方法中访问实例成员的话就要先获得特定对象的引用
            //this在静态属性,静态方法或静态字段初始值的设定无效
            Employee employee=new Employee();
            employee.Height=180;
            FirstEmployee.Age=20;//可以通过虚类.成员名调用
        }
        public double Say()
        {
//            PI=3.1415926;//会报错:Error: read-only fileds cannot be set outside the constructor or when declaring
            return Math.PI;
        }
//        public static Employee()//错误,静态构造函数是不允许出现访问修饰符,所以静态构造函数就是private的
//        {}
        /// <summary>
        /// 实例构造函数
        /// </summary>
        public Employee()
        {
         PI=3.14;//readonly修饰的可以在构造中修改
         Employee.Name="XiaoHong";
         Console.WriteLine("调用实例构造");
        }

        /// <summary>
        /// 静态构造函数
        /// </summary>
        static Employee()//优先级高,所以这里面的值会被后调用的值覆盖掉
        {
            Employee.Name="XiaoMing";
            Console.WriteLine("调用静态构造");
        }
    }
    /// <summary>
    /// 静态类
    /// </summary>
//    public static class NewEmployee:Employee//这种定义是错误的,报错原因是静态类必须从对象派生
//    {
//
//    }
    public static class NewEmployee//会自动生成一个静态构造
    {
        public const int MaxNum=123456;//自动编译成静态的literal字段
        public readonly static string N="nI";//编译成静态inionly string字段
//        public static const int MinVal=123;//错误,不能将常量标记为静态的
    }
//    public static class NewFirstEmployee:NewEmployee//错误,静态类也不能从静态类派生
//    {}
    public abstract class FirstEmployee:Employee//虚类可以从实例类进行派生
    {
        //会自动生成一个protected的构造函数
    }
//    public static class NewFirstEmployee:FirstEmployee//错误
//    {}
    public abstract class SecondEmployee//抽象类的构造函数都是protected的
    {
    }
}
时间: 2024-10-24 12:03:18

C# 静态static 嵌套类 分部类的相关文章

嵌套类 局部类

嵌套类 局部类 <c++ primer 3th> C++嵌套类 1.   嵌套类的名字只在外围类可见. 2.   类的私有成员只有类的成员和友元可以访问,因此外围类不可以访问嵌套类的私有成员.嵌套类可以访问外围类的成员(通过对象.指针或者引用). 3.   一个好的嵌套类设计:嵌套类应该设成私有.嵌套类的成员和方法可以设为 public . 4.   嵌套类可以直接访问外围类的静态成员.类型名( typedef ).枚举值. 嵌套类 一个类可以在另一个类中定义,这样的类被称为嵌套类.嵌套类是其

嵌套类和局部类

嵌套类和局部类在工作中极少使用,且均可在设计上替代,这里仅做简要介绍.1)局部类局部类就是将类定义在函数中.形如:int val = 100;void foo(int val){ struct Bar { }; class Bar::InsideClass//定义InsideClass类 { }; }2)嵌套类嵌套类就是将一个类定义在另一个类中.形如:class Interface{public:? ?virtual void Fun() = 0; ?};?template <class T,

ZeroC ICE源代码中的那些事 - 嵌套类和局部类

使用嵌套类(类中定义的类,c++没有静态类)或局部类(在函数或成员方法中定义的类),进行行为模式的委托(委托请求)或异步 . java中嵌套类和局部类隐式完成了你对外部对象(实例)访问的私有堆栈的初始化,而c++你必须通过类成员变量来保存你要访问到的 外部对象(变量,实例),即自行实现私有堆栈,并使用嵌套类和局部类的构造函数,以参数传递的方式初始化这些用作私有堆栈的成 员变量.当你的局部类(在函数中定义的类)要访问到函数的局部变量时,你并不能确保局部类在局部变量被释放前访问,所以你只能 将局部变

C++ 中的嵌套类和局部类

C++ 中的嵌套类和局部类 最近趁着春节假期空闲,找了本C++ Primer 学了几章,发现C++ 中的许多特性自己都不知道.其中嵌套类和局部类感觉还是蛮有用的,简单的写写他们的用法. 嵌套类 所谓嵌套类就是可以在一个类中定义另一个类.这个被嵌套的类的作用域就只在它的上一级类中.下面是个例子: #include <iostream> using namespace std; class c1 { public: int a; void foo(); class c2 { public: int

Java 嵌套类和内部类示例&lt;一&gt;

<span style="font-size:18px;">package nested_inner_class; public class StaticNestedTest1 { public static void main(String[] args) { //不需要实例化外部类,可以直接创建内部类对象 Outer1.Nested1 nested1 = new Outer1.Nested1(); System.out.println(nested1.getValue(

Java 嵌套类和内部类示例&lt;二&gt;

嵌套类(nested class)是一个在另一个类或接口内部声明的类.嵌套类分为两种:静态内部类(static inner class)和非静态嵌套类(non-static nested class).非静态嵌套类也称为内部类(inner class) <span style="font-size:18px;">package nested_inner_class; public class StaticNestedTest2 { public static void ma

Java 嵌套类和内部类示例&lt;三&gt;

<span style="font-family: Arial, Helvetica, sans-serif;"><span style="font-size:18px;">package nested_inner_class;</span></span> <span style="font-size:18px;"> public class StaticNestedTest3 { pu

Java中的嵌套类和内部类

以前看<Java编程思想>的时候,看到过嵌套类跟内部类的区别,不过后来就把它们的概念给忘了吧.昨天在看<数据结构与算法分析(Java语言版)>的时候,又遇到了这个概念,当时就很大的疑惑:嵌套类跟内部类有什么区别?只有是否有关键字static的区别吗? 所以今天找了个时间查了一下两者的详细区别,总结在这篇博客中,既方便自己的复习和学习,也启示他人吧. 1,概念: 定义在一个类内部的类,叫作"嵌套类".嵌套类分为两种:static的和非static的.后者又有一个专

Java 嵌套类(Nested Class):静态嵌套类,内部类,局部类,匿名类

 将一个人比作类,人由大脑.肢体.器官等组成,而嵌套类相当于其中的某个器官,例如心脏:它也有自己的属性和行为(血液.跳动). 嵌套类(Nested Class)的结构: //外部类 class Out { private int age = 12; //嵌套类 class In { public void print() { System.out.println(age); } } } public class Demo { public static void main(String[]