Chapter25_JDBC JDBC简介概念JDBC是使用 Java 语言操作关系型数据库的一套 API全称：（Java DataBase Connectivity）Java 数据库连接本质官方(sun公司)定义的一套操作所有关系型数据库的规则，即接口各个数据库厂商去实现这套接口，提供数据库驱动jar包我们可以使用这套接口(JDBC)编程，真正执行的代码是驱动jar包中的实现类好处各数据库厂商使用相同的接口，Java代码不需要针对不同数据库分别开发可随时替换底层数据库，访问数据库的Java代码基本不变快速入门package com.bbedu.jdbc; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.Statement; public class JDBCDemo { public static void main(String[] args) throws ClassNotFoundException, SQLException { // 1.注册驱动 Class.forName("com.mysql.jdbc.Driver"); // 2.获取连接 String url = "jdbc:mysql://127.0.0.1:3306/db1"; String username = "root"; String password = "123456"; Connection connection = DriverManager.getConnection(url, username, password); // 3.定义 sql String sql = "UPDATE stu SET math = 100 WHERE NAME = '码云';"; // 4.获取执行sql对象的 Statement Statement statement = connection.createStatement(); // 5.执行sql int count = statement.executeUpdate(sql); // 受影响的行数 // 6.处理结果 System.out.println(count); // 7.释放资源 statement.close(); connection.close(); } }JDBC API 详解DriveManager作用：注册驱动获取数据库连接Connection作用：获取执行 SQL 的对象管理事务​package com.bbedu.jdbc; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.Statement; public class JDBCDemo_Connection { public static void main(String[] args) throws ClassNotFoundException, SQLException { // 1.注册驱动 //Class.forName("com.mysql.cj.jdbc.Driver"); // MySQL5 以后可以不写 // 2.获取连接 String url = "jdbc:mysql://127.0.0.1:3306/db1?useSSL=false"; String username = "root"; String password = "123456"; Connection connection = DriverManager.getConnection(url, username, password); // 3.定义 sql String sql1 = "UPDATE stu SET english = 100 WHERE id = '1';"; String sql2 = "UPDATE stu SET english = 100 WHERE id = '2';"; // 4.获取执行sql对象的 Statement Statement statement = connection.createStatement(); try { // 开启事务 connection.setAutoCommit(false); // 执行 int count1 = statement.executeUpdate(sql1); // 受影响的行数 System.out.println(count1); int i = 3/0; int count2 = statement.executeUpdate(sql2); // 受影响的行数 System.out.println(count2); // 提交事务 connection.commit(); } catch (Exception e) { // 回滚事务 connection.rollback(); e.printStackTrace(); } // 7.释放资源 statement.close(); connection.close(); } }Statement执行 SQL 语句ResultSetpackage com.bbedu.jdbc; import java.sql.*; public class JDBCDemo_ResultSet { public static void main(String[] args) throws ClassNotFoundException, SQLException { // 1.注册驱动 //Class.forName("com.mysql.cj.jdbc.Driver"); // MySQL5 以后可以不写 // 2.获取连接 String url = "jdbc:mysql://127.0.0.1:3306/db1?useSSL=false"; String username = "root"; String password = "123456"; Connection connection = DriverManager.getConnection(url, username, password); // 3.定义SQL String sql = "select * from stu;"; // 4.获取执行对象 Statement statement = connection.createStatement(); // 5.执行sql ResultSet resultSet = statement.executeQuery(sql); // 6.遍历 while (resultSet.next()){ // int id = resultSet.getInt(1); // String name = resultSet.getString(2); // double math = resultSet.getDouble(6); int id = resultSet.getInt("id"); String name = resultSet.getString("name"); double math = resultSet.getDouble("math"); System.out.println(id + " " + name + " " + math); System.out.println("-----------------"); } // 7.释放 resultSet.close(); statement.close(); connection.close(); } }练习@Test public void testResultSet2() throws SQLException { // 1.注册驱动 //Class.forName("com.mysql.cj.jdbc.Driver"); // MySQL5 以后可以不写 // 2.获取连接 String url = "jdbc:mysql://127.0.0.1:3306/db1?useSSL=false"; String username = "root"; String password = "123456"; Connection connection = DriverManager.getConnection(url, username, password); // 3.定义SQL String sql = "select * from stu;"; // 4.获取执行对象 Statement statement = connection.createStatement(); // 5.执行sql ResultSet resultSet = statement.executeQuery(sql); // 创建集合 ArrayList<Account> list = new ArrayList<>(); // 6.遍历 while (resultSet.next()){ Account account = new Account(); int id = resultSet.getInt("id"); String name = resultSet.getString("name"); double math = resultSet.getDouble("math"); account.setId(id); account.setName(name); account.setMath(math); list.add(account); } System.out.println(list); // 7.释放 resultSet.close(); statement.close(); connection.close(); }PreparedStatement作用：预编译 SQL 语句并执行，预防 SQL 注入问题SQL 注入SQL注入是通过操作输入来修改事先定义好的SQL语句，用以达到执行代码对服务器进行攻击的方法。@Test public void testInsert() throws Exception{ // 1.注册驱动 //Class.forName("com.mysql.cj.jdbc.Driver"); // MySQL5 以后可以不写 // 2.获取连接 String url = "jdbc:mysql://127.0.0.1:3306/db1?useSSL=false"; String username = "root"; String password = "123456"; Connection connection = DriverManager.getConnection(url, username, password); // 接收用户输入 用户名和密码 String name = "zhangsan"; String pwd = "' or '1' = '1"; String sql = "select * from tb_user where username = '"+name+"' and password = '"+pwd+"';"; System.out.println(sql); Statement statement = connection.createStatement(); ResultSet resultSet = statement.executeQuery(sql); // 判断登录是否成功 if(resultSet.next()){ System.out.println("登陆成功"); }else { System.out.println("登陆失败"); } // 7.释放资源 resultSet.close(); statement.close(); connection.close(); }package com.bbedu.jdbc; import org.junit.jupiter.api.Test; import java.sql.*; public class JDBCDemo_PreparedStatement { @Test public void testPreparedStatement() throws Exception{ // 1.注册驱动 //Class.forName("com.mysql.cj.jdbc.Driver"); // MySQL5 以后可以不写 // 2.获取连接 String url = "jdbc:mysql://127.0.0.1:3306/db1?useSSL=false"; String username = "root"; String password = "123456"; Connection connection = DriverManager.getConnection(url, username, password); // 接收用户输入 用户名和密码 String name = "zhangsan"; String pwd = "' or '1' = '1"; String sql = "select * from tb_user where username = ? and password = ?"; PreparedStatement preparedStatement = connection.prepareStatement(sql); preparedStatement.setString(1, name); preparedStatement.setString(2, pwd); ResultSet resultSet = preparedStatement.executeQuery(); //判断登录是否成功 if(resultSet.next()){ System.out.println("登陆成功"); }else { System.out.println("登陆失败"); } // 7.释放资源 resultSet.close(); preparedStatement.close(); connection.close(); } }原理数据库连接池实现package com.bbedu.druid; import com.alibaba.druid.pool.DruidDataSourceFactory; import javax.sql.DataSource; import java.io.FileInputStream; import java.sql.Connection; import java.util.Properties; public class DruidDemo { public static void main(String[] args) throws Exception { // 导入jar包 // 定义配置文件 // 加载资源对象 Properties prop = new Properties(); prop.load(new FileInputStream("src/druid.properties")); // 获取连接池对象 DataSource dataSource = DruidDataSourceFactory.createDataSource(prop); // 获取数据库连接 Connection connection = dataSource.getConnection(); System.out.println(connection); // System.out.println(System.getProperty("user.dir")); } } 练习完成商品品牌数据的增删改查操作环境准备数据库表 tb_brand实体类测试用例package com.bbedu.example; import com.alibaba.druid.pool.DruidDataSourceFactory; import com.bbedu.pojo.Brand; import org.junit.jupiter.api.Test; import javax.sql.DataSource; import java.io.FileInputStream; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.util.ArrayList; import java.util.Properties; /** * 品牌数据的增删改查 */ public class BrandTest { /** * 查询所有 * SQL: select * from tb_brand; * 参数: 不需要 * 结果: List<Brand> */ @Test public void testSelectAll() throws Exception { // 导入jar包 // 定义配置文件 // 加载资源对象 Properties prop = new Properties(); prop.load(new FileInputStream("src/druid.properties")); // 获取连接池对象 DataSource dataSource = DruidDataSourceFactory.createDataSource(prop); // 获取数据库连接 Connection conn = dataSource.getConnection(); // 定义 SQL String sql = "select * from tb_brand;"; // 获取对象 PreparedStatement preparedStatement = conn.prepareStatement(sql); // 执行SQL ResultSet rs = preparedStatement.executeQuery(); ArrayList<Brand> brands = new ArrayList<>(); // 处理结果 while (rs.next()) { // 获取数据 int id = rs.getInt("id"); String brandName = rs.getString("brand_name"); String companyName = rs.getString("company_name"); int ordered = rs.getInt("ordered"); String description = rs.getString("description"); int status = rs.getInt("status"); // 封装 Brand 对象 Brand brand = new Brand(); brand.setId(id); brand.setBrandName(brandName); brand.setCompanyName(companyName); brand.setOrdered(ordered); brand.setDescription(description); brand.setStatus(status); // 装载集合 brands.add(brand); } System.out.println(brands); // 释放资源 rs.close(); preparedStatement.close(); conn.close(); } /** * 添加 * * @throws Exception SQL：INSERT INTO tb_brand (brand_name, company_name, ordered, DESCRIPTION, STATUS) VALUES (?, ?, ?, ?, ?); * <p> * 参数：需要，除 id 外所有参数信息 * 结果 boolean */ @Test public void testAdd() throws Exception { // 接收参数 String brandName = "香飘飘"; String companyName = "香飘飘公司"; int ordered = 1; String description = "一年售出三亿杯"; int status = 1; // 导入jar包 // 定义配置文件 // 加载资源对象 Properties prop = new Properties(); prop.load(new FileInputStream("src/druid.properties")); // 获取连接池对象 DataSource dataSource = DruidDataSourceFactory.createDataSource(prop); // 获取数据库连接 Connection conn = dataSource.getConnection(); // 定义 SQL String sql = "INSERT INTO tb_brand (brand_name, company_name, ordered, DESCRIPTION, STATUS) VALUES (?, ?, ?, ?, ?);"; // 获取对象 PreparedStatement pstmt = conn.prepareStatement(sql); // 设置参数 pstmt.setString(1, brandName); pstmt.setString(2, companyName); pstmt.setInt(3, ordered); pstmt.setString(4, description); pstmt.setInt(5, status); // 执行SQL int count = pstmt.executeUpdate(); // 影响的行数 // 处理结果 System.out.println(count > 0); // 释放资源 pstmt.close(); conn.close(); } /** * 测试修改 * * @throws Exception SQL: update tb_brand set brand_name=?, company_name=?, ordered=?, description=?, status=? where id=?; * 参数: 所有参数，包括 id * 结果: boolean */ @Test public void testUpdate() throws Exception { // 接收参数 String brandName = "香飘飘"; String companyName = "香飘飘股份有限公司"; int ordered = 1000; String description = "一年售出三亿杯，绕地球三圈"; int status = 1; int id = 5; // 导入jar包 // 定义配置文件 // 加载资源对象 Properties prop = new Properties(); prop.load(new FileInputStream("src/druid.properties")); // 获取连接池对象 DataSource dataSource = DruidDataSourceFactory.createDataSource(prop); // 获取数据库连接 Connection conn = dataSource.getConnection(); // 定义 SQL String sql = "update tb_brand " + "set brand_name=?, " + "company_name=?, " + "ordered=?, " + "description=?, " + "status=? " + "where id=?;"; // 获取对象 PreparedStatement pstmt = conn.prepareStatement(sql); // 设置参数 pstmt.setString(1, brandName); pstmt.setString(2, companyName); pstmt.setInt(3, ordered); pstmt.setString(4, description); pstmt.setInt(5, status); pstmt.setInt(6, id); // 执行SQL int count = pstmt.executeUpdate(); // 影响的行数 // 处理结果 System.out.println(count > 0); // 释放资源 pstmt.close(); conn.close(); } /** * 删除 * * @throws Exception SQL: delete from tb_brand where id = ? * 参数: id * 返回: boolean */ @Test public void testDelete() throws Exception { // 接收参数 int id = 5; // 导入jar包 // 定义配置文件 // 加载资源对象 Properties prop = new Properties(); prop.load(new FileInputStream("src/druid.properties")); // 获取连接池对象 DataSource dataSource = DruidDataSourceFactory.createDataSource(prop); // 获取数据库连接 Connection conn = dataSource.getConnection(); // 定义 SQL String sql = "delete from tb_brand where id = ?"; // 获取对象 PreparedStatement pstmt = conn.prepareStatement(sql); // 设置参数 pstmt.setInt(1, id); // 执行SQL int count = pstmt.executeUpdate(); // 影响的行数 // 处理结果 System.out.println(count > 0); // 释放资源 pstmt.close(); conn.close(); } }

Chapter24_数据库 MySQL数据库数据库三层结构所谓安装 Mysql 数据库，就是在主机安装一个数据库管理系统(DBMS)，这个管理程序可以管理多个数据库。DBMS(database manage system)一个数据库可以创建多个表，以保存数据(信息)DBMS、数据库和表的关系如图所示：数据库-表的本质仍然是文件表的结构行(row)、列(column)SQL 语句分类DDL：数据定义语句[ create 表，库...]DML：数据操作语句[ insert, update, delete ]DQL：数据查询语句[ select ]DCL：数据控制语句[ 管理数据库：比如用户权限 grant revoke ]SQl 通用语句SQL语句可以单行或多行书写，以分号结尾MySQL 数据库的 SQL 语句不区分大小写，关键字建议使用大写注释：单行注释：-- 注释内容 或 #注释内容多行注释：/ 注释 /DDL操作数据库操作表练习DMLDQL基础查询条件查询排序查询分组查询分页查询约束概念与分类数据库设计表关系多表关系实现一对多：在多的一方建立外键，指向一的一方的主键，即外键约束多对多：一对一：多表查询内连接外连接子查询事务事务四大特征ACIDMySQL 事务默认自动提交

Chapter23_反射 反射(Reflection)反射机制反射机制允许程序再执行期间 借助于 Reflection API 取得任何类的内部消息（比如成员变量、构造器、成员方法等等），并能操作对象的属性及方法。反射在设计模式和框架底层都会用到加载完类之后，在堆中就产生了一个 Class 类型的对象（一个类只有一个Class 对象），这个对象包含了类的完整结构信息。通过这个对象得到类的结构，这个对象就像一面镜子，透过这个镜子看到类的结构，所以形象的称之为：反射Java反射机制原理图反射机制可以完成在运行时判断任意一个对象所属的类在运行时构造任意一个类的对象在运行时得到任意一个类所具有的成员变量和方法在运行时调用任意一个对象的成员变量和方法生成动态代理反射相关的主要类java.lang.Class:代表一个类，Class对象表示某个类加载后在堆中的对象java.lang.reflect.Method:代表类的方法java.lang.reflect.Field:代表类的成员变量java.lang.reflect.Cdnstructor:代表类的构造方法Class 类Class 类也是类，因此也继承Object类Class 类对象不是 new 出来的，而是系统创建的对于某个类的Class 类对象，而内存中只有一份，因此类只加载一次每个类的实例都会记得自己是由哪个 Class 实例所生成通过 Class 可以完整地得到一个类的完整结构，通过一系列 APIClass 对象是存放在堆的类的字节码二进制数据，是存放在方法区的，有的地方称为类的元数据（包括 方法代码，变量名，方法名，访问权限等等）常用方法package com.bbedu.reflection.class_; import com.bbedu.Car; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; /** * Class类的常用方法 */ public class Class02 { public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException { String classAllPath = "com.bbedu.Car"; // <?> 表示不确定的Java类型 Class<?> cls = Class.forName(classAllPath); // 输出cls System.out.println(cls); // 显示cls对象是哪个类的Class对象 class com.bbedu.Car System.out.println(cls.getClass()); // class java.lang.Class // 得到包名 System.out.println(cls.getPackage().getName()); // com.bbedu // 得到全类名 System.out.println(cls.getName()); // com.bbedu.Car // 通过cls创建对象实例 Car car = (Car) cls.getDeclaredConstructor().newInstance(); System.out.println(car); // 通过反射获取属性 Field brand = cls.getField("brand"); System.out.println(brand.get(car)); // 给属性赋值 brand.set(car, "benz"); System.out.println(brand.get(car)); // 获取所有字段 System.out.println("=======所有字段属性========"); Field[] fields = cls.getFields(); for (int i = 0; i < fields.length; i++) { System.out.println(fields[i].getName()); } } }获取 Class 对象的六种方式前提：已知一个类的全类名，且该类在类路径下，可以通过 Class 类的静态方法 forName() 获取，可能抛出 ClassNotFoundException应用场景：多用于配置文件，读取类全路径，加载类package com.bbedu.reflection.class_; import com.bbedu.Car; /** * 获取 Class 对象的各种方式（6） */ public class GetClass_ { public static void main(String[] args) throws ClassNotFoundException { // 1.Class.forName String classAllPath = "com.bbedu.Car"; Class<?> cls1 = Class.forName(classAllPath); System.out.println(cls1); // 2.类名.class Class<Car> cls2 = Car.class; System.out.println(cls2); // 3.对象.getClass() Car car = new Car(); Class cls3 = car.getClass(); System.out.println(cls3); // 4.通过类加载器[4种] ClassLoader classLoader = car.getClass().getClassLoader(); Class cls4 = classLoader.loadClass(classAllPath); System.out.println(cls4); System.out.println(cls1.hashCode()); System.out.println(cls2.hashCode()); System.out.println(cls3.hashCode()); System.out.println(cls4.hashCode()); // 5.基本数据类型 Class<Integer> integerClass = int.class; Class<Character> characterClass = char.class; Class<Boolean> booleanClass = boolean.class; System.out.println(integerClass); // 6.基本数据类型对应的包装类 Class<Integer> type = Integer.TYPE; System.out.println(type); Class<Character> type1 = Character.TYPE; System.out.println(type1); System.out.println(integerClass.hashCode()); System.out.println(type.hashCode()); } }哪些类型有 Class 对象package com.bbedu.reflection.class_; import java.io.Serializable; /** * 那些类型有 Class 对象 */ public class AllTypeClass { public static void main(String[] args) { Class<String> cls1 = String.class; Class<Serializable> cls2 = Serializable.class; Class<Integer[]> cls3 = Integer[].class; Class<Integer[][]> cls4 = Integer[][].class; Class<Deprecated> cls5 = Deprecated.class; Class<Thread.State> cls6 = Thread.State.class; Class<Long> cls7 = long.class; Class<Void> cls8 = void.class; Class<Class> cls9 = Class.class; System.out.println(cls1); System.out.println(cls2); System.out.println(cls3); System.out.println(cls4); System.out.println(cls5); System.out.println(cls6); System.out.println(cls7); System.out.println(cls8); System.out.println(cls9); } }类加载反射机制是 java 实现动态语言的关键，也就是通过反射实现类动态加载静态加载：编译时加载相关的类，如果没有则报错，依赖性太强动态加载：运行时夹杂i需要的累，如果运行时不用该类，则不报错，降低了依赖性类加载过程图加载阶段JVM 在该阶段的主要目的是将字节码从不同的数据源（可能是 class 文件、也可能是 jar 包，甚至网络） 转化位二进制数据加载到内存中，并生成一个代表该类的 java.lang.Class 对象链接阶段-验证-准备-解析虚拟机将常量池内的符号引用替换为直接引用的过程初始化获取类的结构信息package com.bbedu.reflection; import org.junit.jupiter.api.Test; import java.lang.annotation.Annotation; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; /** * 通过反射获取类的结构信息 */ public class ReflectionUtils { public static void main(String[] args) { } // 第一组 @Test public void api_01() throws ClassNotFoundException { Class<?> personCls = Class.forName("com.bbedu.reflection.Person"); // 全类名 com.bbedu.reflection.Person System.out.println(personCls.getName()); // 简单类名 Person System.out.println(personCls.getSimpleName()); // 获取所有public属性，包含本类和父类 Field[] fields = personCls.getFields(); for (Field field : fields) { System.out.println("本类及父类的属性：" + field.getName()); } // 所有属性 Field[] declaredFields = personCls.getDeclaredFields(); for (Field declaredField : declaredFields) { System.out.println("本类所有属性：" + declaredField.getName()); } // 本类及父类的public方法 Method[] methods = personCls.getMethods(); for (Method method : methods) { System.out.println("本类及父类的方法：" + method.getName()); } // 本类所有方法 Method[] declaredMethods = personCls.getDeclaredMethods(); for (Method declaredMethod : declaredMethods) { System.out.println("本类所有方法：" + declaredMethod.getName()); } // 获取本类的public构造器 /** * Returns: * the array of Constructor objects representing the public constructors of this class */ Constructor<?>[] constructors = personCls.getConstructors(); for (Constructor<?> constructor : constructors) { System.out.println("本类的构造器：" + constructor.getName()); } // 获取所有构造器 Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors(); for (Constructor<?> declaredConstructor : declaredConstructors) { System.out.println("本类所有构造器：" + declaredConstructor.getName()); } // 获取包信息 System.out.println(personCls.getPackage()); // 返回父类信息 Class<?> superclass = personCls.getSuperclass(); System.out.println(superclass); System.out.println(superclass.getSuperclass()); // 得到接口信息 Class<?>[] interfaces = personCls.getInterfaces(); for (Class<?> anInterface : interfaces) { System.out.println("接口信息" + anInterface); } // 注解信息 Annotation[] annotations = personCls.getAnnotations(); for (Annotation annotation : annotations) { System.out.println("注解信息" + annotation); } } } class A { public String hobby; public A() { } public void hi() { } } interface IA { } interface IB { } @Deprecated() class Person extends A implements IA, IB { // 属性 public String name; protected int age; String job; private double sal; public Person() { } public Person(String name) { } private Person(String name, int age) { } // 方法 public void m1() { } protected void m2() { } void m3() { } private void m4() { } } 反射爆破创建实例package com.bbedu.reflection; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; public class ReflectionCreateInstance { public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException { // 获取Class对象 Class<?> cls = Class.forName("com.bbedu.reflection.User"); // 1.通过public的无参构造器创建实例 Object o = cls.newInstance(); System.out.println(o); // 2.通过public的有参构造器创建实例 // 2.1 得到构造器 Constructor<?> constructor = cls.getConstructor(String.class); // 2.2 创建实例 Object o1 = constructor.newInstance("hello"); System.out.println(o1); // 私有构造器 /*Returns: the Constructor object of the public constructor that matches the specified parameterTypes*/ // Constructor<?> constructor1 = cls.getConstructor(int.class, String.class); Constructor<?> declaredConstructor = cls.getDeclaredConstructor(int.class, String.class); // 暴破（暴力破解），使用反射可以访问private构造器 // 反射面前，都是纸老虎 declaredConstructor.setAccessible(true); Object emmm = declaredConstructor.newInstance(20, "emmm"); System.out.println(emmm); } } class User { private int age = 10; private String name = "bbchen"; public User() { } public User(String name) { this.name = name; } private User(int age, String name) { this.age = age; this.name = name; } @Override public String toString() { return "User{" + "age=" + age + ", name='" + name + '\'' + '}'; } }操作属性package com.bbedu.reflection; import java.lang.reflect.Field; /** * 反射操作属性 */ public class ReflectionAccessProperty { public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException { Class<?> cls = Class.forName("com.bbedu.reflection.Student"); Object o = cls.newInstance(); System.out.println(o.getClass()); Field age = cls.getField("age"); System.out.println(o); age.set(o, 99); System.out.println(o); System.out.println(age.get(o)); Field name = cls.getDeclaredField("name"); // 暴破 name.setAccessible(true); // name.set(o, "Siri"); // static 属性，因此可以写成null name.set(null, "Siri"); System.out.println(name.get(o)); System.out.println(name.get(o)); } } class Student { public int age; private static String name; public Student() { } @Override public String toString() { return "Student{" + "age=" + age + ", name=" + name + '}'; } }操作方法package com.bbedu.reflection; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; /** * 反射调用方法 */ public class ReflectionAccessMethod { public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException { Class<?> cls = Class.forName("com.bbedu.reflection.Boss"); Object o = cls.newInstance(); // Method hi = cls.getMethod("hi", String.class); Method hi = cls.getDeclaredMethod("hi", String.class); hi.invoke(o, "bbchen"); Method say = cls.getDeclaredMethod("say", int.class, String.class, char.class); // 暴破 say.setAccessible(true); System.out.println(say.invoke(o, 123, "hello", 'm')); // 静态方法还可以这样 System.out.println(say.invoke(null, 123, "hello", 'm')); Object invoke = say.invoke(o, 123, "hello", 'm'); System.out.println(invoke.getClass()); System.out.println(invoke); } } class Boss { public int age; private static String name; public Boss() { } private static String say(int n, String s, char c) { return n + " " + s + " " + c; } public void hi(String s) { System.out.println("hi " + s); } }

Chapter18_IO流 多线程初步概念程序是为了完成特定任务，用某种语言编写的一组指令的集合进程进程是运行中的程序，比如我们使用 QQ，就启动了一个进程，操作系统就会为该进程分配内存空间，当我们使用微信，有启动了一个进程，操作系统将为微信分配新的内存空间进程是程序的一次执行过程，或是正在运行的一个程序，是动态过程，有它自身的产生、存在和消亡的过程线程线程是由进程创建的，是进程的一个实体一个进程可以拥有多个线程单线程同一个时刻，只允许执行一个线程多线程同一个时刻，可以执行多个线程并发同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单来说，单核 CPU 是实现的多任务就是并发并行同一个时刻，多个任务同时执行，多核 CPU 可以实现并行线程基本使用继承 Thread 类， 重写 run 方法实现 Runnable 接口，重写 run 方法真正实现多线程效果的，是start0()，而不是 run()package com.bbedu.threadUse; public class Thread03 { public static void main(String[] args) { Thread thread1 = new Thread(new T1()); Thread thread2 = new Thread(new T2()); thread1.start(); thread2.start(); } } class T1 implements Runnable { int count = 0; @Override public void run() { while (true) { System.out.println("hello~ " + (++count)); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } if (count == 30) { break; } } } } class T2 implements Runnable { int count = 0; @Override public void run() { while (true) { System.out.println("hi~ " + (++count)); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } if (count == 40) { break; } } } }Thread 和 Runnable 的区别线程常用方法练习package com.bbedu.method; public class ThreadMethodExercise { public static void main(String[] args) throws InterruptedException { T2 t2 = new T2(); for (int i = 1; i <= 10; i++) { System.out.println("hi " + i); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } if (i == 5) { t2.start(); t2.join(); } } System.out.println("主线程结束..."); } } class T2 extends Thread{ int num = 0; @Override public void run() { while (num < 10) { System.out.println("hello " + (++num)); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("子线程结束..."); } }线程七大状态Synchronized互斥锁Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻,能有一个线程访问该对象。关键字synchronized来与对象的互斥锁联系。当某个对象 synchronized 修饰时，表明该对象在任一时刻只能由一个线程访问同步的局限性:导致程序的执行效率要降低同步方法(非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)同步方法(静态的)的锁为当前类本身。细节同步方法如果没有使用static修饰:默认锁对象为this如果方法使用static修饰，默认锁对象:当前类.class实现的落地步骤:需要先分析上锁的代码选择同步代码块或同步方法要求多个线程的锁对象为同一个即可!作业package com.bbedu.homework; import java.util.Map; import java.util.Random; import java.util.Scanner; public class Homework01 { public static void main(String[] args) { T01 t01 = new T01(); T02 t02 = new T02(t01); t01.start(); t02.start(); } } class T01 extends Thread { private boolean loop = true; @Override public void run() { while (loop) { System.out.println((int)(Math.random() * 100 + 1)); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } public void setLoop(boolean loop) { this.loop = loop; } } class T02 extends Thread { private T01 t01; private Scanner scanner = new Scanner(System.in); public T02(T01 t01) { this.t01 = t01; } @Override public void run() { while (true) { System.out.println("输入q结束"); char c = scanner.next().toUpperCase().charAt(0); if (c == 'Q') { t01.setLoop(false); System.out.println("t01退出"); break; } } } }package com.bbedu.homework; public class Homework02 { public static void main(String[] args) { Withdraw withdraw = new Withdraw(); Thread thread1 = new Thread(withdraw); Thread thread2 = new Thread(withdraw); thread1.start(); thread2.start(); } } class Withdraw implements Runnable { static final Object obj = new Object(); private static int total = 10000; private boolean loop = true; public void withdraw() { synchronized (obj) { if (total <= 0) { loop = false; return; } total -= 1000; System.out.println("用户 " + Thread.currentThread().getName() + " 取出1000元" + " 剩余=" + total); } } @Override public void run() { while (loop) { withdraw(); try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } } } }

Chapter17_多线程 多线程初步概念程序是为了完成特定任务，用某种语言编写的一组指令的集合进程进程是运行中的程序，比如我们使用 QQ，就启动了一个进程，操作系统就会为该进程分配内存空间，当我们使用微信，有启动了一个进程，操作系统将为微信分配新的内存空间进程是程序的一次执行过程，或是正在运行的一个程序，是动态过程，有它自身的产生、存在和消亡的过程线程线程是由进程创建的，是进程的一个实体一个进程可以拥有多个线程单线程同一个时刻，只允许执行一个线程多线程同一个时刻，可以执行多个线程并发同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单来说，单核 CPU 是实现的多任务就是并发并行同一个时刻，多个任务同时执行，多核 CPU 可以实现并行线程基本使用继承 Thread 类， 重写 run 方法实现 Runnable 接口，重写 run 方法真正实现多线程效果的，是start0()，而不是 run()package com.bbedu.threadUse; public class Thread03 { public static void main(String[] args) { Thread thread1 = new Thread(new T1()); Thread thread2 = new Thread(new T2()); thread1.start(); thread2.start(); } } class T1 implements Runnable { int count = 0; @Override public void run() { while (true) { System.out.println("hello~ " + (++count)); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } if (count == 30) { break; } } } } class T2 implements Runnable { int count = 0; @Override public void run() { while (true) { System.out.println("hi~ " + (++count)); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } if (count == 40) { break; } } } }Thread 和 Runnable 的区别线程常用方法练习package com.bbedu.method; public class ThreadMethodExercise { public static void main(String[] args) throws InterruptedException { T2 t2 = new T2(); for (int i = 1; i <= 10; i++) { System.out.println("hi " + i); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } if (i == 5) { t2.start(); t2.join(); } } System.out.println("主线程结束..."); } } class T2 extends Thread{ int num = 0; @Override public void run() { while (num < 10) { System.out.println("hello " + (++num)); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("子线程结束..."); } }线程七大状态Synchronized互斥锁Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻,能有一个线程访问该对象。关键字synchronized来与对象的互斥锁联系。当某个对象 synchronized 修饰时，表明该对象在任一时刻只能由一个线程访问同步的局限性:导致程序的执行效率要降低同步方法(非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)同步方法(静态的)的锁为当前类本身。细节同步方法如果没有使用static修饰:默认锁对象为this如果方法使用static修饰，默认锁对象:当前类.class实现的落地步骤:需要先分析上锁的代码选择同步代码块或同步方法要求多个线程的锁对象为同一个即可!作业package com.bbedu.homework; import java.util.Map; import java.util.Random; import java.util.Scanner; public class Homework01 { public static void main(String[] args) { T01 t01 = new T01(); T02 t02 = new T02(t01); t01.start(); t02.start(); } } class T01 extends Thread { private boolean loop = true; @Override public void run() { while (loop) { System.out.println((int)(Math.random() * 100 + 1)); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } public void setLoop(boolean loop) { this.loop = loop; } } class T02 extends Thread { private T01 t01; private Scanner scanner = new Scanner(System.in); public T02(T01 t01) { this.t01 = t01; } @Override public void run() { while (true) { System.out.println("输入q结束"); char c = scanner.next().toUpperCase().charAt(0); if (c == 'Q') { t01.setLoop(false); System.out.println("t01退出"); break; } } } }package com.bbedu.homework; public class Homework02 { public static void main(String[] args) { Withdraw withdraw = new Withdraw(); Thread thread1 = new Thread(withdraw); Thread thread2 = new Thread(withdraw); thread1.start(); thread2.start(); } } class Withdraw implements Runnable { static final Object obj = new Object(); private static int total = 10000; private boolean loop = true; public void withdraw() { synchronized (obj) { if (total <= 0) { loop = false; return; } total -= 1000; System.out.println("用户 " + Thread.currentThread().getName() + " 取出1000元" + " 剩余=" + total); } } @Override public void run() { while (loop) { withdraw(); try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } } } }