JAVA小项目-管家婆记账本介绍（2）

今日内容介绍
1、连接池

01添加账务功能分析

* A: 添加账务功能分析
    * a: 编写MainView类中addZhangWu方法
        * 键盘输入新添加的账务信息
        * 调用ZhangWuService类中addZhangWu方法，用来指定账务的添加
        * 添加完毕后，使用输出语句，提示“添加账务成功！”
    * b: 编写ZhangWuService类中addZhangWu方法
        * 调用ZhangWuDao类中addZhangWu方法，用来指定账务的添加
    * c: 编写ZhangWuDao类中addZhangWu方法
        * 通过QueryRunner对象，调用update方法更新数据库表gjp_zhangwu，完成指定账务添加到数据库表中

02添加账务功能菜单和输入功能实现

* A: 添加账务功能菜单和输入功能实现    
    * a: 案例核心代码
        * cn.itcast.gjp.view包中建立MainView类addZhangWu方法
        /*
         * 定义方法addZhangWu
         * 添加账务的方法，用户在界面中选择菜单1的时候调用、
         * 实现思想：
         *    接收键盘输入，5项输入，调用controller层方法
         */
        public void addZhangWu() {
            System.out.println("选择的添加账务功能，请输入以下内容");
            Scanner sc = new Scanner(System.in);
            System.out.println("输入分类名称");
            String flname = sc.next();
            System.out.println("输入金额");
            double money = sc.nextDouble();
            System.out.println("输入账户");
            String zhanghu = sc.next();
            System.out.println("输入日期：格式XXXX-XX-xx");
            String createtime = sc.next();
            System.out.println("输入具体描述");
            String description = sc.next();
            //将接收到的数据，调用controller层的方法，传递参数，实现数据添加
            
        }

03添加账务功能控制层,业务层实现

* A: 添加账务功能控制层,业务层实现
    * a: 案例核心代码
        * cn.itcast.gjp.controller包中的ZhangWuController类addZhangWu方法
            /*
             * 定义方法，实现账务添加功能
             * 由视图层调用，传递参数(传递过来的参数不能是5个数据，传递的是一个ZhangWu类型的对象)
             * 本方法调用service层的方法，传递ZhangWu对象，获取到添加后的结果集(添加成功影响的行数，int)
             * 
             */
            public void addZhangWu(ZhangWu zw) {
                service.addZhangWu(zw);
            }
        * cn.itcast.gjp.service包中的ZhangWuService类addZhangWu方法
            /*
             * 定义方法，实现添加账务
             * 是由控制层调用，传递ZhangWu对象
             */
            public void addZhangWu(ZhangWu zw) {
                dao.addZhangWu(zw);
            }
        * cn.itcast.gjp.dao包中的ZhangWuDao类addZhangWu方法
            /*
             * 定义方法，实现添加账务功能
             * 由业务层调用，传递ZhangWu对象
             * 将ZhangWu对象中的数据，添加到数据库
             */
            public void addZhangWu(ZhangWu zw) {
                 
            }

04添加账务功能dao层实现

* A: 添加账务功能dao层实现
    * a: 案例核心代码 
        * cn.itcast.gjp.dao包中的ZhangWuDao类的addZhangWu方法
            public void addZhangWu(ZhangWu zw) {
                try{
                     //拼接添加数据的sql
                    String sql = "INSERT INTO gjp_zhangwu (flname,money,zhanghu,createtime,description) VALUES(?,?,?,?,?)";
                    //创建对象数组，处处5个占位符的实际参数
                    //实际参数来源是传递过来的对象ZhangWu
                    Object[] params = {zw.getFlname(),zw.getMoney(),zw.getZhanghu(),zw.getCreatetime(),zw.getDescription()};
                    //调用qr对象中的方法update执行添加
                    qr.update(sql, params);
                }catch(SQLException ex) {
                    System.out.println(ex);
                    throw new RuntimeException("账务添加失败");
                }
            }

05添加账务功能view层实现

