面向对象程序设计的概念

电玩女神 2021-12-22 04:37 415阅读 0赞

# OOP啊，给跪了 #

#  #

# 1.1 简介 #

在这一章中，我们将看到继承、重写等面向对象编程的概念是如何在C\#中实现的。我们还将学习有关操作符的重载。

## 1.2 构造函数 ##

构告函数是类中的方法，每次创建类的实例时，都将调用该方法。构造函数用于初始化成员变量。特点在于构造函数与类同名，并且不返回值。

下面我们来研究下示例：

示例1:

using System;

public class DaysInYear

private int days;

public DaysInYear()

days=365;

static void Main(String\[\] args)

DaysInYear newDaysInYear=new DaysInYear();

Console.WriteLine(newDaysInYear.days);

以上示例说明，我们在实例化类的对象时，首先执行的便是类的构造函数。此示例最终显示结果为365，如果我们去掉构造函数，得到的将会是值类型变量days的默认值0。

## 1.3 带参数的构造函数 ##

类是可以有多个构造函数的，可以将不同个数或不同类型的参数传递给这些构造函数，使它们产生不同的运行结果。

我们来看看下面的例子：

示例2:

using System;

public class DaysInYear

private int days;

public DaysInYear()

days=365;

public DaysInYear(int day)

days=day;

public DaysInYear(String dayOne)

days=Convert.ToInt32(dayOne);

public void setDay(int newDays)

days=newDays;

static void Main(String\[\] args)

DaysInYear newDaysInYear=new DaysInYear();

DaysInYear newDaysInYearInt=new DaysInYear(366);

DaysInYear newDaysInYearSrt=new DaysInYear(“366”);

Console.WriteLine(“默认值=\{0\}”,newDaysInYear.days);

Console.WriteLine(“传递的整型值=\{0\}”,newDaysInYearInt.days);

Console.WriteLine(“传递的字符串值=\{0\}”,newDaysInYearStr.days);

## 1.4 析构函数 ##

C\#的析构函数由垃圾回收器调用。垃圾回收器是定期地、或在内存状态要求（内存已满）时执行清理工作。这是C\#的高级机制。

在之前我们已经讲过析构函数的实现方式了。那么我们接下来讲一下垃圾回收器是如何工作的。

不能对结构使用析构函数。只能对类使用析构函数。

一个类只能有一个析构函数。

无法继承或重载析构函数。

无法调用析构函数。它们是被自动调用的。

析构函数既没有修饰符，也没有参数。

### 1.4.1 垃圾回收器和析构函数 ###

垃圾回收器负责释放内存，这是通过销毁不再被引用或不再使用的对象。工作原理如下：

如果为定义析构函数的对象分配了内存，运行库将把该对象添加到需要销毁的对象的列表中。运行库把析构函数当作销毁器，但在C\#中，将它称为析构函数。

垃圾回收器定期检查是否有未被引用的对象。

如果找到了其名称没有列在销毁器列表中的对象，就立即清除该对象。

如果对象名称列在需要销毁的对象列表中，则将它标记为“准备销毁”。

完成垃圾回收后，将调用销毁器线程，该线程则调用所有标记为“准备销毁”的对象的销毁方法（析构函数）。

对象销毁过程发生后，就将该对象从需要销毁的对象列表中删除。

因为该对象没有被引用，也没有列在销毁器列表中，所以下次进行垃圾回收时就会清除该对象。

当然，垃圾回收器也有某些缺陷。这些缺陷包括：

有析构函数的对象占用的资料较多，因为即使不再需要它们，它们仍会在内存中驻留罗长的时间。

销毁过程作为独立的线程执行，从而使资源被大量占用。

所以，建议只在必要时才使用析构函数。

## 1.5 C\#中的方法重载 ##

在C\#中，可以用以下两种方式重载方法：

指定不同个数的参数

指定不同参数的参数类型

C\#不支持对方法返回类型的重载

在示例2中，我们已经看见构造函数的名称相同，但其中两个接收参数，有一个不接收

