一.Java基础语法
1.Jdk环境搭建
- （1）JDK是Java开发环境集【Java Development Kit】
①JAVA_HOME：填写Jdk的安装目录
②Path：在变量值最后输入%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
③CLASSPATH ：.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar
检验是否配置成功 ：运行cmd 输入 java -version （java 和 -version 之间有空格） - （2）Jre是Java运行环境【Java runtime environment】
- （3）Ivm是Java虚拟机【Java Virtual Machine】
★ 三者关系如下：JDK > JRE > JVM2.
2.入门案例
public class Demo {
public static void main(String[] args) {
System.out.println("Hello-World!");
}
}
3.Java数据类型
(1)基础数据类型（四类八种）不能为null
- 整型 : 【byte short int long 】
- 浮点类型 【单精度 float】 【双精度 double】
- 布尔类型 【boolean true和false（默认）】
- 字符类型 【char】
基本数据类型之间的比较：
基本数据类型 大小 最小值 最大值 包装数据类型
byte 1 个字节（1*8 位） -2^7 2^7 - 1 Byte
short 2 个字节（2*8 位） -2^15 2^15-1 Short
int 4 个字节（4*8 位） -2^31 2^31-1 Integer
long 8 个字节（8*8 位） -2^63 2^63 - 1 Long
boolean - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -Boolean
char 2 个字节（2*8 位） 0 2^16 - 1 Character
float 4 个字节（4*8 位） 1.4E - 45 3.4028235E38 Float
double 8 个字节（8*8 位） 4.9E – 324 1.7976931348623157E308 Double
(2)引用数据类型可以=null
-
类 (Class)
预定义的类:官方定义好的类，拿来就可以使用，无需再次创建
自定义的类:官方没有定义的类，只能够自己创建 -
接口 (Interface)
预定义的接口:官方定义好的接口，拿来就可以使用，无需再次创建
自定义的接口:官方没有定义的类，只能够自己创建 -
数组 (Array)
-
枚举 (Enumeration)
4.关键字
- (1)用于数据类型
int 、 byte 、 short 、 long 、 char 、 boolean 、 float 、 double 、 true 、 false 、 new 、 void 、 instanceof
- (2)用于语句
break 、 continue 、 switch 、 case 、 default 、 catch 、 do 、 while 、 else 、 if 、 for return 、 try 、 finally 、 throw 、 this 、 super
- (3)用于修饰
private 、 public 、 static 、 protected 、 final 、 abstract 、 native 、 synchronized
- (4)用于方法、类、接口、包和异常
class 、 extends 、 implements 、 interface 、 package 、 import 、 throws
5.标识符
- 标识符由字母、数字、下划线“_” 组成，数字不能开头。
- 不能把【 关键字】 和 【保留字】 作为标识符。
- 标识符没有长度限制。
- 标识符对大小写敏感。
命名规范：
- 类/接口：首字母大写，多个单词首字母都大写 eg：ClassName
- 包： 倒域名 全部小写字母 以实心点（.）分开 eg：javabs.entity
- 方法/函数名称：一个单词小写，多个单词从第二个开始首字母大写（第一个依旧小写，有括号）eg：getSum()
- 变量（临时存储数据的作用）：一个单词小写，多个单词从第二个开始首字母大写（第一个依旧小写，最后没有括号）eg：getElementById
- 常量：全部大写，多个单词以下划线分割eg：MY_CLORE
6.注释
单行注释
- // 被注释的内容
- 快捷键：ctrl+/ 或 ctrl+shift+C
多行注释
- /* 被注释的内容 */
- 快捷键：ctrl+shift+/
文档注释
- /** 被注释的文档 */
- 快捷键：Alt+shift+J
7.变量和常量
变量
成员变量/全局变量：定义在类中，不在方法、语句、代码块中
public class Demo{
int age;
}
局部变量：定义在方法中或语句中、代码块中
public calss Dmeo{
public static void main(string []arge){
int age;
System.out,println(age);
}
}
成员变量和局部变量的区别？
- 成员变量有默认初始化值
int的初始化值为0
boolean的初始化值为false - 局部变量没有初始化值，在使用之前必须得进行赋值操作
常量
- 不变的量
- 得使用final去修饰变量
8.运算符
- 算术运算符【+ - * / %】
- 比较运算符【< > >= <= == !=】
- 逻辑运算符【或\ 与& 非！ 短路与&& 短路或】
– \ 或：一true则true 都false则false 第一个判断条件不管成立与否，后面的条件条件都会进行执行
– 短路或：一true则true 都false则false 第一个条件成立，后面的条件不再执行返回true
– &与 ：都true则true 一false则false 第一个判断条件不管成立与否，后面的条件条件都会进行执行
– 短路与：都true则true 一false则false 第一个条件不成立，后面的条件不再执行，返回false - 三元/三目元运算符条件表达式 ？ 满足：不满足
例如
public class Demo {
public static void main(String[] args) {
boolean a = 20 > 15 ? true: false;
System.out.println(a);
}
}
- 移位运算符
- 赋值运算符
在Java中，单等于号表示赋值，等于号右边的值赋值给等于号左边的，双等于表示等于
9.语句
选择结构语句
- if
单支语句 if ( ) { }
双支语句 if ( ) { }else if ( ){ }else if ( ){ }
多支语句if ( ) { }else { }
- switch
switch(①){ case xxx : break; default{} }
①的意思是：条件 该条件的类型可以是 整数 在JDK1.7版本后，可以使用字符串作为类型
public class Demo {
public static void main(String[] args) {
System.out.println("请输入分数：");
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
switch (score/10){
case 10:
case 9:
System.out.println("A");
break;
case 8:
System.out.println("B");
break;
case 7:
case 6:
System.out.println("C");
break;
}
System.out.println("分数为：" + score);
}
}
循环结构语句
-
while循环
先判断后循环 -
for循环
i++ 先运算后赋值
++i 先复制后运算
public class Demo {
public static void main(String[] args) {
for (int i = 1; i <= 4; i++) {
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
- do while循环
先循环后判断
10.方法
描述对象具备的功能，就是方法
-
格式：
权限修饰符 返回值类型 方法名称（参数1 的类型 参数1 ，参数2的类型 参数2 ）{
执行语句；
return； 结果值
} -
权限修饰符
public 公共的
private 私有的
default 默认的
protected 受保护的 -
返回值类型
如果有类型，请参照数据类型结构图
如果没有类型，使用void -
方法名称
命名在符合命名规范的前提下 见面知意即可 eg：getSum() 求和 -
返回值
如果有返回值类型，使用return关键字
@Test
public viod getSum(int x,int y){
int z = x + y;
return z;
}
如果没有返回值类型，省略return关键字
@Test
public void print99(){
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(i * j);
}
System.out,println();
}
}
-
重载 overload
方式一：方法名称相同，参数个数不同
方式二：方法名称相同，返回值类型不同 -
Junit单元测试的方法 使用细节
1.在方法名称上 存在 @Test—— 别忘记导包
2.测试方法的权限修饰符 必须是 public
3.测试方法的返回值类型 必须是 void
4.测试方法的方法名称 随便起名
5.测试方法的方法参数 必须为空 -
数组
数组是一个容器，也是一个数据存储结构
一维数组
二维数组
数组的使用
1.存入数组
(1)前提：有剩余的长度
(2)直接对剩余的长度进行分别赋值操作
2.从数组中取出元素
(1)单个取出，制定数组中的索引值位置
(2)循环操作
3.如何排序
(1)Arrays.sort(arr);
@Test
public void print(int [] arr){
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + ", ");
}
System.out.println();
}
@Test
public void bubbleSort(){
int arr [] = {2,55,69,78,41,58};
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1; j++) {
if (arr[j] > arr[j + 1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
print(arr);
}
(1)如何找出最值
public class Demo{
public static void main(String[] args) {
int arr [] = {12,56,99,82,36,555};
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max){
max = arr[i];
}
}
System.out.println(max);
}
}
二 面向对象
概述
- Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想。我们在面向对象思想的指引下，
使用Java语言去设计、开发计算机程序。 这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面
向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算 机事件的设计思想。
它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去 操作实现。 - 面向过程：强调步骤。
- 面向对象：强调对象
- 类：是一组相关属性和行为的集合
- 属性：该事物的状态信息
- 行为：该事物能够做什么
类与对象的关系
- 类是对一类事物的描述，是抽象的
- 对象是一类事物的实例，是具体的
- 类是对象的模板，对象是类的实体
三种特性
封装
- 原则：将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问
- 步骤：使用private关键字来修饰成员变量 ； 对需要访问的成员变量，提供对应的一对一的get××× 和set×××方法
- 封装操作private的含义
private是一个权限修饰符，代表最小权限
可以修饰成员变量和成员方法
被private修饰后的成员变量和成员方法，只在本类中才能访问 - 封装优化this方法
使用 this 修饰方法中的变量，解决成员变量被隐藏的问题
继承
- 类的继承描述的是类与类之间的关系
继承关系–通过已有的类，创建出新类的机制 - 已有的类我们叫父类【超类】 创建出来的新类我们叫子类
- 通过extends关键字完成一个继承关系
具体格式：
访问修饰符 class 子类类名 extends 父类类名{
} - java中只支持单继承【一个类只能由一个父类】
- 充当父类的java类绝对不能用final关键字修饰【被final关键字修饰的类是没有子类的】
多态
- 前提是继承
- 格式：
父类 对象名称 = new 子类名称（）; //父类与子类有继承关系
接口名称 对象名称 = new 实现类名称（）；
class Dog extends Animal{
//狗 是 狗
Dog d = new Dog();
//狗 是 动物
Animal d = new Dog();
}
抽象
- 将没有方法主体的方法称为抽象方法
- 权限修饰符
public
protected
private
default - 抽象方法必须在抽象类中
- 抽象类可以没有抽象方法
- 抽象方法不能new 不是子类不能new
- 如果子类继承了父类，就必须继承抽象方法，必须重写方法体
- 抽象类不能new的原因：
因为有抽象方法，没有构造方法
接口
抽象类 接 口
构造方法 有 没有
成员变量 有普通成员变量 没有
普通方法 可以包含非抽象的 不可包含
访问类型 可以是public protected 只能是public（默public abstract）
静态方法 可以 不可以
静态成员变量 访问类型可以任意 接口中定义的变量只能是public static final类型
- 一个类可以实现多个接口
- 一个类只可以继承一个类（单继承）
- 一个类只可以继承一个类，并且实现多个接口
- 一个接口可以继承另一个接口
- 一个接口可以继承多个接口
- 一个接口不能继承类
- 一个接口不可以实现另一个接口
关键字
this 当前的
super 父类的
static 静态化的
-
优点
1.可以使用【类名 方法名称】进行调用，不必再创建对象
2.优于构造函数先执行------> 任何一个类都会有一个默认的无参数的构造方法
构造方法/函数的作用：为了使类可实例化【就是为了可以new】
3.静态成员被所有对象所共享（静态数据达到成为共享数据）
4.随着类的加载而加载（也就是说类运行了，静态成员也就跟随运行了） -
缺点
1.访问出现局限性 只能访问静态
2.静态成员的生命周期过长
3.不可以与this | super关键字同用
（1）因为this代表使当前类对象，而静态存在时，有可能没有对象
（2）因为super代表的是父亲对象，而静态存在时，有可能没有对象，而且静态优先于对象存在
4.静态方法只能访问静态成员，非静态方法既可以访问静态又可以访问非静态
final 最终化的
构造方法
- 作用：是为了给对象进行初始化而存在的
没有构造方法就不能new - 当你没有写构造方法，jvm会自动给你加上一个无参数的构造方法
成员变量or局部变量
public class Car{
String color; //成员变量
public void driver(){
int speed = 80; //局部变量
System.out.println("时速：" + speed);
}
}
- 在类中的位置不同 ★
成员变量：类中，方法外
局部变量：方法中或者方法声明上(形式参数) - 作用范围不一样 ★
成员变量：类中
局部变量：方法中 - 初始化值的不同 ★
成员变量：有默认值【int为0 boolean为false】
局部变量：没有默认值 必须先定义，赋值，最后使用 - 在内存中的位置不同 了解
成员变量：堆内存
局部变量：栈内存 - 生命周期不同 了解
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
补： - 如果private私有化了，就一定能够得提供公有方法 Getter and Setter方法 string是类
- equals看的是汉字是否一样
- == 看的是两方汉字的地址值是否一样
三.集合
单列集合 collection / 表示为泛型
-
List【线程不安全性】
-
派生类
ArrayList 查询块、增删慢
LinkedList 查询慢、增删块
Vector 查询慢、增删更慢 【线程安全性】 -
特点
使用线性存储
可以重复添加
存入与取出顺序一致 -
Set【线程不安全性】
-
派生类
HashSet
TreeSet -
特点
使用哈希表存储
不可以重复添加
存入与取出顺序不一致 -
为什么不可以重复添加数据？
- 加入Set里面的元素必须定义equals()方法以确保对象的唯一性
- set插入数据时，先比较hashCode
1.如果hashCode相同才会比较equals，equals相同，则两个对象相同，不能插入，equals不同，可以插入；
2.如果hashCode不同，就直接插入了，两个对象hashCode不相等，他们equals一定是false
-
接口：继承了Iterable，迭代器
-
foreach
双列集合 Map /表示为泛型 key value键值对
泛型：限定类型，泛型中的不可以使用基础数据类型，只能使用引用数据类型
-
HashMap 【线程不安全性】
- 迭代器iterator使用
三种迭代器方法- keyset()
先获取键
通过键获取值
打印值 能打印键 - entryset()
可以获取键
也可以获取值
都可以打印 - values()
直接获取值
打印值 不能打印键
- keyset()
- 迭代器iterator使用
-
都需要使用迭代器
Iterator it = Set.iterator();
while (it.hasNext()){
it.next();
}
-
TreeMap 【线程不安全性】
-
HashTable【线程安全性】
properties 既是io流 也是集合 -
list与Map不能转换
-
set与Map可以转换 共同点有【都是线程不安全性 都是接口 都间接的继承了Iterable这个接口】
-
在双列集合接口中，并没有继承Iterable，意味着Map集合中没有迭代器
工具类 Collections
Collections是专门用于对Collection集合进行操作的工具类，它提供了一些便捷的方法，如排序，查找，求最值等等
四. 异常
Error错误
-
CPU中央处理器
-
单核处理器（并行）
-
多核处理器（并发线程）
-
如果是单核处理器，就不是同时在执行
运行速度非常快，快到以为是同时
-
多核处理器真的可以同时在执行，处理器多了可以分开执行
-
Exception异常
系统定义好的/官方的预定义
- 编译时异常
- 写代码过程中，写完未执行时，报错
- 运行时异常
- 已写完后，已经开始运行时，报错
自定义异常
- 导致原因
算数异常
数组异常
图片异常
图标异常
音频异常
io异常 - 解决方案
1.捕捉异常
try{
catch{
finally{
}
2.声明式异常
在方法名称的括号后加上一个 throws - eg：
ClassNotFoundException 找不到类异常
NoClassDefoundError 没有定义类的异常
ArrayIndexOutOfBoundsException 数组角标超出范围的异常
NullPointerException 空指针异常
★ RuntimeException 运行时异常
五.多线程
进程和线程定义和关系：
- 进程（表面）：正在进行中的程序（任务管理器 ctrl+_alt+del）
- 线程（内在）：是存在进程中的一个执行单元（没有箱子，但是有组件）
- 进程和线程的关系：每一个进程中至少存在一个线程，也可拥有多个线程
多线程
- 并行：针对于多个线程，在同一时间内发生 （重在指一段时间内）
- 并发：针对于多个线程，在同一时刻发生 （指的是同时）
线程调度 【Java的继承机制：仅单继承，不可以多继承】
- 分时调度
- 按方式调度
设置线程：Run()方法
开启线程：Start()方法
实现多线程的三种方法
-
继承java.lang.Thread类【extend Thread】
-
实现java.lang.Runnable接口（重写Run方法）【implements Runnable】
-
实现Callable接口（接口中一定不允许存放变量，不能够存放常量）
-
Thread和Runnable的区别（实现接口比继承类的优势）
①可以避免单继承的局限性【若一个类继承 Thread的话，则不适合资源共享；但若实现 Runnable 接口的话，就很容易实现资源共享】②适合多个相同的程序代码的线程去处理同一个资源
③增强程序的扩展性，降低耦合性（避免牵一发而动全身）【代码可以被多个线程共享，代码和数据独立】
④线程池只能放入实现 Runnable 或 Callable 类的线程，不能直接放入继承 Thread 的类
线程的状态可以分为5种：
- 新建new：
当一个线程新建出来，例如 Thread thread = new Thread() 此时，线程状态就是new。 - 可运行Runnable：
当新建的线程调用start方法，线程状态就变为runnable，此时线程随时等待CPU调度执行，但未执行。 - 正在运行running：
CPU开始调度执行此线程，需要注意的是，线程running状态只能从runnable转换过来。 - 阻塞blocked：
当处于正在运行的线程因为一些情况放弃争夺CPU资源，此时就进入了阻塞状态，如果线程需要再次运行必须先转变成runnable状态。 - 死亡dead：
线程运行完成或出现异常，线程S生命周期结束。
线程安全、线程同步、线程互斥、线程通信
- 线程安全：
是指多线程执行同一份代码每次执行结果都和单线程一样。 - 线程同步：
对临界区的共享数据，A线程去操作数据，并且需要另一线程B的操作才能继续完成，这种线程之间协作的就是线程同步。 - 线程互斥：
对临界区的共享数据，两个线程都有修改情况，如果没有加锁或cas等的操作会造成数据混乱异常，这种就是线程互斥。 - 线程通信：
可以认为是线程同步的扩展，因为wait/notify必须获取了对象锁才能使用，通过wait/notify这种方式实现两个线程的等待唤醒。
线程同步的7种方式
- synchronized同步方法。如果是普通方法会锁住这个对象，如果是静态方法锁住的是整个类。
- synchronized同步代码块。
- volatile修饰变量。
- 重入锁ReenreantLock。实现了Lock接口，可重入，但效率低。
- ThreadLocal线程级别的变量共享。
- 阻塞队列LinkedBlockingQueue。主要通过synchronized的put、take实现。
- 原子变量。
线程状态转换
- 进程的基本状态
- 新建状态：创建一个线程对象
- 就绪状态：等待系统分配处理器
- 运行状态：占有处理器正在运行
- 等待状态（阻塞状态）：等待某个事件的完成
- 进程状态变化
- 新建态 -------> 就绪态 【进程创建】
- 运行态 -------> 等待态 【等待某个事件发生】
- 等待态 -------> 就绪态 【等待事件完成】
- 就绪态 -------> 运行态 【进程调度】
- 运行态 -------> 就绪态 【时间片完成】
六.IO流
IO流大致分类
以Stream结尾的为字节流，以Writer或者Reader结尾的为字符流
所有的输入流都是抽象类IuputStream或者是抽象类Reader的子类，所有的输出流都是抽象OutputStream或者是抽象类Writer的子类。字符流能实现的功能字节流都能实现，但字节流能实现的功能字符流不一定能实现。如：图片，视频等二进制文件，只能使用字节流读写。
字节流
- 输入流 InputStream
- 字节流 FileInputStream
- 字节缓冲流 BufferedInputStream
- 输出流 OutputStream
- 字节流 FileOutputStream
- 缓冲字节流 BufferedOutputStream
字符流
- 字符流 Reader
- 字符流 FileReader
- 缓冲字符流 BufferedReader
- 转换流 InputStreamReader
- 字符流 Writter
- 字符流 FileWriter
- 缓冲字符流 BufferedWriter
- 转换流 OutputStreamWriter
public static void main(String[] args) throws Exception {
InputStream in = new FileInputStream("C:\\Users\\学生29\\Desktop\\a.jpg"); //该资源的位置
OutputStream out = new FileOutputStream("E:\\a.jpg"); //到哪里去 文件名称
long begintime = System.currentTimeMillis();
int len = 0; //局部变量 没有默认的初始化值
byte[] b = new byte[1024 * 10]; //b表示缓冲区
while ((len = in.read(b)) != -1){ //read(b)输入方法
out.write(b,0,len); //write(b,0,len)输出方法
}
long endtime = System.currentTimeMillis();
long time = endtime - begintime;
System.out.println("消耗的时间为：" + time);
out.close(); //关闭流 【先开后关，后开先关】
in.close();
}
RandomAccessFile
- 这个类的实例支持对随机存放文件的读和写
- 随机访问
- 操作文件
- 既可以读又可以写
- 内部维护了用于存储数据的byte数组
- 提供了对数组操作的文件指针
- 文件指针可以通过getFilePointer方法获取，并通过seek方法设置
- InputStream有个方法read()可用于读取内容
int len = 0;
while((len = in.read()) != -1){
out.write(len);
}
- 在指定位置
- 创建一个文件
- 读取txt的内容
- 将读取的内容输出道新文件
int b = in.read();
if(b == -1){
break;
}
字节流和字符流的区别
字节流不是汉字的内容，而是字母、数字等，字符流则是汉字，(简体和繁体)；
字节流按字节读写，而字符流按字符读写；
字节流是以stream结尾，而字符流是以reader和writer结尾；
字节流采用ASCII编码，而字符流采用Unicode编码；
字节流默认不使用缓冲区，字符流使用缓冲区。
七.Jdbc
创建过程
/**
* 前提：
* 想使用jdbc连接：导入一个jar包
* |-----------mysql-connector-java-5.1.47------------|
* 1.注册驱动
* 2.通过驱动管理（DrviverManage）获取连接class.forName(url user password)
* 3.通过连接(connection)对象创建statement(陈述 声明)对象
* 4.通过statement对象执行SQL语句 execute执行
* 5.操作结果集对象ResultSet
* 6.释放资源
*/
- 增删改一个套路【比较繁琐】
//全局变量
private static String url = "jdbc:mysql://localhost:3306/bookmanage";
private static String driverClassName = "com.mysql.jdbc.Driver";
private static String username = "root";
private static String password = "root";
@Test
public void addJdbc(){
try {
Class.forName(driverClassName);
Connection con = DriverManager.getConnection(url, username, password);
Statement statement = con.createStatement();
statement.execute("insert into dept(id,name,location) values (100,'学术部','深圳')");
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Test
public void delJdbc(){
try {
Class.forName(driverClassName);
Connection con = DriverManager.getConnection(url, username, password);
Statement statement = con.createStatement();
String sql;
sql="delete from dept where id=100";
statement.execute(sql);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Test
public void editJdbc(){
try {
Class.forName(driverClassName);
Connection con = DriverManager.getConnection(url, username, password);
Statement statement = con.createStatement();
statement.execute("update dept set location='上海' where id = 33");
} catch (Exception e) {
throw new RuntimeException(e);
}
}
- 查询
@Test
public void listJdbc(){
try {
Class.forName(driverClassName);
Connection con = DriverManager.getConnection(url, username, password);
Statement statement = con.createStatement();
String sql;
sql="select * from dept";
ResultSet rs = statement.executeQuery(sql);
int id = 0;
String name = "";
String location = "";
while (rs.next()){ //处理结果集
id = rs.getInt("id");
name = rs.getString("name");
location = rs.getString("location");
System.out.println(id + " " + name + " " + location);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
或者
public void add2() throws Exception{
Class.forName(driverClassName);
Connection con = DriverManager.getConnection(url, username, password);
PreparedStatement ps = con.prepareStatement("insert into lib(id,name,price,date) values(?,?,?,?)");
ps.setInt(1,111);
ps.setString(2,"蜜汁炖鱿鱼");
ps.setDouble(3,36.9);
String date = "1999-8-8 19:52:00";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); //转换
Date d = sdf.parse(date);
long time = d.getTime();
ps.setDate(4,new java.sql.Date(time));
int rows = ps.executeUpdate();
if (rows > 0){
System.out.println("success");
}else{
System.out.println("error");
}
- 简单化
public class JdbcUtil2 {
public static void main(String[] args) {
// update("insert into category (id,name) values (221,'公关部')");
// update("delete from category where i d=?");
// update("update category set name='社会' where id=77");
query("select * from category");
}
public static Connection load(){
String driverClassName = "com.mysql.jdbc.Driver";
String url = "jdbc:mysql:///bookmanage";
String username = "root";
String password = "root";
try {
Class.forName(driverClassName);
Connection connection = DriverManager.getConnection(url, username, password);
return connection;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 增删改 用update
*/
public static void update(String sql){
Connection con = load();
try {
Statement sta = con.createStatement();
boolean execute = sta.execute(sql);
if (!execute){
System.out.println("执行成功");
}else {
System.out.println("执行失败");
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 查询 用query
*/
public static void query(String sql){
Connection con = load();
try {
PreparedStatement ps = con.prepareStatement(sql);
ResultSet resultSet = ps.executeQuery();
while (resultSet.next()){
int id = resultSet.getInt("id");
String name = resultSet.getString("name");
System.out.println(id + " " + name);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
- 疑问
/** * Statement 是编译对象 是执行sql语句的 * |-----PreparedStatement 是预编译对象 是执行sql语句的 *为什么不采用Statement? * 答：因为有可能会发生 SQL安全问题！ SQL注入 * 因此 子类PreparedStatement 解决上面的可会出现的问题，没有 SQL安全问题。所以采用它 * executeUpdate(): 增删改 使用 Update方法 --- > 对应到 QueryRunner 类中的update() * executeQuery()： 查 使用 Query方法 --- > 对应到 QueryRunner 类中的query() */
