C#与Java的语法差异
C与Java的语法差异
前言
程序结构
基本语法
数据类型
字符串
变量与常量
运算符
判断语句
循环语句
访问权限
方法
数组
结构
枚举
类
继承
多态
运算符重载
接口
命名空间
预处理器指令
正则表达式
异常
IO
泛型
集合
属性
索引器
委托
事件
匿名方法
前言
本文主要供有Java基础的读者快速掌握C#基本语法使用，重点落在C#的语法上。

程序结构
C#中使用using关键字引用命名空间（namespace），作用和Java中使用import导入包中的类基本相同，都是为了避免命名冲突。

C#中文件名和类名可以不相同，但Java中文件名必须和主类名相同。

C#中方法名一般是让所有单词的首字母大写（ToString()），Java中一般是驼峰式，即除第一个单词外首字母大写(toString())。

基本语法
C#中标识符可以以字母、下划线以及@开头；Java中可以以字母、下划线以及$开头。

数据类型
C#中byte是8位无符号整型，sbyte是8位有符号整型；Java中byte是8位有符号整型。

C#中还有uint、ulong、ushort数据类型，是int、long、short的无符号版。

C#中使用sizeof()查看数据类型所占字节数（如sizeof(int)）；Java中通过包装类实现（如Integer.SIZE）。

C#中的动态（dynamic）类型的变量可以存储任何类型的值，例：

dynamic d = 100;
1
一般类型变量的类型检查在编译时发生，动态类型变量的类型检查在运行时才发生。比如下面的例子，编译器不会报错：

dynamic d = 100.0;
int x = d;
1
2
C#中可以使用指针，和C与C++中的指针功能相同。

C#中提供了一种特殊的类型：nullable类型。这种类型除了可以表示正常范围内的值外，还可以表示null值。使用方法是在数据类型后面加上一个？。例：

int? x = null;
double? y = null;
1
2
注意两点：
- 即便想使用null值，nullable类型仍需显示初始化为null。
- nullable类型和原类型不是同一种类型，如方法需要int，传递一个int?类型的变量会报错。

字符串
C#中可以使用一种逐字字符串，它会将所有转义字符当做普通字符处理，使用方法是在字符串前加上@：

String str = @"c:\windows\";
1
会输出c:\windows\，而不会将\视为转义字符。

C#中基本类型（int,float等）也可以调用ToString()转换成字符串。

Java中String类提供的各类字符串操作方法基本都能在C#中找到功能类似的实现。

变量与常量
C#中用const声明常量，Java中使用final声明常量。

运算符
C#中包含以下运算符：
- typeof()：返回class的类型。
- &,*：含义与使用方法同C,C++的指针。
- is：判断对象是否为某一类型，同Java的instanceof。
- as：强制将某个对象转成某个类型，转换失败也不会抛出异常。

要注意的是，在C#中，类内部声明的常量都是静态的，但不能加上static。示例：

