此文尚未写完，有时间逐渐补全。
Java和C#访问修饰符的差异性与转换：
在C#中，我们通常会使用到如下几种访问修饰符：
public 访问不受限制。
protected 访问仅限于包含类或从包含类派生的类型。
internal 访问仅限于当前程序集。
protected internal 访问仅限于当前程序集或从包含类派生的类型。
private 访问仅限于包含类型。
而在Java里，则仅有以下几种可供调配：
public 同C#一致
protected 同C#一致
private 同C#一致
internal 在Java中无等价存在(在Java中，如果不为函数或类增加任何修饰符，则意味着仅限当前包中所有类访问，同internal作用有近似处，但范围没有 internal大。而在C#中，不用任何范围修饰符时，默认的则是protected，不能在类外被访问)
另外C#的Type，基本等价于Java的Class，小弟在LGame的C#版中也提供有一些转化工具（此类工具都在命名空间Org.Loon.Framework.Xna.Java下）。
Java和C#中this关键字的差异性与转换：
Java同C#的this关键字基础作用一致，都是引用当前类的当前实例，但细节使用处有些差异。
比如在Java中，我们想利用this调用一个已有的构造函数，使用样式如下：
public test{
this(0,0);
}
public test(int x,int y){
}
而在C#里，则需要如下的使用方式：
public test : this(0,0){
}
public test(int x,int y){
}
而从派生类中访问基类的成员，也就是调用父类的方法，则有如下分别。
Java中
public test(){
super(0,0);
}
C#中
public test():base(0,0){
}
Java和C#数组的差异性与转换：
Java与C#数组的差异，主要体现在多维数组的定义方式上（一维毫无差异）。
比如我们在Java中定义一个3x3的二维数组，需要如下设定。
int[][] test = new int[3][3];
读取方式则为如下：
int v = test[0][0]
而同样的设定，C#中则必须写成
int[,] test = new int[3,3];
读取方式就要顺应格式，变成这样(附带一提，小弟在LGame的C#版里提供有仿写Java数组的方式)：
int v = test[0,0];
另外，C#数组设定上比较严谨，没有Java那么随意。
比如Java中构建如下样式数组，不会有任何问题：
String test[] = new String[3];
而在C#中则必须为如下样式：
string[] test = new string[3];
假如将[]写在变量名而非变量类型后，C#是不认的，连编译都过不去。
Java和C#函数差异性与转换：
在Java中使用函数，不声明[不可重写]，就可以直接[重写]。
在Java环境中，如果我们需要一个公有方法不能重写，需要声明这个函数为final(基本等价于C#的sealed修饰符，但sealed仅对类有效)。
假设A类有公有函数：
public void test(){}
则B类无需任何修饰，复写一次该函数，重写就会被完成。
public void test(){}
如果我们不希望A类中函数test被重置，则需要特别修饰test函数，比如下例：
public final void test(){}
而在C#函数中，特性与Java正好相反，不声明函数[可以重写]，意味着对应一定[无法重写]。
在C#中，假设也有A类，想要完成如Java般操作，则必须先作如下设定：
public virtual void test(){}
而后需要重写的B类，再做如下修饰，才能完整重写过程（在C#里，假如我们需要一个公有方法可以重写，则必须声明为override。Java虽然有override的元数据注释，但可有可无……）。
public override void test(){}
而C#中不希望test被重置，则无需任何设定，直接如下即可：
public void test(){}
另外，virtual修饰符不能与static、abstract, private或者override修饰符同时使用（否则VS直接编译失败，根本无法走到运行）。
Java和C#全局常量差异性与转换：
有时我们需要一个数值永远固定为单一量，这是我们就需要一个全局常量。
在C#中，这点延续了标准C语系的做法，直接使用const关键字即可(不需要static描述，有此关键字就是全局使用)，比如:
public const int type = 0;
这样，我们直接使用类名.type的方式，就可以在任何场合访问到这个常量值。
而在Java中使用，实现同样效果则比较麻烦，因为Java虽然有const关键字，却是保留值（只占位，无实际功能），而需要由final与static关键字结合使用，方可达到近似效果。比如：
public final static int type = 0;
这样，我们使用Java类名.type的方式，才可以在任何场合都访问到这个常量值。
另外在C#中，也可以使用下列方式来达到目的：
public readonly static int type = 0 ;
其实从本质上讲，上述C#表述才和Java的常量用法更贴近（const字段是编译时常量，而readonly字段可用于运行时常量，意味着初始化时有一次动态赋值的机会）。
Java和C#继承的差异性与转换：
在名称上，C#与Java相同，都是类为class(但获得当前类的class时，却不能如Java般getClass，而要GetType) , 接口为interface，抽象为abstract。
但Java继承类需要修饰符【extends】，实现接口需要修饰符【implements】。
比如：
public class Test extends A implements B {
}
而C#仅需一个【:】搞定。
public class Test : A , B {
}
编译时系统会分清那个是继承，那个是接口或其他类型（struct啥的不能被继承）。
另外，想要阻止某个类被派生时，Java中可以使用final关键字，C#中可以使用sealed关键词来修饰目标类。
不过C#中也有一个不如Java的特性，让小弟非常别扭，那就是interface中不能存在常量（不能包含域(Field)，且函数前也不能存在public关键字），导致将Java的某些代码移向C#只能微调。
Java和C#属性的差异性与转换：
在Java中定义和访问属性，在规范上要用get和set方法（当然，不照规矩走也没人拦着），可以不成对出现。
比如
private String name;
public void setName(string n){
this.name = n;
}
public string getName(){
return this.name;
}
而在C#中，则可以直接用如下方式来访问name。
public string name
{
set;
get;
}
此外，Java中我们也可以直接将name设定为public的，这样表面功能上同上述C#语法仿佛没有区别。但是，在C#中我们却可以自由限制该方法的set和get属性，以调控究竟暴露给用户怎样的操作权限，要比Java中批量生成海量Set与Get方便一些。
附带一提，如果我们调用C#的Type中GetMethods方法遍历函数，可以看见name将变成如下样式。
set_name
get_name
其实C#就是替我们自动添加好了set与get属性，与Java在运行机制上倒没有本质区别。
Java和C#在多线程管理上的差异性与转换：
C#中使用MethodImplOptions.Synchronized进行线程同步
[MethodImpl(MethodImplOptions.Synchronized)]
public void test(){
}
大体等于Java中
public synchronized void test(){
}
C#中使用lock关键字作为互斥锁
object o = new object();
public void test(){
lock(o){
}
}
大体等于Java中
Object o = new Object();
public void test(){
synchronized(o){
}
}
C#中使用Monitor.Enter作为排他锁
List<object> list = new List<object>();
public void test()
{
Monitor.Enter(list);
//具体的list排它操作
//......
Monitor.Exit(list);
}
在Java中没有等价存在，不过有一些功能近似类在java.util.concurrent.locks包下可供调配，比如写成这样：
ReentrantReadWriteLock ilock = new ReentrantReadWriteLock();
Lock readLock = ilock.readLock();
Lock writeLock = ilock.writeLock();
List<Object> list = new ArrayList<Object>();
public void test() {
try {
// 读取锁定
readLock.lock();
// 写入解锁
writeLock.unlock();
// 具体的list排它操作
// ......
} finally {
// 读取解锁
readLock.unlock();
// 写入锁定
writeLock.lock();
}
}
其它C#多线程常用函数与Java间函数的关系，可参见如下实现（也可参考LGame的C#版JavaRuntime类中）：
public static void Wait(object o)
{
Monitor.Wait(o);
}
public static void Wait(object o, long milis)
{
Monitor.Wait(o, (int)milis);
}
public static void Wait(object o, TimeSpan t)
{
Monitor.Wait(o, t);
}
public static void NotifyAll(object o)
{
Monitor.PulseAll(o);
}
public static void Notify(object o)
{
Monitor.Pulse(o);
}
