JAVA全栈开发 day21_JDBC与反射结合、设计模式

一、总结

一阶段

day01 java 发展，java 环境( path, java_home, class_path)，java 原理， java 执行， jvm , jre , jdk

day02 变量标识符命名规则数据类型数据类型的转换运算符

day03 选择结构 if , switch

day04 循环结构 for , while , do-while

day05 双重循环（打印星星）

day06 数组（一维数组）：排序（冒泡，选择），数据的扩容与缩容

day07 ATM机

二阶段

面向对象

day08            面向过程，**面向对象的思想**（基于对象 -》类）， 类与对象的关系, 类是模板。           类和对象的概念           方法             重载           类的包括（成员变量，成员方法）day09         封装              this              private               构造函数day10     继承( 多个类重复的信息，提供一个公共类，使用继承去实现)             extends              特点：只能单继承不能多继承            子类可以继承父里哪些（私有的继承不了）           重写day11     多态            要有继承             要有重写           要有父指子类的引用           （编译看左边，除了方法运行看右边外，其它的运行也是看左边； 为什么方法运行看右边，因为它实现重写）day12    抽象类与接口     抽象类: 包括抽象方法类，一定要抽象 类，抽象类可以有构造方法，抽象 方法，还可以有普通方法； 只是不能实例化    接口： 一定要抽象方法， jdk 1.8  default , static jdk 1.9 private 方法（主要指default使用）       多态的分类          具体类多态          抽象 类多态          接口多态 (用的最多)       抽象类与接口区别          关系               类与类，接与接口，类与接口          成员              成员属性              构造方法              成员方法           设计  is a  ,  like a day13 - day14 Math, String , Object ,  Date , Calendar , 包装类 ， 正则表达式 , Scanner , Random 等day16代码块内部类成员内部类，局部内容部， 匿名内类部（本质是一个对象）lamda表达式day17 异常day 18 IOday 19 网络编程day20 多线程**day21-day22 集合**            				    单列 （Connection）                        双列(Map)             list                                set                   HashMap    HashTable ...     ArrayList,  LinkedList, Vecktor       HashSet, TreeSet           put() :存值 ，如果 键名相同，就是修改值 .  键不能重复           考原理：数组与链表               (底层HashMap, Jdk1.9 结合红黑树去实现)                                                                        哈希表(数组+链表的结合)day 23-24 Mysql   关系型数据   增删改查（mysql ）约束（外键约束）查询 （表连接， join, left join ,right join ）索引     事务（ACID）: 隔离性（脏读，不可重复读，幻读  =》  sql 隔离级别）mysql 存储引擎（不同引擎它的支持不一样）day 25 JDBCjava 去连接数据的一种技术 （JDBC api ）不同数据库去实现JDBC 接口下载jar使用jarjdbc连接数据的步骤：1. 注册驱动
2. 创建连接对象
3. 创建sql执行对象  statement
4. 写sql 语句，且调用对象的方法执行。 excuteQuery()  , excuteUpdate();
5. 如果是查询，处理结果集
6. 释放资源 封装 1. 把重复，提成一个方法（创建连接的方法， 释放资源的方法）
2. 把提取方法专门一个独立的类里(JdbcUtils)
3. jdbc连接时，url , 驱动， 用户名，密码； 因为它们可能进行修改，所有独立配置文件，提高了代码的维护性day 26 反射使用Class 对象，获取成员属性，构造方法，成员方法（动态代理）1. 获取 Class 对象类名.class;对象名.getClass();Class.forName(类名-包括包名);2. 构造方法      3. 成员属性(在使用时，必须要有对象)4. 成员方法(在使用时，必须要有对象)(加s 的表示获取所有， 不加s表示获取单个) -- 默认这些方法都调用的public修饰如果要获取所有修饰的类型。 给方法一个Declared 注： 如果是私有的，即便获取 了，也不能使用，如果要使用，把java安全语法检查跳过.    xxx.setAccessable(true);

作业

写一个setProperty(Object obj, String propertyName, object value){}
给ArrayList的一个对象，添加一个字符串
curd(增删改查)商品

商品表(goods)

g_id,g_name,g_price,g_num

思路：

        1.  创建表2.  接口(定义方法)3.  写一个Jdbc工具类4.  接口的实现5.  测试类，调用实现类的方法

二、JDBC 与反射结合

封装了两个方法：增删改 excuteUpdate, 查询 excuteQuery

public class JdbcUntils {static {//1.注册驱动  告诉jdbc我们使用哪一个数据库厂商的驱动try {Class.forName("com.mysql.jdbc.Driver");} catch (ClassNotFoundException e) {throw new RuntimeException(e);}}//写一个jdbc 工具类Connection connection = null;PreparedStatement st = null;ResultSet rs = null;//分析：// 当前方法写完了，发现sql 语句是不是直接传过来，可以如果 有参数，直接进行sql拼接会产生sql注入风险// 所以，就考虑使用参数化// 将数据，传过来，传来后，使用PreparedStatement添加参数public int excuteUpdate(String sql,Object... params)   {int result = -1;try {//2. 创建连接connection = getConnection();//3. 创建statement对象//这个里包括了？ ，所以需要参数指定st = connection.prepareStatement(sql);//要把参数加到PreparedStatement对象中//pst.setString(1,username);// pst.setString(2,pwd);for (int i = 0; i < params.length; i++) {st.setObject((i + 1), params[i]);}result = st.executeUpdate();//4. release 释放资源release();}catch (SQLException e){e.printStackTrace();result = -1;}finally {return result;}}public <T>  List<T> excuteQuery(String sql,Class<T> c,Object... prarms){//创建一个集合，存放所有的结果对象List<T> list  = new ArrayList<>();try {connection = getConnection();//	3. 获得执行对象  Statement// 查询 里的sql语句也可以能有参数st = connection.prepareStatement(sql);//添加参数for (int i = 0; i < prarms.length; i++) {st.setObject((i + 1), prarms[i]);}//	4. 执行sql并获得结果集(ResultSet)rs = st.executeQuery();// 4.1 得到结果集的元数据ResultSetMetaData ms = rs.getMetaData();//列的数量int colCount = ms.getColumnCount(); // 处理结果while (rs.next()){
//                int i = 1;//添加一个 T类的实例T t = c.getDeclaredConstructor().newInstance();// 1. 得到结果集，列名数组//2. 循环列名//   循环体里，根据列名，去找对象的对应的字段 ，然后在进行赋值for(int i=1;i<=colCount;i++){Object value = rs.getObject(i);if(value!=null){//将这对应的值，放到对象对应的字段中String colName = ms.getColumnName(i);//通过反射，设置字段的值//要求结果的列名，与实体对象的属性（字段名）相同Field field = c.getDeclaredField(colName);// 跳出java的语法检查 field.setAccessible(true);// 给字段设置对应的值 field.set(t,value);}}list.add(t);//给实例对象的每个属性，赋值// 方法一： 获取所有字段进行赋值，这个要求字段与数据的列的顺序要求一致
//                Field[] Fields = c.getDeclaredFields(); //获取所有的字段
//                for(Field field : Fields){
//                    //缺点： 实体的字段 与数据查询 出来的字段要一一对应
//                    //思路： 如果不对应怎么？
//                    // 最好，可以得到结果集的列名，根据列名，给对应的字段赋值
//
//                    // 这里值 ，应该从结果集
//                    field.set(t,rs.getObject(i++));
//                }//T对象加入到list中}// 	5. 处理结果集release();}catch (Exception e){e.printStackTrace();list = null;} finally {return list;}}//创建连接public Connection getConnection() throws SQLException {//2.通过驱动管理器获取一个链接Connection connection = (Connection) DriverManager.getConnection("jdbc:mysql://localhost:3306/j352", "root", "");return  connection;}//释放资源public  void release(){if(rs!=null){try {rs.close();} catch (SQLException e) {e.printStackTrace();}rs =null; //让jvm来回收它}if(st!=null){try {st.close();} catch (SQLException e) {e.printStackTrace();}st =null; //让jvm来回收它}if(connection!=null){try {connection.close();} catch (SQLException e) {e.printStackTrace();}connection =null; //让jvm来回收它}}}

三、设计原则

1）创建软件应用程序是为了满足不断变化和发展的需求。一个成功的应用程序还应该提供一种简单的方法来扩展它以满足不断变化的期望。如果在设计和开发软件时应用一组面向对象的设计原则和模式，则可以避免或解决这些常见问题。

2）面向对象的设计原则也被称为 SOLID 。在设计和开发软件时可以应用这些原则，以便创建易于维护和开发的程序。

SOLID 原则包括，单一职责原则、开闭原则、里氏替换原则、接口隔离原则和依赖倒置原则。

单一职责原则：每个类只负责做一件事

专业的人做专业的事。每个类只负责做一件事

单一职责原则，其它就是“高内聚”的体现。

每个类只负责做一件事，对外只提供一个功能，而引起类的变化的原因应该只有一个。

开闭原则：对扩展开放，对修改关闭

核心思想：一个对象对扩展开放，对修改关闭

对类的改动是通过增加代码进行，而不是修改代码

如何实现？这就需要借助于抽象和多态。即把可能变化的内容抽象出来.

因为抽象的部分是相对稳定

里氏替换原则

子类可以扩展父类的功能，但不能改变父类原有的功能

子类继承父类时，除添加新的方法完成新增功能外，尽量不要重写父类的方法。

接口隔离原则

别人不需要的东西不要强加给人家。

接口隔离原则是为了约束接口，降低类对接口的依赖。

接口隔离原则是为了约束接口，降低类对接口的依赖。
接口隔离原则的优点：
1）灵活性，可维护性增强
2）高内聚，低耦合
3）减少代码冗余（减少了方法的实现）
4）体现对象层次

依赖倒置原则：

依赖于抽象，而不是依赖于具体，依赖注入模式

依赖倒置原则(Dependency Inversion Principle，DIP)是面向对象设计中的一个原则，它是SOLID原则中的一部分。依赖倒置原则的核心思想是:

高层模块不应该依赖于低层模块，二者都应该依赖于抽象; 抽象不应该依赖于具体细节，而具体细节应该依赖于抽象。

(依赖于抽象)

简而言之，依赖倒置原则要求我们通过抽象来解耦高层模块和低层模块之间的依赖关系，从而使系统更加灵活、可扩展和易于维护。

核心思路：要依赖于抽象，不要依赖于具体

为了实现这一原则，在编程时针对抽象类或者接口编程，而不是具体要求实现

四、设计模式

设计模式是一套反复被使用，经过验证的，代码的总结；

设计模式不是具体的方法，而一种思想.

学习设计模式就是要建立面向对象的思想，尽可能的面向接口编程，低耦合，高内聚，使程序实现复用

设计模式的几个要素

名字，必须有一个简单，有意义的名称
问题描述在何使用
解决方案如何去解决问题
效果模式优点缺点

设计模式分类：

创建型模式对象的创建

结构型模式对象的组成（结构）

行为型模式对象的行为

创建型模式： 简单工厂模式，工厂模式，单例模式等。。。

**结构型模式：**外观模式，适配器模式，装饰模式。。。

**行为型模式：**模板方法模式，观察者模式，状态模式。。。

1.常见设计模式

简单工厂模式

静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例

优点：客户端不需要负责创建对象，明确了各位类的职责

缺点：静态工厂负责创建对象，如果有新的对象增加，或者创建方式不同，需要不断的修改工厂类，不利于后期维护

public class AnimalFoctory {private AnimalFoctory(){}public static Animal createAnimal(String type){if("dog".equals(type)){return new Dog();}else if("cat".equals(type)){return new Cat();}else{return null;}}public static Dog createDog(){return  new Dog();}public static Cat createCat(){return  new Cat();}
}

工厂模式

工厂模式：抽象工厂类负责定义创建对象的接口，具体对象的创建由继承抽象工厂的具体类实现

优点：客户端不需要负责创建对象，明确了各位类的职责；如果新的对象增加，不修改已有的代码，增加了维护性和扩展性

缺点：需要额外编写代码，增加了工作量

单例模式

单例模式：确保类在内存中只有一个对象，此实例必须自动创建，并且对外提供

优点：

缺点：

（饿汉式）：类加载的就创建对象

public class Student {// 为了让静态方法可以访问此对象，所以把它变成静态的// 为了让外界不能直接访问，加privateprivate static Student s = new Student();private Student(){}public static Student getStudent(){return s;}
}

（懒汉式）：用的时候，才去创建

public class Student2 {private static Student2 s = null;private Student2(){}public static Student2 getStudent(){if(s==null){s = new Student2();}return s;}
}

面试题：单例模式的思想是什么？请写一代码体现。

开发：饿汉式（是不会出现问题的）

面试：懒汉式（可能会出现问题的）

A: 懒加载（延迟加载）

B: 线程安全问题

public class Student2 {private static Student2 s = null;private Student2(){}public static synchronized Student2 getStudent(){if(s==null){s = new Student2();}return s;}
}

Runtime类

public class Runtime {private static Runtime currentRuntime = new Runtime();public static Runtime getRuntime() {return currentRuntime;}/** Don't let anyone else instantiate this class */private Runtime() {}}