* A: 添加账务功能view层实现
    * a: 案例核心代码
        * cn.itcast.gjp.view包中建立MainView类addZhangWu方法
            public void addZhangWu() {
                System.out.println("选择的添加账务功能，请输入以下内容");
                Scanner sc = new Scanner(System.in);
                System.out.println("输入分类名称");
                String flname = sc.next();
                System.out.println("输入金额");
                double money = sc.nextDouble();
                System.out.println("输入账户");
                String zhanghu = sc.next();
                System.out.println("输入日期：格式XXXX-XX-xx");
                String createtime = sc.next();
                System.out.println("输入具体描述");
                String description = sc.next();
                //将接收到的数据，调用controller层的方法，传递参数，实现数据添加
                //将用户输入的所有参数，封装成ZhangWu对象
                ZhangWu zw = new ZhangWu(0, flname, money, zhanghu, createtime, description);
                controller.addZhangWu(zw);
                System.out.println("恭喜添加账务成功");
            }

06编辑账务功能分析

* A: 编辑账务功能分析
    * a: 编写MainView类中editZhangWu方法
        * 键盘输入要编辑的账务信息ID号
        * 键盘输入要修改的账务信息内容
        * 调用ZhangWuService类中editZhangWu方法，用来将指定的账务信息进行更新
        * 更新完毕后，使用输出语句，提示 “编辑账务成功！”
    * b: 编写ZhangWuService类中editZhangWu方法
        * 调用ZhangWuDao类中editZhangWu方法，用来将指定的账务信息进行更新
    * c: 编写ZhangWuDao类中editZhangWu方法
        * 通过QueryRunner对象，调用update方法更新数据库表gjp_zhangwu，完成数据库表中指定账务更新操作

07编辑账务功能功能之前实现查询所有

* A: 编辑账务功能功能之前实现查询所有
    * a: 案例核心代码
        * cn.itcast.gjp.view包中建立MainView类editZhangWu方法
            public void editZhangWu() {
                //调用查询所有账务数据的功能，显示出来
                //看到所有数据，从中选择一项，进行修改
                selectAll();
                System.out.println("选择的是编辑功能，请输入数据");
                
                
            }

08编辑账务功能菜单实现

* A: 编辑账务功能菜单实现
    * a: 案例核心代码
        * cn.itcast.gjp.view包中建立MainView类editZhangWu方法
            public void editZhangWu() {
                //调用查询所有账务数据的功能，显示出来
                //看到所有数据，从中选择一项，进行修改
                selectAll();
                System.out.println("选择的是编辑功能，请输入数据");
                Scanner sc = new Scanner(System.in);
                System.out.print("请输入ID");
                int zwid = sc.nextInt();
                System.out.println("输入分类名称");
                String flname = sc.next();
                System.out.println("输入金额");
                double money = sc.nextDouble();
                System.out.println("输入账户");
                String zhanghu = sc.next();
                System.out.println("输入日期：格式XXXX-XX-xx");
                String createtime = sc.next();
                System.out.println("输入具体描述");
                String description = sc.next();
                //将用户输入的数据，封装到ZhangWu对象中
                //用户输入的ID，必须封装到到对象中
                ZhangWu zw = new ZhangWu(zwid, flname, money, zhanghu, createtime, description);
                //调用controller层中的方法，实现编辑账务
            }           

09编辑账务功能控制层,业务层实现

* A: 编辑账务功能控制层,业务层实现
    * a: 案例核心代码
        * cn.itcast.gjp.controller包中的ZhangWuController类editZhangWu方法
            /*
             * 定义方法，实现编辑账务功能
             * 由视图层调用，传递参数，也是ZhangWu对象
             * 调用service层的方法，也是ZhangWu对象
             */
            public void editZhangWu(ZhangWu zw) {
                service.editZhangWu(zw);
            }
        * cn.itcast.gjp.service包中的ZhangWuService类editZhangWu方法
            /*
             * 定义方法，实现编辑账务
             * 由控制层调用，传递ZhangWu对象
             * 调用dao层的方法，传递ZhangWu对象
             */
            public void editZhangWu(ZhangWu zw) {
                dao.editZhangWu(zw);
            }
        * cn.itcast.gjp.dao包中的ZhangWuDao类editZhangWu方法
            public void editZhangWu(ZhangWu zw) {
                // TODO Auto-generated method stub
                
            }

