精华内容
下载资源
问答
  • C#的New关键字有几种用法

    千次阅读 2009-01-23 13:02:00
    前段时间一个朋友问到C#的New关键字有几种用法,虽说在日常编程中经常用到这个小家伙,但它到底有几种用法还真没有留意过,现将从网上总结出的资料记下以供同仁学习。 (1)new 运算符 用于创建对象和调用构造函数。...

    前段时间一个朋友问到C#的New关键字有几种用法,虽说在日常编程中经常用到这个小家伙,但它到底有几种用法还真没有留意过,现将从网上总结出的资料记下以供同仁学习。

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

      (2)new 修饰符 用于隐藏基类成员的继承成员。

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

      new 运算符

      1.用于创建对象和调用构造函数

      例:Class_Test MyClass = new Class_Test();

      2.也用于为值类型调用默认的构造函数

      例:int myInt = new int();

      myInt 初始化为 0,它是 int 类型的默认值。该语句的效果等同于:int myInt = 0;

      3.不能重载 new 运算符。

      4.如果 new 运算符分配内存失败,则它将引发 OutOfMemoryException 异常。

      new 修饰符

      使用 new 修饰符显式隐藏从基类继承的成员。若要隐藏继承的成员,请使用相同名称在派生类中声明该成员,并用 new 修饰符修饰它。

      请看下面的类:

      1 public class MyClass
      2
      3 {
      4
      5 public int x;
      6
      7 public void Invoke() {}
      8
      9 }
      10
      在派生类中用 Invoke 名称声明成员会隐藏基类中的 Invoke 方法,即:

      1 public class MyDerivedC : MyClass
      2
      3 {
      4
      5 new public void Invoke() {}
      6
      7 }
      8
      但是,因为字段 x 不是通过类似名隐藏的,所以不会影响该字段。

      通过继承隐藏名称采用下列形式之一:

      1.引入类或结构中的常数、指定、属性或类型隐藏具有相同名称的所有基类成员。

      2.引入类或结构中的方法隐藏基类中具有相同名称的属性、字段和类型。同时也隐藏具有相同签名的所有基类方法。

      3.引入类或结构中的索引器将隐藏具有相同名称的所有基类索引器。

      4.在同一成员上同时使用 new 和 override 是错误的。

      注意:在不隐藏继承成员的声明中使用 new 修饰符将生成警告。

     

    示例

      在该例中,嵌套类 MyClass 隐藏了基类中具有相同名称的类。该例不仅说明了如何使用完全限定名访问隐藏类成员,同时也说明了如何使用 new 修饰符消除警告消息。

      1 using System;
      2
      3 public class MyBaseC
      4
      5 {
      6
      7 public class MyClass
      8
      9 {
      10
      11 public int x = 200;
      12
      13 public int y;
      14
      15 }
      16
      17 }
      18
      19
      20
      21 public class MyDerivedC : MyBaseC
      22
      23 {
      24
      25 new public class MyClass // nested type hiding the base type members
      26
      27 {
      28
      29 public int x = 100;
      30
      31 public int y;
      32
      33 public int z;
      34
      35 }
      36
      37
      38
      39 public static void Main()
      40
      41 {
      42
      43 // Creating object from the overlapping class:
      44
      45 MyClass S1 = new MyClass();
      46
      47
      48
      49 // Creating object from the hidden class:
      50
      51 MyBaseC.MyClass S2 = new MyBaseC.MyClass();
      52
      53
      54
      55 Console.WriteLine(S1.x);
      56
      57 Console.WriteLine(S2.x);
      58
      59 }
      60
      61 }
      62
      输出

      100

      200

     

    http://www.68design.net/Development/Aspnet/Skills-AspNet/26007-1.html

    展开全文
  • C#中base关键字几种用法:base()

    万次阅读 2020-12-22 11:46:52
    C#中base关键字几种用法:base() 文章目录C#中base关键字几种用法:base()C#中base关键字几种用法:base()2.1关于base调用基类构造函数2.2关于base在派生类中调用基类的方法。关于base1. 在派生类中调用基类方法...

    C#中base关键字的几种用法:base()

    base其实最大的使用地方在面相对象开发的多态性上,base可以完成创建派生类实例时调用其基类构造函数或者调用基类上已被其他方法重写的方法。


    例如:

    1.关于base调用基类构造函数
    public class A
    {
            public A()
            {
                    Console.WriteLine("Build A");
            }
    }
    public class B:A
    {
            public B():base()
            {
                    Console.WriteLine("Build B");
            }
            static void Main()
            {
                    B b = new B();
                    Console.ReadLine();
            }
    }
    

    创建一个B的实例对象,获得结果是同时打印Build A和Build B.

    2.关于base在派生类中调用基类的方法。
    public class A
    {
            public virtual void Hello()
            {
                    Console.WiriteLine("Hello");
            }
    }
    public class B : A
    {
            public override void Hello()
            {               
                    base.Hello();//调用基类的方法,显示Hello
                    Console.WiriteLine("World");
            }
    }
    

    这样如果程序调用B.Hello()获得的效果将会使Hello World.

    最后补充下,根据MSDN Library介绍来看这两个关键字都是属于[访问关键字]类型



    关于base

    base 关键字用于从派生类中访问基类的成员:

    • 调用基类上已被其他方法重写的方法。
    • 指定创建派生类实例时应调用的基类构造函数。
    • 基类访问只能在构造函数、实例方法或实例属性访问器中进行。

    示例:

    1. 在派生类中调用基类方法。
    using System;
    public class BaseClass
    {
        protected string _className = "BaseClass";
        public virtual void PrintName()
        {
            Console.WriteLine("Class Name: {0}", _className);
        }
    }
    class DerivedClass : BaseClass
    {
        public string _className = "DerivedClass";
        public override void PrintName()
        {
            Console.Write("The BaseClass Name is {0}");
            //调用基类方法
            base.PrintName();
            Console.WriteLine("This DerivedClass is {0}", _className);
        }
    }
    class TestApp
    {
        public static void Main()
        {
            DerivedClass dc = new DerivedClass();
            dc.PrintName();
        }
    }
    
    2. 在派生类中调用基类构造函数。
    // keywords_base2.cs
    using System;
    public class BaseClass
    {
        int num;
        public BaseClass()
        {
            Console.WriteLine("in BaseClass()");
        }
        public BaseClass(int i)
        {
            num = i;
            Console.WriteLine("in BaseClass(int {0})", num);
        }
    }
    public class DerivedClass : BaseClass
    {
        // 该构造器调用  BaseClass.BaseClass()
        public DerivedClass()
            : base()
        {
        }
        // 该构造器调用 BaseClass.BaseClass(int i)
        public DerivedClass(int i)
            : base(i)
        {
        }
        static void Main()
        {
            DerivedClass dc = new DerivedClass();
            DerivedClass dc1 = new DerivedClass(1)();
            Console.ReadLine();
        }
    }
    

    注意:

    • 从静态方法中使用 base 关键字是错误的。
    • base 主要用于面向对象开发的对态这方面,在示例2中有体现。


    关于this

    this 关键字引用类的当前实例。

    以下是 this 的常用用途:

    • 限定被相似的名称隐藏的成员
    • 将对象作为参数传递到其他方法
    • 声明索引器

    示例:

    // this 关键字
    // keywords_this.cs
    using System;
    class Employee
    {
        private string _name;
        private int _age;
        private string[] _arr = new string[5];
        public Employee(string name, int age)
        {
            // 使用this限定字段,name与age
            this._name = name;
            this._age = age;
        }
        public string Name
        {
            get { return this._name; }
        }
        public int Age
        {
            get { return this._age; }
        }
        // 打印雇员资料
        public void PrintEmployee()
        {
            // 将Employee对象作为参数传递到DoPrint方法
            Print.DoPrint(this);
        }
        // 声明索引器
        public string this[int param]
        {
            get { return _arr[param]; }
            set { _arr[param] = value; }
        }
    }
    class Print
    {
        public static void DoPrint(Employee e)
        {
            Console.WriteLine("Name: {0}\nAge: {1}", e.Name, e.Age);
        }
    }
    class TestApp
    {
        static void Main()
        {
            Employee E = new Employee("Hunts", 21);
            E[0] = "Scott";
            E[1] = "Leigh";
            E[4] = "Kiwis";
            E.PrintEmployee();
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine("Friends Name: {0}", E[i]);
            }
            Console.ReadLine();
        }
    }
    


    文章转载自

    展开全文
  • final关键字几种用法

    万次阅读 多人点赞 2018-01-29 12:42:15
    不同于其他关键字,他们都多种用法,而且在一定环境下使用,可以提高程序的运行性能,优化程序的结构。下面我们来了解一下final关键字及其用法。 final关键字 在java中,final的含义在不同的场景下细微的...

    在java的关键字中,staticfinal是两个我们必须掌握的关键字。不同于其他关键字,他们都有多种用法,而且在一定环境下使用,可以提高程序的运行性能,优化程序的结构。下面我们来了解一下final关键字及其用法。

    final关键字

    在java中,final的含义在不同的场景下有细微的差别,但总体上来说,它指的是“这是不可变的”。下面,我们来讲final的四种主要用法。

    1.修饰数据

    在编写程序时,我们经常需要说明一个数据是不可变的,我们成为常量。在java中,用final关键字修饰的变量,只能进行一次赋值操作,并且在生存期内不可以改变它的值。更重要的是,final会告诉编译器,这个数据是不会修改的,那么编译器就可能会在编译时期就对该数据进行替换甚至执行计算,这样可以对我们的程序起到一点优化。不过在针对基本类型和引用类型时,final关键字的效果存在细微差别。我们来看下面的例子:

    复制代码
     1 class Value {
     2     int v;
     3     public Value(int v) {
     4         this.v = v;
     5     }
     6 }
     7 
     8 public class FinalTest {
     9     
    10     final int f1 = 1;
    11     final int f2;
    12     public FinalTest() {
    13         f2 = 2;
    14     }
    15 
    16     public static void main(String[] args) {
    17         final int value1 = 1;
    18         // value1 = 4;
    19         final double value2;
    20         value2 = 2.0;
    21         final Value value3 = new Value(1);
    22         value3.v = 4;
    23     }
    24 }
    复制代码

    上面的例子中,我们先来看一下main方法中的几个final修饰的数据,在给value1赋初始值之后,我们无法再对value1的值进行修改,final关键字起到了常量的作用。从value2我们可以看到,final修饰的变量可以不在声明时赋值,即可以先声明,后赋值。value3时一个引用变量,这里我们可以看到final修饰引用变量时,只是限定了引用变量的引用不可改变,即不能将value3再次引用另一个Value对象,但是引用的对象的值是可以改变的,从内存模型中我们看的更加清晰:

    上图中,final修饰的值用粗线条的边框表示它的值是不可改变的,我们知道引用变量的值实际上是它所引用的对象的地址,也就是说该地址的值是不可改变的,从而说明了为什么引用变量不可以改变引用对象。而实际引用的对象实际上是不受final关键字的影响的,所以它的值是可以改变的。

    另一方面,我们看到了用final修饰成员变量时的细微差别,因为final修饰的数据的值是不可改变的,所以我们必须确保在使用前就已经对成员变量赋值了。因此对于final修饰的成员变量,我们有且只有两个地方可以给它赋值,一个是声明该成员时赋值,另一个是在构造方法中赋值,在这两个地方我们必须给它们赋初始值。

    最后我们需要注意的一点是,同时使用static和final修饰的成员在内存中只占据一段不能改变的存储空间。

    2.修饰方法参数

    前面我们可以看到,如果变量是我们自己创建的,那么使用final修饰表示我们只会给它赋值一次且不会改变变量的值。那么如果变量是作为参数传入的,我们怎么保证它的值不会改变呢?这就用到了final的第二种用法,即在我们编写方法时,可以在参数前面添加final关键字,它表示在整个方法中,我们不会(实际上是不能)改变参数的值:

    复制代码
    public class FinalTest {
    
        /* ... */
    
        public void finalFunc(final int i, final Value value) {
            // i = 5; 不能改变i的值
            // v = new Value(); 不能改变v的值
            value.v = 5; // 可以改变引用对象的值
        }
    }
    复制代码

    3.修饰方法

    第三种方式,即用final关键字修饰方法,它表示该方法不能被覆盖。这种使用方式主要是从设计的角度考虑,即明确告诉其他可能会继承该类的程序员,不希望他们去覆盖这个方法。这种方式我们很容易理解,然而,关于private和final关键字还有一点联系,这就是类中所有的private方法都隐式地指定为是final的,由于无法在类外使用private方法,所以也就无法覆盖它。

    4.修饰类

    了解了final关键字的其他用法,我们很容易可以想到使用final关键字修饰类的作用,那就是用final修饰的类是无法被继承的。

    上面我们讲解了final的四种用法,然而,对于第三种和第四种用法,我们却甚少使用。这不是没有道理的,从final的设计来讲,这两种用法甚至可以说是鸡肋,因为对于开发人员来讲,如果我们写的类被继承的越多,就说明我们写的类越有价值,越成功。即使是从设计的角度来讲,也没有必要将一个类设计为不可继承的。Java标准库就是一个很好的反例,特别是Java 1.0/1.1中Vector类被如此广泛的运用,如果所有的方法均未被指定为final的话,它可能会更加有用。如此有用的类,我们很容易想到去继承和重写他们,然而,由于final的作用,导致我们对Vector类的扩展受到了一些阻碍,导致了Vector并没有完全发挥它应有的全部价值。

    总结

    final关键字是我们经常使用的关键字之一,它的用法有很多,但是并不是每一种用法都值得我们去广泛使用。它的主要用法有以下四种:

    1. 用来修饰数据,包括成员变量和局部变量,该变量只能被赋值一次且它的值无法被改变。对于成员变量来讲,我们必须在声明时或者构造方法中对它赋值;
    2. 用来修饰方法参数,表示在变量的生存期中它的值不能被改变;
    3. 修饰方法,表示该方法无法被重写;
    4. 修饰类,表示该类无法被继承。

    上面的四种方法中,第三种和第四种方法需要谨慎使用,因为在大多数情况下,如果是仅仅为了一点设计上的考虑,我们并不需要使用final来修饰方法和类。


    展开全文
  • C#的new关键字几种用法

    千次阅读 2018-11-02 17:06:45
    一共用法: 在 C# 中,new 关键字可用作运算符、修饰符或约束。 1)new 运算符:用于创建对象和调用构造函数。这种大家都比较熟悉,没什么好说的了。 2)new 修饰符:在用作修饰符时,new 关键字可以显式隐藏...

    一共有三种用法:
    在 C# 中,new 关键字可用作运算符、修饰符或约束。
    1)new 运算符:用于创建对象和调用构造函数。这种大家都比较熟悉,没什么好说的了。
    2)new 修饰符:在用作修饰符时,new 关键字可以显式隐藏从基类继承的成员。
    3)new 约束:用于在泛型声明中约束可能用作类型参数的参数的类型。

    直接上代码:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace NewTest
    {
        /*
         * a)     作为运算符用来创建一个对象和调用构造函数。
         * b)     作为修饰符。
         * c)      用于在泛型声明中约束可能用作类型参数的参数的类型。
         * 
         */
    
        class A
        {
            public A() { }
            public int data;
            public int Data { get { return data; } set { data = value; } }
            public int Data1 { get; set; }
            public virtual void Get()
            {
                Console.WriteLine("AAAAAAA");
            }
        }
    
        class B : A
        {
            public B():base() { }
            new public int data;
            new public int Data { get; set; }
            new public int Data1 { get; set; }
            new public void Get()
            {
                Console.WriteLine("BBBBBBB");
            }
        }
        class C<T> where T:new()
        {
        }
        class Program
        {
            static void Main(string[] args)
            {
                B b = new B();
                b.data = 10;
                b.Data = 12;
                b.Data1 = 13;
                Console.WriteLine($"B:::data:{b.data},Data:{b.Data},Data1:{b.Data1}");
                b.Get();
                A a = b ;
                Console.WriteLine($"A:::data:{a.data},Data:{a.Data},Data1:{a.Data1}");
                a.data = 100;
                a.Data = 120;
                a.Data1 = 130;
                Console.WriteLine($"A:::data:{a.data},Data:{a.Data},Data1:{a.Data1}");
                a.Get();
                Console.WriteLine($"B:::data:{b.data},Data:{b.Data},Data1:{b.Data1}");
                b.Get();
                C<B> c = new C<B>();
            }
        }
    }
    
    

    结果:
    在这里插入图片描述

    b断点调试结果:
    在这里插入图片描述

    这里说明下,重写父类的变量其实是重新定义了一个新的变量,变量名相同是把父类的变量隐藏了,会增加内存

    参考文章:
    C#的new关键字的几种用法

    展开全文
  • //几种类型转换关键字 //static_cast数值类型之间,一方是void*的指针类型转换 //const_cast用于临时去掉const,volatile限制 //reinterpret_cast任意两种指针类型之间,指针于数值类型之间 //dynamic_cast #...
  • [java]final关键字几种用法

    千次阅读 2019-10-02 13:30:33
    不同于其他关键字,他们都多种用法,而且在一定环境下使用,可以提高程序的运行性能,优化程序的结构。下面我们来了解一下final关键字及其用法。 final关键字 在java中,final的含义在不同的场景下细微的差别...
  • C/C++ typedef关键字几种简单用法

    千次阅读 2018-08-06 21:52:39
    现在我就简单的总结一下typedef的用法及几种常见的简单用处。 1、当你不想用极长的一段代码来定义一个数据类型是,可用此来重新命名,如下: typedef std::map&amp;amp;amp;lt;strCarIndex, STRU_...
  • 常见的四用法: 1. 可以用来修饰一个类 格式: public final class 类名称 { //...... } 含义:当前这个类不能任何子类。(太监类) 注意:一个类如果是final的,那么其中所有的成员方法都无法进行...
  • Java中for关键字几种用法

    千次阅读 2013-07-23 11:13:58
    借助这种形式的for循环,可以用更简单地方式来遍历数组和Collection等类型的对象。本文介绍使用这种循环的具体方式,说明如何自行定义能被这样遍历的类,并解释和这一机制的一些常见问题。 在Java程序中,要...
  • C#的New关键字几种用法

    千次阅读 2011-04-14 15:28:00
      OO思想现在已经在软件开发项目中广泛应用,其中最重要的一个特性就是继承,最近偶简单的复习了下在C#中涉及到继承这个特性时,所需要用到的关键字,其中一些关键点,特地整理出来,方便大家查阅。...
  • base关键字用在哪方面? base关键字的具体用法? base在调用基类构造函数中的用法? base在调用基类方法中的用法? base在调用基类属性的用法?
  • 标识符、关键字、基本数据类型
  • static,const和typedef关键字几种用途

    千次阅读 2009-07-13 13:03:00
    static关键字至少下列n个作用: (1)函数体内static变量的作用范围为该函数体 ,不同于auto变量,该变量的内存只被分配一次,因此其值在下次调用时仍维持上次的值; (2)在模块内的static全局变量可以被模块内...
  • 不同于其他关键字,他们都多种用法,而且在一定环境下使用,可以提高程序的运行性能,优化程序的结构。下面我们先来了解一下static关键字及其用法。 static关键字 1,修饰成员变量 类,里面属性和方法 属性里面...
  • C#关键字using的几种用法

    千次阅读 热门讨论 2015-05-20 21:28:24
     一、作为语句,强制对象清理   ... 用于定义一个范围,在此范围的末尾将释放对象 ... 可以在到达 using 语句的末尾时,或者在... C#关键字的多重身份,为提高程序的性能提供帮助。小小的using也不简单。
  • 不同于其他关键字,他们都多种用法,而且在一定环境下使用,可以提高程序的运行性能,优化程序的结构。下面我们来了解一下final关键字及其用法。   二、final关键字    在java中,final的含义在不同的场景...
  • 什么是标识符?  在java语言中用来给一个类,变量或方法命名的... 标识符不能是 Java 关键字和保留字( Java 预留的关键字,以后的升级版本中可能作为关键字),但可以包含关键字和保留字。  标识符严格区分大
  • final关键字的4用法

    万次阅读 多人点赞 2018-08-08 17:12:35
    不同于其他关键字,他们都多种用法,而且在一定环境下使用,可以提高程序的运行性能,优化程序的结构。下面我们来了解一下final关键字及其用法。 final关键字 在java中,final的含义在不同的场景下细微的差别...
  • abstract关键字可以用来修饰类和方法 abstract类可以通过子类来扩展,但是不能够直接实例化 abstract方法在声明的时候没有实现,但必须在声明方法的abstract类的子类中重写 abstract方法所在的...
  • 从Qt谈到C++(一):关键字explicit与隐式类型转换

    千次阅读 多人点赞 2014-04-26 22:59:35
    在生成了一个新的类MainWindow的时候。我们可以看到在它的构造函数里,...出现这个关键字的原因,是在C++中这样规定的基础上:当定义了只有一个参数的构造函数时,同时也定义了一隐式的类型转换。先看类型转换。
  • 32个关键字(表格)【数据类型关键字、控制语句关键字、存储类型关键字、其它关键字】控制语句及其用处(表格)
  • Synchronized关键字的四使用场景: ①、修饰一个方法 ②、修饰代码块 ③、修饰静态方法 ④、修饰一个类 1.修饰一个方法 synchronized 修饰一个方法很简单,就是在方法的前面加synchronized,例如: ...
  • New关键字在我们的程序中可谓是无时不刻在用到,那么new关键字都可以用在哪些地方呢?考虑以下个问题: 1、new一个class对象和new一个struct或者new一个enum什么不同?  答:new一个class时,new完成2个内容...
  • 标识符和关键字 标识符:用来标识程序中用到的变量名、函数名、类型名、数组名、文件名以及符号常量名的有效字符序列。 语法规则(部分): 标识符只能是由英文字母、数字和下划线组成的字符串,并且第一个字符...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 397,082
精华内容 158,832
关键字:

关键字有几种类型