JAVA常用超类

最新推荐文章于 2022-03-05 23:46:30 发布
最新推荐文章于 2022-03-05 23:46:30 发布
阅读量134 收藏
点赞数
分类专栏： Java 文章标签： Java SQL DAO HTML
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. 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.   
garyea
关注
专栏目录
Java基础(3) Object超类(Java核心技术卷笔记)
qq_45348785的博客
02-26 131
java Object超类
java超类_java超类
weixin_34418334的博客
02-15 2833
this是java使用的一个特定意义的引用，它指向当前对象自身。(指向该关键词所在的类,，用来引用自己所在的类中的成员变量或方法。)super关键词指向该关键词所在类的父类，用来引用父类中的成员变量或方法。通过 super.someMethod([paramlist])将调用父类中的 someMethod()方法。该方法不一定是在当前类的直接父类中定义的，可以是直接父类在类的层次体系中继承而来。S...
java超类
iteye_5095的博客
08-18 2607
this是java使用的一个特定意义的引用，它指向当前对象自身。(指向该关键词所在的类,，用来引用自己所在的类中的成员变量或方法。)super关键词指向该关键词所在类的父类，用来引用父类中的成员变量或方法。     通过 super.someMethod([paramlist])将调用父类中的 someMethod()方法。     该方法不一定是在当前类的直接父类中定义的，可以是直接父类在类的层...
java 父类 超类_Java超类-java.lang.object
weixin_36371504的博客
02-13 293
Java是面向对象的，Object是所有对象的超类(不是继承，也不是实现接口)Object类是所有Java类的祖先。每个类都使用 Object 作为超类。所有对象(包括数组)都实现这个类的方法。如果你什么是Object类编辑Object类是所有Java类的祖先。每个类都使用 Object 作为超类。所有对象(包括数组)都实现这个类的方法。在不明确给出超类的情况下，Java会自动把Object作为要...
Java超类-java.lang.object
04-19 181
Java是面向对象的，Object是所有对象的超类(不是继承，也不是实现接口) Object类是所有Java类的祖先。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。 如果你 什么是Object类 编辑 Object类是所有Java类的祖先。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。 在不明确给出超类的情况...
Java 超类和子类（学习 Java 编程语言 042）
bupuxiang的专栏
01-27 780
“is-a” 关系是继承的一个明显特征。 注释： 我们使用员工和经理的例子，不过这个例子要有所保留。在真实的世界里，员工也可能会成为经理，所以你建模时可能希望经理也是员工，而不是员工的一个子类。不过，在例子中，假设公司只有两类人：一些人永远是员工，另一些人一直是经理。 Employee 类： import java.time.LocalDate; import java.util.Objects; public class Employee { private String name; p
Java知识点——类、超类和子类
z__csdn的博客
01-04 6951
定义子类 Java与C++定义继承类的方式十分相似。Java用关键字extends表示继承。在Java中，所有的继承都是公有继承，而没有C++中的私有继承和保护继承。 public class Manager extends Employee { 添加方法和域 } 关键字 extends 表明正在构造的新类派生于一个已存在的类。已存在的类称为超类(superclass)，新类称为子类（subclass)。超类和子类是 Java 程序员最常用的两个术语。在设计类的时候，应该将通用的方法放在超类中， 而将具
JAVA常用类与内部类
12-22
什么是内部类？ 在类中定义的类，称之为内部类。 Java中有几种内部类？ 1、成员内部类：定义在类中的类，...Object类是所有类的父类（超类，根类，基类），Java中所有类都是Object类的子类 Object类中所定义的方法是所
java常用面试题及答案
07-12
- 接口性：超类通过方法签名提供公共接口，子类可以重写或完善这些方法。 - 灵活性和简化性：多态使得代码更简洁，降低耦合度。 多态的实现主要包括： - 接口实现：类实现接口并覆盖接口中定义的方法。 - ...
Java常用英语汇总.doc
06-23
Java编程语言中包含了许多核心概念和技术，这些在文档"Java常用英语汇总.doc"中有所提及。以下是基于这些标签和部分内容的详细解释： 1. **abstract**：在Java中，`abstract`是一个关键字，用于创建抽象类或抽象...
java实现超类，子类，异质类
07-12
*建立一个超类House, 和一个子类Home,并提供一系列属性和方法,包括printDetails方法, 这个方法要采用多态性 *建立一个House和Home的异类集合, 测试printDetails方法的多态性
java超级玛丽
12-06
小游戏超级玛丽项目.
java基础整理笔记超详细
07-17
java入门到精通超详细笔记，分享给大家，绝版收藏，不看后悔
java 所有类的超类_Java中所有类的超类Object
weixin_31173113的博客
02-28 503
Object的地位在Java中所有的类都继承于Object类，但不用在声明一个类时显示的extends ObjectObject中几个重要的方法：1.equals方法:用于检测一个对象是否等于另外一个对象，即判断两个对象是否具有相同的引用.然而对于大多数类来说这种检测没有太大意义。在实际中用户更倾向与更具自己的标准来判断两个对象是否相等。例如：如果来年各个雇员的姓名 薪水和雇佣日期都一样，就认为他...
Java所有类的超类Object
justLym的博客
02-25 702
概述 Object类是Java中所有类的始祖，在Java中每个类都是由它扩展而来的。 如果没有明确指出超类，Object被默认是这个类的超类。 Object的用途 可以使用Object类型的变量引用任何类型的变量 public void demo() { Object object = new Employee(); } 当然Object类型变量只能作为各种值的持有者，如果想要对其中的内容进行...
Java超类Object源码学习
不想起床的小张的博客
03-05 455
Object超类 Java是一门天然的面向对象的语言。而所有我们手动创造出来的类，都继承于同一个类，即Object类。 可以看一下Object类的结构 native方法 首先，超类拥有一个native方法 private static native void registerNatives(); static { registerNatives(); } Java中，用native关键字修饰的函数表明该方法的实现并不是在Java中去完成。而是被C/C++完成，并被编译成了.ddl文件，由Jav
Java™ 教程（Object作为超类）
weixin_34292287的博客
01-08 78
Object作为超类 java.lang包中的Object类位于类层次结构树的顶部，每个类都是Object类的直接或间接的后代，你使用或编写的每个类都继承Object的实例方法，你不需要使用任何这些方法，但是，如果你选择这样做，你可能需要使用特定于你的类的代码重写它们，本节中讨论的从Object继承的方法是： protected Ob...
Java中的超类--super关键字
Owater
09-17 2309
super关键字的使用有两种形式： 一是调用超类的构造方法。 二是访问已被子类成员隐藏的超类成员。 package Test; class People{ String nameString; int age; People(){ System.out.print("我是People类的无参构造函数，"); } People(String name){ System.
JavaSE基础(47) super(超类)
郑清
08-17 6143
作用：在子类中访问父类中的成员（字段 方法 构造方法） super指向父类对象 在子类的构造方法中： super(); 在子类的构造方法中调用父类无参构造方法 super(…); 在子类的构造方法中调用父类有参构造方法 注意： ①必须放在子类构造方法的第一句 ②在子类的构造方法里第一行都会存在默认（隐式）的super(); 会调用父类的无参构造方法 ==>即默...
Java常用词汇详解与编程概念
52. **super** - 超类，用于访问父类的成员。 53. **this** - 当前对象引用。 54. **thread** - 线程，并发执行的程序执行流。 55. **throw** - 抛出，主动引发异常。 56. **transient** - 不持久的，用于标记...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值