今天完成的事情：

1.搞清楚excute(),excuteQuery,excuteUpdate()大致区别

a.excute()可以用来执行插入，删除，修改，查询，而且可以返回多个结果集，在执行查询时，其返回值为ture,需要利用getResultSet()来提取结果到res表中，再利用遍历输出查询结果，相对比较麻烦。若返回值为false则是在执行其他操作。

b.executeQuery()执行给定的SQL语句并返回单个ResultSet对象，其结果不需要提取，直接存进res中，所以使用最多。

c.executeUpdate()可以执行插入，删除，修改和其他DLL语句，但是不能执行查询，其返回值为整数类型，表示受此操作的行数，所以如果需要统计受影响的数据数可以使用其操作并直接赋值给int输出结果。

d.总体而言，如果需要最后来遍历输出查询结果，executeQuery无疑是最方便的,如果要统计数目则是executeUpdate比较好，有多个结果集时用execute。

下面demo为用execute()查询数据：

//利用execute而不是executeQuery查询表中数据并输出
import java.sql.*;

public class JdbcTest6 {
    public static void main(String[]args){
        try{
            Class.forName("com.mysql.jdbc.Driver");
        }catch(ClassNotFoundException e){e.printStackTrace();
    }try (
                Connection c= DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test","root","1024");
                Statement st=c.createStatement();
                )
        {String sql="select * from person1";
        Boolean isSelect=st.execute(sql);
           if(isSelect){                                 //若返回值是ture,则代表执行的查询语句
               ResultSet res=st.getResultSet();      //将查询的结果提取出来，存到res表中
            while (res.next()){     
                int id=res.getInt(1);
                String name=res.getString(2);        
                int age=res.getInt(3);
                String personID=res.getString(4);            
                System.out.printf("%d\t%s\t%d\t%s%n",id,name,age,personID);     //遍历输出结果
            }}}catch(SQLException e){e.printStackTrace();
        }
        }}

结果为

2.基本理解了通过新建一种方法使得在主方法中直接调用此方法进行数据库的操作

