So sánh cú pháp của C# và Java

1.Các kiểu nguyên gốc (primitive) và kiểu đơn giản (simple)
Java có một vài kiểu primitive mà mọi người rất thân thuộc: byte, char,int, long, float, double. Những kiểu primitive là những khối được xây dựng cơ bản của Java, chúng là những “đơn vị” nhỏ nhất. Những gì thường gây khó chịu đối với hầu hết lập trình viên là kiểu primitive thường tách rời khỏi mô hình đối tượng của Java; trong khi tất cả các đối tượng trong Java đều kế thừa từ java.lang.Object, các kiểu primitive không kế thừa từ bất kỳ gì cả. Điều này có nghĩa là bất kỳ một lớp nào khi tính toán trên các đối tượng (ví dụ như các đối tượng trong Tập hợp API) sẽ không làm việc với các kiểu primitive. Các kiểu primitive sẽ phải được ánh xạ (map) thành mô hình đối tượng theo quy định để có thể sử dụng chúng.
Không có những trường hợp như thế trong C#. C# sử dụng hệ thống kiểu/đối tượng trong .NET mà ở đó, các chương trình C# có thể giao tiếp với nhiều ngôn ngữ khác trong .NET mà không gặp rắc rối nào về kiểu. Ví
dụ, kiểu int là một bí danh của System.Int32 được kế thừa cuối cùng từ System.Object. Điều này có nghĩa là các kiểu primitive, hay kiểu simple trong hàm C# cũng giống như bất kỳ các đối tượng khác. Ví dụ, điều này
là đúng khi gọi phương thức toString hoặc GetType trong bất kỳ một kiểu primitive nào.

Mặc dù các kiểu simple trong C# là những đối tượng, tuy nhiên chúng vẫn được truyền theo tham trị (pass-by-value) tương tự như trong Java. Đây là trường hợp khác, bởi vì ngoài việc là những đối tượng, tất cả các
kiểu simple trong C# đều là các đối tượng – cấu trúc (struct) khi được truyền theo tham trị sẽ được truyền theo tham biến một lần nữa (chúng ta sẽ đề cập đến phần này sau).

2.Các phát biểu (statements)
Bây giờ chúng ta có những cấu trúc dữ liệu primitive, chúng ta nên tổ chức chúng ở những phát biểu ở cấp độ cao hơn. Bạn sẽ để ý rằng, không
cần phải nói nhiều với các lập trình viên Java bởi họ đã rất thân thuộc với các cú pháp này, chúng ta sẽ chỉ tập trung vào sự khác nhau giữa C# và Java

3.Khai báo (declarations)
Các biến được định nghĩa trong C# cũng giống như trong Java

int integer = 3;
bool boolean = true;

Java sử dụng các từ khóa “static final” để tạo nên các biến hằng; trong Java một biến “static final” là một biến lớp thay vì là một biến đối tượng, và trình biên dịch sẽ ngăn ngừa bất kỳ các đối tượng khác thay đổi giá trị của biến. C#, theo quy định, có hai cách công bố một biến hằng.
Đánh dấu một biến bằng từ khóa const sẽ làm cho giá trị được chuyển đổi trước khi biên dịch. Với định nghĩa sau:
const int two = 2;
phát biểu
2 * two
được chuyển thành
2 * 2
bằng vi xử lý trước khi biên dịch. Điều này sẽ làm cho chương trình đã được biên dịch sẽ chạy nhanh hơn bởi nó không phải tìm kiếm giá trị của hằng trong suốt thời gian chạy (run-time).
Xem rằng các hằng thường được sử dụng cho BUFFERSIZE hoặc TIMEOUT, điều này có thể sẽ không gây ra một sự chuyển đổi bên trong đoạn mã; nếu một
field được đánh dấu là const, khi đó bất kỳ một đoạn mã nào biên dịch nó một lần nữa sẽ không chuyển đổi hằng và sẽ cần được biên dịch lại theo quy định để thay đổi nó. Thay vì thế, nếu một hằng được đánh dấu
là readonly, khi đó ứng dụng được thực thi vào lần tới, trạng thái sẽ thay đổi cũng như đoạn mã sẽ được kiểm tra giá trị của field readonly, trong khi trình biên dịch vẫn bảo vệ nó không thay đổi theo chương trình.