10编辑账务功能dao层实现

* A：编辑账务功能dao层实现
    * a: 案例核心代码
        * cn.itcast.gjp.dao包中的ZhangWuDao类editZhangWu方法
            /*
             * 定义方法，实现编辑功能
             * 由业务层调用，传递ZhangWu对象
             * 将对象中的数据，更新到数据表
             */
            public void editZhangWu(ZhangWu zw) {
                try {
                    //更新数据的SQL
                    String sql = "UPDATE zhangwu SET flname=?,money=?,zhanghu=?,createtime=?,description=? WHERE zwid=?";
                    //定义对象数组，封装所有数据
                    Object[] params = {zw.getFlname(),zw.getMoney(),zw.getZhanghu(),zw.getCreatetime(),zw.getDescription(),zw.getZwid()};
                    //调用qr对象方法update执行更新
                    qr.update(sql, params);
                } catch (SQLException ex) {
                    System.out.println(ex);
                    throw new RuntimeException("编辑账务失败");
                }
                
            }

11编辑账务功能view层实现

* A: 编辑账务功能view层实现
    * a: 案例核心代码
        * cn.itcast.gjp.view包中建立MainView类editZhangWu方法
            /*
             * 定义方法，实现对账务的编辑功能
             * 实现思想：
             *  接收用户的输入的信息
             *  封装成ZhangWu对象
             *  调用控制层的方法，传递ZhangWu对象，实现编辑
             * 
             */
            public void editZhangWu() {
                //调用查询所有账务数据的功能，显示出来
                //看到所有数据，从中选择一项，进行修改
                selectAll();
                System.out.println("选择的是编辑功能，请输入数据");
                Scanner sc = new Scanner(System.in);
                System.out.print("请输入ID");
                int zwid = sc.nextInt();
                System.out.println("输入分类名称");
                String flname = sc.next();
                System.out.println("输入金额");
                double money = sc.nextDouble();
                System.out.println("输入账户");
                String zhanghu = sc.next();
                System.out.println("输入日期：格式XXXX-XX-xx");
                String createtime = sc.next();
                System.out.println("输入具体描述");
                String description = sc.next();
                //将用户输入的数据，封装到ZhangWu对象中
                //用户输入的ID，必须封装到到对象中
                ZhangWu zw = new ZhangWu(zwid, flname, money, zhanghu, createtime, description);
                //调用controller层中的方法，实现编辑账务
                controller.editZhangWu(zw);
                System.out.println("账务编辑成功");
            }

12删除账务功能分析

* A: 删除账务功能分析
    * a: 编写MainView类中deleteZhangWu方法
        * 键盘输入要删除的账务信息ID号
        * 调用ZhangWuService类中deleteZhangWu方法，用来将指定的账务信息删除
        * 删除完毕后，使用输出语句，提示 “删除账务成功！”
    * b: 编写ZhangWuService类中deleteZhangWu方法
        * 调用ZhangWuDao类中deleteZhangWu方法，用来将指定的账务信息删除
    * c: 编写ZhangWuDao类中deleteZhangWu方法
        * 通过QueryRunner对象，调用update方法更新数据库表gjp_zhangwu，完成数据库表中指定账务删除操作

13删除账务功能菜单实现

* A: 删除账务功能菜单实现
    * a: 案例核心代码
        * cn.itcast.gjp.view包中建立MainView类deleteZhangWu方法
            /*
             * 定义方法，实现账务删除
             * 实现思想：
             *  接收用户的输入，输入一个主键数据
             *  调用控制层方法，传递一个主键
             */
            public void deleteZhangWu() {
                //调用查询所有账务数据的功能，显示出来
                //看到所有数据，从中选择一项，进行修改
                selectAll();
                System.out.println("选择的是删除功能，请输入序号即可");
                int zwid = new Scanner(System.in).nextInt();
                //调用控制层方法，传递主键id即可
            }

14删除账务功能控制层,业务层实现

