C，C++，C#，Java？这些有什么区别？

Dear 丶 2024-02-19 16:56 50阅读 0赞

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/weixin\_37848710/article/details/78123037  
c，c++，c\#，java？这些有什么区别？

C语言:

目前最著名、最有影响、应用最广泛的windows、linux和UNIX三个操作系统都是用C语言编写的。0S是计算机系统(由软硬件两个子系统构成)的核心和灵魂，它是软件中最庞大最复杂的系统软件。既然如此庞大复杂的0S都可以用c语言编写，从狭义而言，还有什么系统软件和应用软件不能用c语言编写呢?由此可以肯定的说，c语言是一门十分优秀而又重要的语言。

c语言程序设计是过程性程序设计语言，它的发展贯穿了计算机发展的历程，它蕴含了程序设计的基本思想，囊括了程序设计的基本概念，所以它是理工科高等院校的一门基础课程。

从市面上有关c语言的书籍和高等院校采用的教材来看，它们有一个共性，那就是：脱离了实际应用（全是小打小闹的小例子），纯粹的过程性程序设计，没有软件工程思想的体现，没有一定程序设计风格，仅仅是为了让大家明白什么是c语言而已。

高等院校开设c语言程序设计的目的是让学生对程序设计有个入门，有个直观的理解，同时为其他后续课程作铺垫。

C++:

C++语言是在C语言的基础是扩展而成的.所以两种语言的基本语法和语义是相同。C++中加入了面向对程序设计(OOP)的特征。

下面的三个主要性质刻划OOP语言的特点：

封装性：把一个数据结构同操作的函数（行为或方法）组合在一起。封装性是借助于一种新的结构和数据类型机制——类实现的。

继承性：建立一个新的派生类，它从一个或多个先前定义的基类中继承函数和数据，而且可能重新定义或加进新的数据行为，这样就建立了类的层次。

多态性：给行为取一个名字或符号，它共享一个类的层次，在这个层次中的每个类都以适合自己的方式实现这个行为。

C\#:

C\#(读做 "C sharp"，中文译音“夏普”)是微软公司发布的一种面向对象的、运行于.NET Framework之上的高级程序设计语言,并定于在微软职业开发者论坛(PDC)上登台亮相.C\#是微软公司研究员Anders Hejlsberg的最新成果.C\#看起来与Java有着惊人的相似;它包括了诸如单一继承,界面,与Java几乎同样的语法,和编译成中间代码再运行的过程.但是C\#与Java有着明显的不同,它借鉴了Delphi的一个特点,与COM(组件对象模型)是直接集成的,而且它是微软公司.NET windows网络框架的主角.

Java:

Java是一种可以编写跨平台应用软件的面向对象的程序设计语言，由升阳（太阳微电子，Sun Microsystems）公司的James Gosling等人于1990年代初开发的.具有以下特征的高级程序语言：

简单面向对象可分布可解释强壮安全性结构化轻便功能强大多线程动态...

Java既可以被编译，也可以被解释。通过编译器，可以把Java程序翻译成一种中间代码 -称为字节码 -可以被Java解释器解释的独立于平台的代码。通过解释器，每条Java字节指令被分析，然后在计算机上运行。只需编译一次，程序运行时解释执行。

C语言与VC＋＋的区别有很多：

1，全新的程序程序思维，C语言是面向过程的，而VC＋＋是面向对象的。

2，C语言有标准的函数库，它们松散的，只是把功能相同的函数放在一个头文件中；而VC++对于大多数的函数都是有集成的很紧密，特别是C语言中没有的VC++6.0中的API是对Window系统的大多数API有机的组合，是一个集体。但你也可能单独调用API。

3，特别是VC++中的图形处理，它和语言的图形有很大的区别。C语言中的图形处理函数基本上是不能用在中VC++中的。主持人注：C语言标准中不包括图形处理。这里的C语言的图形处理指的是DOS下的C语言。