4.Cấu trúc điều kiện (Conditionals structure)
Có hai cấu trúc điều kiện mà các lập trình viên Java mong đợi, các phát
biểu “if–then–else” và “switch”, cả hai đều có sẵn trong C#. Cả hai đều
tương tự ngoại trừ một chút khác nhau trong cú pháp phát biểu “switch”
của C#.
Java cho phép dòng điều khiển phải rơi vào chính xác trong các trường
hợp khác nhau của phát biểu switch, trong khi trình biên dịch C# tuyệt
đối không cho phép điều này – trình biên dịch C# sẽ đánh dấu đây là một
lỗi cú pháp. Ví dụ, trong Java những dòng dưới đây là đúng

Code:

[i]int switching = 3;
switch(switching) {
    case 3:
        System.out.println(“here”);
    default:
        System.out.println(“and here”);
}[/i]


Kết quả là cả hai dòng lệnh println đều được thực thi. Trong C#, trong
định nghĩa dòng điều khiển, nhất thiết phải có một khai báo break hoặc
goto case cho những trường hợp khác nhau ở trong mỗi case.

5.Các vòng lặp (Loops)
C# cũng có những vòng lặp quen thuộc “while’, “do–while” và “for”.
Ngoài ba vòng lặp này, C# còn giới thiệu một vòng lặp “foreach” để tính
toán trên các đối tượng nhằm bổ sung giao tiếp
System.Collections.Ienumerable. Đặc biệt hơn, các mảng trong C#
(System.Array) bổ sung Ienumerable, vì thế đoạn mã Java dưới đây

int[] array = // …
for( int count = 0; count < array.length; count ++ ) {
System.out.println( array[count] );
}

là đúng trong C#, nhưng nó cũng có thể được thay thế trong C# như sau:

foreach( int member in array )
Console.Writeln( member );

Đặc biệt, giao tiếp Ienumerable cung cấp khả năng nhận được một sự thay
thế Ienumerator cho một đối tượng (giống như java.util.Enumeration).
Bất kỳ cái gì bổ sung các giao tiếp Ienumerable và Ienumerator đều có
thể được tính toán trên vòng lặp foreach.

6.Các phát biểu nhảy (Jumps)
Hầu hết các phát biểu nhảy trong Java đều ánh xạ trong C#: continue,
break, goto, return. Các phát biểu này đều sử dụng giống như cách mà
chúng được sử dụng trong Java: thoát khỏi các vòng lặp hoặc trả dòng
điều khiển cho một khối lệnh khác.
Những gì quan trọng để thảo luận chính là mô hình ngoại lệ (exception
model), cũng như nó khác nhau cả về ngữ nghĩa và cú pháp. Tất cả các
ngoại lệ trong C# đều là các ngoại lệ run-time, trình biên dịch sẽ
không giúp đỡ các lập trình viên giữ lại trạng thái của các ngoại lệ.
Cũng nên chú ý rằng bản thân phương thức không chứa các ngoại lệ được
ném ra bên trong các khối lệnh. Cảnh báo của tôi đối với các lập trình
viên Java chuyển sang C# là phải rất cẩn thận.
Khối lệnh “try-catch-finally” mà các lập trình viên Java quen thuộc vẫn
tồn tại trong C#. Tất cả các ngoại lệ đều bắt nguồn từ
System.Exception, vì thế việc bắt System.Exception sẽ bắt tất cả các
ngoại lệ có khả năng được ném ra từ một khối lệnh, cũng giống như trong
Java. Có sẵn một cách đi tắt nếu đối tượng ngoại lệ không cần thiết
bằng việc sử dụng framework dưới đây

try {
// những lệnh có thể gây ra ngoại lệ
}
catch {
// xử lý những ngoại lệ mà không cần nhận một bộ xử lý cho đối tượng ngoại lệ
}