package com.jdbc;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
public class JdbcTest8 {
    public static Person get(int id){          //构建一个get()方法，可以在主方法中调用其来根据id查出一条具体信息
        Person p1=null;
        try{
            Class.forName("com.mysql.jdbc.Driver");
        }catch (ClassNotFoundException e){e.printStackTrace();}
        try (
                Connection c= DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test","root","1024");
                Statement st=c.createStatement();
                ){
            ResultSet res=st.executeQuery("select * from person1 where id="+id);
            while(res.next()){
                p1=new Person();
               String name=res.getString(2);
               int age=res.getInt(3);
               String personID=res.getString(4);
               p1.name=name;
               p1.age=age;
               p1.personID=personID;
               p1.id=id;
            }
}catch(SQLException e){e.printStackTrace();
        }return p1;
    }
    public static  void add(Person person) {        //构建一个add方法用来插入数据
        String sql1 = "insert into person1 values (null,?,?,?)";
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        try (
                Connection c = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test", "root", "1024");
                PreparedStatement pre = c.prepareStatement(sql1);
        ) {
            pre.setString(1, person.name);
            pre.setInt(2, person.age);
            pre.setString(3, person.personID);
            pre.execute();

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public static void delete(Person person){               //定义一个delete方法用来删除数据
        String sql2="delete from person1 where id=?";
        try{
            Class.forName("com.mysql.jdbc.Driver");
        }catch (ClassNotFoundException e){e.printStackTrace();}
        try (
                Connection c=DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test","root","1024");
                PreparedStatement pre=c.prepareStatement(sql2);
                ){pre.setInt(1,person.id);
                pre.executeUpdate();
}catch (SQLException e){e.printStackTrace();}
    }
    public static void update(Person person){                //定义一个update方法用来修改数据
        String sql3="update person1 set name= ? ,age= ? ,personID= ? where id= ?";   //注意mysql语句一定要对
        try {
            Class.forName("com.mysql.jdbc.Driver");
        }catch (ClassNotFoundException e){e.printStackTrace();}
        try(
                Connection c=DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test","root","1024");
                PreparedStatement pre=c.prepareStatement(sql3);
                ){
            pre.setString(1,person.name);
            pre.setInt(2,person.age);
            pre.setString(3,person.personID);
            pre.setInt(4,person.id);
            pre.execute();
        }catch (SQLException e){e.printStackTrace();}
    }
    public static List<Person> list(){         //构建一个数组List<Person>用来存储查询的总数据
        List<Person> persons=new ArrayList();    //新建一个persons的对象，其实是一个数组
        try {
            Class.forName("com.mysql.jdbc.Driver");
        }catch (ClassNotFoundException e){e.printStackTrace();}
        try(
                Connection c=DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test","root","1024");
                Statement st=c.createStatement();){
            String sql4="select * from person1";
            ResultSet res=st.executeQuery(sql4);
            while (res.next()){                        //遍历表中数据
                Person person=new Person();
                int id=res.getInt(1);
                String name=res.getString(2);
                int age=res.getInt(3);
                String personID=res.getString(4);
                person.id=id;
                person.name=name;
                person.age=age;
                person.personID=personID;
                persons.add(person);              //存储完一条信息之后数组转到下一个，同时由循环转到下一条信息的读取
            }
            }catch(SQLException e){e.printStackTrace();
        }return persons;
        }
public static void main(String[]args){
        Person p1=get(1413);
        System.out.printf("%d\t%s\t%d\t%s%n",p1.id,p1.name,p1.age,p1.personID);
        Person p2=new Person();
        p2.id=1414;
        delete(p2);
        Person p3=new Person();
        p3.name="zhaoxiaoliu";
        p3.age=18;
        p3.personID="20111111";
        add(p3);
        Person p4=new Person();
        p4.id=1415;
        p4.name="chener";
        p4.age=55;
        p4.personID="012222222";
        update(p4);
        List<Person> ps=list();
        System.out.println("总信息数为"+ps.size());
}
}

package com.jdbc;

public class Person {             //构建Person类
    int id;
    String name;
    int age;
    String personID;
}

3.现在的问题就是如何将方法分开改为接口的方式来调用了，同时因为每一种方法都有加载驱动，创建c连接的操作，最好是能合并掉。

首先是要有一个Person类，里面有基本信息，一个DAO类，里面有基本的几种方法，一个实现类，里面重写了DAO类的方法，一个DEMO类，里面包含一个主方法，可以在其中实现对数据库的控制，失败了调试了好久总算搞出来了。

public class Person {
       private int id;         //设为private，然后使用get/set方法进行修改调用
       private String name;
       private int age;
       private String personID;
   public int getId(){
             return id;           //get方法注意有返回值
    }
   public String getName() {
             return name;
    }
   public int getAge() {
             return age;
    }
   public String getPersonID() {
             return personID;
    }
   public void setId(int id){
             this.id=id;               //set方法注意写法
    }
   public void setAge(int age) {
             this.age = age;
    }
   public void setName(String name) {
             this.name = name;
    }
   public void setPersonID(String personID) {
             this.personID = personID;
    }
    }

public  interface IPersonDAO {
      Person get(int id);                     //后面不仅不加方法体，连{}都不要加
     void add(Person person);
     void delete(int id);
     void update(Person person);
}

import java.sql.*;
public class PersonImpl implements IPersonDAO {
        public PersonImpl(){            //将加载驱动放在构造方法中，只要调用就需要创建新的对象，就会加载驱动了
              try{
        Class.forName("com.mysql.jdbc.Driver");
        }catch(ClassNotFoundException e){e.printStackTrace();}
       }
        public  Connection getCollection() throws SQLException{      //创建一个方法将繁杂的getConnection变简单一点
               return DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test","root","1024");
       }
    @Override
    public Person get(int id){
       Person p1=new Person();        //注意这里不能使用null，否则会产生空指针异常
                try (
         Connection c=getCollection();
         Statement st=c.createStatement();
          ){
          ResultSet res=st.executeQuery("select * from person1 where id="+id);
                         while (res.next()){
             String name=res.getString(2);
                              int age=res.getInt(3);
             String personID=res.getString(4);
             p1.setName(name);        //使用set方法将遍历的结果储存到p1中然后返回
             p1.setAge(age);
             p1.setPersonID(personID);
             p1.setId(id);
                 }
            }catch (SQLException e){e.printStackTrace();
         }return p1;
       }
@Override
    public  void add(Person person) {
       String sql="insert into person1 values(null,?,?,?)";
                 try (
         Connection c=getCollection();
           PreparedStatement pre=c.prepareStatement(sql);
            ){
           pre.setString(1,person.getName());
           pre.setInt(2,person.getAge());
           pre.setString(3,person.getPersonID());
           pre.executeUpdate();       //第一遍就忘了执行语句了
            }catch(SQLException e){e.printStackTrace();}
          }
@Override
    public void delete(int id) {         //这个应该是最简单的一个
             try (
       Connection c=getCollection();
       Statement st=c.createStatement();
         ){
         st.execute("delete from person1 where id="+id);
         }catch (SQLException e){e.printStackTrace();}
        }
@Override
    public void update(Person person) {
      String sql="update person1 set name= ? ,age= ? ,personID= ? where id="+person.getId();
                try (
         Connection c=getCollection();
         PreparedStatement pre=c.prepareStatement(sql);
           ){
          pre.setString(1,person.getName());
          pre.setInt(2,person.getAge());
          pre.setString(3,person.getPersonID());
          pre.executeUpdate();
           }catch (SQLException e) {
            e.printStackTrace();
           }
        }
    }

public class Demo {
    public static void main(String[]args){
      PersonImpl use=new PersonImpl();          //注意要创建一个实现类对象来调用方法
       Person p1=new Person();
      p1.setName("zhaosi");
      p1.setAge(23);
      p1.setPersonID("201777777");
      use.add(p1);
      use.delete(1501);
      p1.setName("zhaowu");                //因为上一个p1已经执行了，所以可以不用创建p2直接用p1
      p1.setAge(24);
      p1.setPersonID("2017888888");
      p1.setId(1502);
      use.update(p1);
      p1=use.get(1507);
      System.out.printf("%d\t%s\t%d\t%s%n",p1.getId(),p1.getName(),p1.getAge(),p1.getPersonID());
     }
    }

基本功不扎实的结果就是写出的程序这也有错那也有错，你还不能一眼看出来。。。多写些还是有道理的

明天计划的事情：

明天开始看Mybatis，感觉进度有点慢，不过也没办法，不熟练只能慢慢来了，希望三天之内能把这块硬骨头啃掉。
遇到的问题：

其实本来再纠结，想着这个DAO类在这到底有什么用，既然写了实现类，其实根本就不需要DAO类了，直接调用实现类的方法不就行了嘛，后来查了一下发现这是一种规范，为了增加程序的扩展性，以后程序维护更新起来更便捷，而且在接口类可以清晰明了的看到所有方法。
收获：

总算把jdbc的部分搞完了，收获还是蛮多的，刚开始一头雾水到现在自己能写出一些连接数据库之后简单的操作了