队列、循环队列、反射的简单应用

今天主要是 队列 循环队列的学习。以及反射的应用，基于反射我们学习了如何只做一个通用的dao层。利用这个基本逻辑处理类我们可以实现对于数据库的插入和查看。当然剩下的方法还没有写，一会儿尝试写出来。不过最好先把刚刚那段代码抄一遍，然后背一下。做到融会贯通。然后其实可以再背一遍JDBCTemplate模板。

 

队列与循环队列：

这个 版本的反射的应用应该是 1.0版本的。比起前面那一张的那个 坑爹类，可强太多了。只有3个方法，但是 要展示的 反射的应用 却用的比较到位。

以下例程

队列：

package MyQueue;
public class MyQueue {//线性队列
    private Object[] obs = new Object[5];
    private int start=-1;//队头
    private int end=-1;//队尾
    /**
     * 添加元素，这个可以封装Object[] 当然也可把我们昨天写的链表结构拿过来，用作对象的存储
     * @param object
     */
    public void add(Object object){
        if(end>=obs.length){
            System.out.println("队列已满");
            return ;
        }
        obs[++end]=object;
    }
    /**
     * 得到队列的开始元素
     * @return
     */
    public Object getStart(){
        return obs[start+1];
    }
    /**
     * 得到队尾元素
     * @return
     */
    public Object getEnd(){
        return obs[end];
    }
    /**
     * 得到队列的长度
     * @return
     */
    public int getSize(){
        return end-start;
    }
    /**
     * 出队操作
     * @return
     */
    public Object putOut(){
        start++;
        Object object = obs[start];
        obs[start]=null;
        return object;
    }
    /**
     * 按照队列顺序查看队列中的元素
     */
    public void lookout(){
        for(int i=start+1;i<end+1;i++){
            System.out.println(obs[i]);
        }
    }
}

循环队列：

package MyQueue;
/**
 * 线性队列的存在总是很爽，但是很浪费空间，如果每次都能让队列满载，这样就很节省空间。
 * @author Administrator
 *浪费一个空间作为队满的标志
 *修改的时候，总是要记得%，不能直接++
 *对比的时候也要记得，%
 */
public class MyCircleQueue {
    Object[] obs = new Object[5];
    private int start=0;//队头
    private int end=0;//队尾
    /**
     * 为循环队列添加元素
     * @param object
     */
    public void add(Object object){
        if(isFull()){
            System.out.println("队列已满，请等待");
            return ;
        }
        end=(end+1)%obs.length;
        obs[end]=object;
    }
    /**
     * 判断队列是否已满，消耗一个空间用作队满的标志
     * @return
     */
    public boolean isFull(){
        return (end+1)%obs.length==start;
    }
    /**
     * 判断队列是否为空，如果start==(end)%obs.length 则队空
     * @return
     */
    public boolean isEmpty(){
        return (end)%obs.length==start;
    }
    /**
     * 出队操作，里面的队头不可能大于5，所以 上面关于 队满和队空的判断是合理的。并不用为strat也进行求余操作。
     * @return
     */
    public Object putout(){
        if(isEmpty()){
            System.out.println("队列中没有元素");
            return null;
        }
        Object object = obs[start];
        obs[start]=null;
        start=(start+1)%obs.length;
        return object;
    }
    /**
     * 得到循环队列中等待元素的数量
     * @return
     */
    public int getSize(){//如果数组短还好，可以直接访问得到数据个数，如果数组长了这样就不划算了，应该可以有算法
        //数组长度一定小于obs.length()
        int i=0;
        for(;i<obs.length;i++){
            if((end+i)%obs.length==start){
                break;
            }
        }
        return obs.length-i;
    }
    
    /**
     * 按照队列顺序额查看队列中的元素
     */
    public void lookout(){
        if(isEmpty()){
            System.out.println("队列为空");
            return ;
        }
        int i=0;
        while((start+i)%obs.length!=(end+1)%obs.length){
            System.out.println(obs[(start+i)%obs.length]);
            i++;
        }
    }
}

基于jdbc的template：

package com.letben.dao;

import java.lang.reflect.GenericArrayType;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.letben.bean.user_tb;
import com.letben.util.JDBCTemplate;
/**
 * 当前BaseDao使用的前提是：类名和表名要保持一致，属性名和字段名要保持一致
 * 之后我们会写一个映射表，来解决数据库和表名命名需要符合规范的问题
 * @author Administrator
 * 抽空补齐 改 和删！
 */