Nhưng nếu bạn cần bắt một ngoại lệ cụ thể (trong khi không yêu cầu đối tượng ngoại lệ), có thể dùng tương tự như sau:

try {
}
catch (IOException) {
}


7.Các phương thức (methods)
Ở mức độ cơ bản, không có sự khác nhau giữa các phương thức trong Java
và C#, mỗi phương thức đều đặt vào các tham số và có kiểu trả về. Tuy
nhiên, C# có những điều chúng ta có thể làm với các phương thức mà
chúng ta không thể làm với Java.
a.params
Khi gọi một phương thức, trình biên dịch Java sẽ kiểm tra xem có phương
thức nào giống với phương thức yêu cầu hay không. Ví dụ trong Java, nếu
có một phương thức được định nghĩa

public void methodCaller ( int a, int b, int c );

thì khi có một phương thức gọi phương thức đó

methodCaller( 3, 4, 5, 6 );

sẽ tạo ra một lỗi biên dịch do trình biên dịch Java không tìm thấy được
bất kỳ một phương thức methodCaller() nào đặt vào 4 tham số kiểu int.
Chúng ta không thể tạo ra một phương thức yêu cầu rằng cho phép chúng
ta đặt vào một số lượng biến kiểu int như là các tham số.
Tại sao lại không nên có điều này? Nếu một lập trình viên muốn đặt vào
một số lượng biến kiểu int, anh ta có thể định nghĩa một phương thức
yêu cầu đặt vào một dãy các số nguyên và sau đó khởi dựng dãy này khi
gọi phương thức. Trong Java, sẽ có tối thiểu 3 dòng lệnh chỉ để gọi
phương thức – dòng đầu tiên tạo ra một dãy, một hoặc nhiều dòng sau gán
các giá trị vào cho dãy, dòng thứ ba gọi phương thức. C# thay đổi điều
này bằng cách cho phép các lập trình viên đặt vào một tham số trên tham
số cuối cùng của dãy của phương thức, do đó một số lượng các tham số có
thể đặt vào đó. Sử dụng ví dụ dưới đây, phương thức có thể được định
nghĩa như sau:

public void methodCaller ( params int[] a );

Và phương thức có thể được gọi bất kỳ

methodCaller ( 1 );
methodCaller ( 1, 2, 3, 4 );

Bên trong phương thức, các tham số có thể được truy cập thông qua dãy “a” đã được định nghĩa.
b.ref và out
C# cũng có thể thay đổi một tham số được đặt vào như một tham biến trái
với việc đặt vào với một tham trị. Ví dụ với một kiểu primitive

public void increment( int a ) {
a ++;
}

int a = 3;
increment ( a );
// a vẫn bằng 3

sẽ không làm cho biến được đặt vào phương thức increment() không thật
sự được tăng lên bởi vì a được đặt vào như một tham trị, biến a trong
khối lệnh của phương thức increment() nằm trong môt môi trường khác và
vì thế việc thay đổi trong tầm vực (scope) đó không bị ảnh hưởng đến.
Tuy nhiên thay đổi phương thức thành

public void increment ( ref int a ) {
a ++;

}

int a = 3;
increment ( a );
// bây giờ thì a đã tăng lên 4

sẽ làm cho int a được đặt vào như một tham biến (giống như khi đặt vào
một lớp) và vì thế việc chỉnh sửa nó sẽ làm cho giá trị gốc bị thay
đổi. Sử dụng ref với một lớp cho phép một hàm gán lại con trỏ lớp bên
trong hàm và thay đổi được bên ngoài phương thức.
Một từ khóa đi cặp với ref là out. Trong khi ref không bảo đảm rằng bất
kỳ phép toán nào thật sự được tính toán trên biến, sử dụng out sẽ làm
cho trình biên dịch chắc chắn rằng một giá trị đã được ấn định cho
biến. Ví dụ đoạn mã dưới đây

public void doNoThing ( out int a ) {
}

sẽ làm cho trình biên dịch hiểu rằng a sẽ không được gán cho bất kỳ gì cả.