[原创]通用的面向对象查询的dao

最新推荐文章于 2022-01-13 21:36:46 发布
最新推荐文章于 2022-01-13 21:36:46 发布
阅读量114 收藏
点赞数
分类专栏： java 文章标签： java 数据库 

import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.lowca.robot.Crawler;

/**
 * <p>
 * 通用dao类，用法和说明如下：
 * </p>
 * <p>
 * 1.不支持事务
 * </p>
 * <p>
 * 2.不支持连接池
 * </p>
 * <p>
 * 3.命名方法必须严格遵守java pojo和数据库的命名规范/p>
 * <p>
 * 4.主键必须叫做“id”，且必须为Integer类型，其他基本类型的属性必须为其封装类型
 * </p>
 * <p>
 * 5.不支持复杂映射
 * </p>
 * 
 * @author kong
 * 
 */
public class Dao {

	private static final String DRIVER = "org.sqlite.JDBC";
	private static final String CONNECT_URL = "jdbc:sqlite:c:/robot.db";
	private static final String USERNAME = null;
	private static final String PASSWORD = null;
	private static final Log log = LogFactory.getLog(Crawler.class);

	static {
		try {
			Class.forName(DRIVER);
		} catch (ClassNotFoundException e) {
			throw new RuntimeException("加载JDBC驱动失败:\n" + e.getMessage());
		}
	}

	/**
	 * 获取连接
	 * 
	 * @return
	 * @throws SQLException
	 */
	private Connection getConnection() throws SQLException {
		Connection conn = null;
		if (USERNAME != null && PASSWORD != null)
			conn = DriverManager.getConnection(CONNECT_URL, USERNAME, USERNAME);
		else
			conn = DriverManager.getConnection(CONNECT_URL);
		conn.setAutoCommit(false);
		return conn;
	}

	/**
	 * 行集映射
	 * 
	 * @param <T>
	 * @param clazz
	 * @param rs
	 * @return
	 * @throws SQLException
	 */
	private <T> T mapping(Class<T> clazz, ResultSet rs) throws SQLException {
		T t = null;
		if (rs.next()) {
			try {
				t = clazz.newInstance();
			} catch (Exception e) {
				throw new RuntimeException(e);
			}
			ResultSetMetaData metadata = rs.getMetaData();
			int size = metadata.getColumnCount();
			for (int i = 0; i < size; i++) {
				String columnName = metadata.getColumnLabel(i + 1);
				Object columnValue = rs.getObject(metadata
						.getColumnLabel(i + 1));
				if (columnValue == null)
					continue;
				// 给对象赋值
				String propertyName = toJavaCase(columnName);
				String methodName = "set"
						+ propertyName.substring(0, 1).toUpperCase()
						+ propertyName.substring(1);
				Method[] methods = clazz.getMethods();
				for (Method method : methods) {
					if (methodName.equals(method.getName())) {
						try {
							String propertyTypeName = method
									.getParameterTypes()[0].getName();
							String columnTypeName = columnValue.getClass()
									.getName();
							if (propertyTypeName
									.equalsIgnoreCase(columnTypeName))
								method.invoke(t, columnValue);
							else {
								// 转换长整型和日期类型的不适配问题
								if ("java.util.Date".equals(propertyTypeName)
										&& "java.lang.Long"
												.equals(columnTypeName))
									method.invoke(t, new Date(
											(Long) columnValue));
								// 转换整型为布尔型
								if ("java.lang.Boolean"
										.equals(propertyTypeName)
										&& "java.lang.Integer"
												.equals(columnTypeName))
									method.invoke(t, columnValue.toString()
											.equals("0") ? false : true);

							}
						} catch (Exception e) {
							throw new RuntimeException(e);
						}
					}
				}

			}
		}
		return t;
	}

	/**
	 * 释放连接
	 * 
	 * @param rs
	 * @param ps
	 * @param conn
	 */
	public void free(ResultSet rs, PreparedStatement ps, Connection conn) {
		try {
			if (rs != null)
				rs.close();
		} catch (Exception e) {
			log.error(this, e);
		} finally {
			try {
				if (ps != null)
					ps.close();
			} catch (Exception e) {
				log.error(this, e);
			} finally {
				if (conn != null) {
					try {
						conn.close();
					} catch (SQLException e) {
						log.error(this, e);
					}
				}
			}
		}
	}

