c#语法与java语法的对比分析

Posted 2020-06-30 51kata

早期开发的时候一直用c/c++，后来主要用的是java。最近需要用下c#。

熟悉了下c#，发现c#语言在对c/c++基础上做了很多简化，同时参考了很多java的语法习惯，本来在语法上c/c++就有很多和java类似的地方，现在c#就类似的地方更多了，不过还是有很多区别。

本文总结下c# 和 java的语法差别，便于相互学习，加强理解。

一、基本语法的对比

1、程序框架

同java一样，c#要求所有的代码都要在类中，不再同c++一样，既可以定义类，也可以定义全局的方法。

java程序的入口代码必须是某个类中的如下的方法 ：

public static void main(String[] args)；

而在c#中，入口方法是

static void Main(string[] args)

注意：c#中Main的第一个字母M是大写，且Main方法的参数可以不定义。方法的修饰符也可以不加public。

 

2、包和命名空间

在java中，通过包来组织java源文件。在c#中，通过命名空间来组织c#源文件。 它们的含义和作用是类似的。

区别是，java强制要求java源文件的存放补录必须与包路径严格一致。

在java中，通过import引入包，而在c#中通过using引入命名空间。

两者都可以通过全路径来引用类（这样就不需要import和using了）。

 

3、基本数据类型

两者大部分基本类型的名称都一样，如 int ,char等。枚举定义的关键字都是 enum。数组定义和使用语法也是类似。

典型的区别是：

1）布尔型在java中是 boolean，而在c#中是bool。

2）字符串类型名在java中 是 String ，而在c#中是 string （第一个字母s是小写）。

最关键的是在java中进行字符串内容的比较要用 equlas方法，而在c#中直接可以用 == 比较。

 

4、语句

两者的  if 语句，switch语句，for，while, do ...while，break, continue 使用方式都一致。

有个区别是，在java中，可以用for循环遍历集合。而在c#中需要用单独的关键字 foreach来遍历，但使用方法一样。

 

二、面向对象语法的对比

java和 c# 都是通过 class关键字来定义类，也都不需要头文件。类的实现代码用  { }扩起。

 1、类的成员

c#中引入了一个属性的概念。

我们知道在java中，为了提高安全性，我们定义成员变量一搬建议定义private的，这样为了其它类能访问该变量，再定义相应的get 和 set 方法，代码如：

class A{
    private int num;
    public void setNum(int num) {
        this.num = num;
    }
    public int getNum() {
        return num;
    }
}

class B{
    public void test(){
        A a = new A();
        a.setNum(10);
        int num = a.getNum();
    }
}

而在c#中，为了简化操作，引入了一个属性的概念，举例如下

class A
{
    public int num { get; set; }
}

class B
{
    public void test()
    {
        A a = new A();
        a.num = 10;
        int re = a.num;
    }
}

在类A中，定义了一个属性 num，在类B中，直接通过属性名可以访问，简化了java中的语法。
在A中定义num时，可以只有get或set标记，表示只读或只写的。

上面的方式存在一个问题，如果在get或set操作时需要通过一定的计算来返回值，既可以采用如下的代码方式。调用方法不变。

class A
{
    private int _num;
    public int num
    {
        get { return _num; }
        set { _num = value*2; }
    }
}

与上面相比，先定义了一个普通的变量_num（这里是private的，不让外部直接访问）。
然后定义了一个属性num，并且有相应的代码，其中set代码中的 value是隐式参数，是在给属性设置值时传入的参数。

这和java代码的使用方式类似了，只是省去了需要定义  setXXX类似的方法。 另外调用时简化了，直接通过属性名就可以。

 

2、访问修饰符

在java中，有 public, protected,private 和 缺省四种级别的修饰符，在定义类和成员时不加修饰符，默认是缺省的。

