快捷搜索:
来自 计算机编程 2019-07-15 21:57 的文章
当前位置: 67677新澳门手机版 > 计算机编程 > 正文

构造函数和析构函数

  class SimpleClass
  {
  static public Object object = new Object();
  }

{
 public TestClass(): base() {} // 由CLR提供
}
  下面列举了几种类型的构造函数

  构造函数B(int,int)

  声明了一个类Point,它提供了两个构造函数。它们是重载的。一个是没有参数的Point构造函数和一个是有两个double参数的Point构造函数。如果类中没有提供这些构造函数,那么会CLR会自动提供一个缺省构造函数的。但一旦类中提供了自定义的构造函数,如Point()和Point(double x, double y),则缺省构造函数将不会被提供,这一点要注意。

  静态构造函数是实现对一个类进行初始化的方法成员。它一般用于对静态数据的初始化。静态构造函数不能有参数,不能有修饰符而且不能被调用,当类被加载时,类的静态构造函数自动被调用。如:

  至于执行基类的什么构造函数,缺省情况下是执行基类的无参构造函数,如果要执行基类的有参构造函数,则必须在派生类构造函数的成员初始化表中指出。如:

  2. 只有引用类型的引用所指向的对象实例才保存在堆(Heap)中,而堆因为是一个自由存储空间,所以它并没有像"栈"那样有生存期("栈"的元素弹出后就代表生存期结束,也就代表释放了内存),并且要注意的是,"垃圾回收器"只对这块区域起作用;

  一.构造函数与析构函数的原理

class A
{ private int x;
 public A( ) { x = 0; }
 public A( int i ) { x = i; }
};

  1)缺省构造函数

  如果类仅包含静态成员,你可以创建一个private的构造函数:private TestClass() {…},但是private意味着从类的外面不可能访问该构造函数。所以,它不能被调用,且没有对象可以被该类定义实例化。

  实例构造函数是实现对类中实例进行初始化的方法成员。如:

  2)实例构造函数

{
 public TestClass(): base() {}
}
  上面已介绍,它由系统(CLR)提供。

设计一个Book类Book.cs,代码如下所示:

  调用例子:

   7、如果没有写静态构造函数,而类中包含带有初始值设定的静态成员,那么编译器会自动生成默认的静态构造函数。