public class BaseDao extends JDBCTemplate{
    /*
    static String className=null;
    static String tableName = null;
     * 并且发现老师的代码里面每一个地方都有className。所以不妨在程序开始的时候，写一个出来。
     * 表名也是
    BaseDao(){}
    BaseDao(Class c){
        className = c.getName();
        tableName = className.substring(className.lastIndexOf(".")+1);
    }
    static {
        //静态块儿并实现不了，需要一个构造函数
    }
     * 类型安全问题，是不是可以把List后面加一个泛型。
     * @param c
     * @return
     * 
     不不不，这些东西不能放在BaseDao，里面而要放在对应的 user_tb 的dao里面
     */
    public     void addObject(Object obj){
        Class c  = obj.getClass();
        String className = c.getName();
        String tableName = className.substring(className.lastIndexOf(".")+1);
        
        StringBuffer sql = new StringBuffer();
//        对于我们要反复修改的字符串语句来讲，我们最好使用StringBuffer 以节省空间。每new的一个String都会在内存中占用一个地址
        //组拼sql语句： insert into tableName (column1,column2...) values (value1,value2...);
        sql.append(" insert into ");
        sql.append(tableName);
        List<String> fields = new ArrayList<String>();
        List values = new ArrayList();
        Method[] methods = c.getMethods();
        for (Method method : methods) {
            //组拼时，需要对应的属性和值，那么新建了两个集合，通过整体添加的方式保持两者对应一致。
            String methodName = method.getName();
            if(methodName.startsWith("get")&&!methodName.equalsIgnoreCase("getclass")){
                String fieldName = methodName.substring(3);
                fields.add(fieldName);
                try {
                    values.add(method.invoke(obj, new Object[]{}));
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            }
        }
        
        sql.append(" ( ");//这个里面空格可以多不能少，所以尽量在每一个单词前后都加上空格，以免字符连在一起，sql无法解析
        for(int i=0;i<fields.size();i++){
            if(i==fields.size()-1){
                sql.append(fields.get(i));
            }else{
                sql.append(fields.get(i)+",");
            }
        }
        sql.append(" ) ");
        sql.append(" values ");
        sql.append(" ( ");
        for (int i = 0; i < values.size(); i++) {
            if(i==values.size()-1){
                sql.append("'"+values.get(i)+"'");
            }else{
                sql.append("'"+values.get(i)+"',");
            }
        }
        sql.append(" ) ");
        System.out.println(sql.toString());
        updateData(sql.toString());
    }
    
    
    
    
    
    public Object getObjectById(Class c,int id){
        String className = c.getName();//大类名
        String tableName = className.substring(className.lastIndexOf(".")+1);//表名，因为我们的前提是类名与表名一致
        String sql = "select * from "+tableName+" where id = "+id;
        ResultSet resultSet = query(sql);
        Object object  = null;
        try {
            object = c.newInstance();
            if(resultSet.next()){
                Method[] methods = c.getMethods();
                for (Method method : methods) {
                    String methodName = method.getName();
                    if(methodName.startsWith("set")){
                        String fieldName = methodName.substring(3);
                        Class[] cla=method.getParameterTypes();
                        if(cla[0]==String.class){//要求属性和字段都放是String和name的依然没有那么通用
                            method.invoke(object, new Object[]{resultSet.getString(fieldName)});
                        }else{
                            method.invoke(object, new Object[]{resultSet.getInt(fieldName)});
                        }
                        //method.invoke(object,new Object[]{resultSet.getString(fieldName)});
                        //取不出来，事实证明真的不通用，只能是对应的读取
                    }
                }
            }
        } catch (SQLException e) {//resultSet.next();
            e.printStackTrace();
        } catch (InstantiationException e) {//c.newInstance
            e.printStackTrace();
        } catch (IllegalAccessException e) {//c.newInstance
            e.printStackTrace();
        } catch (IllegalArgumentException e) {//invoke
            e.printStackTrace();
        } catch (InvocationTargetException e) {//invoke
            e.printStackTrace();
        }
        return object;
    }

    
    public List getAllObject(Class c){
        String className = c.getName();//得到类名
        System.out.println(className);
        String tableName = className.substring(className.lastIndexOf(".")+1);//得到表名或者 类的类名。
        System.out.println(tableName);
        String sql  = "select * from "+ tableName;
        ResultSet resultSet = query(sql);//这是JDBCTemplate里面的方法
//        System.out.println("****************");
        List list = new ArrayList();
        Object object = null;
        try{
            while(resultSet.next()){
                object=c.newInstance();
                Method[] methods = c.getMethods();//得到所有公开的方法。
                for (int i=0;i<methods.length;i++){
                    Method m=methods[i];//得到当前遍历到的这个方法
//                    System.out.println(m);
                    String methodName = m.getName();
//                    System.out.println(methodName);
                    if(methodName.startsWith("set")){//如果这个方法以set开头
                        String fieldName = methodName.substring(3);//得到对应属性名称
                        Class[] cla = m.getParameterTypes();//得到m方法的全部参数的参数类型。
                        if(cla[0]==String.class){
//                            m.invoke(object, new Object(){});
                            //方法召唤，反射得到的方法再进行调用，先传一个类作为实际使用这个方法的参数进去，后面是参数列表
                            m.invoke(object,resultSet.getString(fieldName));
                            //等效于：object.set<fieldName>(resultSet.getString(fieldName));
                            //即：对象把从结果集里面取出来的属性值赋给对应的属性。
                        }else{
                            m.invoke(object, resultSet.getInt(fieldName));
                            //我们常见的getters和setters的语句是：对象.setField(FieldValue);
                            //在反射里面这样写： 方法（对象，参数们）所以针对参数们：的标准写法是：new Object(){p1,p2...}
                        }
                    }
                }
                //这些轮完一圈儿，说明一个对象已经赋值完成。可以使用。故：
                list.add(object);
                object=null;
            }
        }catch(Exception e){
            e.printStackTrace();
        }
        return list;
    }
    public static void main(String[] args) {
        BaseDao baseDao= new BaseDao();
        List<com.letben.bean.user_tb> list =baseDao.getAllObject(user_tb.class);//刚刚到这里有点儿蒙，忘记了类名.class
        for (user_tb user_tb : list) {
            System.out.println(user_tb);
        }
    }
}

那个 jdbc:刚写过了【笑哭】去那篇名叫jdbc的blog里面找一下吧