public class Persons
{
public const int SIZE = 10;
private String[] names;
}
class Program
{
static void Main(string[] args)
{
int x = Persons.SIZE;
Console.ReadLine();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
可以看到，虽然SIZE没有用static修饰，它仍然是静态的。这和Java不同，Java中静态常量必须声明为static的。

判断语句
和Java基本相同。

循环语句
C#支持用foreach迭代数组或集合对象。语法示例如下：

int[] array = new int[]{1,2,3,4,5};
foreach (int element in array)
{
...
}
1
2
3
4
5
Java中的foreach如下：

int[] array = new int[]{1,2,3,4,5};
for(int element : array){
...
}
1
2
3
4
访问权限
C#中public,private,protected的含义与Java相同。不同之处如下：
- C#中没有包的概念，自然也没有包级私有访问权限。
- C#特有：internal——同一个程序集的对象可以访问；protected internal——同一个程序集内的派生类可以访问，是internal与protected的交集。
- C#成员变量和成员方法默认private，类默认internal，接口方法默认public；Java除接口默认public外默认为包级私有。

方法
C#的参数传递分为三种：
（1）值参数：默认的方式，复制实参给形参，形参的改变不会改变实参。

（2）引用参数：复制实参的内存位置的引用给形参，形参的改变会影响实参。引用参数用ref声明：

public static void Swap(ref int x, ref int y)
{
int temp;

temp = x;
x = y;
y = temp;
}
1
2
3
4
5
6
7
8
使用时也要给参数加上ref：

int x = 1;
int y = 2;
Swap(ref x, ref y);
1
2
3
上面的方法调用会改变x和y的值。

（3）输出参数：C#的return只能从方法中返回一个值，但是使用输出参数就可以返回多个值。输出参数用out声明：

public static void GetValue(out int x)
{
x = 5;
}
1
2
3
4
提供给输出参数的变量不需要赋值，不过传递给方法时要加上out：

int a;
GetValue(out a);
Console.WriteLine(a);
1
2
3
会发现a已经被成功赋值。
注意：如果方法中未给输出参数赋值，编译器会报错。

C#中的变长参数列表是通过在方法的参数列表中用params声明一个数组实现的：

public int AddElements(params int[] arr)
{
int sum = 0;
foreach (int i in arr)
{
sum += i;
}
return sum;
}
1
2
3
4
5
6
7
8
9
数组
C#中只能使用类似int[] array的方式来声明数组，不能使用int array[]的方式。Java中二者均可。

C#多维数组：用[,]声明二维数组，[ , , ]声明三维数组，以此类推。示例：

int[,] array = new int[3, 4]
{
{1, 2, 3, 4 },
{5, 6, 7, 8 },
{9, 10, 11, 12}
};
1
2
3
4
5
6
使用array[x,y]引用上面的数组的元素。

C#交错数组：即数组的数组，用[][]这样的方式声明。示例：

int[][] arr = new int[3][];
1
声明该数组时不会为其分配内存，需要单独创建它的每个元素（也是一个数组）。每个数组元素的长度可以不同。

结构
C#中能够定义和使用结构struct。和C,C++的结构体的区别在于：
- 结构可带有方法、字段、索引、属性、运算符方法和事件。
- 结构可以定义构造函数，但不能定义析构函数。不能覆盖结构的默认构造函数，它会自动被定义，且不能改变。
- 结构不能继承其他的结构或类，也不能作为其他结构和类的基础结构。
- 结构可实现一个或多个接口。
- 结构成员不能声明为abstract、virtual、protected。
- 结构即使不使用New操作符也能完成实例化，但也可使用New以调用合适的构造函数。
- 结构的字段必须先赋值后才能使用。

和类的区别在于：
- 类是引用类型，结构是值类型。
- 结构不支持继承。
- 结构不能声明默认构造函数。

枚举
C#中的枚举和C,C++类似，是一组命名整型常量，不能像Java那样在枚举中声明方法。示例：

enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };
1
默认情况下，第一个枚举符号的值为0，后面依次递增1。不过也可以以赋值的方式自定义各个枚举符号的值。

类
C#的类支持析构函数，析构函数的名称是在类名前加上一个~。它没有返回值，也不带任何参数。

C#支持静态成员和静态方法。

C#的静态初始化块的写法和Java的static{}不同，是使用一种静态构造器的方式：

// Static variable that must be initialized at run time.
static readonly long baseline;

// Static constructor is called at most one time, before any
// instance constructor is invoked or member is accessed.
static SimpleClass()
{
baseline = DateTime.Now.Ticks;
}
1
2
3
4
5
6
7
8
9
继承
C#的继承写法：class Rectangle : Shape；Java的继承写法：class Rectangle extends Shape。

关于在构造器中调用父类的构造器，C#中写法为：public Rectangle(String name) : base(name)；Java中写法为在构造器第一行加上super(参数列表)。

关于串联构造器，C#中写法为：public Rectangle(String name) : this(参数列表)，Java中写法为在第一行加上this(参数列表)。

C#的base与this和Java的super与this在其他用法上基本相同。

C#不支持多重继承，但可以实现多个接口，这点和Java一样。但C#实现接口不用implements，而是直接和继承类一样写在冒号后面，如：class Rectangle : Shape, SomeInterface

多态
C#的重载规则和Java类似，个数和类型不同能够触发重载，返回值类型不同不能触发重载。

C#中可被子类覆盖的成员方法需要在访问控制权限后面加上virtual关键字，Java中默认所有成员方法都可被子类覆盖，加上final可让方法无法被覆盖。

C#中，当子类覆盖父类的方法时，需要加上override关键字，Java中不需要。

C#中，可以将方法声明为abstract的，表示该方法应交由子类实现。包含abstract方法的类本身必须也是abstract的，即无法实例化的抽象类。

C#中，在类定义前加上sealed可以让类无法被继承，Java中使用final关键字实现该效果。

运算符重载
C#支持运算符重载。定义运算符重载的方法必须为静态方法，拥有返回值和参数列表，方法名为operator后跟对应的运算符。例：

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

//重载+运算符
public static Point operator+ (Point a, Point b)
{
return new Point(a.x + b.x, a.y + b.y);
}
}