4，C和VC++中都有结构的概念，但是在C语言中结构只有成员变量，而没成员方法，而在VC++中结构中，它可以有自己的成员变量和成员函数。但是在C语言中结构的成员是公共的，什么想访问它的都可以访问；而在VC++中它没有加限定符的为私有的。

4，C语言可以写很多方面的程序，但是VC++可以写得更多更好，VC++可以写基于DOSr程序，写DLL，写控件，写系统。

5，C语言对程序的文件的组织是松散的，几乎是全要程序处理；而vc++对文件的组织是以工程，各文件分类明确。

6，VC++中的IDE很智能，和VB一样，有的功能可能比VB还强。

7，VC++对可以自动生成你想要的程序结构使你可以省了很多时间。有很多可用的工具如加入MFC中的类的时候，加入变量的时候等等。

8，VC++中的附加工具也有很多，可以进行系统的分析，可以查看API；可以查看控件。

9，调试功能强大，并且方法多样。

首先我先回答你关于“面向对象”和“面向过程”的区别。

他们主要是编程的思想的不同。。。

举个例子：比如你想做一个模型飞机，利用“面向过程”的思想，你所想的就是，先做头再做身体，再做尾巴。。它是一个比较顺着的概念。而如果利用“面向对象”的思想，你所想的就是，你要做飞机的话，它有翅膀，头部，身体，尾巴等各个部件，你先把各个部分做好，再考虑他们的直接的接口怎么连。。。这就是区别。你可以发现“面向对象”的优势。

再就是C，C++,C\#的问题。。由于我是先学的C语言再学的C++，所以，我的想法就是，光是从C语言和C++这个方向上说的话，而不从他们的编程程序VC6.0以及turboC来说，C++是在C语言的思想上引入了关键性的“类（class）”的问题。而从编程的总体思想上即算法上区别不大。所以，我建议你先把C语言学好，学通。。再去学C++，最后学VC++。学C语言主要学算法，C++则主要掌握关于类，封装，虚函数，继承等。。再去学VC++，一定不能乱了顺序，又或者学的不精就转下一个，不然。。。你就知道什么真正的叫“困难”了。。

C\#与Java的比较

C\#（C-Sharp）是Microsoft的新编程语言，被誉为“C/C++家族中第一种面向组件的语言”。然而，不管它自己宣称的是什么，许多人认为C\#更像是Java的一种克隆，或者是Microsoft用来替代Java的产品。事实是否是这样的呢？

本文的比较结果表明，C\#不止是Java的同胞那么简单。如果你是一个Java开发者，想要学习C\#或者了解更多有关C\#的知识，那么本文就是你必须把最初10分钟投入于其中的所在。

一、C\#、C++和Java  
C\#的语言规范由Microsoft的Anders Hejlsberg与Scott Wiltamuth编写。在当前Microsoft天花乱坠的宣传中，对C\#和C++、Java作一番比较总是很有趣的。考虑到当前IT媒体的舆论倾向，如果你早就知道C\#更接近Java而不是C++，事情也不值得大惊小怪。对于刚刚加入这场讨论的读者，下面的表1让你自己作出判断。显然，结论应该是：Java和C\#虽然不是孪生子，但C\#最主要的特色却更接近Java而不是C++。

![Center][]  
了解表1总结的重要语言功能之后，请继续往下阅读，了解C\#和Java的一些重要区别。

二、语言规范的比较  
2.1、简单数据类型  
简单数据类型（Primitive）在C\#中称为值类型，C\#预定义的简单数据类型比Java多。例如，C\#有unit，即无符号整数。表2列出了所有C\#的预定义数据类型：

![Center 1][]

2.2、常量

忘掉Java中的static final修饰符。在C\#中，常量可以用const关键词声明。

public const int x = 55;  
此外，C\#的设计者还增加了readonly关键词。如果编译器编译时未能确定常量值，你可以使用readonly关键词。readonly域只能通过初始化器或类的构造函数设置。

2.3、公用类的入口点

在Java中，公用类的入口点是一个名为main的公用静态方法。main方法的参数是String对象数组，它没有返回值。在C\#中，main方法变成了公用静态方法Main（大写的M），Main方法的参数也是一个String对象数组，而且也没有返回值，如下面的原型声明所示：