在c#中，缺省修饰符需要显示的用internal关键字标识，并且如果定义时不加修饰符，默认不是internal 而是 private的。并且在c#中，可以 protected internal组合使用，其含义是访问仅限于该类或当前程序集（同一命名空间）的派生类。单独的protected范围比protected internal大，允许的派生类不限于当前程序集，加上了internal将派生类限制在当前程序集。

 

3、类的继承语法

两者都支持类的继承，在c++中支持多个父类，在c#中进行了简化，同java一样，一个类只允许有一个父类。

在java中通过extends关键字继承类，在c#中采用的是c++的语法，用 ：后跟父类表示。两者对父类构造函数的处理机制也不一样。下面举例说明。

下面代码是java的例子：

class A{
    private int num;
    public A(int num){
        this.num = num;
    }
}

class B extends A{
    public B(int num) {
        super(num);
        //其它代码，super语句必须放在第一行。
    }
}

可以看出，在java中使用extends关键字来继承父类，用 super方法来调用父类的构造函数。

下面是c#的代码

class A{
    private int num;
    public A(int num){
        this.num = num;
    }
}

class B : A{
    public B(int num):base(num) {

    }
}

可以看出，在c#中是通过 : 标识符来继承父类，而且是通过base关键字来调用父类构造函数。

4、接口

在java中，引入了接口类型，一个类可以实现一个或多个接口.

在c#中，参考java引入了接口的机制，注意在c++中没有接口的机制。

但两者在实现接口的语法上有些区别，在java中通过implements关键字来标识，而在c#中，使用同继承一样。

下面是java的语法例子

interface hello1{}
interface hello2{}

class A implements hello1,hello2{
    private int num;
    public A(int num){
        this.num = num;
    }
}

class B extends A implements hello1,hello2{
    public B(int num) {
        super(num);
        //其它代码，super语句必须放在第一行。
    }
}

在java中，当一个类同时需要继承父类和实现接口时，extends语句要放在 implements语句前。

下面是c#的语法例子

interface hello1 { }
interface hello2 { }
class A:hello1,hello2{
    private int num;
    public A(int num){
        this.num = num;
    }
}

class B : A,hello1,hello2{
    public B(int num):base(num) {

    }
}

在 c#中，当一个类同时需要继承父类和实现接口时，因为都是跟在 ： 后面，需要将父类名放在前面，接口名在后面，如上面例子。

5、重载、重写（多态）

所谓重载，就是一个类可以有多个方法，方法名一样，但参数信息不一样。这个java和 c#都支持。

所谓重写，是面向对象编程中多态特性的体现。就是子类可以定义和父类一样的方法，具体执行时是执行父类方法还是子类方法，动态根据实例绑定。java和c#都有这个特性，区别是使用语法上有些不同。

java的例子：

package com;

public class Demo {
    public static void main(String[] args) {
        A a = new A();
        a.show(); //输出的是 i am A

        B b = new B();
        b.show(); //输出的是 i am B

        A c = new B();
        c.show(); //输出的是 i am B. 多态体现，动态决定调用父类或子类方法。因为c实际是指向B的实例
    }
}

class A {
    public void show() {
        System.out.println("i am A");
    }
}

class B extends A {
    public void show() {
        System.out.println("i am B");
    }
}

可以看出，子类B通过定义相同的方法，重载了父类A的方法。实际执行时，根据变量指向的具体实例决定调用是父类或子类的方法。

c#的例子，c#在多态上的语法参考了c++的特点，需要通过virtual和override关键字来标识。

class Myapp
{
    private static void Main(string[] args)
    {
        A a = new A();
        a.show(); //输出的是 i am A

        B b = new B();
        b.show(); //输出的是 i am B

        A c = new B();
        c.show(); //输出的是 i am B. 多态体现，动态决定调用父类或子类方法。因为c实际是指向B的实例
    }
}

class A {
    virtual public void show() {
        System.Console.WriteLine("i am A");
    }
}

class B : A {
    override public void show() {
        System.Console.WriteLine("i am B");
    }
}

