[转帖]java程序错误类型及异常处理_Android, Python及开发编程讨论区_Weblogic技术|Tuxedo技术|中间件技术|Oracle论坛|JAVA论坛|Linux/Unix技术|hadoop论坛_联动北方技术论坛  
网站首页 | 关于我们 | 服务中心 | 经验交流 | 公司荣誉 | 成功案例 | 合作伙伴 | 联系我们 |
联动北方技术论坛-国内领先的Weblogic、Tuxedo中间件技术论坛
联动北方-国内领先的云技术服务提供商
»  游客             当前位置：  论坛首页 »  自由讨论区 »  Android, Python及开发编程讨论区 »
总帖数
1
每页帖数
101/1页1
返回列表
0
发起投票  发起投票 发新帖子
查看: 3986 | 回复: 0   主题： [转帖]java程序错误类型及异常处理        下一篇 
smile
注册用户
等级：少校
经验：889
发帖：70
精华：2
注册：2013-4-22
状态：离线
发送短消息息给smile 加好友    发送短消息息给smile 发消息
发表于： IP：您无权察看 2013-4-28 9:35:15 | [全部帖] [楼主帖] 楼主

一、程序的错误类型

在程序设计中，无论规模是大是小，错误总是难免的。程序的设计很少有能够一次完成，没有错误的（不是指HelloWorld这样的程序，而是要实现一定的功能，具备一定实用价值的程序），在编程的过程中由于种种原因，总会出现这样或那样的错误，这些程序的错误就是我们常说的“Bug”，而检测并修正这些错误的方法就是“Debug”（调试）。
基本上所有的集成开发环境都提供了强大的和程序调试功能，在程序进行编译，连接，运行时，会对程序中错误进行诊断。

程序的错误可以抽象分为三类：语法错误、运行错误和逻辑错误。
1、语法错误

是指由于编程中输入不符合语法规则而产生的。程序编译就通不过，程序不能运行起来。此类错误最简单，调试起来比较容易

例如：表达式不完整、缺少必要的标点符号、关键字输入错误、数据类型不匹配、循环语句或选择语句的关键字不匹配等。通常，编译器对程序进行编译的过程中，会把检测到的语法错误以提示的方式列举出来，又称为编译错误。
语法错误的调试，则可以由集成开发环境提供的调试功能来实现，在程序进行编译时，编译器会对程序中的语法错误进行诊断。

编译诊断的语法错误分为3中：致命错误、错误和警告。
（1）致命错误：这个错误大多是编译程序内部发生的错误，发生这类错误时，编译被迫中止，只能重新启动编译程序，但是这类错误很少发生，为了安全，编译前最好还是先保存程序。
（2）错误：这个错误通常是在编译时，语法不当所引起的。例如：括号不匹配，变量未声明等。产生这类错误时，编译程序会出现报错提示，我们根据提示对源程序进行修改即可。这类错误是出现最多的。
（3）警告：是指被编译程序怀疑有错，但是不确定，有时可强行通过。例如：没有加void声明的主函数没有返回值，double数据被转换为float类型等。这些警告中有些会导致错误，有些可以通过。

常规解决方法：此类错误一般程序编译系统会自动提示相应的错误地点和错误原因，比如哪一行代码少了个括号等诸如此类的提示，常见的错误，看懂直接改正即可，如果是看不懂原因，可以将错误提示信息输入搜索引擎查找一下，一般都能找到具体的解决办法。或者有些编程平台会本身提供一个本地或者在线的信息库，提供详细的错误原因和解决办法，比如微软的.NET开发平台。

2、运行错误

指程序在运行过程中出现的错误。程序通过语法错误检测，但是运行的时候出现错误，导致程序被迫终止，此类错误有特定的发生条件，因此能够准确的定位错误代码段，因而调试也比较方便。

例如：除法运算时除数为0、数组下标越界、文件打不开、磁盘空间不够、数据库连接错误等。

此类错误发生时，编译平台一般也会提示相应的信息，对于常规的错误会有比较精确地提示，但有时提示的错误原因会比较模糊，但因为此类错误一般在程序运行时，只在特定的条件下才会发生，所以根据错误发生的条件，能够大致判断程序出错的代码段，结合错误的原因，也能比较方便的调试出错误。

3、逻辑错误

程序运行后，没有得到设计者预期的结果，这就说明程序存在逻辑错误。这种错误在语法上是有效的，但是在逻辑上是错误的。