public static void Main(String\[\] args)  
但是，C\#的Main方法不局限于此。如果不向Main方法传递任何参数，你可以使用上述Main方法的一个重载版本，即不带参数列表的版本。也就是说，下面的Main方法也是一个合法的入口点：  
public static void Main()  
另外，如果你认为有必要的话，Main方法还可以返回一个int。例如，下面代码中的Main方法返回1：  
using System;  
public class Hello \{  
public static int Main() \{  
Console.WriteLine("Done");  
return 1;  
\}  
\}  
与此相对，在Java中重载main方法是不合法的。

2.4、switch语句

在Java中，switch语句只能处理整数。但C\#中的switch语句不同，它还能够处理字符变量。请考虑下面用switch语句处理字符串变量的C\#代码：

using System;  
public class Hello \{  
public static void Main(String\[\] args) \{  
switch (args\[0\]) \{  
case "老板":  
Console.WriteLine("早上好！我们随时准备为您效劳！");  
break;  
case "雇员":  
Console.WriteLine("早上好！你可以开始工作了！");  
break;  
default:  
Console.WriteLine("早上好！祝你好运！");  
break;  
\}  
\}  
\}  
与Java中的switch不同，C\#的switch语句要求每一个case块或者在块的末尾提供一个break语句，或者用goto转到switch内的其他case标签。

2.5、foreach语句

foreach语句枚举集合中的各个元素，为集合中的每一个元素执行一次代码块。请参见下面的例子。

using System;  
public class Hello \{  
public static void Main(String\[\] args) \{  
foreach (String arg in args)  
Console.WriteLine(arg);  
\}  
\}  
如果在运行这个执行文件的时候指定了参数，比如“Hello Peter Kevin Richard”，则程序的输出将是下面几行文字：  
  
Peter  
Kevin  
Richard

2.6、C\#没有>>>移位操作符

C\#支持uint和ulong之类的无符号变量类型。因此，在C\#中，右移操作符（即“>>”）对于无符号变量类型和带符号变量类型（比如int和long）的处理方式不同。右移uint和ulong丢弃低位并把空出的高位设置为零；但对于int和long类型的变量，“>>”操作符丢弃低位，同时，只有当变量值是正数时，“>>”才把空出的高位设置成零；如果“>>”操作的是一个负数，空出的高位被设置成为1。

Java中不存在无符号的变量类型。因此，我们用“>>>”操作符在右移时引入负号位；否则，使用“>>”操作符。

2.7、goto关键词

Java不用goto关键词。在C\#中，goto允许你转到指定的标签。不过，C\#以特别谨慎的态度对待goto，比如它不允许goto转入到语句块的内部。在Java中，你可以用带标签的语句加上break或continue取代C\#中的goto。

2.8、声明数组

在Java中，数组的声明方法非常灵活，实际上有许多种声明方法都属于合法的方法。例如，下面的几行代码是等价的：

int\[\] x = \{ 0, 1, 2, 3 \};  
int x\[\] = \{ 0, 1, 2, 3 \};  
但在C\#中，只有第一行代码合法，\[\]不能放到变量名字之后。

2.9、包

在C\#中，包（Package）被称为名称空间。把名称空间引入C\#程序的关键词是“using”。例如，“using System;”这个语句引入了System名称空间。

然而，与Java不同的是，C\#允许为名称空间或者名称空间中的类指定别名：

using TheConsole = System.Console;  
public class Hello \{  
public static void Main() \{  
TheConsole.WriteLine("使用别名");  
\}  
\}  
虽然从概念上看，Java的包类似于.NET的名称空间。然而，两者的实现方式不同。在Java中，包的名字同时也是实际存在的实体，它决定了放置.java文件的目录结构。在C\#中，物理的包和逻辑的名称之间是完全分离的，也就是说，名称空间的名字不会对物理的打包方式产生任何影响。在C\#中，每一个源代码文件可以从属于多个名称空间，而且它可以容纳多个公共类。

