NET中const、readonly、sealed与JAVA中final的差异

NET中const、readonly、sealed与JAVA中final的差异

NET
const：常量，可以是全局或局部，定义（声明）同时赋值，就是说在定义时必须初始化。
readonly: 只读，只能是全局，可以在定义的时候赋值，也可以只定义，然后在构造函数中初始化。
sealed: 密封，修饰类，表示不能被派生类继承，可以用于基类。
sealed: 密封，修饰方法，表示该方法不能被子类的方法覆盖，子类若是继承该方法，则必须添加关键字new,进行重写。不可以用于基类中，因为基类中的方法不能定义为override，只能用于继承类中，比如B:A，B类中的方法public sealed override void F()。C:B，这样C类中的方法就不能覆盖public override void F()，而只能是重写public new void F()。

JAVA
final：常量，可以是全局或局部，初始化可以在定义时或在构造函数中任意一处，二选一。
final: 修饰方法的形式参数, 这个形式参数值在该方法体内不可以被改变，否则会产生编译错误。
final: 修饰类，跟NET的sealed作用相同。
final: 修饰方法，和NET的sealed类似，但和NET不同的是，final可以用于基类中的方法。

经过上面比较，感觉NET在关键字定义这里把事情搞复杂了，而JAVA只用了final全部搞定。

下面我们来看下示例代码，这里主要讲解sealed关键字用法。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TestSealed
{
    class Program
    {
        static void Main(string[] args)
        {

            A a = new A("A绅士");
            a.F();

            B b = new B("B女士");
            b.F();

            C c = new C("C小姐1");
            c.F();

            D d = new D("D青年");
            d.F();

            Console.WriteLine();

            A ab = new B("B女士");
            ab.F();

            A ac = new C("C小姐2");
            ac.F();

            B bc = new C("C小姐3");
            bc.F();
        }
    }

    class A
    {
        //protected string name;
        public A(string name)
        {
            //this.name = name;
            //Name = "Mr.Alan";
            Name = name;
        }

        public virtual string Name { get; set; }

        //public sealed virtual void F() //错误 CS0238 因为“A.F()”不是重写，所以无法将其密封

        public virtual void F()
        {
            Console.WriteLine("[A]" + Name + ": " + "Hello,我是艾伦先生!");
        }
    }

    class B : A
    {
        public B(string name) : base(name)
        {
            //Name = "Mrs.Betty";
            Name = name;
        }

        public override string Name { get; set; }

        //public sealed new void F() //错误 CS0238  因为“B.F()”不是重写，所以无法将其密封

        public sealed override void F()
        {
            Console.WriteLine("[B]" + Name + ": " + "Hum,我是贝蒂.艾伦，请叫我艾伦夫人，这里我说了算!");
        }
    }

    sealed class C : B
    {
        public C(string name) : base(name)
        {
            //Name = "Miss.Cora";   //"Ms.Cheryl"
            Name = name;
        }

        public override string Name { get; set; }

        //public override void F() //错误 CS0239  “C.F()”: 继承成员“B.F()”是密封的，无法进行重写

        public new void F()
        {
            Console.WriteLine("[C]"+Name + ": " + "Hi,我是歌手，请叫我科拉小姐！");
        }
    }

    //class D : C //错误  CS0509   “D”: 无法从密封类型“C”派生
    class D
    {
        public D(string name) //: base(name)
        {
            //Name = "Mr.David";
            Name = name;
        }

        public string Name { get; set; }

        public void F()
        {
            Console.WriteLine("[D]" + Name + ": " + "Hello,我是乐手，请叫我大卫！");
        }
    }
}

代码输出：
[A]A绅士: Hello,我是艾伦先生!
[B]B女士: Hum,我是贝蒂.艾伦，请叫我艾伦夫人，这里我说了算!
[C]C小姐1: Hi,我是歌手，请叫我科拉小姐！
[D]D青年: Hello,我是乐手，请叫我大卫！

[B]B女士: Hum,我是贝蒂.艾伦，请叫我艾伦夫人，这里我说了算!
[B]C小姐2: Hum,我是贝蒂.艾伦，请叫我艾伦夫人，这里我说了算!
[B]C小姐3: Hum,我是贝蒂.艾伦，请叫我艾伦夫人，这里我说了算!

注意第C小姐2和C小姐3的发言被B女士的发言取代了，因为是sealed方法。

版权所有，转载请注明文章出处 http://blog/csdn.net/cadenzasolo