重写Object成员
重写 ToString()
代码实例：
[csharp]
view plain copynamespace _01ObjectOverloading
{
class Program
{
class Coordinate
{
private int m_nX;
private int m_nY;
public Coordinate(int x, int y)
{
m_nX = x;
m_nY = y;
}
public override string ToString()
{
return string.Format("Coordinate: x= {0}, y={1}", m_nX, m_nY);
}
}
static void Main(string[] args)
{
Coordinate testToStingOverride = new Coordinate(10, 20);
Console.WriteLine(testToStingOverride);
Console.ReadKey();
}
}
}
测试结果：
Coordinate: x= 10, y=20
重写 GetHashCode() 和 Equals()
GetHashCode() 和 Equals() 是object 可以重写的另两个方法，而且重写 Equals() 时系统要求重写
GetHashCode()，否则编译时会出现告警。原因是当我们想判断两个对象是否相等时，对于HashCode的
检查也是其中的一项，所以重写了 Equals()，系统也会提示重写 GetHashCode()。
重写 GetHashCode()主要是其中的Hash
算法，算法的性能，安全等等，这里不介绍Hash算法了，太多了。
重写 Equals()时，要主意两个概念，对象的同一性和相等的对象值。
对象的同一性：是指两个对象的引用指向的是堆上同一块内存地址，我们可以用 API ReferenceEquals() 来检查
两个对象是不是同一的。可以看作是物理上的。
对象的相等性：是指我们可以认为对象的某些成员变量的值相等了，这两个对象就相等了。例如我们可以为
同一个人创建两个对象，这两个对象中身份证号码是一样的，我们就可以认为这两个对象是描述的同一个人的
他们是相等的。
重写 Equals() 方法的一些关键点：(这个比较有用，实际情况下可以照搬一下，提高代码可靠性)
1) 检查是否为空
2) 如果是引用类型，就检查引用是否相等
3) 检查数据类型是否相等
4) 调用了一个指定了具体类型的辅助方法，
5) 检查散列码是否相等
6) 如果基类重写了Equals()，就检查 base.Equals()
7) 比较每一个标识字段，判断是否相等
8) 重写GetHashCode()
9) 重写 == 和 != 运算符
代码实例：(包括了重写 GetHashCode() 和 Equals())
[csharp]
view plain copyusing System;
using System.Collections.Generic;
using System.Text;
namespace _01ObjectOverloading
{
class Program
{
class Coordinate
{
private int m_nX;
private int m_nY;
public Coordinate(int x, int y)
{
m_nX = x;
m_nY = y;
}
public int X
{
get {return m_nX;}
}
public int Y
{
get { return m_nY; }
}
public override string ToString()
{
return string.Format("Coordinate: x= {0}, y={1}", m_nX, m_nY);
}
public override bool Equals(object obj)
{
// 1) 检查是否为空
if (obj == null)
{
return false;
}
// 2) 如果是引用类型，就检查引用是否相等
if (ReferenceEquals(this, obj))
{
return true;
}
// 3) 检查数据类型是否相等
if (this.GetType() != obj.GetType())
{
return false;
}
// 4) 调用了一个指定了具体类型的辅助方法，
return Equals((Coordinate)obj);
}
public bool Equals(Coordinate obj)
{
// 5) 检查散列码是否相等
if (this.GetHashCode() != obj.GetHashCode())
{
return false;
}
// 6) 如果基类重写了Equals()，就检查 base.Equals()
if (!base.Equals(obj))
{
return false;
}
// 7) 比较每一个标识字段，判断是否相等
if ((this.X != obj.X) || (this.Y != obj.Y))
{
return false;
}
return true;
}
// 8) 重写GetHashCode()
// 这里偷个懒没有写什么Hash 算法
public override int GetHashCode()
{
return base.GetHashCode();
}
// 9) 重写 == 和 != 运算符
public static bool operator ==(Coordinate leftHandSide, Coordinate rightHandSide)
{
if (ReferenceEquals(leftHandSide, null))
{
return ReferenceEquals(rightHandSide, null);
}
return leftHandSide.Equals(rightHandSide);
}
public static bool operator !=(Coordinate leftHandSide, Coordinate rightHandSide)
{
return !(leftHandSide == rightHandSide);
}
}
static void Main(string[] args)
{
Coordinate testToStingOverride = new Coordinate(10, 20);
Coordinate obj1 = new Coordinate(10, 20);
Coordinate obj1Ref = obj1;
Coordinate obj2 = new Coordinate(10, 20);
Coordinate result = null;
double dResult = 0;
Console.WriteLine(testToStingOverride);
if (obj1.Equals(obj1Ref))
{
Console.WriteLine("Obj1 and Obj1Ref are equal objects\n");
}
// using Equals function
if (obj1.Equals(obj2))
{
Console.WriteLine("using Equal function : Obj1 and Obj2 are equal objects\n");
}
else
{
Console.WriteLine("using Equal function : Obj1 and Obj2 are different objects\n");
}
// using operator "=="
if (obj1 == obj2)
{
Console.WriteLine("using operator == : Obj1 and Obj2 are equal objects\n");
}
else
{
Console.WriteLine("using operator == : Obj1 and Obj2 are different objects\n");
}
}
}
}
运算符重载
实现一个运算符的过程被称为运算符重载。好处是让程序更符合面向对象的概念，程序操作对象更加清晰。例如：如果没有运算符重载，两个对象相加时我们需要一个 add 函数 add(obj1, obj2)。如果重载了 + 运算符，这时就可以直接用 (obj1 + obj2)，对对象进行操作了。
C# 中的运算符重载
一元，运算符
+, -, !, ~, ++, --, true, false
二元运算符
+, -, *, /, %, &, |, ^, <<, >>
代码实例：
[csharp]
view plain copyusing System;
using System.Collections.Generic;
using System.Text;
namespace _01ObjectOverloading
{
class Program
{
class Coordinate
{
private int m_nX;
private int m_nY;
public Coordinate(int x, int y)
{
m_nX = x;
m_nY = y;
}
public int X
{
get {return m_nX;}
}
public int Y
{
get { return m_nY; }
}
public override string ToString()
{
return string.Format("Coordinate: x= {0}, y={1}", m_nX, m_nY);
}
//================================================
//重载操作符 +
public static Coordinate operator +(Coordinate leftHandSide, Coordinate rightHandSide)
{
int x = leftHandSide.X + rightHandSide.X;
int y = leftHandSide.Y + rightHandSide.Y;
Coordinate result = new Coordinate(x, y);
return result;
}
}
static void Main(string[] args)
{
Coordinate obj1 = new Coordinate(10, 20);
Coordinate obj2 = new Coordinate(10, 20);
Coordinate result = null;
double dResult = 0;
// test overloading operator +
Console.WriteLine("test overloading operator + ===========================\n");
result = obj1 + obj2;
Console.WriteLine(result);
Console.ReadKey();
}
}
}
关系运算符
==, !=, <, >, <=, >=
条件运算符不能被重载
&&, ||
数组运算符不能被重载，但可以定义索引器。
[]
转换运算符不能被重载，但可以定义隐式类型转换和显式类型转换运算符
()
代码实例：
[csharp]
view plain copyusing System;
using System.Collections.Generic;
using System.Text;
namespace _01ObjectOverloading
{
class Program
{
class Coordinate
{
private int m_nX;
private int m_nY;
public Coordinate(int x, int y)
{
m_nX = x;
m_nY = y;
}
public int X
{
get {return m_nX;}
}
public int Y
{
get { return m_nY; }
}
public override string ToString()
{
return string.Format("Coordinate: x= {0}, y={1}", m_nX, m_nY);
}
//================================================
//重载隐式转换运算符
public static implicit operator double (Coordinate obj)
{
return obj.X * obj.Y;
}
}
static void Main(string[] args)
{
Coordinate testToStingOverride = new Coordinate(10, 20);
Coordinate obj1 = new Coordinate(10, 20);
Console.WriteLine("test overloading operator implicit() ===========================\n");
dResult = (double)obj1;
Console.WriteLine("dResult = (double)obj1 : X*Y dResult = {0}", dResult);
Console.ReadKey();
}
}
}
赋值运算符不能被重载
+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=
下面的运算符不能被重载
=, ., ?:, ->, new, is, sizeof, typeof