.NET中包的实体称为程序集（Assembly）。每一个程序集包含一个manifest结构。manifest列举程序集所包含的文件，控制哪些类型和资源被显露到程序集之外，并把对这些类型和资源的引用映射到包含这些类型与资源的文件。程序集是自包含的，一个程序集可以放置到单一的文件之内，也可以分割成多个文件。.NET的这种封装机制解决了DLL文件所面临的问题，即臭名昭著的DLL Hell问题。

2.10、默认包

在Java中，java.lang包是默认的包，它无需显式导入就已经自动包含。例如，要把一些文本输出到控制台，你可以使用下面的代码：

System.out.println("Hello world from Java");  
C\#中不存在默认的包。如果要向控制台输出文本，你使用System名称空间Console对象的WriteLine方法。但是，你必须显式导入所有的类。代码如下：  
  
using System;  
public class Hello \{  
public static void Main() \{  
Console.WriteLine("Hello world from C\#");  
\}  
\}  
2.11、面向对象

Java和C\#都是完全面向对象的语言。在面向对象编程的三大原则方面，这两种语言接近得不能再接近。

继承：这两种语言都支持类的单一继承，但类可以实现多个接口。所有类都从一个公共的基类继承。

封装与可见性：无论是在Java还是C\#中，你都可以决定类成员是否可见。除了C\#的internal访问修饰符之外，两者的可见性机制非常相似。

多态性：Java和C\#都支持某些形式的多态性机制，且两者实现方法非常类似。

2.12、可访问性

类的每个成员都有特定类型的可访问性。C\#中的访问修饰符与Java中的基本对应，但多出了一个internal。简而言之，C\#有5种类型的可访问性，如下所示：

public：成员可以从任何代码访问。

protected：成员只能从派生类访问。

internal：成员只能从同一程序集的内部访问。

protected internal：成员只能从同一程序集内的派生类访问。

private：成员只能在当前类的内部访问。

2.13、派生类

在Java中，我们用关键词“extends”实现继承。C\#采用了C++的类派生语法。例如，下面的代码显示了如何派生父类Control从而创建出新类Button：

public class Button: Control \{ . . \}

2.14、最终类

由于C\#中不存在final关键词，如果想要某个类不再被派生，你可以使用sealed关键词，如下例所示：

sealed class FinalClass \{ . . \}

2.15、接口

接口这个概念在C\#和Java中非常相似。接口的关键词是interface，一个接口可以扩展一个或者多个其他接口。按照惯例，接口的名字以大写字母“I”开头。下面的代码是C\#接口的一个例子，它与Java中的接口完全一样：

interface IShape \{ void Draw(); \}  
扩展接口的语法与扩展类的语法一样。例如，下例的IRectangularShape接口扩展IShape接口（即，从IShape接口派生出IRectangularShape接口）  
interface IRectangularShape: IShape \{ int GetWidth(); \}  
如果你从两个或者两个以上的接口派生，父接口的名字列表用逗号分隔，如下面的代码所示：  
interface INewInterface: IParent1, IParent2 \{ \}  
然而，与Java不同，C\#中的接口不能包含域（Field）。

另外还要注意，在C\#中，接口内的所有方法默认都是公用方法。在Java中，方法声明可以带有public修饰符（即使这并非必要），但在C\#中，显式为接口的方法指定public修饰符是非法的。例如，下面的C\#接口将产生一个编译错误。

interface IShape \{ public void Draw(); \}

2.16、is和as操作符

C\#中的is操作符与Java中的instanceof操作符一样，两者都可以用来测试某个对象的实例是否属于特定的类型。在Java中没有与C\#中的as操作符等价的操作符。as操作符与is操作符非常相似，但它更富有“进取心”：如果类型正确的话，as操作符会尝试把被测试的对象引用转换成目标类型；否则，它把变量引用设置成null。

为正确理解as操作符，首先请考虑下面这个例子中is操作符的运用。这个例子包含一个IShape接口，以及两个实现了IShape接口的类Rectangle和Circle。