程序运行了，也没有出错，但是执行出来的结果不是用户想要的，分为两种情况：

A、 能够看出错误：比如查询工资大于5000的人员名单，却出现了3000的；

B、 看不出错误，直到因缘际会发现程序肯定出错了，后果很严重：比如进行一个符合大型运算，把某个常数输入错了，最后的结果人工无法判断对错，又以该结果进行其它的运算等等，最后发现错了误差过大，就得从头排查错误。

例如:使用了不正确的变量，指令的次序错误，循环的条件不正确，程序设计的算法考虑不周全等。通常，逻辑错误也会附带产生运行错误。在一般情况下，编译器在编译程序时，不能检测到程序中的逻辑错误，也不会产生逻辑错误的提示，因此逻辑错误比较难排除，需要程序员仔细的分析程序，并借助集成开发环境提供的调试工具，才能找到出错的原因，并排除错误。

二、java的异常处理（错误处理）

程序的错误就是通常的异常，也叫Exception。

对于语法错误，java编译系统在编就能发现检查出错误。

对于逻辑错误，编译系统是无法发现错误的，错误需要人为去发现排除错误。

对于运行错误，Java语言中代表异常时，使用一个专门的类来代表一种特定的异常情况，在系统中传递的异常情况就是该类的对象，所有代表异常的类组成的体系就是Java语言中的异常类体系。

1、java异常类

Java的异常是一个对象,所有的异常都直接或间接地继承Throwable类。Throwable类的继承层次结构如下:

北京联动北方科技有限公司

为了方便对于这些可传递对象的管理，Java API中专门设计了java.lang.Throwable类，只有该类子类的对象才可以在系统的异常传递体系中进行。该类的两个子类分别是：

1）Error类

该类代表错误，指程序无法恢复的异常情况。对于所有错误类型以及其子类，都不要求程序进行处理。常见的Error类例如内存溢出StackOverflowError等。

2）Exception类

该类代表异常，指程序有可能恢复的异常情况。该类就是整个Java语言异常类体系中的父类。使用该类，可以代表所有异常的情况。

在Java API中，声明了几百个Exception的子类分别来代表各种各样的常见异常情况，这些类根据需要代表的情况位于不同的包中，这些类的类名均以 Exception作为类名的后缀。如果遇到的异常情况，Java API中没有对应的异常类进行代表，也可以声明新的异常类来代表特定的情况。

在这些异常类中，根据是否是程序自身导致的异常，将所有的异常类分为两种：

a) RuntimeException及其所有子类

该类异常属于程序运行时异常，也就是由于程序自身的问题导致产生的异常，例如数组下标越界异常ArrayIndexOutOfBoundsException等。

该类异常在语法上不强制程序员必须处理，即使不处理这样的异常也不会出现语法错误。

b) 其它Exception子类

该类异常属于程序外部的问题引起的异常，也就是由于程序运行时某些外部问题导致产生的异常，例如文件不存在异常FileNotFoundException等。

该类异常在语法上强制程序员必须进行处理，如果不进行处理则会出现语法错误。

熟悉异常类的分类，将有助于后续语法中的处理，也使得在使用异常类时可以选择恰当的异常类类型。

2、常见的error类


异常类名

用途

LinkageError

动态链接失败

VirtualMachineError

虚拟机错误

AWTError

AWT错误


3、常见运行时异常类


异常类名

用途

ArithmeticException

数学运算异常，比如除数为零的异常

IndexOutOfBoundsException

下标越界异常，比如集合、数组等

ArrayIndexOutOfBoundsException

访问数组元素的下标越界异常

StringIndexOutOfBoundsException

字符串下标越界异常

ClassCaseException

类强制转换异常

NullpointerException

当程序试图访问一个空数组中的元素，或访问一个空对象中的方法或变量时产生的异常。


4、常用的非运行时异常


异常类名

用途

ClassNotFoundException

指定类或接口不存在的异常

IllegalAccessException

非法访问异常

Ioexception

输入输出异常

FileNotFoundException

找不到指定文件的异常

ProtocolException

网络协议异常

SocketException

Socket操作异常

MalformedURLException

统一资源定位符（URL）的格式不正确的异常


5、Java的异常处理机制描述如下：

在一个方法的运行过程中，如果发生了异常，

则这个方法（或者是Java虚拟机）生成一个代表该异常的对象（它包含了异常的详细信息），并把它交给运行时系统，运行时系统寻找相应的代码来处理这一异常。我们把生成异常对象并把它提交给运行时系统的过程称为抛出(throw)一个异常。


运行时系统寻找相应的代码来处理这一异常，系统在方法的调用栈中查找，从产生异常的方法开始进行回朔，沿着被调用的顺序往前寻找，直到找到包含相应异常处理的方法为止。其过程如图10-1所示。这一过程称为捕获(catch)一个异常。

如该异常未进行成功捕获，则程序将终止运行。

5、异常捕获和处理


格式：

try{


正常程序段，可能抛出异常；

}
catch (异常类1 异常变量) {


捕捉异常类1有关的处理程序段；

}
catch (异常类2 异常变量) {


捕捉异常类2有关的处理程序段；

}
……
finally{


一定会运行的程序代码；

}

l try块——捕获异常：用于监控可能发生异常的程序代码块是否发生异常，如果发生异常，Try代码块将抛出异常类所产生的对象并立刻结束执行，而转向异常处理catch部分。

对于系统产生的异常或程序块中未用try监控所产生的一场，将一律由java 编译系统自动将异常对象抛出。

l catch块——处理异常 ：抛出的异常对象如果属于catch内所定义的异常类，则catch会捕获该异常，并进入catch中的对应代码段继续运行程序，如果异常对象不属于catch中所定义的异常类，则进入finally块继续运行程序。

Catch包括两个参数：一个是类名，指出捕获的异常类型，必须使Throwable类的子类；一个是参数名，用来引用被捕获的对象。Catch块所捕获的对象并不需要与它的参数类型精确匹配，它可以捕获参数中指出的异常类的对象及其所有子类的对象

l finally块——最终处理：无论是否发生异常都会执行的语句块。比如执行关闭打开的文件、删除临时文件，关闭数据库连接等操作。


注意：

l 一个try、catch、finally块之间不能插入任何其它代码

l catch可以有多个，try和finally只能有一个

l try后面必须要跟catch、finally其中的一个，即但一个try、catch、finally语句只能省略catch、finally中的一个。


定义多个catch可精确地定位java异常。如果为子类的异常定义了特殊的catch块，而父类的异常则放在另外一个catch块中，此时，必须满足以下规则：子类异常的处理块必须在父类异常处理块的前面，否则会发生编译错误。所以，越特殊的异常越在前面处理，越普遍的异常越在后面处理。这类似于 制订防火墙的规则次序：较特殊的规则在前，较普通的规则在后。


异常类常用方法


常用非法

用途

Void String getMessage()

返回异常对象的一个简短描述

Void String toString()

获取异常对象的详细信息

Void printStackTrace()

在控制台上打印异常对象和它的追踪信息



6、异常实例

1) 数学运算异常

class MathException{
      public static void main(String args[]){
            inta=5,b=0;
            intc=a/b; //除数为0，出现异常
            System.out.print(c);
      }
}


在命令提示符下运行该程序，可以发现编译正常，但是执行时出现错误的提示如下：

Exception inthread "main" java.lang.ArithmeticException: / by zero
at MathException.main(MathException.java:4)


翻译过来就是：

在类java.lang.ArithmeticException主线程中“main”方法中出现异常：除数为零，(MathException.java:4“此处指MathException类中的第四行”)

这是一个典型的运行错误，程序告诉了一下几个信息；

l 出错的异常类：java.lang.ArithmeticException

l 出错的类：MathException

l 出错的代码：MathException.java:4

因为编译系统给出了出错的原因和出错类的位置，可以方便地进行代码调试。

2)捕获数学运算异常的处理

[java]view plaincopyprint?

  1. public classTryCatchDemo{ 
  2.       public static void main(String args[]){ 
  3.             try { 
  4.                   int a=8,b=0; 
  5.                   int c=a/b; 
  6.                   System.out.print(c); 
  7.             } 
  8.             // ArithmeticException是异常类的名称，e是引用的参数名称 
  9.             catch(ArithmeticException e) { 
  10.                   System.out.println("发生的异常简短描述是："+e.getMessage()); 
  11.                   System.out.println("发生的异常详细信息是："+e.toString()); 
  12.             } 
  13.       } 
  14. } 


public classTryCatchDemo{
       public static void main(String args[]){
             try {
                   int a=8,b=0;
                   int c=a/b;
                   System.out.print(c);
             }
            // ArithmeticException是异常类的名称，e是引用的参数名称
             catch(ArithmeticException e) {
                   System.out.println("发生的异常简短描述是："+e.getMessage());
                   System.out.println("发生的异常详细信息是："+e.toString());
             }
       }
}

;

程序执行结果：

发生的异常简短描述是：/ by zero

发生的异常详细信息是：java.lang.ArithmeticException: / by zero

3）数组下标越界异常

[java]view plaincopyprint?

  1. public class arrayException{ 
  2.       publicstatic void main(String[] args) { 
  3.             //被监视的代码块 
  4.             try{ 
  5.                   int[]a=new int[4]; 
  6.                   a[4]=9; 
  7.             } 
  8.             //处理下标越界异常 
  9.             catch(ArrayIndexOutOfBoundsExceptionaiobe){ 
  10.                   System.out.println("这里出现的错误类型是：数组下标越界！！"); 
  11.             } 
  12.             //处理空引用异常 
  13.             catch(NullPointerExceptionnpe) { 
  14.                   System.out.println("这里出现的错误类型是：空引用！！"); 
  15.             } 
  16.             finally{ 
  17.                   System.out.println("程序无条件执行该语句!"); 
  18.             } 
  19.       } 
  20. } 


public class arrayException{
       publicstatic void main(String[] args) {
             //被监视的代码块
             try{
                   int[]a=new int[4];
                   a[4]=9;
             }
             //处理下标越界异常
             catch(ArrayIndexOutOfBoundsExceptionaiobe){
                   System.out.println("这里出现的错误类型是：数组下标越界！！");
             }
             //处理空引用异常
             catch(NullPointerExceptionnpe) {
                   System.out.println("这里出现的错误类型是：空引用！！");
             }
             finally{
                   System.out.println("程序无条件执行该语句!");
             }
       }
}

;

三、异常的抛出

异常的抛出可以分为两大类：

l 系统自动抛出异常

比如上面的例子就是系统自动抛出异常，通过try catch捕获异常对象，并继续相应的处理。

l 通过关键字throw将异常对象显性地抛出。

即在程序中生成自己的异常对象，即异常可以不是出错产生，而是人为编写代码主动抛出。显性抛出异常从某种程度上实现了将处理异常的代码从正常流程代码中分离开了，使得程序的主线保证相对完整，同时增加了程序的可读性和可维护性。异常沿着调用层次向上抛出，交由调用它的方法来处理。

为什么要在方法中抛出异常？

系统自动抛出异常一般就能解决大部分问题，但有时候，程序会产生特定的要求，需要由用户自己定义异常信息，又或者联合开发程序模块时，不同程序员需要将各自负责代码部分尽量避免因程序出错影响其他人的编码，都需要显式抛出异常，以便程序进行处理。这时候就需要在方法中抛出异常。

异常抛出的语法：

throw new 异常类( )；

其中异常类必须Throwable类及其子类。

比如：

throw new ThrowableObject();

ArithmeticException e = new ArithmeticException();

throw e;

throws子句的方法声明的一般格式如下：

<类型说明> 方法名(参数列表) throws <异常类型列表>

{

方法体；

}

举例：

[java]view plaincopyprint?

  1. class ThrowException{ 
  2.       // throwOne方法后用throws声明异常类ArithmeticException 
  3.       static void throwOne(int i) throwsArithmeticException { 
  4.             if(i==0) 
  5.             throw new ArithmeticException("i值为零"); //用throw抛出一个异常 
  6.       } 
  7.       public static void main(String args[]){ 
  8.             //捕获异常 
  9.             try{ 
  10.                   throwOne(0); 
  11.             } 
  12.             catch(ArithmeticException e){ 
  13.                   System.out.println("已捕获到异常错误: "+e.getMessage()); 
  14.             } 
  15.       } 
  16. } 


class ThrowException{
       // throwOne方法后用throws声明异常类ArithmeticException
       static void throwOne(int i) throwsArithmeticException {
             if(i==0)
             throw new ArithmeticException("i值为零"); //用throw抛出一个异常
       }
       public static void main(String args[]){
             //捕获异常
            try{
                   throwOne(0);
             }
             catch(ArithmeticException e){
                   System.out.println("已捕获到异常错误: "+e.getMessage());
             }
       }
}

;

程序执行结果：

已捕获到异常错误: i值为零

例：

[java]view plaincopyprint?

  1. import java.io.*; 
  2. class Father{ 
  3.       //父类方法，没有抛出异常 
  4.       publicvoid myFunction() { 
  5.             System.out.println("这里是父类方法，该方法没有异常抛出！！"); 
  6.       } 
  7. } 
  8. class Son extends Father{ 
  9.       //子类重写父类方法，有捕获异常抛出 
  10.       publicvoid myFunction() throws InterruptedException { 
  11.             System.out.println("这里是子类方法，该方法抛出InterruptedException异常！！"); 
  12.       } 
  13. } 
  14. public class TestExceptionDemo{ 
  15.       publicstatic void main(String[] args) { 
  16.             //创建子类对象 
  17.             Son s=new Son(); 
  18.             //受监视的代码 
  19.             try { 
  20.                   s.myFunction(); 
  21.             } 
  22.             //异常处理代码 
  23.             catch(InterruptedExceptione) { 
  24.                   e.printStackTrace(); 
  25.             } 
  26.       } 
  27. } 


import java.io.*;
class Father{
       //父类方法，没有抛出异常
       publicvoid myFunction() {
             System.out.println("这里是父类方法，该方法没有异常抛出！！");
       }
}
class Son extends Father{
//子类重写父类方法，有捕获异常抛出
publicvoid myFunction() throws InterruptedException {
       System.out.println("这里是子类方法，该方法抛出InterruptedException异常！！");
}
}
public class TestExceptionDemo{
       publicstatic void main(String[] args) {
             //创建子类对象
             Son s=new Son();
             //受监视的代码
             try {
                   s.myFunction();
             }
             //异常处理代码
             catch(InterruptedExceptione) {
                   e.printStackTrace();
             }
       }
}

;

例：重新抛出异常对象

程序执行时， 要求用户从键盘输入一个字符号。当输入‘0’时，程序执行结果：devided by 0；当输入非‘0’字符时，程序执行运算出的结果。

import java.io.*;
class JavaThrows{
      public int compute(int x) throws ArithmeticException
      {
            int z = 10/x; //可能抛出异常类型ArithmeticException 的对象
            return z;
      }
      public void method1()
      { intx;
            try{
                  x=System.in.read(); //可能抛出异常类型IOException的对象；
                  x=x-48;
                  x=compute(x); //抛出异常类型ArithmeticException的对象
                  System.out.println(x);
            }
            catch(IOException ioe){ //捕获异常类型IOException的对象；
                  System.out.println("readerror");
            }
            catch(ArithmeticException e){ //捕获异常类型ArithmeticException的对象
                  System.out.println("devided by0");
            }
      }
      public staticvoid main(String args[]) {
            JavaThrowst1=new JavaThrows();
            t1.method1();
      }
}


四、自定义异常

用户自定义的异常类，只需继承一个已有的异常类就可以了，包括继承Execption类及其子类，或者继承已自定义好的异常类。如果没有特别说明，可以直接用Execption类作为父类。

自定义类的格式如下：

class 异常类名 extends Exception

{
……
}


n 自定义异常类必须继承自Throwable或Exception类，建议用Exception类。一般不把自定义异常作为Error的子类，因为Error通常被用来表示系统内部的严重故障。

n 当自定义异常是从RuntimeException及其子类继承而来时，该自定义异常是运行时异常，程序中可以不捕获和处理它。

n 当自定义异常是从Throwable、Exception及其子类继承而来时，该自定义异常是编译时异常，也即程序中必须捕获并处理它。

使用自定义异常的步骤如下：

l 首先通过继承java.lang.Exception类声明自定义的异常类。

l 在方法的声明部分用throws语句声明该方法可能抛出的异常。

l 在方法体的适当位置创建自定义异常类的对象，并用throw语句将异常抛出。

l 调用该方法时对可能产生的异常进行捕获，并处理异常。

例：自定义一个异常类，输入一个数，大于10，捕获异常。

[java]view plaincopyprint?

  1. // MyExceptionDemo.java 
  2. classMyException extends Exception { //继承了Exception这个父类 
  3.       private int detail; 
  4.       MyException(int a) { 
  5.             detail = a; 
  6.       } 
  7.       public String toString() { 
  8.             return"MyException[" + detail + "]"; 
  9.       } 
  10. } 
  12. class MyExceptionDemo{ 
  13.       static void compute(int a) throwsMyException { 
  14.             System.out.println("调用 compute(" + a + ")"); 
  15.             if(a > 10){ //a大于10，则抛出异常 
  16.                   throw newMyException(a); 
  17.             } 
  18.             System.out.println("常规退出 "); 
  19.       } 
  20.       public static void main(String args[]){ 
  21.             try { 
  22.                   compute(1); //a小于10，常规退出 
  23.                   compute(20); //a大于10，则抛出异常 
  24.             } 
  25.             catch (MyException e) { 
  26.                   System.out.println("捕捉 " + e); //这样就可以用自己定义的类来捕捉异常了 
  27.             } 
  28.       } 
  29. } 


// MyExceptionDemo.java
classMyException extends Exception { //继承了Exception这个父类
       private int detail;
       MyException(int a) {
             detail = a;
       }
       public String toString() {
             return"MyException[" + detail + "]";
       }
}

class MyExceptionDemo{
static void compute(int a) throwsMyException {
       System.out.println("调用 compute(" + a + ")");
       if(a > 10){ //a大于10，则抛出异常
             throw newMyException(a);
       }
       System.out.println("常规退出 ");
}
public static void main(String args[]){
       try {
             compute(1); //a小于10，常规退出
             compute(20); //a大于10，则抛出异常
       }
       catch (MyException e) {
             System.out.println("捕捉 " + e); //这样就可以用自己定义的类来捕捉异常了
       }
}
}

;

例：计算两个数之和，当任意一个数超出范围（10，20）时，抛出自己的异常。

[java]view plaincopyprint?

  1. //NewException.java 
  2. classNumberRangeException extends Exception{ 
  3.       public NumberRangeException(String msg){ 
  4.             super(msg); 
  5.       } 
  6.       
  7.       //throws重新抛出异常NumberRangeException 
  8.       public int CalcAnswer(String str1,String str2) throws NumberRangeException{ 
  9.             int int1, int2; 
  10.             int answer = -1; 
  11.             try { 
  12.                   int1 = Integer.parseInt(str1); //可能产生异常对象NumberFormatException e 
  13.                   int2 = Integer.parseInt(str2); //可能产生异常对象NumberFormatException e 
  14.                   if( (int1 < 10) || (int1 > 20) || (int2< 10) || (int2 > 20) ){ 
  15.                         NumberRangeException e = new NumberRangeException("Numbersare not within the specified range."); 
  16.                         throw e; //抛出自定义异常对象NumberRangeExceptione 
  17.                   } 
  18.                   answer = int1 + int2; 
  19.             } 
  20.             catch (NumberFormatExceptione){ //捕获异常对象NumberRangeException e 
  21.                   System.out.println( e.toString() ); 
  22.             } 
  23.             return answer; 
  24.       } 
  25.       //在调用方法getAnswer中捕获异常 
  26.       public void getAnswer(){ 
  27.             String answerStr; 
  28.             try{ 
  29.                   //将num1、num2的中的数字更改为小于10或大于20，以查看捕获异常结果。 
  30.                   Stringnum1="13"; 
  31.                   Stringnum2="12"; 
  32.                   int answer = CalcAnswer(num1, num2); //抛出异常对象NumberRangeException e 
  33.                   answerStr = String.valueOf(answer); 
  34.             } 
  35.             catch (NumberRangeExceptione){ //捕获异常对象NumberRangeException e 
  36.                   answerStr = e.getMessage(); 
  37.             } 
  38.             System.out.println(answerStr); 
  39.       } 
  40.       
  41.       public static void main(String args[]) { 
  42.             NumberRangeExceptiont1=new NumberRangeException("test"); 
  43.             t1.getAnswer(); 
  44.       } 
  45. } 


赞(0)    操作        顶端 
总帖数
1
每页帖数
101/1页1
返回列表
发新帖子
请输入验证码： 点击刷新验证码
您需要登录后才可以回帖 登录 | 注册
技术讨论

Weblogic中间件技术论坛

 |

Tuxedo中间件技术论坛

 |

数据库论坛

 |

Java论坛

 |

Linux/unix论坛

 |

网站地图


Powered by LandingBJ     @ 2008-2018     联动北方   
京ICP证号090597    京ICP备案09017624号    京公网安备110112000093号    
400-810-2327     Email：service@landingbj.com   

Powered by landingbj @ 2008-2015 联动北方
京ICP证号090597 京ICP备案09017624号 京公网安备110112000093号
86-27-87056338 Email：service@landingbj.com