using System;
using System.Collections.Generic;
using System.Text;
namespace BookApplication
67677新澳门手机版 ,{
class Book
{
private string id;
private string name;
private string author;
private double price;

  根据经验,不少难以察觉的程序错误是由于变量没有被正确初始化或清除造成的,而初始化和清除工作很容易被人遗忘。微软利用面向对象的概念在设计C#语言时充分考虑了这个问题并很好地予以解决:把对象的初始化工作放在构造函数中,把清除工作放在析构函数中。当对象被创建时,构造函数被自动执行。当对象消亡时,析构函数被自动执行。这样就不用担心忘记对象的初始化和清除工作。

  也可以这样写,这和上面的做法其实没有区别:

C#构造函数及其函数的重载

  1、静态构造函数既没有访问修饰符,也没有参数。

class Point

创建一个BookApplication项目,为控制台应用程序。

除非是static,否则编译器将会给每一个没有构造函数的类指定一个默认的构造函数
构造函数private时候,类不能被实例化
派生类可以通过base来显式的调用基类的构造函数,当无显式调用时,编译器会自动的调用基类的默认构造函数
基类没有默认构造函数,派生类必须显式的调用base
构造函数可以标记为 public,protected,private,internal,protected internal
实例构造函数,静态构造函数。初始化静态类或者非静态类中的静态变量就必须定义静态构造函数。
私有构造函数存在的意义是为了防止被实例化,当一个类不想被声称为静态类,同时里面都是静态成员时候,可以使用静态构造函数。
C#不提供复制构造函数,如果需要得自己编写。
静态构造函数自动调用,发生在创建第一个实例或者引用任何静态成员之前。
析构函数时自动被调用,是通过垃圾回收机制
程序员无法控制何时调用析构函数,因为这是由垃圾回收器决定的。 垃圾回收器检查是否存在应用程序不再使用的对象。 如果垃圾回收器认为某个对象符合析构,则调用析构函数(如果有)并回收用来存储此对象的内存。 程序退出时也会调用析构函数。

  2、在创建第一个类实例或任何静态成员被引用时,.NET将自动调用静态构造函数来初始化类。

  构造函数的名字不能随便起,必须让编译器认得出才可以被自动执行。它的命名方法既简单又合理:让构造函数与类同名。除了名字外,构造函数的另一个特别之处是没有返回值类型,这与返回值类型为void的函数不同。如果它有返回值类型,那么编译器将不知所措。在你可以访问一个类的方法、属性或任何其它东西之前, 第一条执行的语句是包含有相应类的构造函数。甚至你自己不写一个构造函数,也会有一个缺省构造函数提供给你。

  在这里构造函数的执行次序是一定要分析清楚的。另外,如果基类A中没有提供无参构造函数public A( ) { x = 0; },则在派生类的所有构造函数成员初始化表中必须指出基类A的有参构造函数A(i),如下所示:

  --也就是说我们无法直接调用静态构造函数,也不可能知道静态构造函数何时会被调用。

class Test
{
 static void Main()
 {
  Point a = new Point();
  Point b = new Point(3, 4); // 用构造函数初始化对象
  …
 }
}

class B : A
{ private int y;
 public B( ) { y = 0; }
 public B( int i ) { y = i; }
 public B( int i, int j ):base(i) { y = j; }
};

  在使用静态构造函数的时候应该注意几点:

  虽然C#(更确切的说是CLR)提供了一种新的内存管理机制---自动内存管理机制(Automatic memory management),资源的释放是可以通过“垃圾回收器” 自动完成的,一般不需要用户干预,但在有些特殊情况下还是需要用到析构函数的,如在C#中非托管资源的释放。

  关键字:构造函数;析构函数;垃圾回收器;非托管资源;托管资源

  5、最多只运行一次。

  然而,有些情况下,当需要释放非托管资源时,就必须通过写代码的方式来解决。通常是使用析构函数释放非托管资源,将用户自己编写的释放非托管资源的代码段放在析构函数中即可。需要注意的是,如果一个类中没有使用到非托管资源,那么一定不要定义析构函数,这是因为对象执行了析构函数,那么"垃圾回收器"在释放托管资源之前要先调用析构函数,然后第二次才真正释放托管资源,这样一来,两次删除动作的花销比一次大多的。下面使用一段代码来示析构函数是如何使用的:

{
 public double x, y;
 public Point()
 {
  this.x = 0;
  this.y = 0;
 }
 public Point(double x, double y)
 {
  this.x = x;
  this.y = y;
 }
 …
}

  静态构造函数是C#的一个新特性,在编程过程中用处并不广,它的主要目的是用于初始化一些静态的变量。

}

  四.小结

  3、一个类只能有一个静态构造函数。

B b1 = new B(); //执行基类A的构造函数A(),再执行派生类的构造函数B()
B b2 = new B(1); //执行基类A的构造函数A(),再执行派生类的构造函数B(int)
B b3 = new B(0,1); //执行执行基类A的构造函数A(int) ,再执行派生类的

}

  以上是几种类型构造函数的简单运用,下面将重点介绍一下在类的层次结构中(即继承结构中)基类和派生类的构造函数的使用方式。派生类对象的初始化由基类和派生类共同完成:基类的成员由基类的构造函数初始化,派生类的成员由派生类的构造函数初始化。

构造函数与析构函数是一个类中看似较为简单的两类函数,但在实际运用过程中总会出现一些意想不到的运行错误。本文将较系统的介绍构造函数与析构函数的原理及在C#中的运用,以及在使用过程中需要注意的若干事项。

