Java基础总复习

一.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.注释

单行注释

1. // 被注释的内容
2. 快捷键：ctrl+/ 或 ctrl+shift+C

多行注释

1. /* 被注释的内容 */
2. 快捷键：ctrl+shift+/

文档注释

1. /** 被注释的文档 */
2. 快捷键：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类型

1. 一个类可以实现多个接口
2. 一个类只可以继承一个类（单继承）
3. 一个类只可以继承一个类，并且实现多个接口
4. 一个接口可以继承另一个接口
5. 一个接口可以继承多个接口
6. 一个接口不能继承类
7. 一个接口不可以实现另一个接口

关键字

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()
      直接获取值
      打印值 不能打印键

• 都需要使用迭代器

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()
   */