编译好代码之后，用户可以输入“rectangle”或者“circle”作为Main方法的参数。如果用户输入的是“circle”，则shape被实例化成为一个Circle类型的对象；反之，如果用户输入的是“rectangle”，则shape被实例化成为Rectangle类型的对象。随后，程序用is操作符测试shape的变量类型：如果shape是一个矩形，则shape被转换成为Rectangle对象，我们调用它的GetWidth方法；如果shape是一个圆，则shape被转换成为一个Circle对象，我们调用它的GetRadius方法。

如果使用as操作符，则上述代码可以改成如下形式：

using System;  
interface IShape \{  
void draw();  
\}  
public class Rectangle: IShape \{  
public void draw() \{  
\}  
public int GetWidth() \{  
return 6;  
\}  
\}  
public class Circle: IShape \{  
public void draw() \{  
\}  
public int GetRadius() \{  
return 5;  
\}  
\}  
public class LetsDraw \{  
public static void Main(String\[\] args) \{  
IShape shape = null;  
if (args\[0\] == "rectangle") \{  
shape = new Rectangle();  
\}  
else if (args\[0\] == "circle") \{  
shape = new Circle();  
\}  
Rectangle rectangle = shape as Rectangle;  
if (rectangle != null) \{  
Console.WriteLine("Width : " + rectangle.GetWidth());  
\}  
else \{  
Circle circle = shape as Circle;  
if (circle != null)  
Console.WriteLine("Radius : " + circle.GetRadius());  
\}  
\}  
\}  
在上面代码的粗体部分中，我们在没有测试shape对象类型的情况下，就用as操作符把shape转换成Rectangle类型的对象。如果shape正好是一个Rectangle，则shape被转换成为Rectangle类型的对象并保存到rectangle变量，然后我们调用它的GetWidth方法。如果这种转换失败，则我们进行第二次尝试。这一次，shape被转换成为Circle类型的对象并保存到circle变量。如果shape确实是一个Circle对象，则circle现在引用了一个Circle对象，我们调用它的GetRadius方法。

2.17、库

C\#没有自己的类库。但是，C\#共享了.NET的类库。当然，.NET类库也可以用于其他.NET语言，比如VB.NET或者JScript.NET。值得一提的是StringBuilder类，它是对String类的补充。StringBuilder类与Java的StringBuffer类非常相似。

2.18、垃圾收集

C++已经让我们认识到手工管理内存是多么缺乏效率和浪费时间。当你在C++中创建了一个对象，你就必须手工地拆除这个对象。代码越复杂，这个任务也越困难。Java用垃圾收集器来解决这个问题，由垃圾收集器搜集不再使用的对象并释放内存。C\#同样采用了这种方法。应该说，如果你也在开发一种新的OOP语言，追随这条道路是一种非常自然的选择。C\#仍旧保留了C++的内存手工管理方法，它适合在速度极端重要的场合使用，而在Java中这是不允许的。

2.19、异常处理

如果你听说C\#使用与Java相似的异常处理机制，你不会为此而惊讶，对吧？在C\#中，所有的异常都从一个名为Exception的类派生（听起来很熟悉？）另外，正如在Java中一样，你还有熟悉的try和catch语句。Exception类属于.NET System名称空间的一部分。

三、Java没有的功能

C\#出生在Java成熟之后，因此，C\#拥有一些Java（目前）还没有的绝妙功能也就不足为奇。

3.1、枚举器

枚举器即enum类型（Enumerator，或称为计数器），它是一个相关常量的集合。精确地说，enum类型声明为一组相关的符号常量定义了一个类型名字。例如，你可以创建一个名为Fruit（水果）的枚举器，把它作为一个变量值的类型使用，从而把变量可能的取值范围

