黑马程序员技术交流社区

标题: 【石家庄校区】API [打印本页]

作者: 林志博 时间: 2018-10-18 17:43
标题: 【石家庄校区】API
本帖最后由小石姐姐于 2018-10-19 10:41 编辑

Day14今日API

获取一个类的字节码对象的3种方式:
1. Class.forName("全类名")
2. 类名.class .
3. 对象.getClass()

java.lang.Class<T>类: 表示一个类的字节码对象, 其中包含该类中定义的内容
// 获取功能
// 1. 获取成员变量们
Field[] getFields(): 获取所有 public 的成员变量
Field getField(String name): 获取指定名称的 public 的成员变量
Field[] getDeclaredFields(): 获取所有的成员变量, 不考虑权限修饰符
Field getDeclaredField(String name): 获取指定名称的成员变量, 不考虑权限修饰符
// 2. 获取构造方法们
Constructor<?>[] getConstructors(): 获取所有 public 的构造方法
Constructor<T> getConstructor(Class<?>... parameterTypes): 获取指定的 public 构造方法
Constructor<?>[] getDeclaredConstructors(): 获取所有的构造方法, 不考虑权限修饰符
Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes): 获取指定的构造方法, 不考虑权限修饰符
// 3. 获取成员方法们：
Method[] getMethods(): 获取所有 public 的成员方法
Method getMethod(String name, Class<?>... parameterTypes) : 获取指定的 public 成员方法
Method[] getDeclaredMethods(): 获取所有的成员方法, 不考虑权限修饰符
Method getDeclaredMethod(String name, Class<?>... parameterTypes): 获取指定的成员方法, 不考虑权限修饰符
// 4. 获取Class对象代表的类的全类名
String getName(): 获取当前Class对象代表的类的全类名
// 其他
T newInstance(): 使用当前类的空参构造创建一个对象
A getAnnotation(Class<A> annotationClass): 获取当前类的注解对象
ClassLoader getClassLoader(): 返回该类的类加载器
java.lang.reflect.Field: 表示一个成员变量
// 成员方法
void set(Object obj, Object value): 设置指定对象的成员变量的值
Object get(Object obj): 获取指定对象的成员变量的值
void setAccessible(boolean flag): 传true时忽略访问权限修饰符的安全检查. 暴力反射
java.lang.reflect.Constructor<T>: 表示一个构造方法
// 成员方法
T newInstance(Object... initargs): 使用当前构造方法传入参数, 创建对象
void setAccessible(boolean flag): 注意: 构造方法不能利用此方法忽略权限, 会抛异常
java.lang.reflect.Method类: 表示一个成员方法
// 成员方法
Object invoke(Object obj, Object... args): 使用指定对象和指定参数值调用此方法
String getName(): 获取方法名
void setAccessible(boolean flag): 传true时忽略访问权限修饰符的安全检查. 暴力反射
java.lang.ClassLoader: 类加载器
// 成员方法
InputStream getResourceAsStream(String name): 读取相对于bin目录中的文件, 返回一个字节流
常用元注解:
@Target: 描述注解能够作用的位置
ElementType枚举的常用取值：
TYPE：可以作用于类上
METHOD：可以作用于方法上
FIELD：可以作用于成员变量上
示例: @Target(value = {ElementType.TYPE, ElementType.METHOD})
@Retention: 描述注解被保留的阶段
RetentionPolicy枚举的取值:
SOURCE: 保留到源代码阶段
CLASS: 保留到类对象阶段
RUNTIME: 保留到运行时阶段
示例: @Retention(RetentionPolicy.RUNTIME)：保留注解到class字节码文件中并被JVM读取到
@Documented: 加上后, 当前注解会被抽取到api文档中
@Inherited: 加上后, 当前注解会被子类继承
今日目标
能够通过反射获取成员方法对象，并且调用方法

1. 先获取字节码对象
2. 通过字节码对象 Method getDeclaredMethod(String name, Class... cls)
3. Object result = method.invoke(对象, 实际参数...);
了解可以通过反射获取属性对象且能够给其赋值和获取其值

1. 先获取字节码对象
2. 通过字节码对象 Field getDeclaredField(String name)
field.setAccessible(true);
3. field.set(对象, 值);
4. Object result = field.get(对像)
能够说出注解的作用

1. 生成文档 (@author @param @return )
2. 分析代码 (自己写的测试框架)
3. 编译检测 (@Override)
能够自定义注解和使用注解

定义
元注解
public @interface 注解名 {
属性; (接口的抽象方法)
属性 default 默认值;
}

基本类型
String
枚举
注解
以上的数组

使用
@注解名(属性名 = 属性值, 属性名 = 属性值)
能够说出常用的元注解及其作用

@Target: 约束当前注解的使用位置
ElementType.TYPE METHOD FILED
@Retention: 规定当前注解的保留时期
RetentionPolicy.RUNTIME
@Documented: 将当前注解抽取到文档中
@Inherited: 子类也可以继承该注解
能够解析注解并获取注解中的数据
1. 获取被注解位置的对象 Class, Method, Field
2. 通过位置对象获取注解对象注解对象 = getAnnotation(注解名.class)
3. 通过注解对象调用抽象方法(属性)获取返回值, 返回值就是属性值
-
Day02
SQL分类
1) DDL(Data Definition Language)数据定义语言
用来定义数据库对象：数据库，表，列等。关键字：create, drop,alter 等
2) DML(Data Manipulation Language)数据操作语言
用来对数据库中表的数据进行增删改。关键字：insert, delete, update 等
3) DQL(Data Query Language)数据查询语言
用来查询数据库中表的记录(数据)。关键字：select, where 等
4) DCL(Data Control Language)数据控制语言(了解)
用来定义数据库的访问权限和安全级别，及创建用户。关键字：GRANT， REVOKE 等
一.库database(DDL)
1.创建:create database if not exists db1 character set gbk;如果不存在创建db1,
指定字符集gbk
2.删除:drop database if exists db1; 终止数据库db1
3.修改:alter database db1 character set gbk; 修改数据库字符集
4.查询:show databases 显示所有数据库名称
5.使用:use db1 使用db1数据库
二.表结构(DDL)
1.创建:create table student(id int, 创建student表
name varchar(6),
score double(5,2), --小数点后2位共5位
birthday date --'yyyy-MM-dd'
insert_time timestamp --默认获取系统值
)；
2.删除:drop table if exists student 终止student表
3.修改:
修改表名:alter table student rename to stu; 表名student修改为stu
修改表字符集:alter table student character set gbk;修改表字符集为gbk
修改列名,类型:
1)alter table student change gender(列名) sex(新列名) varchar(10);
修改student表将gender列更换为sex 并设置数据类型为varchar(10)
2)alter table student modify gender varchar(20);
修改student表将gender列的数据类型更改为varchar(20)
增加列:alter table student add gender varchar(10);
删除列:alter table student drop gender;
4.查询:
1).show tables; 显示某个数据库中所有表名称
2)desc 表名; (describe描述)描述表结构
三.表数据(DML:增删改表数据)
1.增加:insert into student(id,name,scoer) values(1,'张三',97)
1) 列名和值要一一对应。
2) 如果表名后，不定义列名，则默认给所有列添加值
insert into 表名 values(值1,值2,...值n);
3) 除了数字类型，其他类型需要使用引号(单双都可以)引起来
2.删除:delete from student where id=1 删除id=1的数据如果是null
则不能用"=" where id is null
1)delete from student(即不加where)删除student表所有数据,不推荐
2)truncate table student 删除表然后创建一样结构的表,推荐(DDL级别)
3.修改:update student set name='张三',age=18 where id = 1;
注意:不加条件则修改全部数据
4.查询:(DQL查询语句)
select * from student;查询student表显示所有数据
1) 语法：
select
字段列表
from
表名列表
where
条件列表
group by
分组字段
having
分组之后的条件
order by
排序
limit
分页限定
2)基础查询
1. 多个字段的查询
select 字段名1，字段名2... from 表名；
* 注意：
* 如果查询所有字段，则可以使用*来替代字段列表。
2. 去除重复：
* distinct
3. 计算列
* 一般可以使用四则运算计算一些列的值。（一般只会进行数值型的计算）
* ifnull(表达式1,表达式2)：null参与的运算，计算结果都为null
* 表达式1：哪个字段需要判断是否为null
* 如果该字段为null后的替换值。
4. 起别名：
* as：as也可以省略
3) 条件查询
1. where子句后跟条件
2. 运算符
* > 、< 、<= 、>= 、= 、<>
* BETWEEN...AND
* IN( 集合)
* LIKE：模糊查询
* 占位符：
* _:单个任意字符
* %：多个任意字符
* IS NULL
* and 或 &&
* or 或 ||
* not 或 !

