Java的第八周学习报告

作者：钟良堂
一：Java的异常捕获和处理
Java提供了try(尝试)、catch(捕捉)、finally(最终)这三个关键字来处理异常。在处理各种异常时，需要用到对应的异常类，指的是由程序抛出的对象所属的类。
1：异常处理的使用：
由于finally块是可以省略的，异常处理格式可以分为三类：try{ }——catch{ }、try{ }——catch{ }——finally{ }、try{ }——finally{ }。

 public static void main(String args[])
    {    
        try
        //要检查的程序语句
        {
            int a[] = new int[5];
            a[10] = 7;//出现异常
        }
        catch(ArrayIndexOutOfBoundsException ex)
        //异常发生时的处理语句
        {
            System.out.println("超出数组范围！");
        }
        finally
        //这个代码块一定会被执行
        {
            System.out.println("*****");
        }
        System.out.println("异常处理结束！");
    }
}

可以看出，在异常捕捉的过程中要进行两个判断，第一是try程序块是否有异常产生，第二是产生的异常是否和catch()括号内想要捕捉的异常相同。
那么，如果出现的异常和catch()内想要捕捉的异常不相同时怎么办呢？事实上我们可以在一个try语句后跟上多个异常处理catch语句，来处理多种不同类型的异常。

public static void main(String args[]){    
        try
        //要检查的程序语句
        {
            int a[] = new int[5];
            a[0] = 3;
            a[1] = 1;
            //a[1] = 0;//除数为0异常
            //a[10] = 7;//数组下标越界异常
            int result = a[0]/a[1];
            System.out.println(result);
        }
        catch(ArrayIndexOutOfBoundsException ex)
        //异常发生时的处理语句
        {
            System.out.println("数组越界异常");
            ex.printStackTrace();//显示异常的堆栈跟踪信息
        }
        catch(ArithmeticException ex)
        {
            System.out.println("算术运算异常");
            ex.printStackTrace();
        }
        finally
        //这个代码块一定会被执行
        {
            System.out.println("finally语句不论是否有异常都会被执行。");
        }
        System.out.println("异常处理结束！");
    }

上述例子中ex.printStackTrace();就是对异常类对象ex的使用，输出了详细的异常堆栈跟踪信息，包括异常的类型，异常发生在哪个包、哪个类、哪个方法以及异常发生的行号。
2：throws关键字
throws声明的方法表示该方法不处理异常，而由系统自动将所捕获的异常信息抛给上级调用方法。

public static void main(String[] args) {
        int[] a = new int[5];
        try
        {
            setZero(a,10);
        }
        catch(ArrayIndexOutOfBoundsException ex)
        {
            System.out.println("数组越界错误！");
            System.out.println("异常："+ex);
        }
        System.out.println("main()方法结束。");
    }
    private static void setZero(int[] a,int index) throws ArrayIndexOutOfBoundsException
    {
        a[index] = 0;
    }

throws关键字抛出异常，“ArrayIndexOutOfBoundsException”表明setZero()方法可能存在的异常类型，一旦方法出现异常，setZero()方法自己并不处理，而是将异常提交给它的上级调用者main()方法。
3：throw关键字
throw的作用是手工抛出异常类的实例化对象。

public static void main(String[] args) 
    {
        try
        {
            //抛出异常的实例化对象
            throw new ArrayIndexOutOfBoundsException("\n个性化异常信息：\n数组下标越界");
        }
        catch(ArrayIndexOutOfBoundsException ex)
        {
            System.out.println(ex);
        }
    }

运行结果：

setZero方法开始：
setZero方法结束。
异常：java.lang.ArrayIndexOutOfBoundsException: 10
main()方法结束！

我们能发现，throw好像属于没事找事，引发运行期异常，并自定义提示信息。事实上，throw通常和throws联合使用，抛出的是程序中已经产生的异常类实例。

二：多线程
1：什么是线程
几乎所有的操作系统都支持同时运行多个任务，一个任务通常就是一个程序，每个运行中的程序就是一个进程。当一个程序运行时，内部可能包含了多个顺序执行流，每个顺序执行流就是一个线程。