* A: 删除账务功能控制层,业务层实现
    * a: 案例核心代码
        * cn.itcast.gjp.controller包中的ZhangWuController类deleteZhangWu方法
            /*
             * 定义方法，实现删除功能
             * 视图层调用，传递int类型主键
             * 调用service层方法，传递int主键
             */
            public void deleteZhangWu(int zwid) {
                service.deleteZhangWu(zwid);
            }
        * cn.itcast.gjp.service包中的ZhangWuService类deleteZhangWu方法
            /*
             * 定义方法，实现删除账务功能
             * 由控制层调用，传递主键id
             * 调用dao层方法，传递主键id
             */
            public void deleteZhangWu(int zwid) {
                dao.deleteZhangWu(zwid);
            }
        * cn.itcast.gjp.dao包中的ZhangWuDao类deleteZhangWu方法
            public void deleteZhangWu(int zwid) {
    
            }

15删除账务功能dao实现

* A: 删除账务功能dao实现
    * a: 案例核心代码
        * cn.itcast.gjp.dao包中的ZhangWuDao类deleteZhangWu方法
            /*
             * 定义方法，实现删除业务
             * 业务层调用，传递主键id
             */
            public void deleteZhangWu(int zwid) {
                try {
                    //拼写删除数据SQL
                    String sql = "DELETE FROM gjp_zhangwu WHERE zwid=?";
                    qr.update(sql, zwid);
                } catch (SQLException ex) {
                    System.out.println(ex);
                    throw new RuntimeException("删除账务失败");
                }
            }

16删除账务功能view层实现

* A: 删除账务功能view层实现
    * a: 案例核心代码
        * cn.itcast.gjp.view包中建立MainView类editZhangWu方法
            /*
             * 定义方法，实现账务删除
             * 实现思想：
             *  接收用户的输入，输入一个主键数据
             *  调用控制层方法，传递一个主键
             */
            public void deleteZhangWu() {
                //调用查询所有账务数据的功能，显示出来
                //看到所有数据，从中选择一项，进行修改
                selectAll();
                System.out.println("选择的是删除功能，请输入序号即可");
                int zwid = new Scanner(System.in).nextInt();
                //调用控制层方法，传递主键id即可
                controller.deleteZhangWu(zwid);
                System.out.println("删除账务成功");
            }

17设计模式概论

* A: 设计模式概论
    * a: 概念
        * 实际的软件开发,对问题的处理总结经验,设计模式
        * 23种设计模式
        * 单例设计模式:
        * 保证一个类的对象唯一性  

18单例模式饿汉式

* A: 单例模式饿汉式
    * a: 单例设计模式代码书写特点
        * 保证一个类的对象唯一性  
        * 私有构造方法
        * 在本类的成员位置,创建出自己类对象
        * 提供公共方法,返回创建的对象
        * 单例模式在Java的应用 java.lang.Runtime
    * b: 案例代码
        /*
         * 单例模式饿汉式
         */
        public class Single {
            private Single(){}
            
            private static final Single s = new Single();
            
            public static Single getInstance(){
                return s;
            }
        }

19单例模式懒汉式

* A: 单例模式懒汉式
    * a: 单例模式懒汉式
        * 对象延迟加载，有安全隐患
    * b: 案例代码
        /*
         * 单例模式懒汉式,对象的延迟加载
         * 安全的,高效的应用
         */
        public class Single {
            private Single(){}
            private static Single s = null;
            
            public static  Single getInstance(){
              if(s == null){    
                s = new Single();
                return s;
            }
        }
        //自定义线程类
        //singleton
        public class Run implements Runnable{
            public void run(){
                for(int x = 0 ; x < 30 ; x++){
                    Single s = Single.getInstance();
                    System.out.println(s);
                    }
            }
        }
        //自定义测试类，多个线程，运行发现创建了多个对象
        public class Test {
            public static void main(String[] args) {
                Run r = new Run();
                new Thread(r).start();
                new Thread(r).start();
                new Thread(r).start();
            }
        }

20单例模式懒汉式的安全问题

* A: 单例模式懒汉式的安全问题
    * a: 案例代码
        public class Single {
            private Single(){}
            private static Single s = null;
            
            public static  Single getInstance(){
              if(s == null){    
                synchronized(Single.class){
                    if( s == null)
                        s = new Single();
                    }
                }
                return s;
            }
        }
    * b: 双层if判断的原因
        * 方法中加入同步锁，保证线程安全
        * 第二个线程调用方法getInstance()的时候，变量s，已经不是null，被前面的线程new过
        * 当已经有对象了，第二个线程没有必要再进入同步了，直接return更好一些

21简单工厂

* A: 简单工厂
    * a: 简单工厂特点
        * 将所有的创建对象的任务,交给一个工厂类实现
        * 找工厂类获取即可
    * b: 案例代码
        public abstract class Animal {
            public abstract void eat();
        }
        
        public class Cat extends Animal{
            public void eat(){
                System.out.println("猫在吃鱼");
            }
        }
        
        public class Dog extends Animal {
            public void eat() {
                System.out.println("狗吃骨头");
            }
        }
        
        /*
         *  工厂类,生产对象,创建对象
         *  只创建动物对象,其他对象不做
         */
        public class Factory {
            //定义方法,创建动物对象
            public static Animal createAnimal(String name){
                if("cat".equals(name))
                    return new Cat();
                else if ("dog".equals(name))
                    return new Dog();
                return null;
            }
        }   
        
        /*
         *  简单工厂设计模式:
         *    将所有的创建对象的任务,交给一个工厂类实现
         *    找工厂类获取即可
         */
        public class Test {
            public static void main(String[] args) {
                //直接调用工厂类的静态方法,传递参数,获取对象
                Animal a = Factory.createAnimal("cat");
                a.eat();
                
                a = Factory.createAnimal("dog");
                a.eat();
                
                a = Factory.createAnimal("car");
                a.eat();
            }
        }

22工厂方法

* A: 工厂方法
    * a:特点
        * 将每个对象,交给了各自工厂去创建
        * 有猫工厂,狗工厂,作用就是建立对象
    * b: 案例代码
        //拷贝上面案例使用的Animal类、Cat类、Dog类
        //定义工厂接口
        public interface Factory {
            public abstract Animal createAnimal();
        }
        
        public class CatFactory implements Factory {
            @Override
            public Animal createAnimal() {
                return new Cat();
            }
        }
        public class DogFactory implements Factory {
            @Override
            public Animal createAnimal() {
                return new Dog();
            }
        }
        /*
         *  工厂方法设计模式:
         *    将每个对象,交给了各自工厂去创建
         *    有猫工厂,狗工厂,作用就是建立对象
         */
        public class Test {
            public static void main(String[] args) {
                Factory f = new CatFactory();
                Animal a = f.createAnimal();
                a.eat();
                
                f = new DogFactory();
                a = f.createAnimal();
                a.eat();
            }
        }   

23装饰模式

* A: 装饰设计模式 
    /*
     *  装饰设计模式
     *    刷墙,铺地板,满足主人爱好,但是墙壁和地面的本质没有变化
     *  
     *  设计手机功能,打电话
     *  class Phone{  public void call(){
     *  }}
     *  设计手机,在打电话同时,彩铃
     *  彩铃: 部分用户愿意,一部分不愿意
     *  原有功能之上,添加一些额外的功能
     *  
     */
     * a: 案例代码
        public interface Phone {
            public abstract void call();
        }
        public class FirstPhone implements Phone {
            public void call() {
                System.out.println("手机打电话");
            }
        }
        public class SecondPhone implements Phone {
            public void call() {
                System.out.println("打电话");
            }

        }
        /*
         *  对于手机加入彩铃功能的装饰类
         */
        public class ColorLingPhone {
            private Phone phone;
            
            public ColorLingPhone(Phone phone){
                this.phone = phone;
            }
            
            public void call(){
                System.out.println("听彩铃");
                phone.call();
            }

        }
        //测试类
        public class Test {

            public static void main(String[] args) {
                
            
                
                Phone p1 = new FirstPhone();
                p1.call();
                
                Phone p2 = new SecondPhone();
                ColorLingPhone clp = new ColorLingPhone(p2);
                clp.call();
                
                clp = new ColorLingPhone(p1);
                clp.call();
            }
        }

24装饰模式在IO中的应用

* A: 装饰模式在IO中的应用
    * 查看BufferedReader流的内容

25总结

* 把今天的知识点总结一遍