⑴ c#怎麼拋出異常，急
可能你對throw語句還不是很熟悉，你看看下面的說明吧：
throw
功能是引發異常，常用格式:
throw;
或者
throw 表達式;
不帶表達式的throw語句只能在catch塊中，在這種情況下，它重新拋出當前正在由catch塊處理的異常。
帶表達式的throw語句拋出表達式的值。表達式必須是類型System.Exception或者System.Exception派生的類類型的值。如果表達式為null，則引發新的異常。
class test
{
static void F()
{
try{G();}
catch(Execption err)
{
Console.WriteLine("方法F中捕捉到："+err.Message);
throw;//重新拋出當前正在由catch塊處理的異常err
}
}
static viod G()
{
throw new Exception("方法G中拋出的異常");
}
static void Main()
{
try{F();}
catch(Exception err){Console.WriteLine("方法Main中捕獲到的："+err.Message);}
}
}
}
⑵ throws，throw，try，catch，finally分別代表什麼意
throw 僅用於方法定義後面，指示該方法可能會拋出什麼異常，使用該方法的方法必須處理該異常，或者再次拋出。
throws 用於當程序判斷發生異常時，用該語句拋出異常，或處理異常時再次拋出異常。
//下面三個關鍵字就是處理異常
try {
//這里放可能會發生異常的語句
} catch(Exception e) {
//這里處理異常
} finally {
//這里的語句必然會得到執行，不管異常發省與否，
//用於關閉資料庫，關閉連接等收尾操作（非必要）
}
java異常的一個簡單例子，比如我有一個除法方法
public int divide(int a, int b) {
return a / b;
}
但是這就有一個問題，當b是0時，程序會報錯。
如果引入異常，改成這樣
public int divide(int a, int b) throws Exception {
if (b == 0) {
throw new Exception("b = 0");
}
return a / b;
}
那麼調用端該怎麼用呢
public class ExceptionTest {
public static void main(String[] args) {
ExceptionTest et = new ExceptionTest();
try {
System.out.println(et.divide(12, 0));
} catch (Exception e) {
System.out.println("0不能做被除數");
}
}
public int divide(int a, int b) throws Exception {
if (b == 0) {
throw new Exception("b = 0");
}
return a / b;
}
}
程序可以繼續執行，不會中斷。
⑶ java中遇到與資料庫相關的問題，為什麼總是拋出得到異常！
首先看一段非常熟悉的用於打開一個文件的C程序段：
FILE *fp；
fp=fopen（filename，"rw"）；
if（fp==NULL）{
printf（"cannot open file\n"）；
exit（0）；
}
在這段程序中，if條件語句中的一段用來處理沒有找到指定文件，或者其它原因無法正確打開指定文件。可是如果遇到一個責任心不強的程序員，他可能認為出現找不到文件的可能性很小，或者由於思路集中在程序功能的實現上而忘記了處理這種情況。這時程序同樣可以正確編譯，而且一般情況下也不會出現問題。但此時這段程序可以肯定說是不夠健壯的，而且一旦這段程序發生了錯誤也會讓程序員很難發現錯誤出在哪裡。在C語言以及其它大多數高級語言中都可以舉出很多這種例子。
也就是一個函數在使用的時候，可能會出現並沒有達到這個函數的使用目的的情況，哪怕在這段程序的特定使用環境下發生這種異常情況的可能性只有萬分之一。常用處理的方法就是，程序員在需要使用某個函數時必須充分了解可能會有什麼原因導致該函數不能正確執行，然後加入相應的條件判斷語句來進行處理。後面將有一個例子說明這個問題。
而Java的" 異常機制"就是在處理上述問題中給了程序員非常簡單而靈活的方式。一般來說，其它高級語言主要是讓函數使用者來關注該函數可能會出現的異常情況，而 java則是把這件事情交給方法（和函數對應的概念，在Java中稱方法）的設計者來做。這對於方法的使用者來說帶來的方便是不會因為責任心不強，或者辦事丟三那四，會忘了在使用方法時處理可能發生的異常情況。而麻煩就是，在使用一個可能會發生異常的方法時，絕對不能視而不見，而必須做出相應的處理。也就是說象上述C程序段中，如果忘了if程序塊，這個程序甚至還能蒙過一個外行上司，但當使用Java來完成這個功能時，只要用到的方法使用了"異常"機制，如果不對可能產生"異常"的方法進行相應處理，java編譯器是不會讓其通過的。
一、"異常類"的組織形式
Java系統類中的方法產生的異常都被組織成"異常類"（還有Error類，不在本文討論范圍），此方法和它相關的"異常類"通過throws 關鍵字關聯在一起，並且這些類都必須是Exception類的子類。任何一個自己開發的類的方法中如果可能會產生某種異常，也可以將這種異常組織成一個" 異常類"，但這個"異常類"同樣必須是Exception的子類，或孫子類等等。
例1：
/*isLegal於檢查數據是否合法，當>0時視為合法，返回合法值，
*否則視為不合法，拋出"異常".*/
int isLegal（int dt） throws LowZeroException//這種定義本文中均稱為方法與"異常"通
{ //過throws建立了關聯
if（dt>=0）{
return data；
}
else
throw new LowZeroException（）；
}
/*自已寫的異常類，繼承自Exception*/
class LowZeroException extends Exception
{
public LowZeroException（）{
super（）；
}
}
仔細觀察方法isLegal（），它體現出的最值得注意的特色是，它有兩種方式的函數出口，一種是通過return語句，返回的是方法本身定義的類型的實例，另一種是通過throw，返回的是"異常類"的對象實例，Java中稱之為拋出"異常".對比一下C中如何處理同樣的問題的：
int isLegal（int dt） {
if（dt>=0）{
return data；
}
else
return -1；//通過一個特定值來表明出錯
}
由於C只能通過return返回函數值，所以在處理異常情況時則可能通過以上方式來處理。當然這就要求isLegal（）函數的使用者必須知道函數中使用返回值-1來表明出現不合法數據的情況。
對比這兩種處理方法，可以知道java的"異常機制"把處理異常事件的職能和方法本身的職能通過兩個不同出口分離開來。
所有這些"異常類"獨立於它具體服務的方法被統一組織成一個類樹。"異常機制"就好比高校的後勤社會化一樣，通過後勤社會化將學校的教學職能和學校的後勤保障分離開來，並且後勤集團的組織形式也是獨立於學校主體的。事實證明，這種組織方式不僅提高了服務效率，也提高了服務質量。整個Java體系中的"異常類"組織形式如圖1所示：
在例1中的isLegal（）方法如果在調用過程中沒有能正常返回整形數，而是在"異常"產生點產生了"異常"對象，那麼這個"異常"對象由誰來接收，並處理它呢？以下就來解答這個問題。
二、"異常"的處理過程
Java中由try…catch語法來處理"異常"，將關聯有"異常類"的方法包含在try{}程序塊中，catch（）{}關鍵字可以使用形參，用於和方法產生的"異常"對象結合。當調用某個方法時，引起異常事件發生的條件成立，便會拋出"異常"，原來的程序流程將會在此方法處中斷，然後 try模塊後緊跟的catch中的"形參"和此異常對象完成了結合，繼而進入了catch模塊中運行。具體過程舉例說明：
例2：
/*將關聯有異常的方法包含在try模塊中*/
int myMethod（int dt）{
int data = 0；
try{
int data = isLegal（dt）；
}catch（LowZeroException e）{
System.out.println（"發生數據錯誤！"）；
}
return data；
}
三、"異常"的處理方法
有兩種方法處理"異常"：第一種如例2，將含有"異常"出口的方法直接放到try塊中，然後由緊隨其後的catch塊捕捉。第二種是不直接監聽捕捉被引用方法的"異常"，而是將這個"異常"關聯傳遞給引用方法，同時監聽捕捉工作也相應向上傳遞。
例3：
int myMethod2（int dt）
{
int data = 0；
try{
data = myMethod（dt）
}catch（LowZeroException e）{
System.out.println（"發生數據錯誤！"）；
e.printStackTrace（）；
}
return data；
}
int myMethod（int dt） throws LowZeroException
{
int data = isLegal（dt）； //此處引用isLegal（）方法，但並沒有捕捉它的"異常"
return data；
}
從上例中可以看到方法myMethod（）與它引用的方法isLegal（）產生的"異常"LowZeroException建立了關聯，也就是完成了將"異常"關聯的向上傳遞，此時的myMethod（）方法體中雖然只有一個return返回語句，但它事實上同樣有兩種方式的函數出口，一種是由return返回的整形值，另一種則是返回方法名中的throws關鍵字所指的"異常類"的實例對象。相應的，監聽捕捉的工作交給了上一層方法 myMethod2（）。同樣的道理，myMethod2（）也可以將"異常"通過throws的關聯繼續向上傳遞。這樣的話，一旦一個"異常"被捕捉到時，這個"異常"必有一個傳遞路徑，而如果我們在捕捉點的catch程序塊中加入printStackTrace（）方法，便能清楚的看到這個"異常"是怎樣傳遞過來的。例如在例3如果有"異常"被捕捉到，e.printStackTrace（）列印出來的結果將是：
LowZeroException：
at Example.isLegal
at Example myMethod
at Example.myMethod2
at Example main
從上結果中我們可以看到，從LowZeroException"異常"產生點，即包含throw new LowZeroException（）；子句的方法開始，然後一直追溯到產生當前線程的方法（注意：printStackTrace（）並不是追溯到捕捉點結束，而是到產生當前線程的方法結束）。"異常"產生點產生的LowZeroException"異常"對象，首先被賦給了isLegal（）關聯的 LowZeroException類的無名引用，然後繼續賦給myMethod（）關聯的LowZeroException類的無名引用，再繼續賦給 myMethod2（）中的catch塊中的形參e，最後在這里被處理掉，這個"異常"對象隨即消失。可以說，catch（）{}就是"異常"對象的生命終結點。
另外還要注意一點，方法與"異常"的關聯可以一直向上傳遞，當傳遞到與main方法關聯後，即在main（）方法的定義中使用了throws Exception，這時除了虛擬機沒有其它方法能夠引用main（）方法，且在程序中可能看不到try…catch程序塊，但並不會產生錯誤，因為此時虛擬機會捕捉"異常"，並且會默認的調用printStackTrace（）方法列印出"異常"路徑。總之只要一個方法關聯了"異常"，可以將這個"異常 "關聯向上傳遞，但是最終必須使用catch來終止"異常"，或者一直傳遞到main（）方法交給Java虛擬機來結束"異常"對象的生命，否則是通不過編譯的。
四、使用"異常機制"的需要注意的幾點
1.一個方法中可能會產生多種不同的異常，你可以設置多個"異常"拋出點來解決這個問題。
2."異常"對象從產生點產生後，到被捕捉後終止生命的全過程中，實際上是一個傳值過程，所以你可以根據需要，來合理的控制檢測到"異常"的粒度。例如在例3中，如果你並不需要知道具體產生的是LowZeroException"異常"，那麼你可以使用"異常"的公共父類Exception來結合"異常"對象，即catch（Exception e）{…}.同樣在"異常"與方法關聯的傳遞過程中，也可以根據需要控制關聯"異常"的粒度，即throws後面跟上異常對象的父類名。
3."異常機制"中還有一種特殊情況――RuntimeException"異常類"，這個"異常類"和它的所有子類都有一個特性，就是"異常 "對象一產生就被Java虛擬機直接處理掉，即在方法中出現throw 子句的地方便被虛擬機捕捉了。因此凡是拋出這種"運行時異常"的方法在被引用時，不需要有try…catch語句來處理"異常".
=== 應該拋出異常的幾種情況 ===
在這些情況下，應該是要拋出異常的：
=== 無法通過參數檢查 ===
例如空值、參數取值范圍等，因為參數的規則說明是作為方法簽名的一部分發布的，調用者應該很清楚
調用這個方法所需要的參數的規格，但是調用者現在傳入的錯誤的參數，說明調用者本身這時候很可能
就已經出現問題了。
對參數進行檢查本身也是一個編寫一個方法的良好習慣，這可以保證方法本身在一個相對比較穩定可知
道狀態下工作，因此方法本身將更簡單也更穩定。
總之，拒絕非法的參數，並拋出異常。
=== 將可能導致以後的相關功能出錯 ===
如果一個異常或者錯誤的參數將導致以後更多的異常或者以後的某個功能異常，那麼不要延遲，立即拋
出異常。
例如有一個屬性 Filename 用來保存將被保存的文件的名稱，一個的方法 Save 將保存到 Filename 所
指定的文件名中去，顯然在給 Filename 屬性賦值時，如果給出一個包含非法文件名字元的字元串，那
么將導致 Save 方法中會有異常發生，不論 Save 方法是否對 Filename 再進行檢查，這時候距離設定
Filename 的代碼可能已經相當遠了，因此在設定 Filename 的時候，就應該要進行這種有關的檢查，
如果文件名不合法，立即拋出異常，而不要等到以後再來發現這個問題。
上述對參數進行檢查其實很多也是這種情況，特別一些空值參數，將可能導致以後使用該參數的時候發
生空值異常。
=== 不應該拋出異常的幾種情況 ===
=== 不影響程序繼續運行 ===
如果一個錯誤並不影響程序邏輯的正確性，或者不影響此後代碼的繼續運行，那麼可以不必拋出異常。
一個典型的例子例如，從集合中刪除指定鍵值對應的元素，但指定的鍵值其實並不在集合中，這顯然是
一個意外情況，但是，就此繼續下去，以後的程序應該還可以繼續有效的運行，因為即使在正常情況下
也不過是這個元素不再存在於集合中而已。返回一個整數值表示刪除掉的元素的個數，如果沒有找到給
定的元素，則返回0表示沒有元素被刪除。這個例子的另一種情形是，當前集合元素因為某種原因被鎖住
不能刪除元素，那麼應該拋出一個異常表示刪除失敗，而不是返回0表示沒有刪除元素。
⑷ 資料庫數據綁定時候拋出異常，如何解決~~
this.dataGridView1.DataSource = ds.Tables[0].DefaultView;
改為
this.dataGridView1.DataSource = ds.Tables["table"].DefaultView;
⑸ Java調用資料庫存儲過程拋出異常
是 from 吧？ 你吧 在java中寫的 sql 語句輸出到控制台，然後再放到 資料庫試試，有的時候在資料庫能運行的，在java里不一定能運行。有可能是缺少空格，也有可能是eclipse的問題 .
你換一個語句 簡單點的試試看。
⑹ 用java進行資料庫操作時拋出異常
您好，這樣的：
首先看一段非常熟悉的用於打開一個文件的C程序段：
FILE *fp；
fp=fopen（filename，"rw"）；
if（fp==NULL）{
printf（"cannot open file\n"）；
exit（0）；
}
在這段程序中，if條件語句中的一段用來處理沒有找到指定文件，或者其它原因無法正確打開指定文件。可是如果遇到一個責任心不強的程序員，他可能認為出現找不到文件的可能性很小，或者由於思路集中在程序功能的實現上而忘記了處理這種情況。這時程序同樣可以正確編譯，而且一般情況下也不會出現問題。但此時這段程序可以肯定說是不夠健壯的，而且一旦這段程序發生了錯誤也會讓程序員很難發現錯誤出在哪裡。在C語言以及其它大多數高級語言中都可以舉出很多這種例子。
也就是一個函數在使用的時候，可能會出現並沒有達到這個函數的使用目的的情況，哪怕在這段程序的特定使用環境下發生這種異常情況的可能性只有萬分之一。常用處理的方法就是，程序員在需要使用某個函數時必須充分了解可能會有什麼原因導致該函數不能正確執行，然後加入相應的條件判斷語句來進行處理。後面將有一個例子說明這個問題。
而Java的" 異常機制"就是在處理上述問題中給了程序員非常簡單而靈活的方式。一般來說，其它高級語言主要是讓函數使用者來關注該函數可能會出現的異常情況，而 java則是把這件事情交給方法（和函數對應的概念，在Java中稱方法）的設計者來做。這對於方法的使用者來說帶來的方便是不會因為責任心不強，或者辦事丟三那四，會忘了在使用方法時處理可能發生的異常情況。而麻煩就是，在使用一個可能會發生異常的方法時，絕對不能視而不見，而必須做出相應的處理。也就是說象上述C程序段中，如果忘了if程序塊，這個程序甚至還能蒙過一個外行上司，但當使用Java來完成這個功能時，只要用到的方法使用了"異常"機制，如果不對可能產生"異常"的方法進行相應處理，java編譯器是不會讓其通過的。
一、"異常類"的組織形式
Java系統類中的方法產生的異常都被組織成"異常類"（還有Error類，不在本文討論范圍），此方法和它相關的"異常類"通過throws 關鍵字關聯在一起，並且這些類都必須是Exception類的子類。任何一個自己開發的類的方法中如果可能會產生某種異常，也可以將這種異常組織成一個" 異常類"，但這個"異常類"同樣必須是Exception的子類，或孫子類等等。
例1：
/*isLegal於檢查數據是否合法，當>0時視為合法，返回合法值，
*否則視為不合法，拋出"異常".*/
int isLegal（int dt） throws LowZeroException//這種定義本文中均稱為方法與"異常"通
{ //過throws建立了關聯
if（dt>=0）{
return data；
}
else
throw new LowZeroException（）；
}
/*自已寫的異常類，繼承自Exception*/
class LowZeroException extends Exception
{
public LowZeroException（）{
super（）；
}
}
仔細觀察方法isLegal（），它體現出的最值得注意的特色是，它有兩種方式的函數出口，一種是通過return語句，返回的是方法本身定義的類型的實例，另一種是通過throw，返回的是"異常類"的對象實例，Java中稱之為拋出"異常".對比一下C中如何處理同樣的問題的：
int isLegal（int dt） {
if（dt>=0）{
return data；
}
else
return -1；//通過一個特定值來表明出錯
}
由於C只能通過return返回函數值，所以在處理異常情況時則可能通過以上方式來處理。當然這就要求isLegal（）函數的使用者必須知道函數中使用返回值-1來表明出現不合法數據的情況。
對比這兩種處理方法，可以知道java的"異常機制"把處理異常事件的職能和方法本身的職能通過兩個不同出口分離開來。
所有這些"異常類"獨立於它具體服務的方法被統一組織成一個類樹。"異常機制"就好比高校的後勤社會化一樣，通過後勤社會化將學校的教學職能和學校的後勤保障分離開來，並且後勤集團的組織形式也是獨立於學校主體的。事實證明，這種組織方式不僅提高了服務效率，也提高了服務質量。整個Java體系中的"異常類"組織形式如圖1所示：
在例1中的isLegal（）方法如果在調用過程中沒有能正常返回整形數，而是在"異常"產生點產生了"異常"對象，那麼這個"異常"對象由誰來接收，並處理它呢？以下就來解答這個問題。
二、"異常"的處理過程
Java中由try…catch語法來處理"異常"，將關聯有"異常類"的方法包含在try{}程序塊中，catch（）{}關鍵字可以使用形參，用於和方法產生的"異常"對象結合。當調用某個方法時，引起異常事件發生的條件成立，便會拋出"異常"，原來的程序流程將會在此方法處中斷，然後 try模塊後緊跟的catch中的"形參"和此異常對象完成了結合，繼而進入了catch模塊中運行。具體過程舉例說明：
例2：
/*將關聯有異常的方法包含在try模塊中*/
int myMethod（int dt）{
int data = 0；
try{
int data = isLegal（dt）；
}catch（LowZeroException e）{
System.out.println（"發生數據錯誤！"）；
}
return data；
}
三、"異常"的處理方法
有兩種方法處理"異常"：第一種如例2，將含有"異常"出口的方法直接放到try塊中，然後由緊隨其後的catch塊捕捉。第二種是不直接監聽捕捉被引用方法的"異常"，而是將這個"異常"關聯傳遞給引用方法，同時監聽捕捉工作也相應向上傳遞。
例3：
int myMethod2（int dt）
{
int data = 0；
try{
data = myMethod（dt）
}catch（LowZeroException e）{
System.out.println（"發生數據錯誤！"）；
e.printStackTrace（）；
}
return data；
}
int myMethod（int dt） throws LowZeroException
{
int data = isLegal（dt）； //此處引用isLegal（）方法，但並沒有捕捉它的"異常"
return data；
}
從上例中可以看到方法myMethod（）與它引用的方法isLegal（）產生的"異常"LowZeroException建立了關聯，也就是完成了將"異常"關聯的向上傳遞，此時的myMethod（）方法體中雖然只有一個return返回語句，但它事實上同樣有兩種方式的函數出口，一種是由return返回的整形值，另一種則是返回方法名中的throws關鍵字所指的"異常類"的實例對象。相應的，監聽捕捉的工作交給了上一層方法 myMethod2（）。同樣的道理，myMethod2（）也可以將"異常"通過throws的關聯繼續向上傳遞。這樣的話，一旦一個"異常"被捕捉到時，這個"異常"必有一個傳遞路徑，而如果我們在捕捉點的catch程序塊中加入printStackTrace（）方法，便能清楚的看到這個"異常"是怎樣傳遞過來的。例如在例3如果有"異常"被捕捉到，e.printStackTrace（）列印出來的結果將是：
LowZeroException：
at Example.isLegal
at Example myMethod
at Example.myMethod2
at Example main
⑺ jdbc資料庫查詢拋出異常 請問大概是什麼異常 java
sql語句拼錯了吧，看看是不是欄位名寫錯了，或者Where這些關鍵字寫得不對！
⑻ C#連接資料庫怎麼拋出異常
C# 連接資料庫時異常 ：這個是屬於SQL語句語法錯誤，不是資料庫連接錯誤。 解決辦法： 1、檢查 sql server 伺服器是否允許遠程連接； 2、連接字元串是否正確； 3、是否有防火牆限制；
⑼ JAVA語言如何進行異常處理,關鍵字:throws,throw,try,catch,finally分別代表什麼意
throw 僅用於方法定義後面，指示該方法可能會拋出什麼異常，使用該方法的方法必須處理該異常，或者再次拋出。
throws 用於當程序判斷發生異常時，用該語句拋出異常，或處理異常時再次拋出異常。
//下面三個關鍵字就是處理異常
try {
//這里放可能會發生異常的語句
} catch(Exception e) {
//這里處理異常
} finally {
//這里的語句必然會得到執行，不管異常發省與否，
//用於關閉資料庫，關閉連接等收尾操作（非必要）
}
java異常的一個簡單例子，比如我有一個除法方法
public int divide(int a, int b) {
return a / b;
}
但是這就有一個問題，當b是0時，程序會報錯。
如果引入異常，改成這樣
public int divide(int a, int b) throws Exception {
if (b == 0) {
throw new Exception("b = 0");
}
return a / b;
}
那麼調用端該怎麼用呢
public class ExceptionTest {
public static void main(String[] args) {
ExceptionTest et = new ExceptionTest();
try {
System.out.println(et.divide(12, 0));
} catch (Exception e) {
System.out.println("0不能做被除數");
}
}
public int divide(int a, int b) throws Exception {
if (b == 0) {
throw new Exception("b = 0");
}
return a / b;
}
}
程序可以繼續執行，不會中斷。
⑽ java拋出異常語句是什麼來著
throw new Exception("異常信息""); //Exception :異常類型
請採納