	/**
	 * 查询方法
	 * 
	 * @param <T>
	 * @param clazz
	 * @param sql
	 * @param values
	 * @return
	 * @throws SQLException
	 */
	public <T> T query(Class<T> clazz, String sql, Object[] values)
			throws SQLException {
		Connection conn = getConnection();
		PreparedStatement ps = conn.prepareStatement(sql);
		if (values != null) {
			for (int i = 0; i < values.length; i++) {
				ps.setObject(i + 1, values[i]);
			}
		}
		ResultSet rs = ps.executeQuery();
		T t = mapping(clazz, rs);
		free(rs, ps, conn);
		return t;

	}

	/**
	 * 查询方法（不带参数）
	 * 
	 * @param <T>
	 * @param clazz
	 * @param sql
	 * @return
	 * @throws SQLException
	 */
	public <T> T query(Class<T> clazz, String sql) throws SQLException {
		return query(clazz, sql, null);
	}

	/**
	 * 查询多个对象
	 * 
	 * @param <T>
	 * @param clazz
	 * @param sql
	 * @param values
	 * @return
	 * @throws SQLException
	 */
	public <T> List<T> queryList(Class<T> clazz, String sql, Object[] values)
			throws SQLException {
		Connection conn = getConnection();
		PreparedStatement ps = conn.prepareStatement(sql);
		if (values != null) {
			for (int i = 0; i < values.length; i++) {
				ps.setObject(i + 1, values[i]);
			}
		}
		ResultSet rs = ps.executeQuery();
		List<T> list = new ArrayList<T>();
		T t = null;
		while ((t = mapping(clazz, rs)) != null) {
			list.add(t);
		}
		free(rs, ps, conn);
		return list;
	}

	/**
	 * 查询多个对象（不带参数）
	 * 
	 * @param <T>
	 * @param clazz
	 * @param sql
	 * @return
	 * @throws SQLException
	 */
	public <T> List<T> queryList(Class<T> clazz, String sql)
			throws SQLException {
		return queryList(clazz, sql, null);
	}

	/**
	 *统计一类对象的个数
	 * 
	 * @param clazz
	 * @return
	 * @throws SQLException
	 */
	public int count(Class<?> clazz) throws SQLException {
		Connection conn = getConnection();
		String tableName = toDbCase(clazz.getSimpleName());
		String sql = "select count(*) from " + tableName;
		PreparedStatement ps = conn.prepareStatement(sql);
		ResultSet rs = ps.executeQuery();
		int num = 0;
		if (rs.next())
			num = rs.getInt(1);
		free(rs, ps, conn);
		return num;
	}

	/**
	 * 根据sql统计
	 * 
	 * @param sql
	 * @param values
	 * @return
	 * @throws SQLException
	 */
	public int count(String sql, Object[] values) throws SQLException {
		Connection conn = getConnection();
		PreparedStatement ps = conn.prepareStatement(sql);
		if (values != null) {
			for (int i = 0; i < values.length; i++) {
				ps.setObject(i + 1, values[i]);
			}
		}
		ResultSet rs = ps.executeQuery();
		int num = 0;
		if (rs.next())
			num = rs.getInt(1);
		free(rs, ps, conn);
		return num;
	}

	/**
	 * 根据sql统计（不带参数）
	 * 
	 * @param sql
	 * @return
	 * @throws SQLException
	 */
	public int count(String sql) throws SQLException {
		return count(sql, null);
	}

	/**
	 * 根据id获取
	 * 
	 * @param <T>
	 * @param clazz
	 * @param id
	 * @return
	 * @throws SQLException
	 */
	public <T> T get(Class<T> clazz, Integer id) throws SQLException {
		String tableName = toDbCase(clazz.getSimpleName());
		String sql = "select * from " + tableName + " where id="
				+ id.intValue();
		Connection conn = getConnection();
		PreparedStatement ps = conn.prepareStatement(sql);
		ResultSet rs = ps.executeQuery();
		T t = mapping(clazz, rs);
		free(rs, ps, conn);
		return t;
	}

	/**
	 * 删除对象
	 * 
	 * @param clazz
	 * @param id
	 * @return
	 * @throws SQLException
	 */
	public int delete(Class<?> clazz, Integer id) throws SQLException {
		String tableName = toDbCase(clazz.getSimpleName());
		String sql = "delete from " + tableName + " where id=" + id.intValue();
		Connection conn = getConnection();
		PreparedStatement ps = conn.prepareStatement(sql);
		int rowCount = ps.executeUpdate();
		free(null, ps, conn);
		return rowCount;
	}