参数。参数也有差别。这已经实现了构造函数重载。方法重载的方式与此类似。

### 1.5.1 不同参数个数的方法重载 ###

我们研究一下示例：

示例3：

using System;

public class Area

private int areaVal;

public void AreaCal(int radius)

areaVal=(22/7) \* radius \* radius;

public void AreaCal(int length,int breadth)

areaVal=length \* breadth;

public void AreaCal(int length, int breadth, int height)

areaVal=length \* breadth \* height;

static void Main(String\[\] args)

Area newArea=new Area();

Console.WriteLine(newArea.areaVal);

NewArea.AreaCal(6,8,10);

Console.WriteLine(newArea.areaVal);

NewArea.AreaCal(4,6);

Console.WriteLine(newArea.areaVal);

以上示例类Area的三个方法名称相同，都是AreaCal()。但是邮于使用不同个数的参数重载了这些方法。

### 1.5.2 不同参数类型的方法重载 ###

另一种重载方法的方式是指定不同的参数类型。传弟的参数个数无关紧要。参数的个数可以相同。

代码段2：

…

public void AreaCal(Int radius)

areaVal=(22/7)\* radius \* radius;

public void AreaCal(string shapeName)

Console.WriteLine(“\{0\}”,shapeName);

…

### 1.5.3 操作符重载 ###

C\#允许重载操作符。重载操作符意味着使操作符具有与其正常行为不同的行为。

下面我们来研究两段代码，这两段代码使用方法执行两个整数变量的加法运算。

代码段3：

…

//第1行

int result=Decimal.Add(54,200)

//第2行

int result2=54+200;

…

第1行使用值类型为Decimail的数据函数类的Add方法计算变量result。第2行使用加法运算符”+”符号计算结果。两者完成的是同样的任务。但是使用操作符的优点是方便而且简单易于理解。假设要建立一个二次方程。或使用方法计算恒星与地球之间的距离的公式，那么不用操作符编写这种算式将是非常困难的。

操作符可以使代码具有更好的可读性，同样，随着程序变得越来越复杂，将会有更多的类，那么这就间味着将要对这些对象执行很多运算。在这种情况下，重载操作符就会很有意义。重载操作符简化了对这些对象所执行的操作。当然也不是所有的操作符都可以重载的。重载操作符的方过程非常类似于创建方法的过程。所有重载的操作符都是静态方法。我们来看看可重载的操作符列表。

表4.1:可以重载的操作符

\+ - ! ~ ++ --

\* / % & | ^

<< >> != <, > <= >=

示例4：

using System;

public struct Distance

public Distance(int lon, int mag)

this.longitude=lon;

this.latitude=mag;

int longitude,latitude;

public static Distance operator – (Distance first,Distance second)

return new Distance(first.longitude – second.longitude,first.latitude – second.latitude)

public static void Main()

Distance start =new Distance();

Distance newDistance =new Distance();

Distance finish =new Distance();

start.longitude=12;

start.latitude=10;

finish.longitude=2;

finish.latitude=1;

newDistance=start – finish;

Console.WirteLine(“坐标X轴为\{0\},Y轴为\{1\}”,newDistance.longitude,newDistance.latitude);

在示例4中：

声明一个名为Distance结构，它有两个名为longitude和latitude的数据成员。

重载-(减号)操作符，当把结构为Distance的两个对象传递给它时该操作符执行两个对象的longitude和latitude分别相减，并返回Distance类型的另一个对象。

在Main()函数中声明三个Distance类型的对象。我们已经设置对象start和finish的longitude和latitude。newDistance对象使用重载的操作符”-”来接受其它两个对象的longitude和latitude相减后的结果。

将newDistance对象的longitude和latitude差值(即start减去finish对象的结果)显示给用户

重载操作符的过程可以详细解释为下列步骤。

请注意示例4的黑体部份，语法非常类似于声明方法的语法。

首先指定访问修饰符。在该示例中，我们使用public 访问修饰符。

关键字static使该操作符成为类的公共操作符，而不是特定对象的操作符。这是强制关建字。

然后，我们定义操作符的返回类型。返回类型是操作符的结果所使用的类型。在该示例中，返回类型是Distance。

在返回类型之后，指定关键字operator，该关键字必须在被子重载的操作符之前指定。这是强制关键字。

然后必须指定被重载的操作符。要注意保证该操作符在表4.1中。

必须指定该操作符执行运算时所用的参数。在该示例中，参数是两个Distance类型的对象。

在该示例中，我们只是将所传递的两个对象的longitude和latitude相减，并用另一个Distance对象返回结果。减法的结果被传回Distance()方法，以便newDistance对象的longitude属性和latitude属性赋值。

## 1.6 C\#中的继承 ##

面向对象的编程可以将新类作为另一个类的后代来声明和使用。这个过程称为继承。继承使我们不用重写代码。并提供代码重用的巨大好处。C\#中不支持多重继承，因为在应用程序变得很复杂时它会引起较大的混乱，并且就内存过载而言它也被视为效率不高的编程方式。现在我们学习一下单一继承。

示例5：

using System;

class characterVal

public int setCharVal(char ch)

char charVal=ch;

Console.WriteLine(“输入的字符是：\{0\}”, charVal);

return(0);

class StringVal : CharacterVal

public string strVal;

public int setStrVal(string str)

strVal=str;

Console.WriteLine(“输入的字符串是：\{0\}”,strVal);

return(0);

class Inheritance

StringVal objec1=new StringVal();

object1.setCharVal(“j”);

object1.setStrVal(“enjoy”);

示例5中，没有为类StringVal声明setCharVal()方法。我们创建了StringVal的对象object1。使用该object1对象，我们能够访问setCharVal方法。这是因为类StringVal继承了CharacterVal类。

### 1.6.1 密封类 ###

在C\#中，通过对类的继承进行密封可以避免对该类的继承。密封类使用的语法如下。

代码段5：

…

sealed class classOne

//类的实现

…

通过指定sealed关键字，可以密封任何类。此类保存在堆中。

当类只包括静态成员时，可能需要必须密封该类。此外在某些情况下密封类可以提高应用程序的性能。

## 1.7 C\#中的方法重写 ##

我们已经知道在C\#中如何实现继承。现在让我们考查如何实现方法重写。方法重写提供了重写或跳过基类的方法的灵活性。

重写基类的方法时，我们在继续类或派生类中声明一个与基类中的方法同名的新方法，并在方法名称前附加new关键字。

下面我们来研究下：

示例6：

using System;

class intAddition

public void Add()

int firstNum=1;

int secondNum=2;

Console.WriteLine(“两数之和为：\{0\}”, firstNum+secondNum);

class StringAddition :IntAdditon

new public Add()

string firstStr=”a”;

string secondStr=”b”;

Console.WriteLine(“两字符串之和为：\{0\}”,firstStr+secondStr);

class MethodOverride

public static void Main()

StringAddition objStringAddition = new StringAddition();

ObjStringAddition.add();

示例输出结果为：ab

在两个不同的类中都有一个名为Add（）的方法。请注意，类StringAddition重官了类IntAddition中方法Add(),因为类StringAddition在定义add方法前指定了new关键字。注意的是就算没有指定new关键字，也是执行重写，输出结果也将相同。编译器会报没有生成new关键字的警告。使用new关键字是比较谨慎的编程做法。

## 1.8 小结 ##

带参数的构造函数是接受参数的是构造函数。

我们将不同个数或不同类型的参数传递给构造函数，以便运行库能够区分它们。

在C\#中，析构函数由垃圾回收器调用。

垃圾回收器负责释放内存，这是通过销毁不再被引用的对象实现的。

在C\#中，可以用两种方式中的任何一种来重载方法。

指定不同个数的参数

指定不同类型的参数

C\#允许重载操作符

重载操作符意味着使操作符（例如，加法操作符+）在应用于结构或类的特定对象时具有不同的行为。

C\#不支持多重继承。

要重写基类的现有方法，需要在继承类中声明一个同名的新方法，并在方法名称前附加new关键字。