精华内容
下载资源
问答
  • C#构造方法

    千次阅读 多人点赞 2014-03-17 17:20:53
    所有的类都有构造方法,如果没有定义的构造方法,系统默认生成空的构造方法;如果自己定义了默认的构造方法就会失效了。 2.用途  构造方法用于对类进行初始化,在创建类时自动调用。 3示例  pri

    1.概念  

      构造方法又叫构造函数,它是一种特殊的方法,因为构造方法本身没有返回值,并且通常是public访问类型,方法的名称必须与类名相同。构造方法在类实例创建之前执行,用来初始化对象。所有的类都有构造方法,如果没有定义的构造方法,系统默认生成空的构造方法;如果自己定义了默认的构造方法就会失效了。

    2.用途

      构造方法用于对类进行初始化,在创建类时自动调用。

    3示例

      

     private void button1_Click(object sender, EventArgs e)
            {
                Cat cat = new Cat("咪咪");//初始化对象,给小猫起名字
                MessageBox.Show(cat.Shout());//调用构造方法
            }
            class Cat
            {
                private string name = "";//声明cat类的私有字符串变量
                public Cat(string name)//定义cat类的构造方法,参数是一个字符串类型
                {
                    this.name = name;//把参数赋给私有变量name 
                }
    
                public string Shout()
                {
                        return "我的名字叫" + name + "喵";
                }
            }

    展开全文
  • c#构造方法

    千次阅读 2010-04-28 13:20:00
    C#之类四)构造方法(静态构造方法、this、方法重载)、析构方法(修改新增) --------------------------------------------------------------------------------2008-12-13 22:43:00 标签:教学思路 C# 构造方法 ...
    (教学思路 C#之类四)构造方法(静态构造方法、this、方法重载)、析构方法(修改新增) 
    
    --------------------------------------------------------------------------------
    
    2008-12-13 22:43:00 标签:教学思路 C# 构造方法 方法重载 析构方法   [推送到技术圈] 
    
    
    版权声明:原创作品,如需转载,请与作者联系。否则将追究法律责任。 
         今天这节课我们来学习类的构造方法和析构方法,同学们现在回忆一下在类一系列中,学习到创建一个类ClassName的实例,也就是对象ObjName时基本语法为:ClassName ObjName=new ClassName();我说过,new后面的ClasName()实际上指的是这个类的构造方法,而且我也说过,这个()中可以有参数,这个有参数,就是指构造方法可以有参数,那么什么是类的构造方法呢? 
    构造方法
    
    --------------------------------------------------------------------------------
    
             构造方法又叫构造函数,也有人叫做构造器,其实就是对类进行初始化。构造方法是一种特殊的方法,在类实例创建之前执行,用来初始化对象,完成对象创建前所需的相关设定,构造方法允许将类实例初始为有效状态的特殊方法,这就是构造方法的定义,用通俗的话说,就是开车前的暖车工作,用洗衣机之前的接上电源的工作,参数可以有多个可以这样理解,洗衣机的插头有两头的、有三项的,在创建洗衣机对象的时候,要分清插头的种类,才能创建成功对象。
            为什么说构造方法是特殊的方法呢?因为构造方法本身没有返回值,并且通常是public访问类型,方法的名称必须与类名相同,当我们没有明确的在类中定义构造方法的时候,例如我们以前所定义的类,都是没有定义构造方法的,这时系统会使用默认的构造方法,如创建ClassName类的默认构造方法,public ClassName(){}。默认的构造方法并没有进行任何类初始化行为,你可以自己定义构造方法,当然如果你有自定义构造方法,那么默认的构造方法就会失效了。也就是说,当我们在ClassName类中没有定义构造方法时,C#语言会生成一个空的构造方法ClassName(),当然这个空的方法是什么也没做,只是为了让我们定义的类能够在创建对象时顺利的实例化而已。
             构造方法可以有两个,因为参数的不同区别开,这就构成了方法的重载,方法重载的最大的好处在与可以利用相同的名称来组织应用程序的方法成员,当一个复杂的类被创建的时候,对功能相同的方法最好采用相同的命名方式,用不同的参数来区别,比如,计算面积时,我们就可以把四边形面积的计算方法的名字起同一个,用参数来区别如正方形定义一个参数(一个边长),长方形定义三个参数(一个长,一个宽,另一个长方形的标志如0),梯形定义三个参数(一个底,一个高,另一个梯形的标志如1),通过第三个参数标志区别长方形和梯形不同的面积公式。方法的重载要注意的是,方法名相同,但是参数类型或个数必须要有所不同,方法重载的优点就是可以在不改变原方法的基础上,新增功能。
                下面我们来看实例,通过实例我们来体会构造方法是如何在创建对象时初始化的。
    构造方法实例
    
    namespace hello 
    { 
            
            //创建一个人类Ren 
            class Ren 
            { 
                    /*观察字段成员如果不赋初值时,在创建对象的时候, 
                     * 编译器会按照类型默认的给变量一个初值,如年龄、姓名 
                     * 我们可以在构造方法中,对未赋值的字段进行改变,如年龄 
                     * 如果字段已经赋初值了,那么创建对象的时候, 
                     * 就会使用初值,如果需要改变,就在构造方法中重新赋值即可,如性别*/ 
     
                    //定义一个年龄变量,不赋初值 
                    int age; 
                    //定义一个姓名变量,不赋初值 
                    string name; 
                    //定义一个性别变量,赋初值为男 
                    string Sex = "男"; 
     
                    //定义一个方法,读取类中字段成员,值的变化。 
                    void Say() 
                    { 
                            Console.WriteLine("我的年龄:{0},我的名字:{1},我的性别:{2}", age, name,Sex ); 
                    } 
     
     
                    /*1.以下方法都为Ren这个类的构造方法,他们因为参数不同,形成了方法的重载, 
                     * 2.this关键字:this关键字用来引用对象本身,已经是说,this.name指的是对象中的name字段, 
                     *     而=name的这个name指的是方法中离它定义最近的name,这里值的是构造方法中传入的name参数 
                     * this关键字在例子结束后,还会具体的讲解。*/     
                        
                    //在无参的构造方法中,给性别重新赋值,年龄和姓名按照创建对象时默认的赋初值 
                    public Ren() 
                    { 
                            //改变性别的值 
                            Sex = "女"; 
                            Console.WriteLine("我刚出生!还没有名字,年龄也从0岁开始!"); 
                            //此时读取对象中的字段值的变化,应该性别改变,年龄和姓名都为默认值 
                            Say(); 
                    }    
                
                    //创建一个带姓名参数的构造方法,将创建对象时传入的name参数赋给对象中的字段name值,这样say方法中的姓名也有了改变 
                    //同时在这个构造方法中,给age字段自定义赋值。 
                    public Ren( string name ) 
                    {    
                         this. name =name ; 
                         Console.WriteLine("呦!我使用双截棍,我有名字了!,但是年龄呢?,我自己定,我就27岁了。"); 
                         age = 27; 
                         Say(); 
                    } 
     
                    //创建一个带姓名参数、姓名的构造方法,将创建对象时传入的name参数赋给对象中的字段name值, 
                    //将创建对象时传入的age参数的值赋给对象中的字段age,这样say方法中的姓名、年邻都有了改变 
                    
                        public Ren(int age, string name) 
                    { 
                            this.age = age; 
                            this.name = name; 
                            Console.WriteLine("哦!你给我起名字,告诉我多大了吧!你说的算!"); 
                            Say(); 
                    } 
     
                    //定义静态的构造函数,我把她放在在最后,但是会第一个被调用。 
                        static Ren() 
                        { 
                                Console.WriteLine("我是静态的构造函数,不能有参数及访问修饰符,并且创建对象时,我只执行一次,最先调用"); 
                                Console.WriteLine(); 
                        } 
             
            } 
            class Program 
            { 
                    static void Main(string[] args) 
                    { 
                            //创建无参的对象boby,并且创建时会先调用静态的构造方法,再调用无参的构造方法 
                            Ren boby = new Ren(); 
                            Console.WriteLine(); 
     
                            //创建有姓名参数的对象songer歌手 
                            Ren songer = new Ren("周杰伦"); 
                            Console.WriteLine(); 
     
                            //创建有年龄、姓名参数的对象man 
                            Ren man = new Ren(33,"贝克汉姆"); 
                            Console.WriteLine(); 
                    } 
     
            } 
    }
     
    结果如下
    我是静态的构造函数,不能有参数及访问修饰符,并且创建对象时,我只执行一次,最先调用
    我刚出生!还没有名字,年龄也从0岁开始!
    我的年龄:0,我的名字:,我的性别:女
    呦!我使用双截棍,我有名字了!,但是年龄呢?,我自己定,我就27岁了。
    我的年龄:27,我的名字:周杰伦,我的性别:男
    哦!你给我起名字,告诉我多大了吧!你说的算!
    我的年龄:33,我的名字:贝克汉姆,我的性别:男 
     
          在上面的例子中同学们会观察到我定义了一个static  Ren(){}的构造方法被称为静态构造方法。构造方法的重载中还包括一种,在方法的名字前的修饰符只有static,称为静态构造方法,使用静态构造方法要注意以下几点: 
    1.静态构造方法只有一个;
    2.并且没有参数;
    3在所有的构造方法中最先被执行;
    4.静态的构造方法不会被继承,因为它的修饰符是私有的并且只能是私有的;
    5.静态构造方法在所有静态成员本初始化后执行,也就是说如果在类中定义了静态成员,就会自动生成一个静态构造方法,否则如果要使用静态构造方法就得自定义。
    6.静态构造方法在所有静态成员被引用之前执行。
    7.静态构造方法在所有实例成员被分配之前执行。
           本例中还出现了this关键字,下面我们来说说this关键字,this关键字最大的用途就是用来区分类级别的变量和局部变量,当一个位于方法内部的局部变量与类级别的变量名称相同的时候,因为有效区域不同,因为并不不会发生冲突,但是如此一来,在方法内部所访问的变量,一定是其中所定义的局部变量,而非类级别的同名变量,在这种情况下,我们就使用this关键字,比如第一个实例中,用this代表对象本身,this.name指的是类级别中定义的name字段.使用this虽然可以让我们分辨出不同级别的变量,但是最好还是起不同的名字来区分变量。this关键字还有一种用法,就是在同类的构造方法中,指代无参的构造函数,使用:this()来实现继承。下面我们来看静态构造方法和this关键字的构造方法继承用法实例:
     
    静态构造方法和this关键字
    
     1 class StaticTest 
     2        { 
     3                //如果i没有初值,编译器不会自动创建静态构造方法。 
     4                public static int i = 1; 
     5 
     6                //创建自定义的静态构造器,观察它的执行顺序。 
     7                static StaticTest() 
     8                { 
     9                        Console.WriteLine("我应该在1的前面被调用,我只被调用一次。"); 
    10                } 
    11 
    12                //定义私有的实例变量j和s,不赋初值 
    13                int j; 
    14                string s; 
    15 
    16             //定义无参的构造器,同时给j和s赋值 
    17                public StaticTest() 
    18                { 
    19                        Console.WriteLine("我是无参构造器!,我给j赋值后,只要继承我,使用:this(),你们的j和s都是这个值"); 
    20                        j = 10; 
    21                        s = "原来的值"; 
    22                } 
    23 
    24                //通过:this()方式,继承了j和s的值 
    25 
    26                public StaticTest(string ss):this() 
    27                { 
    28                        //此时j=10,如果没有继承,j=0. 
    29                        Console.WriteLine("j=" + j); 
    30 
    31                        //通过传参进入的值,改变了继承了无参构造器中s的值, 
    32                        //说明即使继承了s的值,也可以在本构造方法中改变s的值 
    33                        s = ss; 
    34                        Console.WriteLine(s); 
    35                        
    36                } 
    37        } 
    38        class Program 
    39        { 
    40                static void Main(string[] args) 
    41                { 
    42                        //先调用静态成员i的值,结果会是先执行静态构造方法,再显示i=1; 
    43                        Console.WriteLine("用我前,先会查看是否有静态构造方法的定义,如果有先执行它,再得出i="+StaticTest.i); 
    44                        Console.WriteLine("-------------"); 
    45 
    46                        //此时不会再出现static构造器的内容,因为前面已经执行了一次。 
    47                        StaticTest A = new StaticTest(); 
    48                        Console.WriteLine("-------------"); 
    49 
    50                        //观察j和s值的变化: 
    51                        StaticTest B = new StaticTest("s的值改变了"); 
    52 
    53                } 
    54        }
     
    结果如下我应该在1的前面被调用,我只被调用一次。
    用我前,先会查看是否有静态构造方法的定义,如果有先执行它,再得出i=1
    -------------
    我是无参构造器!,我给j赋值后,只要继承我,使用:this(),你们的j和s都是这个值
    -------------
    我是无参构造器!,我给j赋值后,只要继承我,使用:this(),你们的j和s都是这个值
    j=10
    s的值改变了 
           通过上面的实例和注释,对照运行结果,同学们要熟练的运用和理解。
           因为我们现在还没有学习到继承,其实在一个类创建成对象的时候,创建时,编译器会先看这个类是否有父类,如果有父类,再继续找是否有父类的父类,我习惯叫爷爷类,如果有爷爷类,再看有没有太爷爷类,如果没有太爷爷类,就会先执行爷爷类的构造方法,再执行爸爸类的构造方法,最后才执行自己的构造方法,当然所有的构造方法的继承都是指实例构造函数,静态的构造函数是无法被继承的。下面的实例就是一个构造方法的继承顺序,现在看不懂没有关系,只是想让大家了解创建对象的工作过程,这里提前讲一个知识点就是继承的语法如A是父类,B是子类,那么在定义B类的时候,语法是这样写的Class B:A,用“:”来表明继承关系,在java中是用“extends”关键字,现在看看代码,理解一下构造方法的继承结果:
    构造方法在继承中的顺序
    
    class Class1                                    可以看出,类在继承时,构造函数在实例化的过程中,是会被再次调用的。 
            {    
                    static void Main()    
                    {    
                            Console.WriteLine("**********");    
                            A a = new A();    
                            Console.WriteLine("**********");    
                            B b = new B();    
                            Console.WriteLine("***** AC : A*****");    
                            AC ac = new AC();    
                            Console.WriteLine("*****BC : B*****");    
                            BC bc = new BC();    
                            Console.WriteLine("*****CC : AC*****");    
                            CC cc = new CC();    
                            Console.WriteLine("*****CCC : BC*****");    
                            CCC ccc = new CCC();    
                    }    
            }    
            class A    
            {    
                    public A()    
                    {    
                            Console.WriteLine("Call method A()");    
                    }    
            }    
            class B    
            {    
                    public B()    
                    {    
                            Console.WriteLine("Call method B()");    
                    }    
            }    
            class AC : A    
            {    
                    public AC()    
                    {    
                            Console.WriteLine("Call method AC()");    
                    }    
            }    
            class BC : B    
            {    
                    public BC()    
                    {    
                            Console.WriteLine("Call method BC()");    
                    }    
            }    
            class CC : AC    
            {    
                    public CC()    
                    {    
                            Console.WriteLine("Call method CC()");    
                    }    
            }    
            class CCC : BC    
            {    
                    public CCC()    
                    {    
                            Console.WriteLine("Call method CCC()");    
                    } 
     
    结果如下:**********
    Call method A()
    **********
    Call method B()
    ***** AC : A*****
    Call method A()
    Call method AC()
    *****BC : B*****
    Call method B()
    Call method BC()
    *****CC : AC*****
    Call method A()
    Call method AC()
    Call method CC()
    *****CCC : BC*****
    Call method B()
    Call method BC()
    Call method CCC()
    请按任意键继续. . . 
     
        虽然我没有写注释,但是相信同学们都应该能理解这个过程,构造器的继承我也会在类七中再继续深化讲解。构造方法的出现使得我们开发人员可设置默认值、限制实例化以及编写更加灵活且便于阅读的代码。接下来我们来学习本节课最后一个知识点,析构方法。
    析构方法
    
    --------------------------------------------------------------------------------
    
           析构方法也叫销毁方法,也有人称为析构器,类借助构造方法进行对象的初始化,借助析构方法进行对象的终止操作,析构方法也是使用类名相同的名称命名,用“~”修饰,当对象被系统终止并且回收时,析构方法执行,我们可以在析构方法中写方法,它会最后被执行,析构方法的语法书写如:~ClassName(){},析构函数是不能有参的,并且一个类中只能有一个析构方法,类中有几个构造方法,析构方法就有被执行几次。我们把上面的实例中加入析构方法,再执行一次代码。
    加入析构方法的第一个实例
    
    namespace hello 
    { 
            //创建一个人类Ren 
            class Ren 
            { 
                    //虽然我把析构方法写在最上面的,但是它是最后执行的方法。 
                    ~Ren() 
                    { 
                            Console.WriteLine("灭亡了"); 
                    } 
                    /*观察字段成员如果不赋初值时,在创建对象的时候, 
                     * 编译器会按照类型默认的给变量一个初值,如年龄、姓名 
                     * 我们可以在构造方法中,对未赋值的字段进行改变,如年龄 
                     * 如果字段已经赋初值了,那么创建对象的时候, 
                     * 就会使用初值,如果需要改变,就在构造方法中重新赋值即可,如性别*/ 
     
                    //定义一个年龄变量,不赋初值 
                    int age; 
                    //定义一个姓名变量,不赋初值 
                    string name; 
                    //定义一个性别变量,赋初值为男 
                    string Sex = "男"; 
     
                    //定义一个方法,读取类中字段成员,值的变化。 
                    void Say() 
                    { 
                            Console.WriteLine("我的年龄:{0},我的名字:{1},我的性别:{2}", age, name,Sex ); 
                    } 
     
     
                    /*1.以下方法都为Ren这个类的构造方法,他们因为参数不同,形成了方法的重载, 
                     * 2.this关键字:this关键字用来引用对象本身,已经是说,this.name指的是对象中的name字段, 
                     *     而=name的这个name指的是方法中离它定义最近的name,这里值的是构造方法中传入的name参数 
                     * this关键字在例子结束后,还会具体的讲解。*/     
                        
                    //在无参的构造方法中,给性别重新赋值,年龄和姓名按照创建对象时默认的赋初值 
                    public Ren() 
                    { 
                            //改变性别的值 
                            Sex = "女"; 
                            Console.WriteLine("我刚出生!还没有名字,年龄也从0岁开始!"); 
                            //此时读取对象中的字段值的变化,应该性别改变,年龄和姓名都为默认值 
                            Say(); 
                    }    
                
                    //创建一个带姓名参数的构造方法,将创建对象时传入的name参数赋给对象中的字段name值,这样say方法中的姓名也有了改变 
                    //同时在这个构造方法中,给age字段自定义赋值。 
                    public Ren( string name ) 
                    {    
                         this. name =name ; 
                         Console.WriteLine("呦!我使用双截棍,我有名字了!,但是年龄呢?,我自己定,我就27岁了。"); 
                         age = 27; 
                         Say(); 
                    } 
     
                    //创建一个带姓名参数、姓名的构造方法,将创建对象时传入的name参数赋给对象中的字段name值, 
                    //将创建对象时传入的age参数的值赋给对象中的字段age,这样say方法中的姓名、年邻都有了改变 
                    
                        public Ren(int age, string name) 
                    { 
                            this.age = age; 
                            this.name = name; 
                            Console.WriteLine("哦!你给我起名字,告诉我多大了吧!你说的算!"); 
                            Say(); 
                    } 
     
                    
                    //定义静态的构造函数,我把她放在在最后,但是会第一个被调用。 
                        static Ren() 
                        { 
                                Console.WriteLine("我是静态的构造函数,不能有参数及访问修饰符,并且创建对象时,我只执行一次,最先调用"); 
                                Console.WriteLine(); 
                        } 
                        
            } 
            class Program 
            { 
                    static void Main(string[] args) 
                    { 
                            //创建无参的对象boby,并且创建时会先调用静态的构造方法,再调用无参的构造方法 
                            Ren boby = new Ren(); 
                            Console.WriteLine(); 
     
                            //创建有姓名参数的对象songer歌手 
                            Ren songer = new Ren("周杰伦"); 
                            Console.WriteLine(); 
     
                            //创建有年龄、姓名参数的对象man 
                            Ren man = new Ren(33,"贝克汉姆"); 
                            Console.WriteLine(); 
                    } 
     
            } 
    }
     
    结果如下:
    
    我是静态的构造函数,不能有参数及访问修饰符,并且创建对象时,我只执行一次,最先调用
    我刚出生!还没有名字,年龄也从0岁开始!
    我的年龄:0,我的名字:,我的性别:女
    呦!我使用双截棍,我有名字了!,但是年龄呢?,我自己定,我就27岁了。
    我的年龄:27,我的名字:周杰伦,我的性别:男
    哦!你给我起名字,告诉我多大了吧!你说的算!
    我的年龄:33,我的名字:贝克汉姆,我的性别:男
    灭亡了
    灭亡了
    灭亡了
    请按任意键继续. . . 
    
    --------------------------------------------------------------------------------
    
             因为析构方法比较好理解,看这个实例同学们就能明白他的用法,析构函数的继承顺序是按照从派生程度最大到最小的顺序调用的,也就是与构造方法继承顺序相反,先结束子类的析构方法,再结束爸爸类的,再结束爷爷类的,这点也比较好理解,可以把构造方法和析构方法看出一对开始和结束的标记,内部的开始标记最先结束,最外部的开始标记,最后结束。
             本节课我们就学到这里,下节课我们来学习类的六大分类。
    本文出自 “叶子文文” 博客,转载请与作者联系!
    
    本文出自 51CTO.COM技术博客 
    
    展开全文
  • C#构造方法赋初始值

    千次阅读 2018-06-29 09:02:54
    namespace ConsoleApplication1 { public class Test { public int Id { get; set; } public string Name { get; set; } public string Country { get; set; } //public ...
    namespace ConsoleApplication1
    {
        public class Test
        {
    
            public int Id { get; set; }
            public string Name { get; set; }
            public string Country { get; set; }
    
            //public Test(int id, string name) : this(Id, Name, Country: "china")
            //{
    
            //}
            public Test(int id, string name, string country)
            {
                Id = id;
                Name = name;
                Country = country;
            }
    
            public Test(int id, string name) : this(id, name, "默认值")
            {
    
            }
    
            public override string ToString()
            {
                return this.Id + "---" + this.Name + "---" + this.Country;
            }
        }
    }
    

    using System;
    
    namespace ConsoleApplication1
    {
        static class Program
        {
    
            static void Main(string[] args)
            {
    
                Test test = new Test(1, "wang");
                Console.WriteLine(test);
                Test test1 = new Test(1, "wang121","lallaallaalal");
                Console.WriteLine(test1);
                Console.ReadKey();
            }
        }
    }

    展开全文
  • 定义一个构造方法 { Console.Write( " 1 " ); } } }     using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 { ...

     

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace ConsoleApplication1
    {
        class Program
        {
            static void Main(string[] args)
            {
                a a1 = new a();
    
                Console.ReadKey();
            }
        }
        class a
        {
            public a()//定义一个构造方法
            {
                Console.Write("1");
            }
        }
    }

     

     

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace ConsoleApplication1
    {
        class Program
        {
            static void Main(string[] args)
            {
                a a1 = new a("1");
    
                Console.ReadKey();
            }
        }
        class a
        {
            public a(string str)//定义一个构造方法
            {
                Console.Write(str);
            }
        }
    }

     

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace ConsoleApplication1
    {
        class Program
        {
            static void Main(string[] args)
            {
                a a1 = new a("1");
    
                Console.ReadKey();
            }
        }
        class a
        {
            /*
            public a()//如果自己不写那么默认这个
            { 
                
            }
            */
            public a(string str)//定义一个构造方法
            {
                Console.Write(str);
            }
        }
    }

     

     

     

     

    展开全文
  • C#构造方法

    热门讨论 2015-11-29 15:48:53
    C#构造方法
  • C#~构造方法

    千次阅读 2018-08-22 10:42:53
    构造方法的作用 构造方法的主要作用就是为类中的成员变量进行初始化。 ## 构造的注意事项 ## <1>构造方法名必须和类名相同。 <2>构造方法能狗添加参数。 <3>构造...
  • C#无参构造方法

    千次阅读 2019-05-31 13:17:23
    *如果没有显示定义构造方法,则会有一个默认的无参的构造方法 *如果显示定义了构造方法,则没有默认构造方法 *只能用new 方法名()的形式调用构造方法 *构造方法通常声明为public *构造方法没有返回值类型 *...
  • C# 静态构造方法

    2019-05-10 10:16:58
    1、静态的构造方法必须无参数 2、静态构造方法中不允许出现访问修饰符 3、静态构造方法内部只能含有static变量或者static其他方法,不能使用this关键字 二、静态构造函数执行顺序 1、先子类后父类 ...
  • 1、类的构造方法和结构体的构造方法都有空构造方法,但当在类中创建新的构造方法时,新的构造方法会覆盖无参的构造方法,但是在结构体中创建新的构造方法时,新的构造方法不会覆盖无参的构造方法 2、类的构造方法...
  • C#-构造方法+方法重载

    千次阅读 热门讨论 2014-02-17 16:47:00
    之前讲完什么是类和实例,现在我又学习了什么是构造方法和方法重载,总结一下!大家多提提意见! 一、构造方法是什么  构造方法又叫构造函数,其实就是对类进行初始化,构造方法与类同名,无返回制,也不需要void,...
  • C#---类的构造方法构造方法重载

    千次阅读 2017-03-18 21:31:41
    一,为什么用类的构造方法? 1. 解决在赋初值时重复的书写对象名的繁琐过程。 2. 假如有个属性,不允许用户随意改动,我们一般吧这个属性定义为只读属性,那么这个只读类型的属性就不能在实例化后对他赋值了,那我们...
  • 文章目录1 C#中的构造方法1.1 默认的无参构造方法1.2 自定义的无参构造方法1.3 自定义的有参数的构造函数 C#中的方法类型主要有如下几种: 实例方法 静态方法 抽象方法、虚方法 构造方法(对象创建的时候使用) ...
  • C#构造函数

    2019-06-09 20:01:43
    由于对象有状态,对象用户通过希望在使用对象之前先给对象的字段数据赋相关的值,每个C#类都提供了内建的默认构造函数,除了默认构造函数之外,类还会定义其他构造函数,也就是说在创建时直接初始化对象的状态。...
  • C#:继承之构造方法

    2019-01-27 12:43:34
    一、子类继承父类构造方法 演示:在各个子类中编写各自的构造方法,使用 base 关键字传值给父类。 父类: using System; using System.Collections.Generic; using System.Linq; using System.Text; using ...
  • 在子类中调用父类的默认构造函数(无参)(会先调用父类的,然后是子类的), 在这里 :base()可以直接不写,因为默认会调用父类中的默认构造函数。  调用有参数的构造函数,同样是会先调用父类的,然后是子类的...
  • c#继承中的构造方法那些事……

    千次阅读 2013-12-16 12:38:53
    对于继承,我想你们都很了解,但对于继承中的构造方法中的一些细节,我想你们中的某些人还未必了解……在此就扯蛋一下吧…… 1)子类诞生记: 当子类对象在堆内存中被创建时,会在子类对象内部同时创建一个...
  • http://www.zxbc.cn/html/20081215/68959.html关于C# WinForm中实现基于角色的权限菜单 大家都知道C#构造函数主要用来设置类中属性的初始值,但经常会忽视类的构造方法也可以象方法一样引用调用父类中的构造方法或...
  • 问题描述:两个类,继承关系,他们的构造方法没有方法体,但是类又不是抽象类 现有图片如下: ![图片说明](https://img-ask.csdn.net/upload/201709/21/1505990005_39562.png)![图片说明]...
  • c#构造函数练习

    千次阅读 2017-10-26 10:24:28
    写一个ticket类,有一个距离属性(本属性只读,在构造方法赋值),不能为负数,有一个价格属性,只读,并且根据distance计算价格每公里一块 0-100 不打折,101-200 9.5折 201-300 9折 300以上 8折 有一个方法。显示...
  • C# 构造函数避免IL代码膨胀的方法--C#编译有点狂啊
  • c#构造函数

    2013-11-11 18:50:00
    C#构造函数是在创建给定类型的对象时执行的类方法。构造函数具有与类相同的名称,它通常初始化新对象的数据成员。不带参数的构造函数称为“默认构造函数”。 无论何时,只要使用 new 运算符实例化对象,并且不为 new...
  • C#的继承以及继承中的构造方法

    千次阅读 2019-09-30 19:20:42
    简单的理解就是,让a类去继承b类,那么a类就会有b类中的属性,变量,方法,但不会继承b类的构造方法(相关构造方法的问题,下面再解释),当a类继承b类后,a类称作b类的子类,而b类称作a类的父类,还有其他的叫法,...
  • C#构造方法重载的相互调用

    千次阅读 2008-01-03 10:56:00
    C#中,构造函数可以使用 this 关键字调用同一对象中的另一构造函数。和 base 一样,this 可带参数使用也可不带参数使用,构造函数中的任何参数都可用作 this 的参数,或者用作表达式的一部分。namespace ...
  • C#构造函数详解

    万次阅读 2018-06-03 00:19:47
    构造函数 本文提供全流程,中文翻译。 Chinar 坚持将简单的生活方式,带给世人!(拥有更好的阅读体验 —— 高分辨率用户请根据需求调整网页缩放比例) Chinar —— 心分享、心创新!助力快速理解 构造...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 154,759
精华内容 61,903
关键字:

c#构造方法

c# 订阅