① java靜態代理和iOS代理模式這兩個概念的理解上的疑惑
java靜態代理模式,舉例給你，看下如何理解：
public class Ts {
public static void main(String[] args) throws Exception {
// 通過中介公司生產一批衣服
ClothingProct cp = new ProxCompany( new LiNingCompany());
cp.proctClothing();
}
}
/**
* 定義生產一批衣服功能的介面
*
*/
interface ClothingProct {
void proctClothing(); // 有生產一批衣服的功能
}
/**
*
* 代理類：中介公司
*
*/
class ProxCompany implements ClothingProct {
private ClothingProct cp ; // 中介公司不會生產衣服，需要找一家真正能生產衣服的公司
ProxCompany(ClothingProct cp) {
super ();
this . cp = cp;
}
@Override
public void proctClothing() {
System. out .println( "收取1塊錢的中介費" );
cp .proctClothing();
}
}
/**
*
* 李寧公司是生產服裝的目標類
*
*/
class LiNingCompany implements ClothingProct {
@Override
public void proctClothing() {
System. out .println( "生產一批衣服。。。。" );
}
}
上面程序的做法，使用的模式是靜態代理模式
靜態代理模式在現實編程中的弊端：
它的特徵是代理類和目標對象的類都是在編譯期間確定下來的，不利於程序上的擴展，上面示例中，如果客戶還想找一個「生產一批鞋子」的工廠，那麼還需要新增加一個代理類和一個目標類。如果客戶還需要很多其他的服務，就必須一一的添加代理類和目標類。那就需要寫很多的代理類和目標類
代理模式到底做了什麼？
我眼中的代理模式只有兩個關注點：協議和代理者
協議定義了一組方法，由某一個類負責實現。
代理者作為某個類的一個屬性，通常是另一個類的實例對象，可以負責完成原來這個類不方便或者無法完成的任務。
首先談一談代理者，在腦中重新回想一下代理模式的實現過程。在頁面B中定義一個代理對象的時候，好像和定義一個普通的property非常類似（除了 weak和id《delegate》>）。這也正是我對代理的概括：代理本來就是一個屬性而已，並沒有非常神秘。
當然，代理者並不只是一個類普通的屬性，否則我只需要重寫一下B的初始化方法即可達到同樣的效果：
self.BVC = [[BViewController alloc]initWithDelegate:self];
然後在BViewController.m中定義一個AViewController *AVC並在初始化方法中賦值即可。
注意到代理者在定義的時候，格式往往是這樣的：
id <SomeDelegate> delegate;
所以我對代理的優勢的理解是：
代理的核心優勢在於解耦
與直接聲明一個屬於某個固定的類的代理者相比，聲明為id的代理者具備兩個明星的優勢。
允許多個不同的類成為本類的代理。試想一下在本文例子中，如果頁面B可以跳轉回N個頁面，如果還是通過聲明一個普通對象的方式，那怎麼辦？
允許代理者的類還不固定。試想一下，UITableView也有delegate，它根本不知道那個類會成為它的代理者。
再看一看協議。協議更加簡單了。協議只是定義了一組方法。在代理模式中，完全可以不用在頁面B中定義一個協議，然後A再去遵循這個協議。直接調用A的方法即可。
個人認為協議的優點在於以下幾點：
可以利用Xcode的檢查機制。對於定義為@required的方法，如果實現了協議而沒有實現這個方法，編譯器將會有警告。這樣可以防止因為疏忽，忘記實現某個代碼的情況，而由於OC的運行時特性，這樣的錯誤往往在運行階段才會導致程序崩潰。
有利於代碼的封裝。如果一個類，實現了某個協議，那麼這個協議中的方法不必在.h中被聲明，就可以被定義協議的類調用。這樣可以減少一個類暴露給外部的方法。
有利於程序的結構化與層次化。一個協議往往是解決問題的某個方法，對於一個其他的不過卻類似的問題，我們只用再次實現協議即可，避免了自己再次構思一組方法。協議的繼承機制使得這一有點更加強大。
說了怎麼多，總結起來只有一句：代理模式並不神秘，只是一個經過了優化的小技巧（讓某個類持有另一個類的指針）。代理和協議也只是讓程序耦合度更低，結構感更強而已。
② 什麼是java代理模式，具體相關的動態代理和靜態代理分別是什麼舉例更好啦~
簡單的例子: HelloSpeaker.java
import java.util.logging.*;
public class HelloSpeaker {
private Logger logger = Logger.getLogger(this.getClass().getName());
public void hello(String name) {
logger.log(Level.INFO, "hello method starts...."); //日誌記錄
System.out.println("Hello, " + name); //!!!!!!!!!!!
logger.log(Level.INFO, "hello method ends...."); //日誌記錄
}
}
HelloSpeaker在執行hello()方法時，我們希望能記錄該方法已經執行以及結束，
最簡單的作法就是如上在執行的前後加上記錄動作，然而Logger介入了HelloSpeaker中，
記錄這個動作並不屬於HelloSpeaker，這使得HelloSpeaker的職責加重。
------------------------------------------------------------------------------------------
怎麼辦，用下面的方法或許好一些:
先定義一個介面:
public interface IHello {
public void hello(String name);
}
------------------------------------------------------------------------------------------
實現該介面
public class HelloSpeaker implements IHello {
public void hello(String name) {
System.out.println("Hello, " + name);
}
}
public class Greeting implements IHello{
public void hello(String name){
System.out.println("Greeting, " + name);
}
}
------------------------------------------------------------------------------------------
實現一個代理對象: HelloProxy
import java.util.logging.*;
public class HelloProxy implements IHello {
private Logger logger = Logger.getLogger(this.getClass().getName());
private IHello helloObject; //被代理對象
public HelloProxy(){}
public HelloProxy(IHello helloObject) {
this.helloObject = helloObject; //把被代理對象傳入
}
public void setHelloObject(IHello helloObject){
this.helloObject = helloObject;
}
public IHello getHelloObject(){
return this.helloObject;
}
public void hello(String name) {
logger.log(Level.INFO, "hello method starts...."); //日誌記錄
helloObject.hello(name); //!!!!!!!!調用被代理對象的方法
logger.log(Level.INFO, "hello method ends...."); //日誌記錄
}
}
-----------------------------------------------------------------------------------------------------
執行:
IHello helloProxy = new HelloProxy(new HelloSpeaker()); //生成代理對象, 並給它傳入一個被代理的對象
helloProxy.hello("world");
//IHello h=factory.getBean("hello"); // IoC
//h.hello("world");
IHello helloProxy = new HelloProxy(new Greeting()); //生成代理對象, 並給它傳入一個被代理的對象
helloProxy.hello("world");
-----------------------------------------------------------------------------------------------------
代理對象HelloProxy將代理真正的HelloSpeaker來執行hello()，並在其前後加上記錄的動作，
這使得我們的HelloSpeaker在寫時不必介入記錄動作，HelloSpeaker可以專心於它的職責。
這是靜態代理的基本範例，然而，代理對象的一個介面只服務於一種類的對象，而且如果要代理的方法很多，
我們勢必要為每個方法進行代理，靜態代理在程序規模稍大時就必定無法勝任.
Java在JDK 1.3之後加入協助開發動態代理功能的類，我們不必為特定對象與方法寫特定的代理，使用動態代理，
可以使得一個handler服務於各個對象，首先，一個handler必須實現java.lang.reflect.InvocationHandler：
import java.util.logging.*;
import java.lang.reflect.*;
public class LogHandler implements InvocationHandler { //
private Logger logger = Logger.getLogger(this.getClass().getName());
private Object delegate; //被代理的對象
public Object bind(Object delegate) { //自定義的一個方法，用來綁定被代理對象的，返回值為被代理方法的返回值
this.delegate = delegate;
return Proxy.newProxyInstance(
delegate.getClass().getClassLoader(),
delegate.getClass().getInterfaces(),
this); //通過被代理的對象生成它的代理對象, 並同handler綁定在一起
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
try {
logger.log(Level.INFO, "method starts..." + method); //日誌記錄
result = method.invoke(delegate, args); //!!!!!!!!調用被代理對象的方法
logger.log(Level.INFO, "method ends..." + method); //日誌記錄
} catch (Exception e){
logger.log(Level.INFO, e.toString());
}
return result;
}
}
InvocationHandler的invoke()方法會傳入被代理對象的方法名稱與參數, 實際上要執行的方法交由method.invoke()，
並在其前後加上記錄動作，method.invoke()返回的對象是實際方法執行過後的回傳結果。
動態代理必須有介面:
public interface IHello {
public void hello(String name);
}
實現該介面:
public class HelloSpeaker implements IHello {
public void hello(String name) {
System.out.println("Hello, " + name);
}
}
執行:
LogHandler logHandler = new LogHandler();
IHello helloProxy = (IHello) logHandler.bind(new HelloSpeaker()); //傳入被代理對象, 傳回代理對象
helloProxy.hello("Justin");
③ C#和Java定義介面語法的不同點
C#與Java的區別
C#最引人的地方是它與Java的區別而不是其相似性。下面主要來介紹C#區別 於Java的不同的運行特點及Java完全沒有的特點。
中間語言
當MSIL被編譯成最終的機器碼時，微軟公司在如何選擇上是非常靈活的。微 軟公司很謹慎的對外宣稱說MSIL不是解釋型的，而是被編譯成機器碼。因為開發 人員都有這樣一個觀念：Java程序天生就比C程序運行慢，所以這暗示著基於MSIL 的程序優於解釋型的Java位元組碼。當然，既然C#和其它MSIL 產品編譯器還未發布 ，那麼這一點就還未證明，但是Java無處不在的即時編譯器使得C#和Java在效能 上是一樣的。象「C#是編譯型的，Java是解釋型的」這樣話只是銷售中的技巧。 Java的位元組碼和MSIL碼都是的類似匯編的中間語言，在運行時執行這些中間碼。
與COM的整合
對於基於Windows的C#開發人員來說，最大的收獲是對COM的無損整合，COM是 微軟Win32的組件技術。實際上，任何一種.Net體系結構上的語言最終都可能去寫 COM的客戶端和伺服器端程序。用C#編寫的類也會作為COM組件的子類；結果類 （resulting class）也能作為COM組件使用，並作為COM組件的子類。
微軟公司的目標是使越來越多的語言都能訪問組件，並使這些組件能整合到. Net體系結構中。已有幾個廠商開始著手開發支持.Net功能的編程語言，如COBOL 和Haskell。開發人員能選擇不同的語言解決不同問題，更重要的是，開發人員不 必為採用.Net體系結構而必須學習新語言，可以選擇一種他們熟悉的語言。
用範例說明了C#與Java兩者在 相似性外，它們又是非常不同的，有許多細微的語義和設計區別，適合不同的技 術和市場環境，又談到了微軟公司對C#進行標准化方面的嘗試，及其對Java的影 響。
c#與java的區別
1.屬性：
java中定義和訪問均要用get和set方法，可以不成對出現。
c#中是真正的屬性，定義時get和set必須同時出現,房問時用.號即可。不用 get,set
2.對象索引
就是對象數組
public Story this [int index] {
3.C#中,不用任何范圍修飾符時,默認的是protect,因而不能在類外被訪問.
4.因為JAVA規定,在一個文件中只能有一個public類,而且這個類的名稱必須與文 件名一模一樣,這是一個區別
5.在C#中,它是以Main方法來定位入口的.如果一個程序中沒有一個名為Main的方 法,就會出"找不到入口的錯誤".不要把Main寫成main喲
6.C#預定義的簡單數據類型比Java多。例如，C#有unit，即無符號整數
7.忘掉Java中的static final修飾符。在C#中，常量可以用const關鍵詞聲明
C#的設計者還增加了readonly關鍵詞,readonly域只能通過初始化器或類的構造函 數設置
8.公用類的入口點:c#是可以對Main進行重載（java中是main）,允許有int返回值 和空參數的Main
9.在Java中，switch語句只能處理整數。但C#中的switch語句不同，它還能夠處 理字元變數。請考慮下面用switch語句處理字元串變數的C#代碼
10.C#沒有>>>移位操作符
11.goto關鍵詞:
Java不用goto關鍵詞。在C#中，goto允許你轉到指定的標簽。不過，C#以特別謹 慎的態度對待goto，比如它不允許goto轉入到語句塊的內部。在Java中，你可以 用帶標簽的語句加上break或continue取代C#中的goto。
12.int[] x = { 0, 1, 2, 3 };
int x[] = { 0, 1, 2, 3 };
但在C#中，只有第一行代碼合法，[]不能放到變數名字之後。
13.與Java不同的是，C#允許為名稱空間或者名稱空間中的類指定別名：
using TheConsole = System.Console;
14.在Java中，包的名字同時也是實際存在的實體，它決定了放置.java文件的目 錄結構。在C#中，物理的包和邏輯的名稱之間是完全分離的
.NET 中包的實體稱為程序集（Assembly）。每一個程序集包含一個manifest結構 。manifest列舉程序集所包含的文件，控制哪些類型和資源被顯露到程序集之外 ，並把對這些類型和資源的引用映射到包含這些類型與資源的文件。程序集是自 包含的，一個程序集可以放置到單一的文件之內，也可以分割成多個文件。.NET 的這種封裝機制解決了DLL文件所面臨的問題，即臭名昭著的DLL Hell問題。
15.在Java中，java.lang包是默認的包,C#中不存在默認的包
16.C#中的訪問修飾符與Java中的基本對應，但多出了一個internal。簡而言之， C#有5種類型的可訪問性，如下所示：
public：成員可以從任何代碼訪問。
protected：成員只能從派生類訪問。
internal：成員只能從同一程序集的內部訪問。
protected internal：成員只能從同一程序集內的派生類訪問。
private：成員只能在當前類的內部訪問。
17.由於C#中不存在final關鍵詞，如果想要某個類不再被派生，你可以使用 sealed關鍵詞
18.與Java不同，C#中的介面不能包含域（Field）。
另外還要注意，在C#中，介面內的所有方法默認都是公用方法。在Java中，方法 聲明可以帶有public修飾符（即使這並非必要），但在C#中，顯式為介面的方法 指定public修飾符是非法的。例如，下面的C#介面將產生一個編譯錯誤。
19.C# 中的is操作符與Java中的instanceof操作符一樣，兩者都可以用來測試某 個對象的實例是否屬於特定的類型。在Java中沒有與C#中的as操作符等價的操作 符。as操作符與is操作符非常相似，但它更富有「進取心」：如果類型正確的話 ，as操作符會嘗試把被測試的對象引用轉換成目標類型；否則，它把變數引用設 置成null。
20.C#仍舊保留了C++的內存手工管理方法，它適合在速度極端重要的場合使用， 而在Java中這是不允許的
21.在C#中，所有的異常都從一個名為Exception的類派生
22.枚舉器即enum類型(java無),把它作為一個變數值的類型使用，從而把變數可 能的取值范圍限制為枚舉器中出現的值。
23.結構（Struct）與類很相似,而結構是一種值類型，它存儲在棧中或者是嵌入 式的,結構可以實現介面，可以象類一樣擁有成員，但結構不支持繼承
24.屬性聲明語法的第一部分與域聲明很相似，第二部分包括一個set過程和/或一 個get過程
25.傳值方式：
在java中簡單數據類型的值傳參時，都以傳值方式;
在c#中如果加ref則會以引用的方式傳值（方法內部改變該參數，則外部變數一起 跟著變）;
加out與ref基本相同，但out不要求參數一定要初始化.
26.c#保留了指針。unsafe
27.代理：代理（delegate）可以看作C++或者其他語言中的函數指針
代理用來封裝可調用方法。你可以在類裡面編寫方法並在該方法上創建代理，此 後這個代理就可以被傳遞到第二個方法。這樣，第二個方法就可以調用第一個方 法。
代理是從公共基類System.Delegate派生的引用類型。定義和使用代理包括三個步 驟：聲明，創建實例，調用。代理用delegate聲明語法聲明。
④ Java的回調函數和觀察者模式的區別
java的回調 叫listener 模式。
無論是listener模式，還是C++裡面的callback模式，本質是一樣的
他們都是觀察者模式的具體實現。
觀察者模式是設計模式中定義的一種思想，而具體到不同的語言環境，使用不同的語法表現出來就會有java的listener objc的 delegate，或者C++的 callback。
⑤ 編程:請問java與c#都是由c演變的,那麼java與c有哪些區別呢
一、首先，給你個形象的例子讓你明白：
如果說JAVA好比是奔4，C語言就是386電腦了。
兩者都是編譯語言，但是後者是計算機發展中的一個基礎語言，而JAVA則是新興的功能更加強大的編寫語言。
二、其次，再給你詳細一些的說明兩者的區別：
1． Java沒有預處理指令。（如C中的#define , #include , #ifdef等）。C中的常量定義在Java中用static final來取代。
2． Java中沒有C中的全局變數。
3． Java中的主類型的size是確定的，而C中主類型的size跟平台相關。
4． Java中沒有了指針，它使用了類似的句柄來取代指針，但是Java中不允許對句柄進行加減，沒有取地址操作符之類的東東。
5． Java有垃圾收集機制，不需要自己釋放空間。
6． Java沒有goto語句。Java在C提供的控制語句基礎上增加了異常處理和標簽break和continue語句。這些可以替代goto的作用。
7． C要求一個方法或塊中使用的所有局部變數的定義在該方法或塊的最開始處定義，而Java允許這些定義在方法或塊的任意地方出現。
8． Java不要求在調用一個函數以前已經定義了該函數，可以在調用點後面定義。而C有這個要求。
9． Java不支持C中的strut 和 union類型。Java支持方法重載。
10． Java不支持C中的enum關鍵字。
11． Java不支持C中的bitfields能力。
12． Java不支持C的typedef。
13． Java不支持C的方法指針。
14. Java不支持C的可變參數表。
三、最後，再向你介紹一下JAVA與C#的區別：
1.屬性：
java中定義和訪問均要用get和set方法，可以不成對出現。
c#中是真正的屬性，定義時get和set必須同時出現,房問時用.號即可。不用get,set
2.對象索引
就是對象數組
public Story this [int index] {
3.C#中,不用任何范圍修飾符時,默認的是protect,因而不能在類外被訪問.
4.因為JAVA規定,在一個文件中只能有一個public類,而且這個類的名稱必須與文件名一模一樣,這是一個區別
5.在C#中,它是以Main方法來定位入口的.如果一個程序中沒有一個名為Main的方法,就會出"找不到入口的錯誤".不要把Main寫成main喲
6.C#預定義的簡單數據類型比Java多。例如，C#有unit，即無符號整數
7.忘掉Java中的static final修飾符。在C#中，常量可以用const關鍵詞聲明
C#的設計者還增加了readonly關鍵詞,readonly域只能通過初始化器或類的構造函數設置
8.公用類的入口點:c#是可以對Main進行重載（java中是main）,允許有int返回值和空參數的Main
9.在Java中，switch語句只能處理整數。但C#中的switch語句不同，它還能夠處理字元變數。請考慮下面用switch語句處理字元串變數的C#代碼
10.C#沒有>>>移位操作符
11.goto關鍵詞:
Java不用goto關鍵詞。在C#中，goto允許你轉到指定的標簽。不過，C#以特別謹慎的態度對待goto，比如它不允許goto轉入到語句塊的內部。在Java中，你可以用帶標簽的語句加上break或continue取代C#中的goto。
12.int[] x = { 0, 1, 2, 3 };
int x[] = { 0, 1, 2, 3 };
但在C#中，只有第一行代碼合法，[]不能放到變數名字之後。
13.與Java不同的是，C#允許為名稱空間或者名稱空間中的類指定別名：
using TheConsole = System.Console;
14.在Java中，包的名字同時也是實際存在的實體，它決定了放置.java文件的目錄結構。在C#中，物理的包和邏輯的名稱之間是完全分離的
.NET中包的實體稱為程序集（Assembly）。每一個程序集包含一個manifest結構。manifest列舉程序集所包含的文件，控制哪些類型和資源被顯露到程序集之外，並把對這些類型和資源的引用映射到包含這些類型與資源的文件。程序集是自包含的，一個程序集可以放置到單一的文件之內，也可以分割成多個文件。.NET的這種封裝機制解決了DLL文件所面臨的問題，即臭名昭著的DLL Hell問題。
15.在Java中，java.lang包是默認的包,C#中不存在默認的包
16.C#中的訪問修飾符與Java中的基本對應，但多出了一個internal。簡而言之，C#有5種類型的可訪問性，如下所示：
public：成員可以從任何代碼訪問。
protected：成員只能從派生類訪問。
internal：成員只能從同一程序集的內部訪問。
protected internal：成員只能從同一程序集內的派生類訪問。
private：成員只能在當前類的內部訪問。
17.由於C#中不存在final關鍵詞，如果想要某個類不再被派生，你可以使用sealed關鍵詞
18.與Java不同，C#中的介面不能包含域（Field）。
另外還要注意，在C#中，介面內的所有方法默認都是公用方法。在Java中，方法聲明可以帶有public修飾符（即使這並非必要），但在C#中，顯式為介面的方法指定public修飾符是非法的。例如，下面的C#介面將產生一個編譯錯誤。
19.C#中的is操作符與Java中的instanceof操作符一樣，兩者都可以用來測試某個對象的實例是否屬於特定的類型。在Java中沒有與C#中的as操作符等價的操作符。as操作符與is操作符非常相似，但它更富有「進取心」：如果類型正確的話，as操作符會嘗試把被測試的對象引用轉換成目標類型；否則，它把變數引用設置成null。
20.C#仍舊保留了C++的內存手工管理方法，它適合在速度極端重要的場合使用，而在Java中這是不允許的
21.在C#中，所有的異常都從一個名為Exception的類派生
22.枚舉器即enum類型(java無),把它作為一個變數值的類型使用，從而把變數可能的取值范圍限制為枚舉器中出現的值。
23.結構（Struct）與類很相似,而結構是一種值類型，它存儲在棧中或者是嵌入式的,結構可以實現介面，可以象類一樣擁有成員，但結構不支持繼承
24.屬性聲明語法的第一部分與域聲明很相似，第二部分包括一個set過程和/或一個get過程
25.傳值方式：
在java中簡單數據類型的值傳參時，都以傳值方式;
在c#中如果加ref則會以引用的方式傳值（方法內部改變該參數，則外部變數一起跟著變）;
加out與ref基本相同，但out不要求參數一定要初始化.
26.c#保留了指針。unsafe
27.代理：代理（delegate）可以看作C++或者其他語言中的函數指針
代理用來封裝可調用方法。你可以在類裡面編寫方法並在該方法上創建代理，此後這個代理就可以被傳遞到第二個方法。這樣，第二個方法就可以調用第一個方法。
代理是從公共基類System.Delegate派生的引用類型。定義和使用代理包括三個步驟：聲明，創建實例，調用。代理用delegate聲明語法聲明。
⑥ java中source - generate delegate methods是用來完成什麼功能的
字面上翻譯就是「生成代理方法」，就是如果你有一個類的屬性，只要它不是基本類型(int, long, float...)，就根據這個類型的所有父類型（包括介面）生成同名的方法，並調用父類型的方法。
這么解釋起來有點抽象，你可以創建一個屬性，比如
public class Test {
private String testStr; //在這個變數名上點右鍵「generate delegate methods"
...
你會發現所有String類以及父類Object類的所有方法都列出來了，你可以生成其中某個或全部方法的代理方法，例如生成length()方法的代理方法如下：
public int length() {
return testStr.length();
}
你可以看到」代理方法「一般只是簡單的對父類型的同名方法做了調用，一般你還需要添加一部分功能，但是eclipse已經把重復勞動的那一部分替你做了。
這么解釋能明白了吧
⑦ java 為什麼引入函數式介面而不是委託知乎
一個函數式介面是一個能夠使用類函數做為參數的類型，一個lambda表達式支持提供這樣一個實參。舉個例子，forEach類方法在集合類上有如下簽名：必須為forEach提供並實現一個Block介面的一個單例類方法實例，才能被使用forEach類方法。
⑧ 在Java中沒有C#的delegate類型,ref和out類型的參數,那在Java中如何變通地實現相同功能
delegate你可以用相關對象的addXXXListener實現，如果沒有你想要的listener，你可以自己寫一個，然後在set方法裡面通知這些listener就可以了，比方你要監視Obj的屬性變化，可以這樣，先定義一個借口PropertyChangeListener{public void execute();}
class Obj{
List<PropertyChangeListener> listeners;
void firePropertyChanged(PropertyChangeEvent e){
for (PropertyChangeListener l:listeners){
l.execute(e);
}
}
void addPropertyChangeListener(PropertyChangeListener l){
listeners.add(l);
}
}
ref就是傳引用，隨便一個對象就可以傳引用，除了String，還有out，你直接在函數裡面修改傳引用的參數就ok
⑨ 什麼是delegate
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class test
{
public static void main(String[] args)throws Exception
{
int[] b=new int[200];
int[] c=new int[200];
int i, j;
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String str=null;
⑩ C#與JAVA的異同總結（詳細）
C#是.net系列的，基於C++語言進行面向對象的程序開發環境，開發技術
java是sun公司推出的純面向對象的語言，程序開發技術。是開源的
java是基於C++變化而來的，其優點在於其的開源和共享！
C#是微軟推出的，其優點在於開發的可視性強，學習起來比較方便！
java編寫的程序相對.net來說是比較耗費內存的，比較有代表性的就是orcle
.net編寫的程序相對java來說是是比較耗費CPU的