static void Main(string[] args)
{
Point a = new Point(1, 2);
Point b = new Point(2, 1);
//运算符重载
Point c = a + b;
Console.WriteLine("x={0}, y={1}", c.x,c.y);
Console.ReadLine();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
下面是对各个运算符能否重载的总结：
- +, -, !, ~, ++, – 这些一元运算符只有一个操作数，且可以被重载。
- +, -, *, /, % 这些二元运算符带有两个操作数，且可以被重载。
- ==, !=, <, >, <=, >= 这些比较运算符可以被重载。
- &&, || 这些条件逻辑运算符不能被直接重载。
- +=, -=, *=, /=, %= 这些赋值运算符不能被重载。
- =, ., ?:, ->, new, is, sizeof, typeof 这些运算符不能被重载。

Java中不能自定义运算符重载。

接口
C#中接口内方法默认public。接口支持继承。这些和Java基本一致。

C#中接口名称通常以I开头。

C#中，实现接口中的方法时不需要加上override（实际上是不能，会报错）。

命名空间
命名空间namespace是C#独有。命名空间的定义方法如下：

namespace namespace_name
{
class A{

}
}
1
2
3
4
5
6
使用命名空间中的类时需要加上命名空间名和’.’：

namespace_name.A a = new namespace_name.A();
1
可以在开头加上using 命名空间名，这样就不用每次引用命名空间中的类时加上前缀。

命名空间可以嵌套，即可以在一个命名空间中声明另一个命名空间。

其他命名空间用法：
（1）using static 指令：指定无需指定类型名称即可访问其静态成员的类型

using static System.Math;var = PI; // 直接使用System.Math.PI
1
（2）起别名

using Project = PC.MyCompany.Project;
1
（3）using语句：将实例与代码绑定

using (Font font3 = new Font("Arial", 10.0f),
font4 = new Font("Arial", 10.0f))
{
// Use font3 and font4.
}
1
2
3
4
5
代码段结束时，自动调用font3和font4的Dispose方法，释放实例。

预处理器指令
C#的预处理器指令源于C,C++。可用的预处理器指令如下：

#define 它用于定义一系列成为符号的字符。
#undef 它用于取消定义符号。
#if 它用于测试符号是否为真。
#else 它用于创建复合条件指令，与 #if 一起使用。
#elif 它用于创建复合条件指令。
#endif 指定一个条件指令的结束。
#line 它可以让您修改编译器的行数以及（可选地）输出错误和警告的文件名。
#error 它允许从代码的指定位置生成一个错误。
#warning 它允许从代码的指定位置生成一级警告。
#region 它可以让您在使用 Visual Studio Code Editor 的大纲特性时，指定一个可展开或折叠的代码块。
#endregion 它标识着 #region 块的结束。
1
2
3
4
5
6
7
8
9
10
11
使用示例：

#define DEBUG
#define VC_V10
using System;
public class TestClass
{
public static void Main()
{
#if (DEBUG && !VC_V10)
Console.WriteLine("DEBUG is defined");
#elif (!DEBUG && VC_V10)
Console.WriteLine("VC_V10 is defined");
#elif (DEBUG && VC_V10)
Console.WriteLine("DEBUG and VC_V10 are defined");
#else
Console.WriteLine("DEBUG and VC_V10 are not defined");
#endif
Console.ReadKey();
}
}

输出：DEBUG and VC_V10 are defined
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
正则表达式
C#同样支持正则表达式。C#中的正则表达式的优势在于，可以使用逐字字符串（双引号前加@）来简化输入（不需要考虑字符串本身的转义，但正则表达式的转义仍需考虑）。具体的正则表达式语法规则和Java基本一致。

异常
C#中不能在方法后面用throws指明可能抛出的异常类型，其余和Java一致。

I/O
C#的I/O与文件系统体系和Java很像，但具体使用上会产生差异。
具体见http://www.runoob.com/csharp/csharp-file-io.html

泛型
C#中，声明泛型类的方法和Java相同，都是在声明类时在类名后面加<泛型参数列表>，但声明泛型方法的语法不太一样，体现在不需要声明泛型参数列表上。下面是C#中一个泛型方法的声明与使用：

public static void Swap<T>(ref T a, ref T b)
{
T temp;

temp = a;
a = b;
b = temp;
}

static void Main(string[] args)
{
int x = 10;
int y = 20;
Swap(ref x, ref y);
Console.WriteLine(x);
Console.WriteLine(y);
Console.ReadLine();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Java中的话，Swap方法的返回值前还得加上<T>。

集合
Java中的集合几乎都能在C#中找到对应的实现，名称也基本相同,除了Map。C#对应Map的集合类是Dictionary类。

属性
属性是C#独有的语法，它形式上类似于在字段的基础上添加了get和set两个访问器形成的。下面是一个例子：

class Person
{
private int age;
public int Age
{
get
{
return age;
}
set
{
if (value <= 200)
{
age = value;
}
else
{
throw new Exception("");
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Age就是一个属性。当外部需要获取Age的值时会自动调用get，当外部需要设置Age的值时会自动调用set。注意set中的value，它指代的是外部想要为其设置的值。
对于声明了属性的类，还可以用下面的方式来初始化：

Person person = new Person
{
Age = 15
};
1
2
3
4
访问属性时时使用属性名，而不是字段名：

int x = person.Age;
person.Age++;
1
2
注意Age = 15后面没有分号。

属性可以只有get，也可以只有set，但不能两个都没有。

还能够像这样声明自动完成的属性，并设置初始值：

public String Name { get; set; } = "father";
1
可以为属性的某个访问器声明访问控制权限。

类还可以使用virtual或者abstract声明一个属性，它们可以在子类中覆盖或实现。

索引器
C#的索引器允许一个对象像一个数组一样被索引。当为一个类声明了索引器，就可以用对象名[]的方式访问对象的一些字段。
索引器用下面的语法声明：

element-type this[int index]
{
// get 访问器
get
{
// 返回 index 指定的值
}

// set 访问器
set
{
// 设置 index 指定的值
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
示例：

public class Persons
{
public const int SIZE = 10;
private String[] names = new String[SIZE];

public Persons()
{
for(int i = 0; i < SIZE; i++)
{
names[i] = i.ToString();
}
}

public String this[int index]
{
get
{
String temp = "";
if(index >= 0 && index < SIZE)
{
temp = names[index];
}
return temp;
}
set
{
if (index >= 0 && index < SIZE)
{
names[index] = value;
}
}
}
}
class Program
{
static void Main(string[] args)
{
Persons persons = new Persons();
for(int i = 0; i < Persons.SIZE; i++)
{
Console.WriteLine(persons[i]);
}
Console.ReadLine();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
索引器还可以被重载，重载规则和方法的相同。

委托
C#中有一种叫委托的引用类型，它和C,C++的函数指针很像，用来持有某个方法的引用。引用可在运行时改变。
委托在C#中常被用于实现事件和回调方法。

委托使用delegate关键字声明，形式上和接口中的一个方法很像。委托可指向一个与其签名相同的方法。下面是一个示例：

public delegate int DoSomething(int x);
1
这个委托的实例可指向一个参数为一个int且返回值也为int的方法，下面是使用示例：

class Program
{
public delegate int DoSomething(int x);

public static int AddOne(int a)
{
return a + 1;
}

public int MinusOne(int a)
{
return a - 1;
}

static void Main(string[] args)
{
int x = 10;
DoSomething doSomeThing = new DoSomething(Program.AddOne);
Console.WriteLine(doSomeThing(x));

Program program = new Program();
DoSomething doSomething2 = new DoSomething(program.MinusOne);
Console.WriteLine(doSomething2(x));

Console.ReadLine();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
委托实例还可以利用+、-、+=、-=、=等进行各种方法拼接、移除操作，这叫做委托的多播。调用这样的委托的实际效果相当于按照顺序依次调用一系列的方法。

事件
事件是C#的一种实现进程间通信的机制，使用发布-订阅模型。
事件由委托和event关键字声明。下面是完整地实现一个事件的过程：
（1）声明事件的委托类型：

public delegate void NumManipulationHandler(int value);
1
（2）使用event关键字声明事件：

public event NumManipulationHandler NumChanged;
1
（3）利用委托的多播，在事件上使用+、-等实现订阅/取消订阅。
下面是一个完整的例子:

public class Publisher
{
private int value = 0;

public delegate void NumManipulationHandler(int value);
public event NumManipulationHandler NumChanged;

protected virtual void OnNumChanged()
{
if(NumChanged != null)
{
NumChanged(value);
}
}

public void SetValue(int x)
{
if(value != x)
{
value = x;
OnNumChanged();
}
}
}

class Subscriber
{
public void Printf(int value)
{
int x = value;
Console.WriteLine("new value: {0}",x);
}
}

class Program
{
static void Main(string[] args)
{
Publisher publisher = new Publisher();
Subscriber subscriber = new Subscriber();

publisher.NumChanged += new Publisher.NumManipulationHandler(subscriber.Printf);

publisher.SetValue(100);
publisher.SetValue(200);

Console.ReadLine();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
其实这和Java中先定义回调接口，之后在外部实现回调接口的思想很像。

匿名方法
有些委托实现可能只会使用一次，因此可以用匿名的方式传递给需要委托的方法，和Java的匿名内部类非常相似。示例：

public delegate void DoSomething(int x);

DoSomething doSomething = delegate (int x)
{
Console.WriteLine(x);
};
---------------------
作者：swt369
来源：CSDN
原文：https://blog.csdn.net/swt369/article/details/78238130
版权声明：本文为博主原创文章，转载请附上博文链接！