4)排序查询
语法: order by 排序字段1 排序方式1(ASC 升序,默认的),
排序方式2 排序方式2(DESC 降序)...
注:多个排序条件,第一个条件值一样时,才会判断第二条件

5)聚合函数:将一列数据作为一个整体,进行纵向的计算
count 计算个数
一般选择非空的列:主键
count(*)
max 计算最大值
min 计算最小值
sum 计算和
avg 计算平均值

注意:聚合函数的计算,排除null值
解决方案:
1.选择不包含费控的列进行计算
2.ifnull函数
6)分组查询:
1.语法:group by 分组字段
2.注意:
* 分组后跟查询字段:分组字段, 聚合函数
* where 和 having区别?
where用在分组前,对数据条件在限定;
having用在分组后,显示限定.
7)分页查询:(MySQL方言:limit)
语法: limit 开始索引,显示页数;
公式：开始的索引 = （当前的页码 - 1） * 每页显示的条数
- - 例: 每页显示3条记录
SELECT * FROM student LIMIT 0,3; -- 第1页
SELECT * FROM student LIMIT 3,3; -- 第2页
SELECT * FROM student LIMIT 6,3; -- 第3页
-------------------------------------------------------------
5.综合查询例:
查询查询受雇日期早于 2007-05-23的员工，并且按照部门分组，查询每个部门的薪水总和，且部门的总薪水大于25000，最终按照总薪水的大小进行降序排列
SELECT deptno,SUM(sal) --显示部门(deptno),薪水总和
FROM emp --从emp表查
WHERE hiredate < '2007-05-23' --筛选受雇日期< '2007-05-23'的数据
GROUP BY deptno --按照部门分组
HAVING SUM(sal)>25000 --从分组后的数据中筛选出薪水综合>2500的
ORDER BY SUM(sal) DESC; --按照薪水总和降序排序

Day03
约束
概念:对表中数据进行限定,保证数据的正确性,有效性,完整性
分类:
1.非空约束 not nul
2.主键约束 primary key
3.唯一约束 unique
4.外键约束 foreign key

* 非空约束：not null，某一列的值不能为null
1. 创建表时添加约束

[Java] 纯文本查看 复制代码

CREATE TABLE stu(

id int,

name VARCHAR(20) not null -- name为非空

);

2. 创建表完后，添加非空约束
alter table stu modify name varchar(20) not null;
3. 删除name的非空约束
lter table stu modify name varchaar(20)
* 唯一约束：unique，某一列的值不能重复
1. 注意：
* 唯一约束可以有NULL值，但是只能有一条记录为null
2. 在创建表时，添加唯一约束
CREATE TABLE stu(
id INT,
phone_number VARCHAR(20) unique -- 手机号
);
3. 删除唯一约束
alter table stu drop index phone_number;
4. 在表创建完后，添加唯一约束
atler table stu modify phone_number varchar(20) unique
* 主键约束：primary key。
1. 注意：
1. 含义：非空且唯一
2. 一张表只能有一个字段为主键
3. 主键就是表中记录的唯一标识

