经常会有人问：小伙子，有没有对象啊，要不要大叔我帮你介绍一个啊，小伙子会说：大叔，不用我自己new一个就好了。（PS：活该你没有对象）

上边当然是一个段子咯，程序员那会没有对象，自己new一个就有了啊。好了进入今天的主题 new和this的关键字。

new关键字

new 关键字可用作运算符、修饰符或约束三种用法：

1） new 运算符：用于创建对象和调用构造函数。

a)   Person person = new Person();//new是一个运算符
（1）在内存中开辟一块合适大小的空间
（2）在这个空间里创建对象
（3）调用这个对象的构造函数
（4）返回这个空间的引用地址

代码展示：

class Program
    {
        static void Main(string[] args)
        {
            Reporter rep = new Reporter("记者", 11, '男', "偷拍");
            rep.SayHello();
            rep.Test();
            Console.ReadKey();
        }
    }

    public class Person
    {
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        private int _age;
        public int Age
        {
            get { return _age; }
            set { _age = value; }
        }
        private char _gender;
        public char Gender
        {
            get { return _gender; }
            set { _gender = value; }
        }


        public Person(string name, int age, char gender)
        {
            this.Name = name;
            this.Age = age;
            this.Gender = gender;
        }

        public void Test()
        {
            Console.WriteLine("测试");
        }

        public void SayHello()
        {
            Console.WriteLine("大家好，我是人类");
        }
    }


    public class Reporter : Person
    {
        public Reporter(string name, int age, char gender, string hobby)
            : base(name, age, gender)
        {
            this.Hobby = hobby;
        }


        private string _hobby;

        public string Hobby
        {
            get { return _hobby; }
            set { _hobby = value; }
        }

        public void ReporterSayHello()
        {
            Console.WriteLine("我叫{0},我是一名狗仔，我的爱好是{1}，我是{2}生，我今年{3}岁了", this.Name, this.Hobby, this.Gender, this.Age);
        }


        public new void SayHello()
        {
            Console.WriteLine("大家好，我是记者");
        }
    }

　　

2） new 修饰符：在用作修饰符时，new 关键字可以显式隐藏从基类继承的成员。

代码展示：

public class BaseClass
    {
        public void functionA()
        {
            Console.WriteLine("BaseFunctionA http://www.cnblogs.com/sosoft/");
        }
        public virtual void functionB()
        {
            Console.WriteLine("BaseFunctionB http://www.cnblogs.com/sosoft/");
        }
    }
   public class DerivedClass:BaseClass
    {
        public new void functionA()
        {
            Console.WriteLine("DerivedFunctionA http://www.cnblogs.com/sosoft/");
        }
        public override void functionB()
        {
            Console.WriteLine("DerivedFunctionB http://www.cnblogs.com/sosoft/");
        }
    }

调用：
BaseClass baseFunction=new DerivedClass();
baseFunction.functionA();
baseFunction.functionB();

运行结果：

　BaseFunctionA http://www.cnblogs.com/sosoft/

　DerivedFunctionB http://www.cnblogs.com/sosoft/

new是隐藏基类方法，override是覆写基类方法。如果要访问new隐藏了的基类成员需要使用base关键字实现。

隐藏和重写基类方法的异同：

1：方法重写：就是在基类中的方法用virtual关键字来标识，然后在继承类中对该类进行重写（override），这样基类中的方法已经被重写了，已经失去了功能了。当让基类的对象的引用直接指向继承类的对象时（多态性），调用该方法则是调用的继承类的方法。

2：方法隐藏：无论基类中的方法是否用了virtual关键字，继承类中都可以用new关键字（如果不用new的话，不会产生错误，但会生成一个编译警告）将基类中的方法隐藏，所谓隐藏就是隐藏，不像重写，重写就是原来的（基类中）已经不存在了，而隐藏是原来的还存在。所以当让基类的对象的引用直接指向继承类的对象时（多态性），调用该方法则是调用的基类的方法。

 

3）new 约束：用于在泛型声明中约束可能用作类型参数的参数的类型。 

代码展示：

class Person<T> where T : new()
    {
        public T GetName()
        {
            return new T();
        }
    }

    class Boy
    {
        private string _name;

        public string Name
        {
            get{return _name;}
            set { _name = value; }
        }

        public Boy()
        {
            _name = "feng";
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Person<Boy> MBoy = new Person<