C#基础知识整理：基础知识（12） 超类Object
面向对象三大特性：封装，继承，多态。那么类是从哪里继承呢？在面向对象语言中有基类或者也叫做超类的概念，也就是所有类都是从这个类继承得来的，这个超类叫Object。.net中是这样描述Object类的：
支持 .NET Framework 类层次结构中的所有类，并为派生类提供低级别服务。这是 .NET Framework 中所有类的最终基类；它是类型层次结构的根。
既然是超类，Object定义了一些关键的方法。如下：
Equals方法——用于比较两个实例是否相等。
public virtual bool Equals(Object obj)，比较当前实例是否与obj相等；
public static bool Equals(Object objA,Object objB)，比较指定两个实例是否相等。
Finalize 方法——允许 Object 在“垃圾回收”回收 Object 之前尝试释放资源并执行其他清理操作。
GetHashCode 方法——获取一个对象的Hash值。
GetType方法——获取当前实例的Type。
MemberwiseClone 方法——创建当前实例的浅表副本，也就是如果当前实例有值，新创建的实例中只获取值类型的值，引用类型是没有获取值。
ReferenceEquals 方法——比较两个实例是否相同，与static bool Equals(Object objA,Object objB)用法一样。
ToString 方法——这个平时用的比较多，用于返回当前实例的string。
Object是超类，所以C#中的所有类都具有这些方法。
下面着重介绍下Equals和ToString方法。
一、对象比较
C#中有值类型和引用类型，简单的理解就是值类型保存对象的值，而引用类型是实例的引用，类似于C语言的指针。因此在使用对象的比较的时候，值类型比较两个对象值是否相等，引用类型比较指定的引用是否引用同一个对象。当然有时也会比较引用类型指向的实例值是否相同。
下面是对象比较的代码：
using System;
using System.Collections.Generic;
using System.Text;
namespace YYS.CSharpStudy.MainConsole.AboutObject
{
public class Int32Value : ICloneable
{
//字段，定义字段最好赋上初值
private int intValue = 0;
/// <summary>
/// 属性
/// </summary>
public int IntValue
{
get
{
return this.intValue;
}
set
{
this.intValue = value;
}
}
/// <summary>
/// 定义一个无参构造器
/// </summary>
public Int32Value() { }
/// <summary>
/// 带参数的构造器
/// </summary>
public Int32Value(int value)
{
this.intValue = value;
}
///// <summary>
///// 实现ICloneable接口
///// </summary>
public object Clone()
{
return this.MemberwiseClone();
}
}
}调用：
using System;
using YYS.CSharpStudy.MainConsole.AboutObject;
namespace YYS.CSharpStudy.MainConsole
{
class Program
{
static void Main(string[] args)
{
//声明一个Int32Value类型的引用value1，指向一个实例
Int32Value value1 = new Int32Value(30);
//声明value2，指向value1，此时两个引用是指向一个实例的
Int32Value value2 = value1;
//使用==比较
Console.WriteLine(string.Format("value1和value2 {0}", value1 == value2 ? "相同" : "不相同"));//相同
//调用Clone，复制一个value1的副本，赋值给value2
//此时是两个实例了
value2 = (Int32Value)value1.Clone();
//使用==比较
Console.WriteLine(string.Format("value1和value2 {0}", value1 == value2 ? "相同" : "不相同"));//不相同
//将value1赋给value2，此时他们指向同一个实例
value2 = value1;
//使用Equals比较
Console.WriteLine(string.Format("value1和value2 {0}", value1.Equals(value2) ? "相同" : "不相同"));//相同
//调用Clone，复制一个value1的副本，赋值给value2
//此时是两个实例了
value2 = (Int32Value)value1.Clone();
//使用Equals比较
Console.WriteLine(string.Format("value1和value2 {0}", value1.Equals(value2) ? "相同" : "不相同"));//不相同
Console.ReadLine();
}
}
}结果：
由代码可以看出：
a、对于引用类型，=运算符将引用从一个变量传递到另一个变量，所以=两边的变量引用同一个对象；
b、对于引用相同的两个变量，使用==运算符返回true；
c、对象的Clone方法产生一个新实例，返回该实例的引用，该实例的所有字段值和原对象相同，即Clone方法得到对象的一个副本。从Object类继承下来的保护方法MemberwiseClone返回当前对象的副本；
d、对于Clone方法返回的对象，其引用和原对象不同，==运算符返回false；
e、从Object继承下来的Equals方法结果和==运算符相同，只是比较当前引用(this)和参数保存的引用是否引用到了同一个对象上。
在上述代码的基础上，重写Equals方法。
using System;
using System.Collections.Generic;
using System.Text;
namespace YYS.CSharpStudy.MainConsole.AboutObject
{
public class Int32Value : ICloneable
{
//字段，定义字段最好赋上初值
private int intValue = 0;
/// <summary>
/// 属性
/// </summary>
public int IntValue
{
get
{
return this.intValue;
}
set
{
this.intValue = value;
}
}
/// <summary>
/// 定义一个无参构造器
/// </summary>
public Int32Value() { }
/// <summary>
/// 带参数的构造器
/// </summary>
public Int32Value(int value)
{
this.intValue = value;
}
///// <summary>
///// 实现ICloneable接口
///// </summary>
public object Clone()
{
return this.MemberwiseClone();
}
/// <summary>
/// 覆盖Equals方法
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public override bool Equals(object obj)
{
bool isEquals = Object.ReferenceEquals(obj, this);
if (isEquals == false)
{
Int32Value value = obj as Int32Value;
if (value != null)
{
isEquals = value.intValue == this.intValue;
}
}
return isEquals;
}
}
}调用
using System;
using YYS.CSharpStudy.MainConsole.AboutObject;
namespace YYS.CSharpStudy.MainConsole
{
class Program
{
static void Main(string[] args)
{
//声明一个Int32Value类型的引用value1，指向一个实例
Int32Value value1 = new Int32Value(30);
//声明value2，指向value1，此时两个引用是指向一个实例的
Int32Value value2 = value1;
//使用==比较
Console.WriteLine(string.Format("value1和value2 {0}", value1 == value2 ? "相同" : "不相同"));//相同
//调用Clone，复制一个value1的副本，赋值给value2
//此时是两个实例了
value2 = (Int32Value)value1.Clone();
//使用==比较
Console.WriteLine(string.Format("value1和value2 {0}", value1 == value2 ? "相同" : "不相同"));//不相同
//将value1赋给value2，此时他们指向同一个实例
value2 = value1;
//使用Equals比较
Console.WriteLine(string.Format("value1和value2 {0}", value1.Equals(value2) ? "相同" : "不相同"));//相同
//调用Clone，复制一个value1的副本，赋值给value2
//此时是两个实例了
value2 = (Int32Value)value1.Clone();
//使用Equals比较
Console.WriteLine(string.Format("value1和value2 {0}", value1.Equals(value2) ? "相同" : "不相同"));//相同
Console.ReadLine();
}
}
}结果：
修改后的代码：
覆盖了Equals方法，程序运行结果则不同了：Equals不再比较两个变量保存的对象引用是否相同，而是比较两个变量所引用的对象是否具有相同的属性值。
覆盖后的Equals执行流程是这样的：
我们看一下覆盖后Equals方法的具体执行流程：
a、使用Object静态方法ReferenceEquals比较参数obj和当前对象引用(this)是否相同，如果引用相同，则必为相同对象；
b、如果变量obj和当前引用不相同，则使用as运算符，尝试将obj类型转换和当前对象相同的类型，转换成功表示obj变量引用着和当前对象类相同的对象，as运算符转换后对象的引用，否则返回null，只有同类型的对象才需要比较，不同类型的对象必然是不同的对象；
c、如果as运算符转换对象成功，则进一步比较当前对象引用(this)和参数obj引用对象的字段值是否相等。
由上面两段代码可以看出：
==和Object类的Equals方法都是比较对象的引用是否相同，并不比较对象的字段是否相等；而Equals方法可以覆盖，以求让其对对象的字段进行等值比较或者其它的比较的需求。
因此，如果需要比较两个C#引用类型变量，除非确定需要比较的就是对象引用时才可以使用==运算符，否则应该使用对象的Equals方法，防止对象所属的类覆盖了这个方法。
上面是引用类型的比较，相对来说，值类型的比较就比较纯粹。值类型是不存在引用的，所以值类型就是比较两个对象值是否相等。当然如果覆盖了Equals方法就除外了。不过一般情况下，我们无需覆盖Equals方法。对于引用类型来说，等值比较就是比较对象的引用，引用不同的两个对象应该就是不同的对象；对于值类型来说，比较的就是所有字段的值，字段值不同的两个对象是不同的对象。只有在特殊情况下，才需要覆盖Equals方法，已定义某个类特殊的对象比较方法。
对于覆盖Equals方法，要注意：
注意：理论上可以用任意代码覆盖Equals方法，但要保证如下原则：
a、Equals只能用于对象比较，不能做其它任何用途；
b、对于两个已存在的对象，在对象未作任何改变的情况下，无论任何时候调用Equals方法，返回的结果应该是一样的；
c、对于对象a和b，则a.Equalse(b)和b.Equals(a)返回的结果应该是一样的；
d、覆盖了Equals方法，同时要覆盖GetHashCode(方法)，这个后面再详细说明。
二、ToString()
代码：
public class Int32Value : ICloneable
{
//字段，定义字段最好赋上初值
private int intValue = 0;
/// <summary>
/// 属性
/// </summary>
public int IntValue
{
get
{
return this.intValue;
}
set
{
this.intValue = value;
}
}
/// <summary>
/// 定义一个无参构造器
/// </summary>
public Int32Value() { }
/// <summary>
/// 带参数的构造器
/// </summary>
public Int32Value(int value)
{
this.intValue = value;
}
///// <summary>
///// 实现ICloneable接口
///// </summary>
public object Clone()
{
return this.MemberwiseClone();
}
/// <summary>
/// 重写ToString方法
/// </summary>
/// <returns></returns>
public override string ToString()
{
return this.intValue.ToString();
//return "重写ToString";
}
}调用：
class Program
{
static void Main(string[] args)
{
Int32Value value = new Int32Value(30);
Console.WriteLine(value.ToString());//30
//Console.WriteLine(value.ToString());//重写ToString
Console.ReadLine();
}
}可以看出，ToString方法可以用任意代码覆盖，只要返回string即可，但是在覆盖时也要返回符合需求的返回值。
以上就是C#基础知识整理：基础知识（12） 超类Object 的内容，更多相关内容请关注PHP中文网（www.php.cn）！
热AI工具
Undresser.AI Undress
人工智能驱动的应用程序，用于创建逼真的裸体照片
AI Clothes Remover
用于从照片中去除衣服的在线人工智能工具。
Undress AI Tool
免费脱衣服图片
Clothoff.io
AI脱衣机
Video Face Swap
使用我们完全免费的人工智能换脸工具轻松在任何视频中换脸！
热门文章
热工具
记事本++7.3.1
好用且免费的代码编辑器
SublimeText3汉化版
中文版，非常好用
禅工作室 13.0.1
功能强大的PHP集成开发环境
Dreamweaver CS6
视觉化网页开发工具
SublimeText3 Mac版
神级代码编辑软件(SublimeText3)
使用 C# 的活动目录
Sep 03, 2024 pm 03:33 PM
使用 C# 的 Active Directory 指南。在这里，我们讨论 Active Directory 在 C# 中的介绍和工作原理以及语法和示例。
c#多线程和异步的区别
Apr 03, 2025 pm 02:57 PM
多线程和异步的区别在于，多线程同时执行多个线程，而异步在不阻塞当前线程的情况下执行操作。多线程用于计算密集型任务，而异步用于用户交互操作。多线程的优势是提高计算性能，异步的优势是不阻塞 UI 线程。选择多线程还是异步取决于任务性质：计算密集型任务使用多线程，与外部资源交互且需要保持 UI 响应的任务使用异步。