可以看出，在c#中，要想实现继承的多态性，需要在父类方法中用virtual关键字标识，然后在子类的方法中用override关键字进行标识。

需要说明的是，对于父类定义的virtual或非vritual方法，子类可以不重载，但也可以定义同样的方法（没有用override关键字），这是允许的，这时子类的该方法将隐藏父类的方法，这个不是动态的特性。

 

6、抽象类和抽象方法

有时在父类中定义一个序方法，但该方法在基类中不需要有具体的实现，需要在子类中实现。这个特性java和c#都支持。

只是语法上有细微差别。这里举例说明下。

 java的例子：

package com;

public class Demo {
    public static void main(String[] args) {
        B b = new B();
        b.show(); //输出的是 i am B

        A c = new B();
        c.show(); //输出的是 i am B. 多态体现，动态决定调用父类或子类方法。因为c实际是指向B的实例
    }
}

abstract class A {
    public abstract void show();
}

class B extends A {
    public void show() {
        System.out.println("i am B");
    }
}

在java中，是通过abstract关键字标识抽象类和抽象方法的，具体有如下细节：
1）一个类有抽象方法，其所在的类必须定义为抽象类。

2）子类继承抽象父类，要么实现父类的抽象方法，要么继续把自己定义为抽象类。

3）抽象方法没有方法体。抽象类不能实例化。

 下面是c#中的例子

class Myapp
{
    private static void Main(string[] args)
    {
        B b = new B();
        b.show(); //输出的是 i am B

        A c = new B();
        c.show(); //输出的是 i am B. 多态体现，动态决定调用父类或子类方法。因为c实际是指向B的实例
    }
}

abstract class A {
    abstract public void show();
}

class B : A {
     override public void show() {
        System.Console.WriteLine("i am B");
    }
}

除了子类方法定义需要加override关键字，其它语法要求与java一样。另外对抽象类和抽象方法的要求也与java中的要求一致。

 三、其它对比

 1、常量和只读字段

在java中，可以通过final来定义只读变量，可以使成员变量，可以是方法的内的局部变量，也可以是形参。并且定义和初始化可以一起，也可以分开。

如果是定义的的final成员变量，则需要在构造函数中初始化。 如果是方法内的局部变量，可以在定义后赋值。

在c#中，可以用 const关键字定义常量，要求必须在定义时理解赋值。

在c#中，还可以用 readonly来定义类的成员（注意不能定义局部变量），可以在定义时赋值，也可以定义时不赋值，而在构造函数中赋值。

 

2、异常处理

java和 c#有类似的异常处理机制和语法，都有  try, catch, finally, throw 这几个使用关键字。 区别是：

1）java中的异常分为检查时异常和运行期异常两种，而c#中只有一种（运行期异常）。

2）在java中 ,catch语句必须带异常类型参数。

而在c#中，可以不带，表示是缺省的，表示对所有异常处理，但如果定义了多个异常，不带参数的必须放在最后。

 

3、参数传递

在java中，参数传递只有值传递一种方式。对于基本数据类型，如 int等，在方法内无法修改方法的值。

而在c#中，保留了c/c++的特性，通过 ref 和 outer 关键字，可以让形参和实参指向同样的值，这样在方法内修改形参的值，方法外的实参值也跟着变化。

不过，为了提高程序的可读性，建议少用这种特性。

 

4、内部类

在java中，支持内部类，包括匿名内部类。但在c#中，支持内部类，但不支持匿名内部类。

如下面的匿名内部类在java中是允许的，但在c#中是不行的。

package com;

public class Demo {
    public static void main(String[] args) {
        A a = new A() {
            public void show() {
                ;
            }
        };
        a.show();
    }
}

abstract class A {
    public abstract void show();
}

5、分部类

在c#中，编写代码时可以将一个类的定义分到多个cs文件中，后续由编译器自动合并。这个在java中不支持。

这个特性感觉很不好，强烈建议正常情况下不要使用。