2：进程和线程
进程：
几乎所有的操作系统都支持进程的概念，所有运行中的任务通常对应一个进程（ Process）。当一个程序进入内存运行时，即变成一个进程。进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位。
进程特征：
独立性：进程是系统中独立存在的实体，它可以拥有自己独立的资源，每一个进程都拥有自己私有的地址空间。在没有经过进程本身允许的情况下，一个用户进程不可以直接访问其他进程的地址空间。
动态性：进程与程序的区别在于，程序只是一个静态的指令集合，而进程是一个正在系统中活动的指令集合。在进程中加入了时间的概念。进程具有自己的生命周期和各种不同的状态，这些概念在程序中都是不具备的。
并发性：多个进程可以在单个处理器上并发执行，多个进程之间不会互相影响。

线程：
线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。
线程特征：
并发：同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行。
并行：同一时刻，有多条指令在多个处理器上同时执行。

3：多线程：
多线程就是几乎同时执行多个线程（一个处理器在某一个时间点上永远都只能是一个线程！即使这个处理器是多核的，除非有多个处理器才能实现多个线程同时运行。）。几乎同时是因为实际上多线程程序中的多个线程实际上是一个线程执行一会然后其他的线程再执行，并不是很多书籍所谓的同时执行。
多线程优点：
进程之间不能共享内存，但线程之间共享内存非常容易。
系统创建进程时需要为该进程重新分配系统资源，但创建线程则代价小得多，因此使用多线程来实现多任务并发比多进程的效率高。
Java语言内置了多线程功能支持，而不是单纯地作为底层操作系统的调度方式，从而简化了Java的多线程编程。

4：多线程的创建：
（1）继承Thread类：
第一步：定义Thread类的之类，并重写run方法，该run方法的方法体就代表了线程需要执行的任务。
第二步：创建Thread类的实例。
第三步：调用线程的start()方法来启动线程。

public class FirstThread extends Thread {
     
    private int i;
    public void run() {
        for(;i<100;i++) {
            System.out.println(getName()+" "+i);
        }
    }
     
    public static void main(String[] args) {
        for(int i=0;i<100;i++) {
            //调用Thread的currentThread方法获取当前线程
            System.out.println(Thread.currentThread().getName()+" "+i);
            if(i==20) {
                new FirstThread().start();
                new FirstThread().start();
            }
        }
         
    }
 
}

（2）实现Runnable接口：
第一步：定义Runnable接口的实现类，并重写该接口的run方法，该run方法同样是线程需要执行的任务。
第二步：创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。

public class SecondThread implements Runnable {
     
    private int i;
 
    @Override
    public void run() {
        for(;i<100;i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }
     
    public static void main(String[] args) {
        for(int i=0;i<100;i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
            if(i==20) {
                SecondThread s1=new SecondThread();
                new Thread(s1,"新线程1").start();;
                new Thread(s1,"新线程2").start();
            }
        }
    }
     
}

（3）使用Callable和Future创建线程
细心的读者会发现，上面创建线程的两种方法。继承Thread和实现Runnable接口中的run都是没有返回值的。于是从Java5开始，Java提供了Callable接口，该接口是Runnable接口的增强版。Callable接口提供了一个call()方法可以作为线程执行体，但call()方法比run()方法功能更强大。
创建并启动有返回值的线程的步骤如下：
第一步：创建 Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，且该call()方法有返回值，再创建 Callable实现类的实例。从Java8开始，可以直接使用 Lambda表达式创建 Callable对象。
第二步：使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call方法的返回值。
第三步：使用FutureTask对象作为Thread对象的target创建并启动新线程。
第四步：通过FutureTask的get()方法获得子线程执行结束后的返回值。

public class ThirdThread {
     
    public static void main(String[] args) {
        //ThirdThread rt=new ThirdThread();
        FutureTask<Integer> task=new FutureTask<Integer>((Callable<Integer>)()->{
            int i=0;
            for(;i<100;i++) {
                System.out.println(Thread.currentThread().getName()+"的循环变量i"+i);
            }
            return i;
        }) ;
         
        for(int i=0;i<100;i++) {
            System.out.println(Thread.currentThread().getName()+"的循环变量i为"+i);
            if(i==20) {
                new Thread(task,"有返回值的线程").start();;
            }
        }
        try {
            System.out.println("子线程的返回值"+task.get());
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
 
}

采用继承 Thread类的方式创建多线程的优缺点：
优点
编写简单，如果需要访问当前线程，则无须使用 Thread.current Thread()方法，直接使用this即可获得当前线程。
缺点：
因为线程已经继承了Thread类，所以不能再继承其他类。

采用Runnable、Callable接口的方式创建多线程的优缺点：
优点：
1、线程类只是实现了 Runnable接口或 Callable接口，还可以继承其他类
2、在这种方式下，多个线程可以共享同一个 target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
缺点：
编程稍稍复杂，如果需要访问当前线程，则必须使用Thread.currentThread()方法。

新建和就绪状态：
当程序使用new关键字创建一个线程后，该线程就处于新建状态。
当线程对象调用了start()方法后，该线程就处于就绪状态。

运行和阻塞状态：
如果处于就绪状态的线程获取了CPU，开始执行run()方法的线程执行体，则该线程处于运行状态。
当线程调用sleep()，调用一个阻塞式IO方法，线程会被阻塞

死亡状态：
1、run()或者call()方法执行完成，线程正常结束
2、线程抛出一个未捕获的Exception或Error
3、直接调用该线程的stop方法来结束该线程——该方法容易导致死锁，不推荐使用

5：控制线程
（1）join线程
Thread提供了让一个线程等待另一个线程完成的方法——join方法。当在某个程序执行流中调用其直到被 join方法加入的join线程执行完为止。

 public class JoinThread extends Thread {
     
    //提供一个有参数的构造器，用于设置该线程的名字
    public JoinThread(String name) {
        super(name);
    }
     
    //重写run方法，定义线程体
    public void run() {
        for(int i=0;i<10;i++) {
            System.out.println(getName()+" "+i);
        }
    }
     
    public static void main(String[] args) throws InterruptedException {
        //启动子线程
        new JoinThread("新线程").start();
        for(int i=0;i<10;i++) {
            if(i==5) {
                JoinThread jt=new JoinThread("被join的线程");
                jt.start();
                //main线程调用了jt线程的join方法，main线程
                //必须等jt执行结束才会向下执行
                jt.join();
            }
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }
}

运行结果：

main 0
main 1
main 2
main 3
main 4
新线程 0
新线程 1
新线程 2
新线程 3
被join的线程 0
新线程 4
被join的线程 1
新线程 5
被join的线程 2
新线程 6
被join的线程 3
新线程 7
被join的线程 4
新线程 8
被join的线程 5
新线程 9
被join的线程 6
被join的线程 7
被join的线程 8
被join的线程 9
main 5
main 6
main 7
main 8
main 9

（2）后台线程：
有一种线程，它是在后台运行的，它的任务是为其他的线程提供服务，这种线程被称为“后台线程（ Daemon Thread）”，又称为“守护线程”或“精灵线程”。JVM的垃圾回收线程就是典型的后台线程。
后台线程有个特征：如果所有的前台线程都死亡，后台线程会自动死亡。
调用 Thread对象的 setDaemon(true)方法可将指定线程设置成后台线程。下面程序将执行线程设置成后台线程，可以看到当所有的前台线程死亡时，后台线程随之死亡。当整个虚拟机中只剩下后台线程时，程序就没有继续运行的必要了，所以虚拟机也就退出了。

public class DaemonThread extends Thread {
    //定义后台线程的线程体与普通线程没有什么区别
    public void run() {
        for(int i=0;i<1000;i++) {
            System.out.println(getName()+" "+i);
        }
    }
     
    public static void main(String[] args) {
        DaemonThread t=new DaemonThread();
        //将此线程设置为后台线程
        t.setDaemon(true);
        t.start();
        for(int i=0;i<10;i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
        //程序到此执行结束，前台线程(main)结束，后台线程也随之结束
    }
}

运行结果：

main 0
Thread-0 0
main 1
Thread-0 1
Thread-0 2
main 2
Thread-0 3
Thread-0 4
Thread-0 5
main 3
main 4
Thread-0 6
main 5
Thread-0 7
Thread-0 8
main 6
main 7
main 8
Thread-0 9
main 9
Thread-0 10
Thread-0 11
Thread-0 12
Thread-0 13
Thread-0 14
Thread-0 15
Thread-0 16
Thread-0 17
Thread-0 18
Thread-0 19
Thread-0 20
Thread-0 21

（3）线程睡眠：
如果需要让当前正在执行的线程暂停一段时间，并进入阻塞状态，则可以通过调用 Thread类的静态 sleep方法来实现。 sleep方法有两种重载形式。
static void sleep(long millis)：让当前正在执行的线程暂停millis毫秒，并进入阻塞状态。
static void sleep(long millis,int nanos)：让当前正在执行的线程暂停millis毫秒加上nanos毫微秒，并进入阻塞状态，通常我们不会精确到毫微秒，所以该方法不常用。

public class SleepTest {
    public static void main(String[] args) throws InterruptedException {
        for(int i=0;i<10;i++) {
            System.out.println("当前时间"+new Date());
            Thread.sleep(1000);
        }
    }
}

（4）、改变线程优先级：
每个线程执行时都有一定的优先级，优先级高的线程获得较多的执行机会，优先级低的线程则获得较少的执行机会。
每个线程默认的优先级都与创建它的父线程的优先级相同，在默认情况下，main线程具有普通优先级，由main线程创建的子线程也具有普通优先级。
Thread类提供了 setPriority（int newPriority）、 getPriority()方法来设置和返回指定线程的优先级，其中 setPriority()方法的参数可以是一个整数，范围是1-10之间，也可以使用 Thread类的如下三个静态常量
MAX_PRIORITY：其值是10
MIN_PRIORITY：其值时1
NORM_PRIPRITY：其值是5
public class PriorityTest extends Thread {

    //定义一个构造器，用于创建线程时传入线程的名称
    public PriorityTest(String name) {
        super(name);
    }
     
    public void run() {
        for(int i=0;i<50;i++) {
            System.out.println(getName()+",其优先级是："+getPriority()+"循环变量的值："+i);
        }
    }
     
    public static void main(String[] args) {
        //改变主线程的优先级
        Thread.currentThread().setPriority(6);
        for(int i=0;i<30;i++) {
            if(i==10) {
                PriorityTest low=new PriorityTest("低级");
                low.start();
                System.out.println("创建之初的优先级："+low.getPriority());
                //设置该线程为最低优先级
                low.setPriority(Thread.MIN_PRIORITY);
            }
            if(i==20) {
                PriorityTest high=new PriorityTest("高级");
                high.start();
                System.out.println("创建之初的优先级"+high.getPriority());
                high.setPriority(Thread.MAX_PRIORITY);
            }
        }
    }
}

三：MySQL数据库
1.数据库数据类型
Java数据类型: 8大基本数据类型:byte short int long double float char boolean String date

2.Mysql对应的数据类型
主要包括以下五大类：
整数类型：BIT、BOOL、TINY INT、SMALL INT、MEDIUM INT、 INT、 BIG INT
浮点数类型：FLOAT、DOUBLE、DECIMAL
字符串类型：CHAR、VARCHAR、TINY TEXT、TEXT、MEDIUM TEXT、LONGTEXT、TINY BLOB、BLOB、MEDIUM BLOB、LONG BLOB
日期类型：Date、DateTime、TimeStamp、Time、Year
其他数据类型：BINARY、VARBINARY、ENUM、SET、Geometry、Point、MultiPoint、LineString、MultiLineString、Polygon、GeometryCollection等
(1)整型
tinyint(m) 1个字节 范围(-128~127)
smallint(m) 2个字节 范围(-32768~32767)
mediumint(m) 3个字节 范围(-8388608~8388607)
int(m) 4个字节 范围(-2147483648~2147483647)
bigint(m) 8个字节 范围(±9.22*10的18次方)
取值范围如果加了unsigned，则最大值翻倍，如tinyint unsigned的取值范围为(0~256)。
int(m)里的m是表示SELECT查询结果集中的显示宽度，并不影响实际的取值范围，没有影响到显示的宽度，不知道这个m有什么用。

2)浮点型(float和double)
float(m,d) 单精度浮点型 8位精度(4字节) m总个数，d小数位
double(m,d) 双精度浮点型 16位精度(8字节) m总个数，d小数位
设一个字段定义为float(6,3)，如果插入一个数123.45678,实际数据库里存的是123.457，但总个数还以实际为准，即6位。整数部分最大是3位，如果插入数12.123456，存储的是12.1234，如果插入12.12，存储的是12.1200.

(3)定点数
浮点型在数据库中存放的是近似值，而定点类型在数据库中存放的是精确值。
decimal(m,d) 参数m<65 是总个数，d<30且 d<m 是小数位。

(4)字符串(char,varchar,_text)
char(n) 固定长度，最多255个字符
varchar(n) 固定长度，最多65535个字符
tinytext 可变长度，最多255个字符
text 可变长度，最多65535个字符
mediumtext 可变长度，最多2的24次方-1个字符
longtext 可变长度，最多2的32次方-1个字符
char和varchar的区别：
1.char(n) 若存入字符数小于n，则以空格补于其后，查询之时再将空格去掉。所以char类型存储的字符串末尾不能有空格，varchar不限于此。
2.char(n) 固定长度，char(4)不管是存入几个字符，都将占用4个字节，varchar是存入的实际字符数+1个字节（n<=255）或2个字节(n>255)，
所以varchar(4),存入3个字符将占用4个字节。
3.char类型的字符串检索速度要比varchar类型的快。

varchar和text的区别：
1.varchar可指定n，text不能指定，内部存储varchar是存入的实际字符数+1个字节（n<=255）或2个字节(n>255)，text是实际字符数+2个字
节。
2.text类型不能有默认值。
3.varchar可直接创建索引，text创建索引要指定前多少个字符。varchar查询速度快于text,在都创建索引的情况下，text的索引似乎不起作用。

（5）二进制数据(_Blob)
1._BLOB和_text存储方式不同，_TEXT以文本方式存储，英文存储区分大小写，而_Blob是以二进制方式存储，不分大小写。
2._BLOB存储的数据只能整体读出。
3._TEXT可以指定字符集，_BLO不用指定字符集。

（6）日期时间类型
date 日期 ‘2020-3-5’
time 时间 ‘12:25:36’
datetime 日期时间 ‘2020-3-5 12:25:36’
timestamp 自动存储记录修改时间
若定义一个字段为timestamp，这个字段里的时间数据会随其他字段修改的时候自动刷新，所以这个数据类型的字段可以存放这条记录最后被修改的时间。

（7）数据类型的属性
NULL 数据列可包含NULL值
NOT NULL 数据列不允许包含NULL值
DEFAULT 默认值
PRIMARY KEY 主键
AUTO_INCREMENT 自动递增，适用于整数类型
UNSIGNED 无符号
CHARACTER SET name 指定一个字符集

3：表格的列定义了几个重要的约束
每一个表格中不允许出现2条完全相同的记录（或行）
可以给某个字段id建立一个 主键约束(primary key) 一般查询用户 是根据id查询 自动创建索引(主键索引)
唯一约束 unique 对应的列 都是独一无二的 可以有一个空值
检查约束 check 设置列的取值范围 性别(男，女) 年龄(1-100)
非空约束 not null 列值不允许为空 密码? 性别 ?
自动增长列 Auto_increment id自增 (不想人为插入数据 数据库帮我们自动插入填充)

4：数据库操作
数据库：创建、删除

-- 通过代码创建的数据库称之为  用户数据库
-- 1.创建用户数据库语句  CREATE DATABASE  自定义库名;
CREATE DATABASE StudentDB;
-- 定义字符编码
CHARACTER SET utf8 COLLATE utf8_unicode_ci;
 
-- 2.设置当前使用的数据库
-- 创表的时候 默认保存在  当前正在使用的数据库中
USE StudentDB;
 
-- 3.删除数据库  数据库存在 删除存在的数据库
DROP DATABASE IF EXISTS  StudentTestDB;

创建表格

-- 学生表   
-- 编号   学生姓名      学生密码          学生性别    学生年级      学生的成绩
-- int   varchar(20)   varchar(20)     varchar(10)     int              double

CREATE TABLE Student(
id INT AUTO_INCREMENT PRIMARY KEY,
stuName VARCHAR(20) UNIQUE NOT NULL,
stuPass VARCHAR(20) DEFAULT '123' NOT NULL, -- 当不手动插入密码的时候 会给定默认值
stuSex VARCHAR(10) CHECK(stuSex='男' OR stuSex='女'), -- 检查约束
gradeId INT ,
score DOUBLE  -- 最后一个字段后面不能加逗号   没加 not null 就默认允许为空
);
 
-- 创建年级表   编号 年级名称
CREATE TABLE grade(
id INT AUTO_INCREMENT PRIMARY KEY,
gradeName VARCHAR(10) NOT NULL
);

插入数据
– 往表格中插入数据 grade():自动增长列 /默认值/ 允许为空的数值 可以不写

INSERT INTO grade(gradeName) VALUES('大一');
INSERT INTO grade(gradeName) VALUES('大二');
INSERT INTO grade(gradeName) VALUES('大三');
INSERT INTO grade(gradeName) VALUES('大四');
 
-- 插入数据Student   字段与值得顺序必须一一对应
INSERT INTO Student(stuName,stuSex,gradeId,score)
VALUES('charles','男',1,88);
 
INSERT INTO Student(stuName,stuSex,gradeId,score)
VALUES('jack','男',1,68);
 
INSERT INTO Student(stuName,stuSex,gradeId,score)
VALUES('Tina','女',2,78);
 
INSERT INTO Student(stuName,stuSex,gradeId,score)
VALUES('rouse','女',2,58);
 
INSERT INTO Student(stuName,stuSex,gradeId,score)
VALUES('marry','女',3,98);
 
INSERT INTO Student(stuName,stuSex,gradeId,score)
VALUES('tomorrow','男',4,88);
 
INSERT INTO Student(stuName,stuSex,gradeId)
VALUES('quekezhe','男',4);
 
INSERT INTO Student(stuName,stuSex,gradeId)
VALUES('reduce','男',4); -- 8
 
 
INSERT INTO Student(stuName,stuSex,gradeId)
VALUES('reduce1','男',4); -- 8

查询数据：

-- 1.查询表格中所有的数据  *(代表所有列的意思)
SELECT * FROM student; -- 表名
SELECT * FROM grade; -- 表名
 
-- 2. 查询表格中的部分字段
SELECT stuName,stuPass,score  FROM student;
 
-- 逻辑连接词  or 或者(java ||)  and(java &&)  not(!)
 
-- 3.查询及格的学生信息  WHERE：根据什么条件查询
SELECT * FROM student WHERE score>=60;
 
-- 4.查询 所有及格的女学生
SELECT * FROM student WHERE score>=60 AND stuSex='女';
 
-- 5.id =1 id=2 id=3的学员信息查询出来
SELECT * FROM student WHERE id=1 OR id=2 OR id=3; 
SELECT * FROM student WHERE id>=1 AND id<=3;  -- 连续的可以考虑使用
SELECT * FROM student WHERE id BETWEEN 1 AND 3;   -- 连续的可以考虑使用
 
-- 6.id=1 id=3 id=5 的学员信息查询出来
SELECT * FROM student WHERE id=1 OR id=3 OR id=5;
SELECT * FROM student WHERE id IN(1,3,5); -- in 包含
 
-- 7.查询缺考的学生信息  score IS NULL 分数为空
SELECT * FROM student WHERE score IS NULL;
-- 8.查询没有缺考的学生信息 
SELECT * FROM student WHERE score IS NOT NULL;

修改数据

--修改表格数据
UPDATE student SET stuPass='1234',stuSex='女' WHERE id=2 ;-- 不写where条件默认修改全部

删除数据

-- 2.删除
DELETE FROM student WHERE id=9;-- 不加where条件 默认删除全部

截断数据

-- id会重置
TRUNCATE  student;

删除表格
删除表格之后添加信息，id不会重置

DELETE FROM student ;  -- id不会重置

数据排序

-- 1. 从小到大 参加考试的学生根据成绩顺序排名
SELECT * FROM student WHERE score IS NOT NULL ORDER BY score ASC; -- asc 顺序
 
-- 2.从大到小 参加考试的学生根据成绩倒序排名
SELECT * FROM student WHERE score IS NOT NULL ORDER BY score DESC; -- desc 倒序

聚合数据

-- 聚合函数: 计算平均分 avg() / 总分sum() /最高分max()  /最低分min()
-- 统计 表格中总的记录数 count()
 
SELECT AVG(score),SUM(score),MAX(score),MIN(score),COUNT(*)
FROM student;
 
SELECT  
AVG(score) AS '平均分',
SUM(score) AS '总分',
MAX(score) AS '最高分',
MIN(score) AS '最低分',
COUNT(*) AS '总人数'
FROM student;
 
-- 也适用于  简单表查询
SELECT stuName AS '学生姓名' ,stuPass AS '学生密码' FROM student;