public class Demo \{  
public enum Fruit \{  
Apple, Banana, Cherry, Durian  
\}  
public void Process(Fruit fruit) \{  
switch (fruit) \{  
case Fruit.Apple:  
...  
break;  
case Fruit.Banana:  
...  
break;  
case Fruit.Cherry:  
...  
break;  
case Fruit.Durian:  
...  
break;  
\}  
\}  
\}  
在上例的Process方法中，虽然你可以用int作为myVar变量的类型，但是，使用枚举器Fruit之后，变量的取值范围限制到了Applet、Banana、Cherry和Durian这几个值之内。与int相比，enum的可读性更好，自我说明能力更强。

3.2、结构

结构（Struct）与类很相似。然而，类是作为一种引用类型在堆中创建，而结构是一种值类型，它存储在栈中或者是嵌入式的。因此，只要谨慎运用，结构要比类快。结构可以实现接口，可以象类一样拥有成员，但结构不支持继承。

然而，简单地用结构来取代类可能导致惨重损失。这是因为，结构是以值的方式传递，由于这种传递方式要把值复制到新的位置，所以传递一个“肥胖的”结构需要较大的开销。而对于类，传递的时候只需传递它的引用。

下面是一个结构的例子。注意它与类非常相似，只要把单词“struct”替换成“class”，你就得到了一个类。

struct Point \{  
public int x, y;  
public Point(int x, int y) \{  
this.x = x;  
this.y = y;  
\}  
\}

3.3、属性

C\#类除了可以拥有域（Field）之外，它还可以拥有属性（Property）。属性是一个与类或对象关联的命名的特征。属性是域的一种自然扩展——两者都是有类型、有名字的类成员。然而，和域不同的是，属性不表示存储位置；相反，属性拥有存取器（accessor），存取器定义了读取或者写入属性值时必须执行的代码。因此，属性提供了一种把动作和读取、写入对象属性值的操作关联起来的机制，而且它们允许属性值通过计算得到。

在C\#中，属性通过属性声明语法定义。属性声明语法的第一部分与域声明很相似，第二部分包括一个set过程和/或一个get过程。例如，在下面的例子中，PropertyDemo类定义了一个Prop属性。

public class PropertyDemo \{  
private string prop;  
public string Prop \{  
get \{  
return prop;  
\}  
set \{  
prop = value;  
\}  
\}  
\}  
如果属性既允许读取也允许写入，如PropertyDemo类的Prop属性，则它同时拥有get和set存取过程。当我们读取属性的值时，get存取过程被调用；当我们写入属性值时，set存取过程被调用。在set存取过程中，属性的新值在一个隐含的value参数中给出。

与读取和写入域的方法一样，属性也可以用同样的语法读取和写入。例如，下面的代码实例化了一个PropertyDemo类，然后写入、读取它的Prop属性。

PropertyDemo pd = new PropertyDemo();  
pd.Prop = "123"; // set  
string s = pd.Prop; // get

3.4、以引用方式传递简单数据类型的参数

在Java中，当你把一个简单数据类型的值作为参数传递给方法时，参数总是以值的方式传递——即，系统将为被调用的方法创建一个参数值的副本。在C\#中，你可以用引用的方式传递一个简单数据类型的值。此时，被调用的方法将直接使用传递给它的那个值——也就是说，如果在被调用方法内部修改了参数的值，则原来的变量值也随之改变。

在C\#中以引用方式传递值时，我们使用ref关键词。例如，如果编译并运行下面的代码，你将在控制台上看到输出结果16。注意i值被传递给ProcessNumber之后是如何被改变的。

using System;  
public class PassByReference \{  
public static void Main(String\[\] args) \{  
int i = 8;  
ProcessNumber(ref i);  
Console.WriteLine(i);  
\}  
public static void ProcessNumber(ref int j) \{  
j = 16;  
\}  
\}  
C\#中还有一个允许以引用方式传递参数的关键词out，它与ref相似。但是，使用out时，作为参数传递的变量在传递之前不必具有已知的值。在上例中，如果整数i在传递给ProcessNumber方法之前没有初始化，则代码将出错。如果用out来取代ref，你就可以传递一个未经初始化的值，如下面这个修改后的例子所示。  
using System;  
public class PassByReference \{  
public static void Main(String\[\] args) \{  
int i;  
ProcessNumber(out i);  
Console.WriteLine(i);  
\}  
public static void ProcessNumber(out int j) \{  
j = 16;  
\}  
\}

