zoukankan      html  css  js  c++  java
  • C#修饰符详解

      不定期更新,2017.8.9

    一、new

      别看new这个修饰符经常用,恐怕很多人都不知道其本质。我们先来看看new修饰符的官方定义:

      new 仅允许在嵌套类声明中使用,表明类中隐藏了由基类中继承而来的与类中同名的成员。

      看懂了吗?不懂没关系,咱们接着往下看

      首先,我定义一个类:

     1 namespace 修饰符概念
     2 {
     3     class new修饰符
     4     {
     5 
     6         private string StrName;
     7 
     8         public string strName
     9         {
    10             get { return StrName; }
    11             set { StrName = value; }
    12         }
    13 
    14         private int IntPassWord;
    15 
    16         public int intPassWord
    17         {
    18             get { return IntPassWord; }
    19             set { IntPassWord = value; }
    20         }
    21 
    22         //上面是俩字段和属性,下面来构造,啊哈哈哈
    23         public new修饰符( )
    24         {
    25             strName = "我是蜀云泉";
    26             intPassWord = 1234567;
    27         }
    28     }
    29 }

    这个类里面有两个字段属性,一个构造,构造在new的时候会调用默认的那一个,其中构造的作用就是在new的时候初始化类数据。

      控制台代码及结果:

     1 namespace 修饰符概念
     2 {
     3     class Program
     4     {
     5         static void Main(string[] args)
     6         {
     7             new修饰符 vae = new new修饰符();
     8             Console.WriteLine(vae.strName);
     9             Console.WriteLine(vae.intPassWord);
    10             Console.ReadLine();
    11         }
    12     }
    13 }

      

    我的new修饰符这个类写完之后呢他是保存在硬盘中的,和内存没有半毛钱关系(除非这个类里面含有static关键字)。然后在控制台里面你new了一个该类类型的对象vae出来的时候,系统就会在内存中给这个对象vae分配一个该类大小的存储空间出来。就是这样。

    二、public修饰符

      来看看官方的定义

      public  表示不限制对该类的访问

      public应该就不用讲了吧,这个用的最多,只要一个成员定义成public之后呢,该类内部可以随意的访问他,其他类也可以随意的访问他,该类被继承之后其子类也可以随意的访问他。通俗的说就是“我的就是大家的,随意拿去用,别客气”

    三、protected修饰符

      来看看官方的定义

      protected  表示只能从所在类和所在类派生的子类进行访问

      看着官方的定义就应该明白了,我还是贴上代码吧:

      首先我新建一个类:  

     1 namespace 修饰符概念
     2 {
     3     class protected修饰符
     4     {
     5         private string StrName;
     6 
     7         protected string strName
     8         {
     9             get { return StrName; }
    10             set { StrName = value; }
    11         }
    12 
    13         protected void Start()
    14         {
    15             Console.WriteLine("这是被保护的一个方法");
    16         }
    17     }
    18 }

      在控制台里面调用这个类里面的方法试试行不行:

      

    namespace 修饰符概念
    {
        class Program
        {
            static void Main(string[] args)
            {
    
                 protected修饰符 vae = new protected修饰符();
                 vae.
                
                Console.ReadLine();            
            }
        }
    }

    结果是无法调用的。

    接下来看看子类能不能调用:

     1 namespace 修饰符概念
     2 {
     3     class protected类的继承者:protected修饰符
     4     {       
     5 
     6         public void test()
     7         {
     8             Start();
     9         }
    10     }
    11 }

    完全ok啊。

    那么接下来我要做一个猜想了,其子类的实例化对象能不能调用这个保护的方法呢?

    namespace 修饰符概念
    {
        class Program
        {
            static void Main(string[] args)
            {
               
                 protected类的继承者   vae = new protected类的继承者();
                 vae.test();
              
                Console.ReadLine();            
            }
        }
    }

    是可以的。好了,现在能完全了解protected的官方定义了吧。

    四、static

    static在百度百科里面介绍的已经很详细了,我再叙述一下吧。static分为静态字段和静态方法。存储在全局数据区,所以不占用类的空间大小。

    对于一个全局变量。全局范围内都可以访问到他。这是不用通过什么关系来找的,因为全局变量就摆在那里,大家都看得到,你爱访问就访问。

    对于一个静态的成员。它的访问原理跟全局变量是一样的。但是它隐身了,一般类人看不到它,但是它又设置了隐身对自己的类可见,那么那个类就可以看到它。

    一个全局变量不属于某个类,或某个函数。
    一个静态成员对象它属于某个类,但是它只有一个,这个类可以使用它,但是它是也公有财产,不属于某个对象。当你为一个对象分配空间时,不用再另外给它一个空间来放静态成员对象。所以你在sizeof()时,静态对象的大小没有影响。

    五、internal

      internal的意思就是只能在程序集中访问。

    例如下面,命名空间Test下的两个类

    namespace Test
    {
        internal class a
        {
             public void b()
             {
                 Console.Write("蜀云泉真帅");
             }
        }
        public class Write
        {
            public void WriteOut()
            {
                class x = new a();    
                x.b();
            }
        }
    }

    现在我外部想调用这个类里面的方法:

    //可以这么访问  
    Test.Write x = new Test.Write();
    x.WriteOut();
    //但不可以这么访问
    Test.a x = new Test.a();
    x.b();

    这就是internal的功能,只能在程序集中访问。

     六、sealed

      sealed是禁止继承的修饰符,例如类A定义了sealed,那么类A就不能被继承,同样,可以用在虚方法,虚属性上面。总之,就是防止被继承。 

  • 相关阅读:
    HashMap于Hashtable的区别
    redis分布式锁
    mybatis基本认识
    怎么获取硬件线程数,Future,创建线程
    查看端口号有什么在用
    javaScript 中的字符操作
    获取类里面的所有属性
    给Date赋值
    实现多人聊天
    客户端与服务器端执行报重置问题
  • 原文地址:https://www.cnblogs.com/yunquan/p/4905790.html
Copyright © 2011-2022 走看看