Ⅰ java中， try catch（IOException s）什么意思，怎么用
这是java用来捕捉异常的，捕捉程序在运行时可能出现的异常。
1，当代码在运行时可能出现异常时用try{} catch{}捕捉异常，这样程序出现异常不会立即跳出程序，可以经过余明漏处理后让程序继续运行或者跳出。例如：
String a = "12211a";
try {
int b = Integer.parseInt(a); // 将字符串转为数字，a里面有字母，转换失败，将会抛出异常。
System.out.println("is a number:"+b);
} catch (Exception e) {
System.out.println("not a number");
}
2，还有很多其他异常，列举一些常见异常:
算术异常类：
ArithmeticExecption
空指针异常类：
NullPointerException
类型强制转换异常：
ClassCastException
类未找到异常：
ClassNotFoundException
数组负下标异常：
NegativeArrayException
数组下标越界异常：
违背安竖烂全原则异常：
SecturityException
文件已结束异常：
EOFException
文件槐旦未找到异常：
FileNotFoundException
字符串转换为数字异常：
NumberFormatException
操作数据库异常：
SQLException
输入输出异常：
IOException
Ⅱ Java中try catch
这段代复码
1.返回的值是5
，
2.没有任何输出制效果。
执行过程：
1.首先执行main方法。调用静态函数getconn();
2.定义变量conn
。初始值为8.
3.进入try
代码块。将conn的值改写成5.过程中没有发生异常。跳过catch语句块。
4.执行return语句，返回conn变量值，5。
5.返回函数调用的地方，也就是主函数。
6.运行结束。
代码要点解释：
使用try
catch
1.无异常发生
包裹起来的代码块执行时与正常的语句块没有不同。
2.发生异常
21.try语句块中，从发生异常的哪行代码处断开，不再往下执行，跳转到catch语句块中
22.程序会根据try中发生的异常的类型，选择最合适的catch语句块。按照catch的顺序向下选择，遇到适当的范围，就会进入catch块执行并跳出catch,注意catch语句可以有多个，但只执行一次。因此应当按照范围从小到大排列。
23.try
catch语句执行完后会继续执行catch后面的语句,不会重新返回try中。
Ⅲ 请问JAVA中 try-catch-finally 语句的执行顺序是怎么样的啊
try中写正确的程序。catch中处理异常，finally无论如何都会执行里面的代码块。就像连接数据库一样，不管正确与否都
要在finally中关闭
Ⅳ JAVA语言如何进行异常处理
Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理。x0dx0a用try来指定一块预防所有异常的程序。紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的异常的类型。x0dx0athrow语句用来明确地抛出一个异常。x0dx0athrows用来标明一个成员函数可能抛出的各种异常。x0dx0a可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try语句，异常的框架就放到堆栈上面，直到所有的try语句都完成。
Ⅳ 应用技巧:Java中的异常处理
异常处理是初学者经常忽视执行的编程技巧。然而，当他们完成了一项大型项目后，就会发现仅仅停留在表面的工作是不够的。在本文中，我们将对异常处理进行讨论，并为大家解释其重要性，尤其是要告诉大家怎样处理这些情况。
首先，让我们解释一下什么是异常情况，通常也称例外。正如在其他的编程语言中那样，它也适用于Java：异常情况是那些在运行时出现错误的情况。这些错误并非真正的错误，因为他们是一些例外。我们可以将这些情况理解为必须解决的异常事件，否则程序将无法继续执行。所以我们就有必要了解怎样处理异常事件。
在异常事件的例子中最显著的应该是在程序执行时，运行时的分配变成了零。这样程序就无法执行，于是Java就会抛出一个异常事件，确切点说是ArithmeticException。从Java程序员的角度来看，异常事件是对象。抛出异常事件类似于抛出对象。但是，并非所有的对象都可以被抛出。
为了充分理解可毕山抛出的异常事件，整个类层次结构的一些部分要消数闷被提交。主要的类称为Throwable。这个类拥有两个子类：Exception 和Error。一个异常事件对象应从Throwable的类中传出。意味着它应该是Exception子类或Error子类的一个对象实例。这些都可以在 java.lang数据包中找到。
异常处理就是捕捉可能在运行时被抛出的异常事件的一项技术。Java通过try-catch-finally的异常处理语句为我们提供了强大的异常处理解决方案。而在另一方面，你也可以使用已经声明的异常事件，如ArithmeticException, NullPointerException等。其他类扩展了Exception 类，如IOException子类。
此外，我们应该注意到异常事件包含了两种情况：检查过的和没检查的。技术上，我们认为没检查过的异常事件RuntimeExceptions。这些不需要在抛出的语句中作出声明，而且对它们的捕捉也是选择性的。不过，它们一般不会有什么影响，如果程序员根本不能发现它们的存在。在大多数情况下，这些都是逻辑性的编程错误，如NullPointerException或者ArrayIndexOutOfBounds。
同时，对异常事件进行技术性检查也迫使程序员对其进行处理和管理，意味着要对其进行单独捕捉并覆盖。这些都来自Exceptions类和它的子类，包括我们之前讨论过的RuntimeExceptions。检查过的异常事件要求异常事件处理因为它们有可拿弯能导致程序终止。
现在，我们对异常事件有了个基本的了解，下面就让我们启动集成开发环境开始编码吧!
异常处理
前面我们提到了异常处理就是指处理代码中的异常事件，或者在运行时向运行引擎抛出异常事件，在引擎末端它会搜索异常事件处理例程。它使用包含了一系列方法调用的调用堆栈进行搜索。
一般而言，异常事件可能因为包含一个异常活动或其他异步异常导致的。我们讨论的异常事件包括了一些基本的处理议题：怎样捕捉和处理这些异常事件。
Java允许我们创建自己的Exception对象和类，但是会有一个关键的请求。这些对象和类必须是扩展的Exception类。编码标准要求异常事件应该充分命名，意味着它们的名字就代表了其本身。
throw new Exception(“ This is an exception!”)
下面，我们看看要怎样捕捉和处理这些异常事件。检查以下代码：
try{
// this is the block of code where the exception happens
// sometimes called as source/root of exception
// or even called as tricky block or tricky method
｝
catch{Exception_Typel e) {
// dealing with this kind of exception
｝
Catch (Exception_Type2 e) {
// dealing witn this kind of exception
｝
//... unlimited number of catches are possible
finally {
// this block of code is always executed
｝
try-catch-finally语句的第一个部分是尝试阻止。这是异常事件有可能发生的部分。通常，我们建议代码行用最小的数量来编写，因为它们只会在异常事件发生的时候执行。这种情况发生时，执行会跳转去捕捉那些异常事件被比较的块中。如果它们匹配，那么就可以处理异常事件。
不论尝试阻止的时候，异常事件会不会发生，或不管能不能得到处理，阻止总会执行。由于它总是被执行，所以我们推荐你在这里做一些清理。因此，正如所预料的那样，执行起来就是具有选择性的。
Try-catch模块的结构类似于switch-case的结构。在检查过的需要处理的异常事件中，是有可能在相同方法中将其处理或者抛出的。后者可以通过关键词抛出。在这种情况下，异常事件的种类必须在方法签名中被指定。看这个例子：
Void myMethod () throws SomeKindOfException{
// method goes here
}
接下来，我们将为大家展示更多的异常处理实例。
初学者常常与非匹配数据类型纠缠不清。通常，它们会引发一些问题，例如，在做加法时出现非数字型代码。下面给大家展示的代码中，出现了异常处理的工作环境。检查该网页以完成嵌入式Exception种类的清单。现在，我们要处理NumberFormatException 的发生。
public static void main (String args[] ) {
double sum= 0;
for (int i=0; i﹤args. length; ++1)
try {
sum+= Double.parseDboule (args[i]);
}
Catch (NumberFormatException e) {
Ststem.out.printIn(args[i] + “non-numeric data on”);
}
System.out.printIn(“Total sum: “+ sum);
}
正如你所见到的，它和命令行参数一起运行，而且一旦轮到非数字型参数，它就会写入system.out，意指出现的问题。但是项目会继续进行，因为try模块是循环的。否则，没有合适的异常处理，项目就会终止。用这种方式总和还是可以计算处理并在最后显示处理。 我们来看看另一个例子。在这个例子中，我们会要建立自己的异常实例类，该类扩展了其母Exception类。应用程序会模拟用于异常处理和抛出的堆栈机制，如堆栈是满的或者是空的。检查一下。
Public class StackException extends Exception {
Public StackException (String text) {
Super (text)
}
}
现在让我们创建一个Stack类。注意push和pop方法。它们正抛出StackException，而这一动作由方法签名导入。此外，还有一个if条件，且条件满足时，异常事件会被抛出。否则，一切都会顺利运行。
public class Stack {
private final int SIZE = 100;
private Object st[];
private int size;
private int sp;
public Stack (int size) {
if (size < MAXSIZE)
this.size = size;
else
this.size = MAXSIZE;
this.st = new Object [size];
this.sp = -1;
}
public void push (Object o) throws StackException {
if (sp == this.size - 1)
throw new StackException ("Stack is full");
this.st [++this.sp] = o;
}
public Object pop () throws StackException {
if (sp == -1)
throw new StackException ("Stack is empty");
Object o = this.st [this.sp];
this.sp--;
return o;
}
public boolean isEmpty() {
return this.sp == -1;
}
}
好的，现在是时候写一写Main class连同主要方法了。在这一部分，请对try-catch语句给予更多关注。有两类异常情况可以被捕捉到。你也可以很容易地找出它们。
public class Main {
public static void main (String args[]) {
Stack s = new Stack (10);
for (int i = 0; i <= 10; ++i)
try {
s.push (new Integer(i));
}
catch (StackException e) {
System.out.println (e);
}
while (! s.isEmpty() ) {
try {
System.out.println( (Integer)(s.pop()) );
}
catch (StackException e) {
System.out.println(e);
}
}
}
}
当然，这里也会有附带输出。如你所见，第一行显示出的就是异常事件，因为我们要用11个要素填补堆栈，因此，在循环到isEmpty是错误的时，异常事件不会抛出。
Stack is full
练习几次以上的几段代码。如果异常事件被抛出但是却能够正确被处理那就不要感到惊讶。这就是异常处理的神奇之处。
总结
在这篇文章里我们就异常处理的实用性和重要性进行了分析。我们都知道，不管是检查过的或是未经检查的，程序员都要处理好异常事件，否则可能出现程序的异常终止。我们强调要将理论与实践相结合。坦率地说，本文虽只是冰山一角，但一些基本的知识已经介绍给了大家。希望能在异常处理方面对大家有所帮助。
Ⅵ java中try 与catch的使用
try{
//代码区
}catch(Exception e){
//异常处理
}
try语句：
try语句用大括号{}指定了一段代码，该段代码可能会抛弃一个或多个例外。
catch语句：
catch语句的参数类似于方法的声明，包括一个例外类型和一个例外对象。例外类型必须为Throwable类的子类，它指明了catch语句所处理的例外类型，例外对象则由运行时系统在try所指定的代码块中生成并被捕获，大括号中包含对象的处理，其中可以调用对象的方法。
catch语句可以有多个，分别处理不同类的例外。Java运行时系统从上到下分别对每个catch语句处理的例外类型进行检测，直到找到类型相匹配的catch语句为止。这里，类型匹配指catch所处理的例外类型与生成的例外对象的类型完全一致或者是它的父类，因此，catch语句的排列顺序应该是从特殊到一般。
也可以用一个catch语句处理多个例外类型，这时它的例外类型参数应该是这多个例外类型的父类，程序设计中要根据具体的情况来选择catch语句的例外处理类型。
Ⅶ Java里try catch的简单用法
Java里try catch的简单用法：
1、try+catch
程序的流程是：运行到try块中，如果有异常抛出，则转到catch块去处内理。然容后执行catch块后面的语句
扩展部分：
1、try+catch+finally
程序的流程是：运行到try块中，如果有异常抛出，则转到catch块,catch块执行完毕后，执行finally块的代码，再执行finally块后面的代码。
如果没有异常抛出，执行完try块，也要去执行finally块的代码。然后执行finally块后面的语句
2、try+finally
程序的流程是：运行到try块中,如果有异常抛出的话，程序转向执行finally块的代码。那末finally块后面的代码还会被执行吗？不会！因为没有处理异常，所以遇到异常后，执行完finally后，方法就已抛出异常的方式退出了。
Ⅷ Java中异常处理语句有哪些
JAVA使用try-catch语句来处理异常。
将有可能出现的异常操作放在try-catch的try部分，一旦try部分抛出异常对象，或调用某个可能抛出异常对象的方法，并且该方法抛出了异常对象，那么try立即结束执行，转向catch部分。所以程序将发生异常后的处理放在catah部分。
Ⅸ 关于JAVA t中try-catch的用法
你所说的一个try-catch只能捕获一个错误是对的，不论后面跟着多少个catch都一样，try-catch语句是这样执行的：首先逐个从上到下执行try块中的java语句，如果没有发生异常，则执行完try块后跳过catch块(不论有多少个catch都跳过)。如果try块中某条语句存在异常，则跳到相对应的catch块中(发生什么异常，就跳到什么catch里，如果没有准确对应的，就跳到父类异常的catch中)，执行完该catch块中的语句，然后跳过其它的catch块，接着往下走，明白了么？总之，try-catch只能处理一个异常，这就是为什么后面通常跟finally，要有一个统一的出口。
如果还不明白，你就在环境下用一段代码试试就好了，不要着急，随便找两个异常一试就OK！
比如：
try{
int b=25/0;
Thread.sleep(2000);
}
catch(ArithmeticException e){
System.out.println("除零错误！");
}
catch(InterruptedException e){
System.out.println("延时错误!");
}
上面这个例子就会在屏幕上显示"除零错误！"四个字，因为众所周知，任何数字不能除0，所以25/0是错的，它抛出ArithmeticException(数学异常)，则直接跳进第一个catch块内，而没有进入第二个块，尽管Thread.sleep(2000);也有异常。