经过修改之后，虽然i值在传递给ProcessNumber方法之前没有初始化，但PassByReference类能够顺利通过编译。

3.5、C\#保留了指针

对于那些觉得自己能够恰到好处地运用指针并乐意手工进行内存管理的开发者来说，在C\#中，他们仍旧可以用既不安全也不容易使用的“古老的”指针来提高程序的性能。C\#提供了支持“不安全”（unsafe）代码的能力，这种代码能够直接操作指针，能够“固定”对象以便临时地阻止垃圾收集器移动对象。无论从开发者还是用户的眼光来看，这种对“不安全”代码的支持其实是一种安全功能。“不安全”的代码必须用unsafe关键词显式地标明，因此开发者不可能在无意之中使用“不安全”的代码。同时，C\#编译器又和执行引擎协作，保证了“不安全”的代码不能伪装成为安全代码。

using System;  
class UsePointer \{  
unsafe static void PointerDemo(byte\[\] arr) \{  
.  
.  
\}  
\}  
C\#中的unsafe代码适合在下列情形下使用：当速度极端重要时，或者当对象需要与现有的软件（比如COM对象或者DLL形式的C代码）交互时。

3.6、代理

代理（delegate）可以看作C++或者其他语言中的函数指针。然而，与函数指针不同的是，C\#中的代理是面向对象的、类型安全的、可靠的。而且，函数指针只能用来引用静态函数，但代理既能够引用静态方法，也能够引用实例方法。代理用来封装可调用方法。你可以在类里面编写方法并在该方法上创建代理，此后这个代理就可以被传递到第二个方法。这样，第二个方法就可以调用第一个方法。

代理是从公共基类System.Delegate派生的引用类型。定义和使用代理包括三个步骤：声明，创建实例，调用。代理用delegate声明语法声明。例如，一个不需要参数且没有返回值的代理可以用如下代码声明：

delegate void TheDelegate();  
创建代理实例的语法是：使用new关键词，并引用一个实例或类方法，该方法必须符合代理指定的特征。一旦创建了代理的实例，我们就可以用调用方法的语法调用它。

3.7、包装和解除包装

在面向对象的编程语言中，我们通常使用的是对象。但为了提高速度，C\#也提供了简单数据类型。因此，C\#程序既包含一大堆的对象，又有大量的值。在这种环境下，让这两者协同工作始终是一个不可回避的问题，你必须要有一种让引用和值进行通信的方法。

在C\#以及.NET运行时环境中，这个“通信”问题通过包装（Boxing）和解除包装（Unboxing）解决。包装是一种让值类型看起来象引用类型的处理过程。当一个值类型（简单数据类型）被用于一个要求或者可以使用对象的场合时，包装操作自动进行。包装一个value-type值的步骤包括：分配一个对象实例，然后把value-type值复制到对象实例。

解除包装所执行的动作与包装相反，它把一个引用类型转换成值类型。解除包装操作的步骤包括：首先检查并确认对象实例确实是给定value-type的一个经过包装的值，然后从对象实例复制出值。

Java对该问题的处理方式略有不同。Java为每一种简单数据类型提供了一个对应的类封装器。例如，用Integer类封装int类型，用Byte类封装byte类型。

【结束语】本文为你比较了C\#和Java。这两种语言很相似，然而，说C\#是Java的克隆或许已经大大地言过其实。面向对象、中间语言这类概念并不是什么新东西。如果你准备设计一种面向对象的新语言，而且它必须在一个受管理的安全环境内运行，你难道不会搞出与C\#差不多的东西吗？

\---------------------  
作者：张小洛  
来源：CSDN  
原文：https://blog.csdn.net/weixin\_37848710/article/details/78123037  
版权声明：本文为博主原创文章，转载请附上博文链接！

[Center]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/afb1f3c08e174d32a8d4bf04a3fff538.png
[Center 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/73856624d1074bc5b9930fbbb7fb5c73.png