	/**
	 * 保存对象
	 * 
	 * @param object
	 * @throws SQLException
	 */
	public void save(Object object) throws SQLException {
		// 通过反射提取属性和属性值
		Method[] methods = object.getClass().getMethods();
		Map<String, Object> kvMap = new HashMap<String, Object>();
		for (Method method : methods) {
			if (method.getName().startsWith("set")) {
				String key = method.getName().substring(3, 4).toLowerCase()
						+ method.getName().substring(4);
				Method getMethod = null;
				Object value = null;
				try {
					getMethod = object.getClass().getDeclaredMethod(
							method.getName().replaceFirst("set", "get"));
					value = getMethod.invoke(object);
				} catch (Exception e) {
					throw new RuntimeException(e);
				}
				kvMap.put(key, value);
			}
		}
		// 生成sql
		String tableName = toDbCase(object.getClass().getSimpleName());
		Object[] values = new Object[kvMap.size()];
		StringBuffer sb = new StringBuffer("INSERT INTO " + tableName + "(");
		StringBuffer params = new StringBuffer();
		int index = 0;
		for (String key : kvMap.keySet()) {
			String columnName = toDbCase(key);
			sb.append(columnName + ",");
			params.append("?,");
			values[index] = kvMap.get(key);
			index++;
		}
		if (sb.charAt(sb.length() - 1) == ',')
			sb.delete(sb.length() - 1, sb.length());
		if (params.charAt(params.length() - 1) == ',')
			params.delete(params.length() - 1, params.length());
		sb.append(") VALUES(").append(params).append(");");
		String sql = sb.toString();
		// 执行sql
		Connection conn = getConnection();
		PreparedStatement ps = conn.prepareStatement(sql);
		if (values != null) {
			for (int i = 0; i < values.length; i++) {
				ps.setObject(i + 1, values[i]);
			}
		}
		conn.setAutoCommit(true);
		ps.execute();
		conn.setAutoCommit(false);
		// 获取主键
		ps = conn.prepareStatement("select last_insert_rowid()");
		ResultSet rs = ps.executeQuery();
		Integer pk = 0;
		if (rs.next())
			pk = rs.getInt(1);
		// 给对象赋主键的值
		try {
			Method method = object.getClass().getDeclaredMethod("setId",
					Integer.class);
			method.invoke(object, pk);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		free(null, ps, conn);
	}

	/**
	 * 更新对象
	 * 
	 * @param object
	 * @throws SQLException
	 */
	public void update(Object object) throws SQLException {
		// 通过反射提取属性和属性值
		Method[] methods = object.getClass().getMethods();
		Map<String, Object> kvMap = new HashMap<String, Object>();
		for (Method method : methods) {
			if (method.getName().startsWith("set")) {
				String key = method.getName().substring(3, 4).toLowerCase()
						+ method.getName().substring(4);
				Method getMethod = null;
				Object value = null;
				try {
					getMethod = object.getClass().getDeclaredMethod(
							method.getName().replaceFirst("set", "get"));
					value = getMethod.invoke(object);
				} catch (Exception e) {
					throw new RuntimeException(e);
				}
				kvMap.put(key, value);
			}
		}
		// 生成sql
		String tableName = toDbCase(object.getClass().getSimpleName());
		Object[] values = new Object[kvMap.size()];
		StringBuffer sb = new StringBuffer("UPDATE " + tableName + " ");
		int index = 0;
		Integer id = 0;
		boolean firstTime = true;
		for (String key : kvMap.keySet()) {
			String columnName = toDbCase(key);
			if (key.equalsIgnoreCase("id")) {
				id = (Integer) kvMap.get(key);
				continue;
			}
			sb.append((firstTime ? " SET " : "") + columnName + "=?,");
			firstTime = false;
			values[index] = kvMap.get(key);
			index++;
		}
		values[index] = id;
		if (sb.charAt(sb.length() - 1) == ',')
			sb.delete(sb.length() - 1, sb.length());
		sb.append(" WHERE id=?;");
		String sql = sb.toString();
		// 执行sql
		Connection conn = getConnection();
		PreparedStatement ps = conn.prepareStatement(sql);
		if (values != null) {
			for (int i = 0; i < values.length; i++) {
				ps.setObject(i + 1, values[i]);
			}
		}
		conn.setAutoCommit(true);
		ps.executeUpdate();
		conn.setAutoCommit(false);
		free(null, ps, conn);
	}

	/**
	 * 执行sql语句
	 * 
	 * @param sql
	 * @param values
	 * @return
	 * @throws SQLException
	 */
	public boolean execute(String sql, Object[] values) throws SQLException {
		Connection conn = getConnection();
		PreparedStatement ps = conn.prepareStatement(sql);
		if (values != null) {
			for (int i = 0; i < values.length; i++) {
				ps.setObject(i + 1, values[i]);
			}
		}
		conn.setAutoCommit(true);
		boolean r = ps.execute();
		conn.setAutoCommit(false);
		free(null, ps, conn);
		return r;
	}

	/**
	 * 执行sql语句，不带参数
	 * 
	 * @param sql
	 * @return
	 * @throws SQLException
	 */
	public boolean execute(String sql) throws SQLException {
		return execute(sql, null);
	}

	/**
	 * 检查数据库是否有这个表
	 * 
	 * @param clazz
	 * @return
	 * @throws SQLException
	 */
	public boolean existTable(Class<?> clazz) throws SQLException {
		String tableName = toDbCase(clazz.getSimpleName());
		String sql = "SELECT COUNT(*) AS table_count FROM sqlite_master WHERE TYPE='table' AND NAME=?;";
		Connection conn = getConnection();
		PreparedStatement ps = conn.prepareStatement(sql);
		ps.setObject(1, tableName);
		ResultSet rs = ps.executeQuery();
		int num = 0;
		if (rs.next()) {
			num = rs.getInt("table_count");
		}
		free(null, ps, conn);
		return num > 0 ? true : false;
	}

	/**
	 * 使用类来创建表
	 * 
	 * @param clazz
	 * @param delIfExist
	 *            如果表已存在，true表示删除旧表并重新建表，false表示保留旧表不再重新建
	 * @throws SQLException
	 */
	public void createTable(Class<?> clazz, boolean delIfExist)
			throws SQLException {
		// 如果表已经存在，则看看是否需要删除
		boolean existTable = existTable(clazz);
		if (!delIfExist && existTable) {
			return;
		}
		if (delIfExist && existTable) {
			deleteTable(clazz);
		}
		// 通过反射提取属性和属性值
		Method[] methods = clazz.getMethods();
		Map<String, String> kvMap = new HashMap<String, String>();
		for (Method method : methods) {
			if (method.getName().startsWith("set")) {
				String property = method.getName().substring(3, 4)
						.toLowerCase()
						+ method.getName().substring(4);
				String propertyClassName = method.getParameterTypes()[0]
						.getName();
				kvMap.put(property, propertyClassName);
			}
		}
		// 生成sql
		String tableName = toDbCase(clazz.getName());
		StringBuffer sb = new StringBuffer("CREATE TABLE " + tableName
				+ " (id INTEGER PRIMARY KEY,");
		for (String key : kvMap.keySet()) {
			if (key.equalsIgnoreCase("id")) {
				continue;
			}
			String columnName = toDbCase(key);
			String propertyClassName = kvMap.get(key);
			String dbTypeName = getDbTypeName(propertyClassName);
			sb.append(columnName + " " + dbTypeName + ",");
		}
		if (sb.charAt(sb.length() - 1) == ',')
			sb.delete(sb.length() - 1, sb.length());
		sb.append(");");
		String sql = sb.toString();
		// 执行sql
		Connection conn = getConnection();
		PreparedStatement ps = conn.prepareStatement(sql);
		conn.setAutoCommit(true);
		ps.execute();
		conn.setAutoCommit(false);
		free(null, ps, conn);
	}

	/**
	 * 使用sql来建表
	 * 
	 * @param sql
	 * @throws SQLException
	 */
	public void createTable(String sql) throws SQLException {
		// 创建表
		Connection conn = getConnection();
		PreparedStatement ps = conn.prepareStatement(sql);
		conn.setAutoCommit(true);
		ps.execute();
		conn.setAutoCommit(false);
		free(null, ps, conn);
	}

	/**
	 * 创建表，如果表已经存在，则不新建
	 * 
	 * @param clazz
	 * @throws SQLException
	 */
	public void createTable(Class<?> clazz) throws SQLException {
		createTable(clazz, false);
	}

	/**
	 * 删除表
	 * 
	 * @param clazz
	 * @throws SQLException
	 */
	public void deleteTable(Class<?> clazz) throws SQLException {
		String tableName = toDbCase(clazz.getSimpleName());
		String sql = "DROP TABLE IF EXISTS " + tableName;
		execute(sql);
	}

	private String getDbTypeName(String propertyClassName) {
		if ("java.lang.Integer".equals(propertyClassName)
				|| "java.lang.Long".equals(propertyClassName)
				|| "java.lang.Character".equals(propertyClassName)
				|| "java.lang.Short".equals(propertyClassName))
			return "INTEGER";
		if ("java.lang.Float".equals(propertyClassName)
				|| "java.lang.Double".equals(propertyClassName))
			return "REAL";
		if ("java.util.Date".equals(propertyClassName))
			return "DATETIME";
		if ("java.lang.Boolean".equals(propertyClassName))
			return "TINYINT";
		if ("java.lang.String".equals(propertyClassName))
			return "VARCHAR";
		return "";
	}

	/**
	 * 数据库命名方式转换成java的命名方式
	 * 
	 * @param s
	 * @return
	 */
	private static String toJavaCase(String s) {
		if (s == null || s.trim().length() == 0)
			return s;
		StringBuffer sb = new StringBuffer();
		String[] array = s.split("_");
		boolean firstTime = true;
		for (String e : array) {
			if (e.length() == 0)
				continue;
			else if (e.length() == 1)
				sb.append(!firstTime ? e.toUpperCase() : e);
			else
				sb.append(!firstTime ? (e.substring(0, 1).toUpperCase() + e
						.substring(1)) : e);
			firstTime = false;
		}
		return sb.toString();
	}

	/**
	 * Java命名方式转换成数据库的命名方式
	 * 
	 * @param s
	 * @return
	 */
	private static String toDbCase(String s) {
		if (s == null || s.trim().length() == 0)
			return s;
		char[] chars = s.toCharArray();
		boolean firstTime = true;
		StringBuffer sb = new StringBuffer();
		for (char c : chars) {
			if (c >= 'A' && c <= 'Z') {
				char c1 = (char) (c + 32);
				sb.append(firstTime ? c1 : "_" + c1);
			} else
				sb.append(c);
			firstTime = false;
		}
		return sb.toString();
	}

	public static void main(String[] args) {
		// System.out
		// .println(toDbCase("theyBeganToHumWhenSeeingJacksonWalkIntoTheHall"));
		// System.out
		// .println(toJavaCase(toDbCase("theyBeganToHumWhenSeeingJacksonWalkIntoTheHall")));
		StringBuffer sb = new StringBuffer("sdsdfds1");
		sb.delete(sb.length() - 1, sb.length());
		System.out.println(sb);
	}

}
kong0csd
关注
专栏目录
软件架构设计杂记: 分层架构 与 PO、VO、DTO、BO、POJO、BO/DO、DAO
AI天才研究院
08-17 1万+
软件架构设计杂记: 分层架构 与 PO、VO、DTO、BO、POJO、BO/DO、DAO 原创：陈光剑Kotlin 开发者社区前天 某位计算机大师说过: 计算机科学领域任何问题，都可以间接的通过添加一个中间层来解决. 什么是架构? 先引用《系统架构：复杂系统的产品设计与开发》里面的一句话： 结构良好的创造活动要优于毫无结构的创造活动。 架构始于建筑，是因为人类发展（原...
Spring Boot入门(12)：从零开始！轻松掌握Spring Boot整合MyBatis-Plus的最佳实践！
**My Coding Family**
08-17 1万+
一文吃透SpringBoot整合mybatis-plus及实战演练，赶紧来学！
[原创]通用的面向对象查询的dao（二）
java技术交流
08-01 109
dao的改进版，支持简单的注解，例如@DbConfig(length = 20000,type="BLOB")，其中len为字段长度，type为映射到的类型，支持orm查询和其他查询方式。为sqllite数据库写的。 1.数据源类DataSource： [code="java"] package com.lowca.robot.dao.support; import java.io...
面向对象12：Dao层
weixin_34362991的博客
06-15 127
1.Dao层步骤 第一步：建表 第二步：实体类 第三步：写接口（需求） 第四步：帮助类（BaseDao）（只需写一次） 第五步：实现类 表--->实体类--->dao--->biz--->controller ser...
Java 将ResultSet映射到实体Entity
weixin_34195546的博客
09-04 491
2019独角兽企业重金招聘Python工程师标准>>> ...
Java面向对象系列[v1.0.0][SQL语法之基础查询]
一块大洋
09-29 396
select语句的功能就是查询数据，select语句也是SQL语句中功能最丰富的语句，单表查询，多表联合查询，子查询，本质上它就是用于从一个或者多个数据表中选出特定行、特定列的交集
使用Java实现面向对象编程
weixin_41913929的博客
03-28 4122
 第一章 对象和封装1.现实是面向对象的，面向对象是采用“现实模拟”的方法设计和开发程序。2.面向对象设计的过程就是抽象的过程3.面向对象的设计过程：发现类，发现类的属性，发现类的方法4.创建类和对象：类属性和行为组成，属性和行为又称为类的成员变量.5.类和对象是面向对象的核心概念，类是抽象的，对象是具体的6.类名首字母大写，属性名和方法名采用驼峰命名法，常量名所有字母大写7.构造方法及重载：构造...
重拾面向对象软件设计
阿里云技术
11-25 116
从上个世纪五十年代冯·诺依曼创造第一台计算机开始，一直到现在只有短短70年时间，从第一门计算机语言FORTRAN，到现在我们常用的C++，JAVA，PYTHON等，计算机语言的演进速度远超我们所使用的任何一门自然语言。
Springboot原创歌曲分享平台开发详解
- 开发语言：Java，一种广泛使用的通用编程语言，适用于各类应用程序开发，具有跨平台、面向对象、安全等特性。 - 框架：SpringBoot，简化了基于Spring的应用开发，让开发者能够快速启动、开发和运行Spring应用程序...
47个经典Spring面试题详解(附带答案)
GitChat
03-02 793
​这篇文章主要分享了47个Spring经典面试题,现在分享给大家，也给大家做个参考。正好现在金三银四，希望对大家有所帮助，有用的话点赞支持！ 一、一般问题 二、依赖注入（Ioc） 三、Beans 四、注解 五、数据访问 六、AOP 七、MVC ...
DAO,如何实现模糊查询
奔跑在路上
03-14 1万+
定义一个DAO public class DAO { private QueryRunner queryRunner = new QueryRunner(); private Class clazz; public DAO(){ Type superClass = getClass().getGenericSuperclass(); if(superClass in
使用java反射将数据库结果集转换成对象结果集
凉粉
11-07 2263
使用java反射将数据库结果集转换成对象结果集
通用型Dao层简单化查询通用方法
liuyuqin1991的专栏
03-19 3042
与hibernate的Critical类似，是一种通用的Dao层简单化查询通用方法，是我在13年刚接触hibernate的，因为当时的业务性质，需要频繁的简单查询，但我还不知Critical，所以编写了这么一套通用查询方法，思想应该与Critical是一致的 首先是service层，这个通用的service使得可以直接从action层传递参数，查询出相应的对象或集合 package c
JDBC结果集ResultSet映射为实体类(对象)
LuckFairyLuckBaby的博客
03-26 9111
1.方法抽取 public static List<Object> handler(ResultSet rs, Class<?> clazz) { List<Object> list = new ArrayList<>(); Object obj = null; try { ...
以面向对象的思想实现数据表的添加和查询，JDBC代码超详细
weixin_30362083的博客
12-04 145
以面向对象的思想编写JDBC程序，实现使用java程序向数据表中添加学生信息，并且可以实现给定身份证号查询学生信息或给定准考证号查询学生信息。 创建的数据表如下： CREATE TABLE EXAMSTUDENT( FlowID INTEGER, Type INTEGER, IDCard VARCHAR(18), ExamCard VARCHAR(1...
java语句实现数据库的增删查改（面向对象方式，以student为例）
Fredrik的博客
06-06 3311
java语句实现数据库的增删查改（面向对象方式，以student为例）
java面向对象之查找
csdncaoguo940713的博客
01-13 854
javascript，java，查找对象
JAVA学习笔记总结(六)：用面向对象的方法实现数组的插入，删除，查找，显示
Jill Liang的专栏
02-16 3246
第一个例子：我们把数据存储结构，也就是数组从程序的其他部分中分离出来，程序的其他部分将成为这个结构的用户。我们把程序分成两个class,:     一个class用来封装数组(LowArray)，外界不能直接访问这个数组，但是该封装提供了供外界访问的方法setElem()和getElem()，该方法是外界应用和该数组之间通信的方式。     另一个class创建了一个LowArray的对象，用
C++面向对象编程与MFC基础教程
"面向对象程序设计（VC++）的学习资料，涵盖了从C++基础到Windows MFC编程的多个方面，适合初学者。" 面向对象程序设计（C++）是计算机科学中的一个核心概念，它基于类和对象的概念，强调封装、继承和多态性。在C++...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值