2. 在创建表时，添加主键约束
create table stu(
id int primary key,-- 给id添加主键约束
name varchar(20)
);

3. 删除主键
-- 错误 alter table stu modify id int ;
alter table stu drop primary key;

4. 创建完表后，添加主键
alter table stu modify id int primary key

5. 自动增长：
1. 概念：如果某一列是数值类型的，使用 auto_increment 可以来完成值的自动
增长
2. 在创建表时，添加主键约束，并且完成主键自增长
create table stu(
id int primary key auto_increment,-- 给id添加主键约束
name varchar(20)
);

3. 删除自动增长
alter table stu modify id int;

4. 添加自动增长
alter table stu modify id int auto_increment;

* 外键约束：foreign key,让表与表产生关系，从而保证数据的正确性。
1. 在创建表时，可以添加外键
* 语法：
create table 表名(
....
外键列
constraint 外键名称 foreign key (外键列名称) references
主表名称(主表列名称)
);

2. 删除外键
alter table 表名 drop foreign key 外键名称

3. 创建表之后，添加外键
alter table 表名 add constraint 外键名称 foreign key (外键字段名称)
references 主表名(主表列名称)
4. 级联操作
1. 添加级联操作
语法: alter table 表名 add constraint 外键名称 foreign key(外键字段名称) references on update cascade on delete cascade;
2. 分类：
1. 级联更新： on update cascade
2. 级联删除： on delete cascade
数据库的设计
1. 多表之间的关系
1. 分类：
1. 一对一(了解)：
2. 一对多(多对一)：
3. 多对多：
2. 数据库设计的范式

* 分类：
1. 第一范式（1NF）：每一列都是不可分割的原子数据项
2. 第二范式（2NF）：在1NF的基础上，非码属性必须完全依赖于码（在1NF基础上消除非主属性对主码的部分函数依赖）
* 几个概念：
1. 函数依赖：A-->B,如果通过A属性(属性组)的值，可以确定唯一B属性的值。则称B依赖于A
例如：学号-->姓名。（学号，课程名称） --> 分数
2. 完全函数依赖：A-->B，如果A是一个属性组，则B属性值得确定需要依赖于A属性组中所有的属性值。
例如：（学号，课程名称） --> 分数
3. 部分函数依赖：A-->B，如果A是一个属性组，则B属性值得确定只需要依赖于A属性组中某一些值即可。
例如：（学号，课程名称） -- > 姓名
4. 传递函数依赖：A-->B, B -- >C . 如果通过A属性(属性组)的值，可以确定唯一B属性的值，在通过B属性（属性组）的值可以确定唯一C属性的值，则称 C 传递函数依赖于A
例如：学号-->系名，系名-->系主任
5. 码：如果在一张表中，一个属性或属性组，被其他所有属性所完全依赖，则称这个属性(属性组)为该表的码
例如：该表中码为：（学号，课程名称）
* 主属性：码属性组中的所有属性
* 非主属性：除过码属性组的属性
3. 第三范式（3NF）：在2NF基础上，任何非主属性不依赖于其它非主属性（在2NF基础上消除传递依赖）
数据库的备份和还原
数据库的备份和还原
1. 命令行：
* 语法：
* 备份： mysqldump -u用户名 -p密码数据库名称 > 保存的路径
* 还原：
1. 登录数据库
2. 创建数据库
3. 使用数据库
4. 执行文件。source 文件路径
2. 图形化工具：
Day04
1.       多表查询(掌握)
1.1概述:
多个表放在一起查询
笛卡尔积：
      * 有两个集合A,B .取这两个集合的所有组成情况。
      * 要完成多表查询，需要消除无用的数据(笛卡尔积)