C#静态构造函数

声明了一个有静态构造函数的类Employee。注意静态构造函数只能对静态数据成员进行初始化,而不能对非静态数据成员进行初始化。

    public Book() // 默认的构造函数
    {

    }

    public Book(string id) // 第一个重载的构造函数
    {
         this.id = id;
     }

    public Book(string id, string name, string author, double price)  // 第二个重载的构造函数
    {
         this.id = id;
         this.name = name;
         this.author = author;
         this.price = price;
     }

    public string ISBN
     {
         get
         {
             return id;    // 设定ISBN属性为只读
        }
     }

    public string Name
     {
         set
         {
             this.name = value;
         }
         get
         {
             return name;
         }
     }

    public string Author
     {
         set
         {
             this.author = value;
         }
         get
         {
             return author;
         }
     }

    public double Price
     {
         set
         {
             this.price = value;
         }
         get
         {
             return price;
         }
     }

    public void updateBook(Book book)    // 修改图书Book的函数
    {
         this.Name = book.Name;
         this.Author = book.Author;
         this.Price = book.Price;
     }

    public void updateBook(string id)    // 重载的修改图书Book的函数
    {
         Book book = getBook(id);   // 调用getBook(string id)方法获取到一个Book对象
        this.Name = book.Name;
         this.Author = book.Author;
         this.Price = book.Price;
     }

public Book getBook(string id) // 根据图书Book的id,即ISBN编号,获取一个Book对象的方法
    {
         return new Book(id,"A New Bestseller Book","Bush",5.01);
     }
 }

  资源的释放一般是通过"垃圾回收器"自动完成的,但具体来说,仍有些需要注意的地方:

class TestClass

使用VS2005调试学习,如果想要在控制台调试输出,首先要创建一个基于C#的控制台项目。

但是,非静态构造函数既可以对静态数据成员赋值,也可以对非静态数据成员进行初始化。

关于说明,均在程序注释中,非常详尽。

   6、静态构造函数不可以被继承。

  1. 值类型和引用类型的引用其实是不需要什么"垃圾回收器"来释放内存的,因为当它们出了作用域后会自动释放所占内存,因为它们都保存在栈(Stack)中;

class B : A

现在测试一下,设计测试类为Program.cs,该类中在入口函数Main中进行测试:

namespace BookApplication
{
class Program
{
static void Main()
{
Book bookA = new Book("ISBN-2008-45-79-21"); // 通过构造函数public Book(string id)构造一个Book对象,并打印输出
bookA.Name = "Spring and Lucene";
bookA.Author = "Kekleet";
bookA.Price = 100.00;
Console.WriteLine("Book : " bookA);
Console.WriteLine("Book.ISBN : " bookA.ISBN);
Console.WriteLine("Book.Name : " bookA.Name);
Console.WriteLine("Book.Author : " bookA.Author);
Console.WriteLine("Book.Price : " bookA.Price);
Console.ReadLine();

using System;

  在程序中我们可以这样写:

  构造函数与析构函数虽然是一个类中形式上较简单的函数,但它们的使用决非看上去那么简单,因此灵活而正确的使用构造函数与析构函数能够帮你更好的理解CLR的内存管理机制,以及更好的管理系统中的资源

  析构函数是实现销毁一个类的实例的方法成员。析构函数不能有参数,不能任何修饰符而且不能被调用。由于析构函数的目的与构造函数的相反,就加前缀‘~’以示区别。

   4、无参数的构造函数可以与静态构造函数共存。

public class ResourceHolder
{

~ResourceHolder()
{
 // 这里是清理非托管资源的用户代码段
}
}

using System.Data;
class Employee
{
 private static DataSet ds;
 static Employee()
 {
  ds = new DataSet(...);
 }
 ...
}

  作为比C更先进的语言,C#提供了更好的机制来增强程序的安全性。C#编译器具有严格的类型安全检查功能,它几乎能找出程序中所有的语法问题,这的确帮了程序员的大忙。但是程序通过了编译检查并不表示错误已经不存在了,在“错误”的大家庭里,“语法错误”的地位只能算是冰山一角。级别高的错误通常隐藏得很深,不容易发现。

  --因为是.NET调用的,所以像public和private等修饰符就没有意义了。

  当创建派生类的对象时,系统将会调用基类的构造函数和派生类的构造函数,构 造函数的执行次序是:先执行基类的构造函数,再执行派生类的构造函数。如果派生类又有对象成员,则,先执行基类的构造函数,再执行成员对象类的构造函数,最后执行派生类的构造函数。

using System;
using System.Collections.Generic;
using System.Text;

{
private int y;
 public B():A(i) { y = 0; }
 public B(int i):A(i) { y = i; }
 public B(int i, int j):A(i) { y = j; }
};

class A
{ private int x;
 public A( int i ) { x = i; }
};

  3) 静态构造函数

  --尽管参数列表相同,但一个属于类,一个属于实例,所以不会冲突。

  三.析构函数和垃圾回收器在C#中的运用

        Console.WriteLine("*****************************************");
         Book bookB = new Book("ISBN-2008-20-08-08", "VS2005开发指南", "猫猫", 56.89); // 通过构造函数public Book(string id, string name, string author, double price)构造一个Book对象,并打印输出
        Console.WriteLine("Book : "   bookB);
         Console.WriteLine("Book.ISBN : "   bookB.ISBN);
         Console.WriteLine("Book.Name : "   bookB.Name);
         Console.WriteLine("Book.Author : "   bookB.Author);
         Console.WriteLine("Book.Price : "   bookB.Price);
         Console.ReadLine();

        Console.WriteLine("*****************************************");
         Book bookC = new Book("ISBN-9999-99-99-99", "9999数字技术", "阿盟", 99.99); 
        bookA.updateBook(bookC);    // 调用public void updateBook(Book book)函数修改bookA信息
        Console.WriteLine("bookA 修改之后信息如下所示:" );
         Console.WriteLine("Book : "   bookA);
         Console.WriteLine("Book.ISBN : "   bookA.ISBN);
         Console.WriteLine("Book.Name : "   bookA.Name);
         Console.WriteLine("Book.Author : "   bookA.Author);
         Console.WriteLine("Book.Price : "   bookA.Price);
         Console.ReadLine();

        Console.WriteLine("*****************************************");
         string id = "ISBN-0000-00-00-00";
         bookB.updateBook(id);   // 调用public void updateBook(string id)函数修改bookB信息
        Console.WriteLine("bookB 修改之后信息如下所示:");
         Console.WriteLine("Book : "   bookB);
         Console.WriteLine("Book.ISBN : "   bookB.ISBN);
         Console.WriteLine("Book.Name : "   bookB.Name);
         Console.WriteLine("Book.Author : "   bookB.Author);
         Console.WriteLine("Book.Price : "   bookB.Price);
         Console.ReadLine();
     }
 }

  因为这个构造函数是属于类的,而不属于任何一个实例,所以这个构造函数只会被执行一次,而且是在创建此类的第一个实例或引用任何静态成员之前,由.NET自动调用。

  二.构造函数在C#中的运用

  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  namespace test1_constrator
  {
  class Program
  {
  static void Main(string[] args)
  {
  Class1 o1 = new Class1();
  Class1 o2 = new Class1();
  }
  }
  class Class1
  {
  private static int count = 0;
  static Class1(){
  count ;
  System.Console.Write("Static" count.ToString());
  }
  public Class1()
  {
  count ;
  System.Console.Write("Public" count.ToString());
  }
  }
  }

class TestClass

  class SimpleClass
  {
  static public Object object;
  // Static constructor
  static SimpleClass()
  {
  // Initialize static parameter
  somthing
  }
  }

本文由67677新澳门手机版发布于计算机编程,转载请注明出处:构造函数和析构函数

关键词: