`

JAVA常用超类

    博客分类：
  • Java
JavaSQLDAOHTML 
阅读更多
java 代码
  1. package com.wide.cabaret.dao;   
  2.   
  3. import com.wide.cabaret.consts.Consts;   
  4. import com.wide.cabaret.utils.DataConn;   
  5. import com.wide.cabaret.utils.Html;   
  6. import com.wide.cabaret.utils.Utils;   
  7. import java.io.PrintStream;   
  8. import java.sql.Connection;   
  9. import java.sql.ResultSet;   
  10. import java.sql.Statement;   
  11.   
    12.  
  12. public class BaseDao extends DataConn{   
  13.   Html html = new Html();   
  14.   Utils utils = new Utils();   
  15.   Consts consts = new Consts();   
  16.   public BaseDao(){   
  17.     super();   
  18.   }   
  19.   /**  
  20.    * 單條寫入訊息  
  21.    * @param sql String  
  22.    * @return int  
  23.    */  
  24.   public int addData(String sql){   
  25.     int retint = consts.DATA_ADD_ERROR_STATE;   
  26.     Connection con=null;   
  27.     Statement stmt=null;   
  28.     ResultSet rs=null;   
  29.     try{   
  30.       con=this.getCon();   
  31.       stmt=con.createStatement();   
  32.       stmt.executeUpdate(sql);   
  33.       //this.printBug("建立訊息", sql);   
  34.       retint = consts.DATA_ADD_SUCCEED_STATE;   
  35.     } catch (Exception ex){   
  36.       ex.printStackTrace();   
  37.     } finally{   
  38.       this.freeCon(con, stmt);   
  39.     }   
  40.     return retint;   
  41.   }   
  42.   /**  
  43.    * 批量寫入新訊息  
  44.    * @param sql String[]  
  45.    * @return int  
  46.    */  
  47.   public int addData(String sql[]){   
  48.     int retint = consts.DATA_ADD_ERROR_STATE;   
  49.     Connection con=null;   
  50.     Statement stmt=null;   
  51.     ResultSet rs=null;   
  52.     try{   
  53.       con=this.getCon();   
  54.       stmt=con.createStatement();   
  55.       for (int i=0;i
  56.         stmt.executeUpdate(sql[i]);   
  57.       }   
  58.       //this.printBug("建立訊息", sql);   
  59.       retint = consts.DATA_ADD_SUCCEED_STATE;   
  60.     } catch (Exception ex){   
  61.       ex.printStackTrace();   
  62.     } finally{   
  63.       this.freeCon(con, stmt);   
  64.     }   
  65.     return retint;   
  66.   }   
  67.   /**  
  68.    * 寫入符閤條件的新訊息  
  69.    * @param sqla String  
  70.    * @param sqlb String  
  71.    * @return int  
  72.    */  
  73.   public int addData(String sqla, String sqlb){   
  74.     int retint = consts.DATA_ADD_ERROR_STATE;   
  75.     Connection con=null;   
  76.     Statement stmt=null;   
  77.     ResultSet rs=null;   
  78.     try{   
  79.       con=this.getCon();   
  80.       stmt=con.createStatement();   
  81.       rs=stmt.executeQuery(sqla);   
  82.       //this.printBug("條件查詢", sqla);   
  83.       if (!rs.next()){   
  84.         stmt.executeUpdate(sqlb);   
  85.         //this.printBug("新增訊息", sqlb);   
  86.         retint = consts.DATA_ADD_SUCCEED_STATE;   
  87.       } else{   
  88.         retint = consts.DATA_ADD_CONDITION_ERROR_STATE;   
  89.       }   
  90.     } catch (Exception ex){   
  91.       System.err.println(ex.getMessage());   
  92.     } finally{   
  93.       this.freeCon(con, stmt, rs);   
  94.     }   
  95.     return retint;   
  96.   }   
  97.   /**  
  98.    * 根據批量條件批量寫入訊息  
  99.    * @param sqla String[]  
  100.    * @param sqlb String[]  
  101.    * @return int  
  102.    */  
  103.   public int addData(String sqla[],String sqlb[]){   
  104.     int retint = consts.DATA_ADD_ERROR_STATE;   
  105.     Connection con=null;   
  106.     Statement stmt=null;   
  107.     ResultSet rs=null;   
  108.     try{   
  109.       con=this.getCon();   
  110.       stmt=con.createStatement();   
  111.       for(int i=0;i
  112.         rs=stmt.executeQuery(sqla[i]);   
  113.         //this.printBug("條件查詢", sqla[i]);   
  114.         if(!rs.next()){   
  115.           stmt.executeUpdate(sqlb[i]);   
  116.           //this.printBug("新增訊息", sqlb[i]);   
  117.           retint = consts.DATA_ADD_SUCCEED_STATE;   
  118.         }else{   
  119.           retint = consts.DATA_ADD_CONDITION_ERROR_STATE;   
  120.         }   
  121.       }   
  122.     } catch (Exception ex){   
  123.       ex.printStackTrace();   
  124.     } finally{   
  125.       this.freeCon(con, stmt);   
  126.     }   
  127.     return retint;   
  128.   }   
  129.   /**  
  130.    * 單條修改訊息  
  131.    * @param sql String  
  132.    * @return int  
  133.    */  
  134.   public int editData(String sql){   
  135.     int retint = consts.DATA_EDIT_ERROR_STATE;   
  136.     Connection con=null;   
  137.     Statement stmt=null;   
  138.     ResultSet rs=null;   
  139.     try{   
  140.       con=this.getCon();   
  141.       stmt=con.createStatement();   
  142.       stmt.executeUpdate(sql);   
  143.       //this.printBug("修改訊息", sql);   
  144.       retint = consts.DATA_EDIT_SUCCEED_STATE;   
  145.     } catch (Exception ex){   
  146.       System.err.println(ex.getMessage());   
  147.     } finally{   
  148.       this.freeCon(con, stmt);   
  149.     }   
  150.     return retint;   
  151.   }   
  152.   /**  
  153.    * 批量脩改訊息  
  154.    * @param sql String[]  
  155.    * @return int  
  156.    */  
  157.   public int editData(String sql[]){   
  158.     int retint = consts.DATA_EDIT_ERROR_STATE;   
  159.     Connection con=null;   
  160.     Statement stmt=null;   
  161.     ResultSet rs=null;   
  162.     try{   
  163.       con=this.getCon();   
  164.       stmt=con.createStatement();   
  165.       for (int i=0;i
  166.         stmt.executeUpdate(sql[i]);   
  167.       }   
  168.       //this.printBug("修改訊息", sql);   
  169.       retint = consts.DATA_EDIT_SUCCEED_STATE;   
  170.     } catch (Exception ex){   
  171.       System.err.println(ex.getMessage());   
  172.     } finally{   
  173.       this.freeCon(con, stmt);   
  174.     }   
  175.     return retint;   
  176.   }   
  177.   /**  
  178.    * 脩改符閤條件后的訊息  
  179.    * @param sqla String  
  180.    * @param sqlb String  
  181.    * @return int  
  182.    */  
  183.   public int editData(String sqla, String sqlb){   
  184.     int retint = consts.DATA_EDIT_ERROR_STATE;   
  185.     Connection con=null;   
  186.     Statement stmt=null;   
  187.     ResultSet rs=null;   
  188.     try{   
  189.       con=this.getCon();   
  190.       stmt=con.createStatement();   
  191.       rs=stmt.executeQuery(sqla);   
  192.       //this.printBug("條件查詢", sqla);   
  193.       if (!rs.next()){   
  194.         stmt.executeUpdate(sqlb);   
  195.         //this.printBug("修改訊息", sqlb);   
  196.         retint = consts.DATA_EDIT_SUCCEED_STATE;   
  197.       } else{   
  198.         retint = consts.DATA_EDIT_CONDITION_ERROR_STATE;   
  199.       }   
  200.     } catch (Exception ex){   
  201.       System.err.println(ex.getMessage());   
  202.     } finally{   
  203.       this.freeCon(con, stmt, rs);   
  204.     }   
  205.     return retint;   
  206.   }   
  207.   /**  
  208.    * 根據批量條件批量修改訊息  
  209.    * @param sqla String[]  
  210.    * @param sqlb String[]  
  211.    * @return int  
  212.    */  
  213.   public int editData(String sqla[], String sqlb[]){   
  214.     int retint = consts.DATA_EDIT_ERROR_STATE;   
  215.     Connection con=null;   
  216.     Statement stmt=null;   
  217.     ResultSet rs=null;   
  218.     try{   
  219.       con=this.getCon();   
  220.       stmt=con.createStatement();   
  221.       for(int i=0;i
  222.         rs=stmt.executeQuery(sqla[i]);   
  223.         //this.printBug("條件查詢", sqla[i]);   
  224.         if(!rs.next()){   
  225.           stmt.executeUpdate(sqlb[i]);   
  226.           //this.printBug("編輯訊息", sqlb[i]);   
  227.           retint = consts.DATA_EDIT_SUCCEED_STATE;   
  228.         }else{   
  229.           retint = consts.DATA_EDIT_CONDITION_ERROR_STATE;   
  230.         }   
  231.       }   
  232.     } catch (Exception ex){   
  233.       System.err.println(ex.getMessage());   
  234.     } finally{   
  235.       this.freeCon(con, stmt, rs);   
  236.     }   
  237.     return retint;   
  238.   }   
  239.   
  240.   /**  
  241.    * 單條刪除訊息  
  242.    * @param sql String  
  243.    * @return int  
  244.    */  
  245.   public int delData(String sql){   
  246.     int retint = consts.DATA_DEL_ERROR_STATE;   
  247.     Connection con=null;   
  248.     Statement stmt=null;   
  249.     ResultSet rs=null;   
  250.     try{   
  251.       con=this.getCon();   
  252.       stmt=con.createStatement();   
  253.       stmt.executeUpdate(sql);   
  254.       //this.printBug("刪除訊息", sql);   
  255.       retint = consts.DATA_DEL_SUCCEED_STATE;   
  256.     } catch (Exception ex){   
  257.       System.err.println(ex.getMessage());   
  258.     } finally{   
  259.       this.freeCon(con, stmt);   
  260.     }   
  261.     return retint;   
  262.   }   
  263.   /**  
  264.    * 刪除數據訊息  
  265.    * @param sql String[]  
  266.    * @return int  
  267.    */  
  268.   public int delData(String sql[]){   
  269.     int retint = consts.DATA_DEL_ERROR_STATE;   
  270.     Connection con=null;   
  271.     Statement stmt=null;   
  272.     ResultSet rs=null;   
  273.     try{   
  274.       con=this.getCon();   
  275.       stmt=con.createStatement();   
  276.       for (int i=0;i
  277.         stmt.executeUpdate(sql[i]);   
  278.       }   
  279.       //this.printBug("刪除訊息", sql);   
  280.       retint = consts.DATA_DEL_SUCCEED_STATE;   
  281.     } catch (Exception ex){   
  282.       System.err.println(ex.getMessage());   
  283.     } finally{   
  284.       this.freeCon(con, stmt);   
  285.     }   
  286.     return retint;   
  287.   }   
  288.   /**  
  289.    * 刪除符閤條件后的數據訊息  
  290.    * @param sqla String  
  291.    * @param sqlb String  
  292.    * @return int  
  293.    */  
  294.   public int delData(String sqla, String sqlb){   
  295.     int retint = consts.DATA_DEL_ERROR_STATE;   
  296.     Connection con=null;   
  297.     Statement stmt=null;   
  298.     ResultSet rs=null;   
  299.     try{   
  300.       con=this.getCon();   
  301.       stmt=con.createStatement();   
  302.       rs=stmt.executeQuery(sqla);   
  303.       //this.printBug("條件查詢", sqla);   
  304.       if (rs.next()){   
  305.         stmt.executeUpdate(sqlb);   
  306.         //this.printBug("刪除訊息", sqlb);   
  307.         retint = consts.DATA_DEL_SUCCEED_STATE;   
  308.       } else{   
  309.         retint = consts.DATA_DEL_CONDITION_ERROR_STATE;   
  310.       }   
  311.     } catch (Exception ex){   
  312.       System.err.println(ex.getMessage());   
  313.     } finally{   
  314.       this.freeCon(con, stmt, rs);   
  315.     }   
  316.     return retint;   
  317.   }   
  318.   /**  
  319.    * 根據批量條件批量刪除訊息  
  320.    * @param sqla String[]  
  321.    * @param sqlb String[]  
  322.    * @return int  
  323.    */  
  324.   public int delData(String sqla[], String sqlb[]){   
  325.     int retint = consts.DATA_DEL_ERROR_STATE;   
  326.     Connection con=null;   
  327.     Statement stmt=null;   
  328.     ResultSet rs=null;   
  329.     try{   
  330.       con=this.getCon();   
  331.       stmt=con.createStatement();   
  332.       for(int i=0;i
  333.         rs=stmt.executeQuery(sqla[i]);   
  334.         //this.printBug("條件查詢", sqla[i]);   
  335.         if(!rs.next()){   
  336.           stmt.executeUpdate(sqlb[i]);   
  337.           //this.printBug("刪除訊息", sqlb[i]);   
  338.           retint = consts.DATA_DEL_SUCCEED_STATE;   
  339.         }else{   
  340.           retint = consts.DATA_DEL_CONDITION_ERROR_STATE;   
  341.         }   
  342.       }   
  343.     } catch (Exception ex){   
  344.       System.err.println(ex.getMessage());   
  345.     } finally{   
  346.       this.freeCon(con, stmt, rs);   
  347.     }   
  348.     return retint;   
  349.   }   
  350.   
  351.   
  352.   /**  
  353.    * 打印單條錯誤訊息  
  354.    * @param str String  
  355.    * @param sql String  
  356.    */  
  357.   public void printBug(String str, String sql){   
  358.     System.out.println("---------------------------------------------");   
  359.     System.out.println("<=========["+str+"]->打印調試訊息開始=========>");   
  360.     System.out.println("*");   
  361.     System.out.println("SQL==>"+sql+"");   
  362.     System.out.println("*");   
  363.     System.out.println("<=========["+str+"]->打印調試訊息結束=========>");   
  364.     System.out.println("---------------------------------------------");   
  365.   }   
  366.   
  367.   /**  
  368.    * 批量打印錯誤訊息  
  369.    * @param str String  
  370.    * @param sql String[]  
  371.    */  
  372.   public void printBug(String str, String sql[]){   
  373.     System.out.println("---------------------------------------------");   
  374.     System.out.println("<=========["+str+"]->打印調試訊息開始=========>");   
  375.     for (int i=0;i
  376.       System.out.println("*");   
  377.       System.out.println("SQL-("+i+")==>"+sql[i]+"");   
  378.       System.out.println("*");   
  379.     }   
  380.     System.out.println("<=========["+str+"]->打印調試訊息結束=========>");   
  381.     System.out.println("---------------------------------------------");   
  382.   }   
  383. }   
  384.   
分享到：
| JAVA常用连接数据库关闭数据库等类
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    JAVA编程常用英文单词汇总.pdf

    70 个常用的 Java 编程英文单词，涵盖了 object-oriented 编程、Java 开发工具包、Java 虚拟机、编译、运行、类、对象、系统、输出、打印、行、变量、类型、操作、数组、参数、方法、函数、成员变量、成员函数、获取...

    java常用公共类

    以上只是Java中常用公共类的一部分，Java标准库中还有很多其他实用的类，如`Collections`、`Random`、`Pattern`、`Matcher`等，它们为Java开发者提供了强大的工具箱，使得编写高效、健壮的代码变得容易。在实际项目...

    JAVA中常用类的常用方法.pdf

    Object类是Java中所有类的超类，它提供了多种方法，这些方法在Java中所有的对象中都是通用的。 - clone()：创建并返回此对象的副本。 - equals(Object obj)：比较此对象与指定对象是否相等。 - finalize()：在垃圾...

    java常用英语单词（1）

    23. **Extends, Base class, Super class, Overloaded method, Overridden method**：继承、基类、超类、方法重载和方法重写，是面向对象的特性。 24. **Public, Private, Protected, Static, Abstract, Interface,...

    java常用及 总结

    Java是一种广泛使用的面向对象的编程语言，以其跨平台、健壮性和安全性著称。本文将对Java的一些核心知识点进行深入的探讨，包括Java Standard Edition (SE)、Web开发基础、Android匿名内部类以及文件和流的处理。 ...

    C院Java常用单词

    在Java编程语言中，了解和掌握这些常用的单词和概念对于编写高效、安全的代码至关重要。以下是对这些术语的详细解释： 1. **API (Application Programming Interface)**：API是一组预定义的函数、类、接口和其他...

    Java常用英语汇总.doc

    Java编程语言中包含了许多核心概念和技术，这些在文档"Java常用英语汇总.doc"中有所提及。以下是基于这些标签和部分内容的详细解释： 1. **abstract**：在Java中，`abstract`是一个关键字，用于创建抽象类或抽象...

    java常用单词

    ### Java基础常见英语词汇解析 #### 面向对象 (OO: object-oriented) 面向对象是一种编程范式，它将程序中的各种元素组织成对象。在Java中，几乎所有的东西都是对象。 #### 面向对象编程 (OOP: object-oriented ...

    java常用面试题及答案

    - 接口性：超类通过方法签名提供公共接口，子类可以重写或完善这些方法。 - 灵活性和简化性：多态使得代码更简洁，降低耦合度。 多态的实现主要包括： - 接口实现：类实现接口并覆盖接口中定义的方法。 - ...

    java io包中简单的常用类使用

    本篇文章将深入探讨`java.io`包中一些常用的类，并通过实例来展示它们的使用方法。 1. **InputStream 和 OutputStream**： - `InputStream` 是所有字节输入流的超类，代表一个字节序列的输入源。常见的子类有 `...

    100家大公司java笔试题汇总

    Java是最流行的编程语言之一，在软件开发行业中非常常用。以下是Java笔试题汇总，涵盖了Java的多个方面，包括Java基础、Java面向对象编程、Java多线程、Java网络编程、Java数据库编程等。 Java基础 1. Java的基本...

    Java笔试常见英语题（附答案）.doc

    当你尝试将一个超类对象赋值给子类类型的变量时，需要进行显式类型转换。例如，如果你有一个`Animal`类型的对象，但要将其赋值给`Dog`类型的变量，需要进行如下转换： ```java Animal myAnimal = ...; Dog myDog...

    Java语言编程-常用类

    Java语言编程中，数组作为最基础且常用的数据结构之一，其理解和掌握对于任何Java程序员都是至关重要的。在本文中，我们将深入探讨Java中的数组概念、声明、创建、初始化以及相关类和异常处理等方面的知识点。 ### ...

    JAVA编程常用英文单词汇总.doc

    70 个常用的 Java 编程英文单词，涵盖了 Java 基础、面向对象编程、Java 开发工具包、Java 虚拟机、编译、运行、类、对象、系统、输出、打印、行、变量、类型、操作、数组、参数、方法、函数、成员变量、成员函数、...

    2023年Java程序员必考60道Java面试题

    - 字符串是 Java 中常用的对象，通常使用 `String` 类来处理。 - `String` 是不可变的，意味着一旦创建，就不能修改。 - 字符串连接、子串提取、替换、查找等相关操作是面试中常见的问题。 5. **内存管理**： -...

    100家大公司java笔试题汇总.docx

    2. Java中的实例方法可以直接调用超类的实例方法和类方法，但不能直接调用其他类的实例方法。 3. Java中的多态性是通过方法的重写和重载来实现的。 二、面向对象编程 1. 在Java中，子类可以继承父类的成员变量和...

    JAVA基础培训教程

    java.util包包含了一些Java编程中常用的类和接口，比如集合框架（Collection Framework）中的List、Set、Map等接口及其实现类，这些都是进行数据结构操作的基本工具。此外，还包括日期时间操作的Calendar类、Random...

    JAVA常用类与内部类

    什么是内部类？ 在类中定义的类，称之为内部类。 Java中有几种内部类？ 1、成员内部类：定义在类中的类，...Object类是所有类的父类（超类，根类，基类），Java中所有类都是Object类的子类 Object类中所定义的方法是所

Magicbox
Global site tag (gtag.js) - Google Analytics