通过主键和外键关联(因为外键的值来源于主键值)
1.2多表查询的分类：

内链接,只会把查询的表中符合连接条件的数据展示出来
左外链接,显示左表全部信息,若左表的某行在有表中没有匹配行,则右表对应的行为null.
1.-- 隐式内连接
SELECT
      t1.* ,t2.*
FROM
      emp t1, dept t2
WHERE
      t1.dept_id = t2.id;
2.-- 显式内连接
SELECT  t1.*,t2.* FROM  emp t1  [INNER]  JOIN  dept t2  ON  t1.dept_id = t2.id;
3.-- 左外链接(左表全部数据以及右表交集部分 --左表:t1,右表:t2 )
SELECT  t1.*,t2.* FROM  emp t1 LEFT JOIN  dept t2  ON  t1.dept_id = t2.id;
4.-- 右外链接(右表所有数据以及左表交集部分  --左表:t1,右表:t2)
SELECT  t1.*,t2.* FROM  emp t1 RIGHT  JOIN  dept t2  ON  t1.dept_id = t2.id;

1.3子查询:查询中嵌套查询,称被嵌套的查询为子查询
子查询三种情况:
(1).子查询作为一个值(单行单列) 用于条件判断
Select max(salary) from emp;
Select * from emp where emp.salary=(Select max(salary) from emp

(2).:子查询作为一个数组(多行单列)

(3)       .子查询作为一张虚拟表(多行多列)
查询员工入职日期是2011-11-11日之后的员工信息和部门信息
-- 子查询
SELECT *
FROM dept t1 ,(SELECT * FROM emp WHERE emp.`join_date` > '2011-11-11') t2
WHERE t1.id = t2.dept_id;-----------(效率高)

-- 普通内连接
SELECT *
FROM emp t1,dept t2
WHERE t1.`dept_id` = t2.`id` AND t1.`join_date` >  '2011-11-11'

`

2.       事务
2.1事务的基本介绍
1)概念:如果一个包含多个步骤的业务操作,被事务管理,那么这些操作要么同时成                功,要么同时失败.
2)操作:
1．开启事务: start transaction;
2．回滚: rollback;
3．提交: commit;
Day05
1.       JDBC
1.1 JDBC概念: Java DateBase Connectivity
Java数据库连接,Java语言操作数据库
*JDBC本质:其实是官方(sun公司)定义的一套操作所有关系型数据库的规则,即接口. 各个数据库厂商去实现这套接口,提供数据库驱动jar包.我们可以使用这套接口(JDBC)编程,真正执行的代码是驱动jar包中的实现类.
Jdbc的一套接口:java.sql.*
不同的数据库厂商实现一套接口
//mysqlConnection.mysql数据库厂商提供的实现类
//Connection 就是sun官方提供的接口,去调用相关的实现类的方法,
//java.sqlConnection 接口,实现类:com.mysql.jdbc.MySqlConnection(mysql数据库提供的)
public mysqlConnection implement java.sql.Connection{...}
1.2快速入门:
步骤:
1.导入驱动jar包 mysql-connector-java-5.1.37-bin.jar
                     1.复制mysql-connector-java-5.1.37-bin.jar到项目的libs目录下
                     2.右键-->Add As Library
            2. 注册驱动
            3. 获取数据库连接对象 Connection
            4. 定义sql
            5. 获取执行sql语句的对象 Statement
            6. 执行sql，接受返回结果
            7. 处理结果
            8. 释放资源1.3
1.3详解各个对象
1.       Java.sql.DriverManager(类)驱动管理对象
*功能:
1.注册驱动告诉程序该使用哪一个数据库驱动jar
      static void registerDriver(Driver driver) :注册与给定的                                     驱动程序 DriverManager 。
写代码使用：Class.forName("com.mysql.jdbc.Driver");
      通过查看源码发现：在com.mysql.jdbc.Driver类中存       在静态代码块

[Java] 纯文本查看 复制代码

     static {

                                        try {

                    java.sql.DriverManager.registerDriver(new Driver());

                                        } catch (SQLException E) {

                                       throw new RuntimeException("Can't register                                                         driver!");

                                        }

                                        }

                              注意：mysql5之后的驱动jar包可以省略注册驱动的步骤。
2.JDBC控制事务：

1. 事务：一个包含多个步骤的业务操作。如果这个业务操作被事务管理，则这多个步骤要么同时成功，要么同时失败。
2. 操作：
1. 开启事务
2. 提交事务
3. 回滚事务
3. 使用Connection对象来管理事务
* 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务
      * 在执行sql之前开启事务
* 提交事务：commit()
      * 当所有sql都执行完提交事务
* 回滚事务：rollback()

day06
1.数据库连接池
1.1 概念：
其实就是一个容器(集合)，存放数据库连接的容器。当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。
1.2       好处:
1. 节约资源: 没有数据库连接池时,使用connection以后,释放资源.
使用数据库连接池后, 使用完后归还connection到连接池中.
      2. 用户访问高效: 不用每次都创建连接对象,可以从数据库连接池取
1.3 实现：
1. 标准接口：DataSource javax.sql包下的
1. 方法：
      * 获取连接：getConnection()
      * 归还连接：Connection.close()。如果连接对象Connection是从连接池中获取的，那么调用Connection.close()方法，则不会再关闭连接了。而是归还连接

2. 一般我们不去实现它，由数据库厂商来实现.
1. C3P0：数据库连接池技术
2. Druid：数据库连接池实现技术，由阿里巴巴提供的(温少)

1.4 C3P0：数据库连接池技术
* 步骤：
1. 导入jar包 (两个) c3p0-0.9.5.2.jar mchange-commons-java-0.2.12.jar ，
            * 不要忘记导入数据库驱动jar包
      2. 定义配置文件：(c3p0会自动读取配置文件但必须如下定义)
            * 名称： c3p0.properties 或者 c3p0-config.xml
            * 路径：直接将文件放在src目录下即可。

      3. 创建核心对象数据库连接池对象 ComboPooledDataSource
      4. 获取连接： getConnection
1.5.Druid：数据库连接池实现技术，由阿里巴巴提供的
1. 步骤：
            1. 导入jar包 druid-1.0.9.jar
            2. 定义配置文件：
                     * 是properties形式的
                     * 可以叫任意名称，可以放在任意目录下
            3. 加载配置文件。Properties
            4. 获取数据库连接池对象：通过工厂来来获取  DruidDataSourceFactory
            5. 获取连接：getConnection
2. 定义工具类
      1. 定义一个类 JDBCUtils
      2. 提供静态代码块加载配置文件，初始化连接池对象
      3. 提供方法
            1. 获取连接方法：通过数据库连接池获取连接
            2. 释放资源
            3. 获取连接池的方法
2.Spring JDBC
* 概述:
Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
* 步骤：
      1. 导入jar包
      2. 创建JdbcTemplate对象。依赖于数据源DataSource
            * JdbcTemplate template = new JdbcTemplate(ds);-->可以使用自定义的Druid工具类获取DataSource对象
      3. 调用JdbcTemplate的方法来完成CRUD的操作
(1)       update():执行DML语句。增、删、改语句
(2)       queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合
* 注意：这个方法查询的结果集长度只能是1
(3)       queryForList():查询结果将结果集封装为list集合
* 注意：将每一条记录封装为一个Map集合,再将Map集合装载到List集合中
(4)       query():查询结果，将结果封装为JavaBean对象
            * query的参数：RowMapper
                     * 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到                                              JavaBean的自动封装
                              * new BeanPropertyRowMapper<类型>(类型.class)
(5)                queryForObject：查询结果，将结果封装为对象
            * 一般用于聚合函数的查询

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2