精华内容
下载资源
问答
  • 区别对待作废标准被代替标准
  • 老年人关节有响声需区别对待
  • 建议94:区别对待overridenew overridenew使类型体系应为继承而呈现出多态性。多态要求子类具有与基类同名的方法,overridenew的作用就是: 如果子类中的方法前面带有new关键字,则该法被定义为独立于基类的...

    建议94:区别对待override和new

    override和new使类型体系应为继承而呈现出多态性。多态要求子类具有与基类同名的方法,override和new的作用就是:

    • 如果子类中的方法前面带有new关键字,则该法被定义为独立于基类的方法。
    • 如果子类中的方法前面带有override关键字,则子类的对象将调用该方法。而不调用基类的方法。

    我们来看一个继承体系:

    复制代码
            public class Shape
            {
                public virtual void MethodVirtual()
                {
                    Console.WriteLine("base MethodVirtual call");
                }
    
                public void Method()
                {
                    Console.WriteLine("base Method call");
                }
            }
    
            class Circle : Shape
            {
                public override void MethodVirtual()
                {
                    Console.WriteLine("circle override MethodVirtual");
                }
            }
    
            class Rectangle : Shape
            {
    
            }
    
            class Triangle : Shape
            {
                public new void MethodVirtual()
                {
                    Console.WriteLine("triangle new MethodVirtual");
                }
    
                public new void Method()
                {
                    Console.WriteLine("triangle new Method");
                }
            }
    
            class Diamond : Shape
            {
                public void MethodVirtual()
                {
                    Console.WriteLine("Diamond default MethodVirtual");
                }
    
                public void Method()
                {
                    Console.WriteLine("Diamond default Method");
                }
            }
    复制代码

    Shape是所有子类的基类。

    Circle类override父类的MethodVirtual,所以即使子类转型为Shape,调用的还是子类方法:

                Shape s = new Circle();
                s.MethodVirtual();
                s.Method();

    输出为:

    circle override MethodVirtual
    base Method call

                Circle s = new Circle();
                s.MethodVirtual();
                s.Method();

    输出也为:

    circle override MethodVirtual
    base Method call

    类型Rectangle没有对基类做任何处理,所以无论是否转型为Shape,调用的都是基类Shape的方法。
    类型Triangle将基类Shape的virtual方法和非virtual方法都new了一般,所以第一种方法为:

                Shape s = new Triangle();
                s.MethodVirtual();
                s.Method();

    因为子类应经new了父类的方法,故子类方法和基类方法完全没有关系了,只要s被转型为Shape,针对s调用搞得都是父类方法。

                Triangle triangle = new Triangle();
                triangle.MethodVirtual();
                triangle.Method();

    调用的都是子类方法,输出为:

    triangle new MethodVirtual
    triangle new Method


    类型Diamond包含了两个和基类一模一样的方法,并且没有额外的修饰符。这在编译器中会提出警示。但是如果选择忽略这些警示,程序还是一样可以运行。

                Shape s=new Diamond();
                s.MethodVirtual();
                s.Method();

    编译器会默认new的效果,所以输出和显示设置为new时一样。

    输出为:

    base MethodVirtual call
    base Method call

                Diamond s = new Diamond();
                s.MethodVirtual();
                s.Method();

    输出为:

    Diamond default MethodVirtual
    Diamond default Method
    最后给一个综合示例:

    复制代码
     static void Main(string[] args)
            {
                TestShape();
                TestDerive();
                TestDerive2();
            }
    
            private static void TestShape()
            {
                Console.WriteLine("TestShape\tStart");
                List<Shape> shapes = new List<Shape>();
                shapes.Add(new Circle());
                shapes.Add(new Rectangle());
                shapes.Add(new Triangle());
                shapes.Add(new Diamond());
                foreach (Shape s in shapes)
                {
                    s.MethodVirtual();
                    s.Method();
                }
                Console.WriteLine("TestShape\tEnd\n");
            }
    
            private static void TestDerive()
            {
                Console.WriteLine("TestDerive\tStart");
                Circle circle = new Circle();
                Rectangle rectangle = new Rectangle();
                Triangle triangel = new Triangle();
                Diamond diamond = new Diamond();
                circle.MethodVirtual();
                circle.Method();
                rectangle.MethodVirtual();
                rectangle.Method();
                triangel.MethodVirtual();
                triangel.Method();
                diamond.MethodVirtual();
                diamond.Method();
                Console.WriteLine("TestShape\tEnd\n");
            }
    
            private static void TestDerive2()
            {
                Console.WriteLine("TestDerive2\tStart");
                Circle circle = new Circle();
                PrintShape(circle);
                Rectangle rectangle = new Rectangle();
                PrintShape(rectangle);
                Triangle triangel = new Triangle();
                PrintShape(triangel);
                Diamond diamond = new Diamond();
                PrintShape(diamond);
                Console.WriteLine("TestDerive2\tEnd\n");
            }
    
            static void PrintShape(Shape sharpe)
            {
                sharpe.MethodVirtual();
                sharpe.Method();
            }
    复制代码

    输出为:

    TestShape       Start
    circle override MethodVirtual
    base Method call
    base MethodVirtual call
    base Method call
    base MethodVirtual call
    base Method call
    base MethodVirtual call
    base Method call
    TestShape       End

    TestDerive      Start
    circle override MethodVirtual
    base Method call
    base MethodVirtual call
    base Method call
    triangle new MethodVirtual
    triangle new Method
    Diamond default MethodVirtual
    Diamond default Method
    TestShape       End

    TestDerive2     Start
    circle override MethodVirtual
    base Method call
    base MethodVirtual call
    base Method call
    base MethodVirtual call
    base Method call
    base MethodVirtual call
    base Method call
    TestDerive2     End



     

    转自:《编写高质量代码改善C#程序的157个建议》陆敏技

    展开全文
  • Tip11 区别对待==Equals “相等性”分为两类: 1、“值相等性”——比较的两个变量所包含的数值相等。 2、“引用相等性”——比较的两个变量引用的是内存中的同一个对象。“==”“Equals”都倾向于表达这样一...

    Tip11 区别对待==和Equals
    “相等性”分为两类:
    1、“值相等性”——比较的两个变量所包含的数值相等。
    2、“引用相等性”——比较的两个变量引用的是内存中的同一个对象。

    “==”和“Equals”都倾向于表达这样一个原则:
    对于值类型,如果类型的值相等,就应该返回True。
    对于引用类型,如果类型只想同一个对象,则返回True。

    “==”和“Equals”都可以被重载。比如,string是引用类型,但是在FCL中被重载为针对“类型的值”的比较,而不是针对“引用本身 ”的比较。下面举个例子:

    类型Person,如果两者的IDCode相等,我们就认为是同一个人,这时就需要重载Equals方法

        class Person
        {
            public string IDCode { get; private set; }
    
            public Person(string idCode)
            {
                this.IDCode = idCode;
            }
    
            public override bool Equals(object obj)
            {
                return IDCode == (obj as Person).IDCode;
            }
        }
    
    
                object a = new Person("NB123");
                object b = new Person("NB123");
                //False
                Console.WriteLine(a == b);
                //True
                Console.WriteLine(a.Equals(b));

    “==”和“Equals”的一点区别:
    一般来说,对于引用类型,我们要定义“值相等性”,应该去重载Equals方法,同时让“==”表示“引用相等性”。

    展开全文
  • Tip3 区别对待强制转型asis 如果类型之间都上溯到了某个共同的基类,那么根据此基类进行的转型应该使用as。子类于子类之间的转型,则应该提供转型操作符,以便进行强制转型 class FirstType { public string ...

    Tip3 区别对待强制转型as和is
    如果类型之间都上溯到了某个共同的基类,那么根据此基类进行的转型应该使用as。子类于子类之间的转型,则应该提供转型操作符,以便进行强制转型

        class FirstType
        {
            public string Name { get; set; }
        }
    
        class SecondType
        {
            public string Name { get; set; }
            public static explicit operator SecondType(FirstType firstType)
            {
                SecondType secondType = new SecondType() { Name = "转型自:" + firstType.Name };
                return secondType;
            }
        }
    
      FirstType firstType = new FirstType() { Name = "First Type" };
      SecondType secondType = (SecondType)firstType;         //转型成功
      //secondType = firstType as SecondType;     //编译期转型失败,编译不通过
    
            static void DoWithSomeType(object obj)
            {
                //SecondType secondType = (SecondType)obj;//若传入参数为FirstType对象,会引发异常
                                                          //因为编译器运行时会检查obj是不是SecondType,绕过了转换操作符
                SecondType secondType = obj as SecondType;
                if (secondType != null)
                {
                    // do someting
                }
            }

    若FirstType是SecondType的基类,则as和强转都可以用

            //is的用法
            static void DoWithSomeType(object obj)
            {
                if (obj is SecondType)
                {
                    SecondType secondType = obj as SecondType;
                    //do something
                }
            }
    展开全文
  • 建议11: 区别对待==Equals 在开始本建议之前,首先要明确概念“相等性”。CLR中将“相等性”分为两类:“值相等性”“引用相等性”。如果用来比较的两个变量所包含的数值相等,那么将其定义为“值相等性”;...

    建议11: 区别对待==和Equals

    在开始本建议之前,首先要明确概念“相等性”。CLR中将“相等性”分为两类:“值相等性”和“引用相等性”。如果用来比较的两个变量所包含的数值相等,那么将其定义为“值相等性”;如果比较的两个变量引用的是内存中的同一个对象,那么将其定义为“引用相等性”。

    无论是操作符“==”还是方法“Equals”,都倾向于表达这样一个原则:

    对于值类型,如果类型的值相等,就应该返回True。

    对于引用类型,如果类型指向同一个对象,则返回True。

    下面的代码输出所遵循的就是以上原则:

     
    1. static void ValueTypeOPEquals()  
    2. {  
    3.     int i = 1;  
    4.     int j = 1;  
    5.     //True  
    6.     Console.WriteLine(i == j);  
    7.     j = i;  
    8.     //True  
    9.     Console.WriteLine(i == j);  
    10. }  
    11.  
    12. static void ReferenceTypeOPEquals()  
    13. {  
    14.     object a = 1;  
    15.     object b = 1;  
    16.     //False  
    17.     Console.WriteLine(a == b);  
    18.     b = a;  
    19.     //True  
    20.     Console.WriteLine(a == b);  
    21. }  
    22.  
    23. static void ValueTypeEquals()  
    24. {  
    25.     int i = 1;  
    26.     int j = 1;  
    27.     //True  
    28.     Console.WriteLine(i.Equals(j));  
    29.     j = i;  
    30.     //True  
    31.     Console.WriteLine(i.Equals(j));  
    32. }  
    33.  
    34.  static void ReferenceTypeEquals()  
    35. {  
    36.     object a = new Person("NB123");  
    37.     object b = new Person("NB123");  
    38.     //False  
    39.     Console.WriteLine(a.Equals(b));  
    40.     b = a;  
    41.     //True  
    42.     Console.WriteLine(a.Equals(b));  

    但是,我们同时也要了解,无论是操作符“==”还是“Equals”方法都是可以被重载的。比如,对于string这样一个特殊的引用类型,微软觉得它的现实意义更接近于值类型,所以,在FCL中,string的比较被重载为针对“类型的值”的比较,而不是针对“引用本身”的比较。

    从设计上来说,很多自定义的类型(尤其是自定义的引用类型)会存在和string类型比较接近的情况。如例子中所举的类型Person,在现实生活中,如果两者的IDCode是相等的,我们就认为两者是同一个人,这个时候,就要重载Equals这个方法,代码如下所示:

     
    1. class Person  
    2. {  
    3.     public string IDCode { get; private set; }  
    4.  
    5.     public Person(string idCode)  
    6.     {  
    7.         this.IDCode = idCode;  
    8.     }  
    9.  
    10.     public override bool Equals(object obj)  
    11.     {  
    12.         return IDCode == (obj as Person).IDCode;  
    13.     }  

    这时,再通过Equals去比较两个具有相同IDCode的Person对象的值,返回的就会是true,代码如下所示:

     
    1. object a = new Person("NB123");  
    2. object b = new Person("NB123");  
    3. //False  
    4. Console.WriteLine(a == b);  
    5. // True  
    6. Console.WriteLine(a.Equals(b)); 

    这里,再引出操作符“==”和“Equals”方法之间的一点区别。一般来说,对于引用类型,我们要定义“值相等性”,应该仅仅去重载Equals方法,同时让“==”表示“引用相等性”。

    注意 由于操作符“==”和“Equals”方法从语法实现上来说,都可以被重载为表示“值相等性”和“引用相等性”。所以,为了明确有一种方法肯定比较的是“引用相等性”,FCL中提供了Object. ReferenceEquals方法。该方法比较的是:两个示例是否是同一个示例。

    转自:《编写高质量代码改善C#程序的157个建议》陆敏技

    展开全文
  • 建议3: 区别对待强制转型与asis 在阐述本建议之前,首先需要明确什么是强制转型,以及强制转型意味着什么。从语法结构上来看,类似下面的代码就是强制转型。 secondType = (SecondType)firstType;  但是,...
  • inline-blockfloat应区别对待

    千次阅读 2016-05-20 10:10:37
    参考资料:http://www.w3cplus.com/css/inline-blocks.htmlinline-blockfloat大战已经持续了一段时间,有的人钟爱float,整个页面都用的是float布局,而有些人因为float之后的元素会脱离文档流,而钟情于inline-...
  • 事情 1、今天晚上一个大学同学通了电话。聊了一些事情。主要关于他辞职的事情。 他辞职了,原因是他原本在公司...然后他觉得不公平,不想被区别对待,只有他转正的时候才要做任务,为什么别人不需要完成任务就可以...
  • 强转as的区别 如果类型之间都上溯到了某个共同的基类,那么根据此基类进行的转型(即基类转型为子类本身)应该使用as。子类与子类之间的转型,则应该提供转换操作符,以便进行强制转型。 as操作符不能操作基元...
  •  老师您好我是一名软件学院大三的学生,现在在准备考研,我想问问老师专硕学硕在找工作的时候,例如研究所什么的会不会区别对待?  【回信】  答复你这封邮件,是一件风险无限大的事。当我告诉你会区别对待,...
  • 最近,程序员又被区别对待了。这次是最近全球第二大开源代码托管平台——GitLab。GitLab在最新的声明中表示:GitLab不会招聘中国人俄罗斯人,并禁止有权限的工程师等员工移居俄罗斯中国。并且GitLab还表示这种...
  • 都是技术人员,还要分三六九等区别对待? Hello,各位小伙伴大家好,我是小栈君。昨天收到了小伙伴的私信吐槽某大公司某行对技术人员进行区别对待,虽然在以往的鄙视程序员行列里面涵盖了相亲嘲讽,发际线嘲讽,格子...
  • 当一个顾客进入店门的那...1、区别对待不同类型的 顾客 要迎合不同人群的购物风格 (1)女性 顾客 购买动机具有主动性。 容易产生冲动性购买。 追求时髦,注意外观。 喜欢炫耀,自尊心强。 挑剔,精打细算。...
  • 写下这个标题,真有点担心被骂“作死”,战战兢兢如履薄冰……不过,如果你打算拍死我,...不扯了,咱们讨论正题儿:为什么要区别对待女程序员,也就是阿媛? 男人与女人的不同 我们得先说说男人女人的不同,才
  • 碰到一个问题,公司有个HP的小机器,需要安装CentOS,各种无法用U盘镜像引导.期间试过各种办法排除是不是...比如,惠普的机器安装黑苹果的时候,惠普的设置,总会有那么一点区别于其他机器的地方~ 经过百度一搜索,果然有,跟
  • /* * Returns 1 to let vcpu_run() continue the guest execution loop without * exiting to the userspace. Otherwise, the value will be returned to the * userspace. */ static int vcpu_enter_guest...
  • java 中 equals ==的区别 值类型是存储在内存中的堆栈以后简称栈而引用类型的变量在栈中仅仅是存储引用类型变量的地址而其 本身则存储在堆中 ==操作比较的是两个变量的值是否相等对于引用型变量表示的是两个变量...
  • 尼尔森博士在她的书《正面教育》中说,当小孩的归属感确认自己重要性的需求没有得到满足时,他/她就会觉得沮丧。 孩童尚且如此,更别说我们这些成年人了。 在多年带部属的过程中,我发现尤其是对于一些年轻员工来...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 86,065
精华内容 34,426
关键字:

区别对待和差别对待