Java与C#的比较学习记录(4)

1、多线程
多线程模型基本相同，都有线程和线程池概念，调用方法一基本相同。线程基类都叫Thread.但由于Java不支持函数引用(delegate)，因此线程代码只能以实现了Runnable或者继承Thread的对象的run方法来完成，相对C#来说不够简洁。Java中的线程组和C#中线程池概念类似，但区别还是非常大，Java中的线程组是可以自己创建自己管理的，比较灵活，可控性比较强，而C#中的线程池是由DotNet框架维护，与操作系统比较紧密，是为了减少线程创建开销，而实现的一种线程共享机制，因此性能上比较好。当然，用户的可控性就差一些。 另外Java中的线程组最终可以形成一个线程组树，而C#中的线程池则没有这种机制。
在多线程同步方便，Java提供的机制比较简单，而C#提供的控制更丰富一些。

2、类

主要不同如下：
1)默认的访问级别不同，不特别指明访问级别的情况下，Java默认是公共的(public),C#是私有的;
2)Java的继承是是用extends,实现接口是implements,而C#都是冒号(:)
3)C#提供的internel,Java没有对应的控制方式。
4) Java 不能定义静态类；
当然这都是细节上的差异，但对于嵌套类，双方的处理差别还是很大的，C# 对嵌套类的处理比较简单，嵌套类只是一种定义在类中的类类型，除了访问需要使用路径外（类A中嵌套类别B，则类B的访问是A.B),其它与正常类没什么不同。但Java的处理要复杂些，如果类B是类A中的嵌套类，Java认为类B是属于类A的实例对象的（如果在第3方使用B时，不能用A.B theB = new A.B()完成实例化，而必须类似A theA = new A();A.B theB = theA.new B() 来完成实例化。而且对B有如下限制：
1）在如果不指明B是静态类，则在B中不能定义静态方法，但这个静态指示定义的静态类跟C#有很大的差别，这里的静态指示(static)只是告诉编译器类B有静态方法。虽然类B有static修饰，类B还是可以实例化的，还是是动态类。
2）对于顶层类来说，可以定义静态方法，而嵌套类如果需要定义类方法，则必须使用static修饰符号来修饰类声明。
因此严格来说Java没有C# 那样严格意义上的静态类，Java的静态方法应该叫类方法比较好。

总体来说，Java和C#的机制和语法其实都很相似，但细节上还是有很多的差异。具体的差异可以在实践中再去学习，对于比较生僻的地方的差异也没比要都弄清楚，毕竟学习语言是用来编程解决问题的，而不是用来咬文嚼字的。

测试:

public class NestedClass {
	protected static String getName1()
	{
		return "xxxx";
	}
	public static String getName2()
	{
		return "dddd";
	}
	private static String getName3()
	{
		return "private";
	}
	protected   String getName4()
	{
		return "xxxx";
	}
	public   String getName5()
	{
		return "dddd";
	}
	private   String getName6()
	{
		return "private";
	}
	public String getName8()
	{
		return "";
	}
	public static String getName9()
	{
		class class1
		{
			public String getName()
			{
				return "ddd";
			}
			public String getName1()
			{
				return "ddd";
			}
		}
		return "";
	}
	public String getName7()
	{
		class class2
		{
			public String getName()
			{
				return "ddd";
			}
			public String getName1()
			{
				return "ddd";
			}
		}
		class2 theA = new class2();
		
		//匿名类
		Runnable theRun = new Runnable(){

			@Override
			public void run() {
				// TODO Auto-generated method stub
				getName1();
	        	getName2();
	        	getName3();
	        	getName4();
	        	getName5();
	        	getName6();
			}
			
		};
		return "ddd";
	}
    protected class InnerClass1
    {
        public  void doSomething1()
        {
        	getName1();
        	getName2();
        	getName3();
        	getName4();
        	getName5();
        	getName6();
        }
        protected  void doSomething2()
        {
        	this.doSomething3();
        }
        private  void doSomething3()
        {
        	getName1();
        	getName2();
        	getName3();
        	getName4();
        	getName5();
        	getName6();
        }
    }
    private class InnerClass2
    {
        public  void doSomething()
        {
        	getName1();
        	getName2();
        	getName3();
        	getName4();
        	getName5();
        	getName6();
        }
    }
    public class InnerClass3
    {
        public  void doSomething()
        {
        	getName1();
        	getName2();
        	getName3();
        	getName4();
        	getName5();
        	getName6();
        }
    }
    
    protected static class InnerClass4
    {
    	/**
    	 * 动态方法*/
        public  void doSomething1()
        {
        	getName1();
        	getName2();
        	getName3();
        	//静态类中不能访问外部类的非静态成员
        	//getName4();
        	//getName5();
        	//getName6();
        }
        protected  void doSomething2()
        {
        	this.doSomething3();
        }
        //静态方法
        public static void doSomething3()
        {
        	getName1();
        	getName2();
        	getName3();
        	//静态类中不能访问外部类的非静态成员
        	//getName4();
        	//getName5();
        	//getName6();
        }
    }
}

public class MyTest {

  public static void main(String[] args) 
	{
	    NestedClass theClass = new NestedClass();
	    //嵌套普通类实例化方式
	    NestedClass.InnerClass1 theInner = theClass.new InnerClass1();
	    //下面这种实例方法是错的.
	    //NestedClass.InnerClass4 theInner = new NestedClass.InnerClass4();
	    //保护方法
	    theInner.doSomething1();
	    //公用方法
	    theInner.doSomething2();
	    //静态的嵌套类实例方法
	    NestedClass.InnerClass4 theInner4 = new NestedClass.InnerClass4();
	    //静态的嵌套类不能使用如下实例方法
	    //NestedClass.InnerClass1 theInner4 = theClass.new InnerClass4();
	    NestedClass.InnerClass4.doSomething3();
	    theInner4.doSomething1();
	    NestedClass.InnerClass4 theInner5 =new NestedClass.InnerClass4();
	    
	    theInner5.doSomething1();//public
	    //从外面可以访问保护级方法.
	    theInner5.doSomething2();//protected 
	    
	    theClass.getName4();//保护方法可以访问.
	    
	    
	    
	}
  
}