面向对象, 常用类, 集合, 异常, JDBC, mysql数据库复习

最新推荐文章于 2024-09-12 01:15:37 发布

垒咚一夏

最新推荐文章于 2024-09-12 01:15:37 发布

阅读量602

点赞数 30

文章标签： mysql 数据库

本文链接：https://blog.csdn.net/2301_78875117/article/details/140044441

版权

1.面向对象

（1）面向过程和面向对象

● 面向过程的程序设计思想 （procedure -Oriented Programming)，简称POP

● 关注的焦点是过程：过程就是操作数据的步骤。如果某个过程的实现代码重复出

现，那么就可以把这个过程抽取为一个函数。这样就可以大大简化冗余代码，便

于维护。

● 典型的语言：C语言

● 代码结构：以函数为组织单位。

● 是一种“执行者思维” ，适合解决简单问题。

分析出解决问题所需要的步骤，然后把步骤一步一步实现。

扩展能力差、后期维护难度较大。

● 面向对象的程序设计思想 （ Object Oriented Programming），简称OOP

● 关注的焦点是类：在计算机程序设计过程中，参照现实中事物，将事物的属性特

征、行为特征抽象出来，用类来表示。

● 典型的语言：Java、C#、C++、Python、Ruby和PHP等

● 代码结构：以类为组织单位。每种事物都具备自己的 属性和行为/功能 。

● 是一种 设计者思维 ，适合解决复杂问题。代码扩展性强、可维护性高。

（2）类和对象

1. 类(Class)和对象(Object)是面向对象的核心概念

● 什么是类？

类：具有相同特征的事物的抽象描述，是抽象的、概念上的定义。

● 什么是对象

对象：实际存在的该类事物的每个个体，是具体的，因而也称为实例。

2.类的结构

• 变量：事物属性的描述(名词)

• 方法:事物的行为（可以做的事情动词）

• 构造方法：初始化对象

• 块：一段没有名称的代码块

• 内部类：即在类体中声明的类

3.创建并使用对象

对象：是类的一个实例，是以类为模板在内存中创建的实际存在的实例。

对象的创建和使用

Car bm= new Car();

Car bm :使用Car类作为类型声明一个变量 bm .

new Car() :使用new 创建对象,然后调用Car类的构造方法初始化对象.

= : 将右边创建的对象地址赋给左边的 bm 变量

同一类的每个对象有不同存储空间。

对象是类的一个实例，必然具备该类事物的属性和行为（即方法）。

使用对象名.属性或对象名.方法的方式访问对象成员（包括属性和方法）

4.总结类和对象

类是一类事物的抽象概念,是一个模型.

对象是由这个模型所创造的,一个个具体存在的,实实在在存在的实例.

所以创建对象的过程也叫实例化对象.

现实生活中先有对象后有类,而编程时先设计类后创建对象。

（3）构造方法

作用: 在构造方法中为创建的对象成员变量初始化赋值

特点: 每个类都有构造方法,如果没有显式地为类定义构造方法，Java将会为该类提供一个默

认无参构造方法,但是只要在一个Java类中定义了一个有参构造方法后，默认的无参构造方法

会失效。

一个类可以有多个构造方法。

例： public class Car{

public Car(){ }

public Car(String name){ // 这个构造方法有一个参数：name }

}

例：创建Car类的对象

Car car1 = new Car();

Car car2 = new Car(“宝马”)

（4）方法重载

l 方法的重载是指一个类中具有相同的名字，但参数不同的多个方法。

l 参数不同（可以有三方面的不同）

• 数量不同

• 类型不同

• 顺序不同

l 调用时，会根据不同的参数表选择对应的方法。

注意：方法重载跟方法的返回值类型没有任何关系

（5）对象与引用

Java 语言中除基本类型之外的变量类型都称之为引用类型。

Java中的对象是通过引用对其操作的.

例如：我们有一个自定义类为 Car （汽车类）

class Car{

String name;

1 ）右边的“ new Car()” ，是以 Car 类为模板 , 在堆空间里创建一个 Car 类对象。

2 ）左边的“ Car bm” 创建了一个 Car 类型引用变量。所谓 Car 类的引用，就是以后可以用来指

向 Car 对象的对象引用。

3 ） ”=” 操作符使对象引用指向刚创建的那个 Car 对象。

我们可以把这条语句拆成两部分：

Car bm;

bm= new Car();

这样写，就比较清楚了，有两个实体：一个是对象引用变量，一个是对象本身。

new Car(); 这个语句在堆空间里创建了实体，尽管它们也是确确实实存在的实体，但是，

我们看不见，也摸不着。

对象没有名字，也就没法直接访问它。我们需要通过对象引用来间接访问对象。

对象好比是一只很大的气球，但是我们抓不住它。引用变量是一根绳，可以用来系汽球。

Car car1; （ 1 ）创建一根绳子，一根还没有系上任何一个汽球的绳；

Car car2; （ 2 ）又做了一根绳，还没系上汽球，

car1 = new Car(); （ 3 ）给 car1 系上气球；

car2 = car1 ；（ 4 ）这里，发生了复制行为。要说明的是，对象本身并没有被复制，被复

制的只是对象引用。

结果是， car2 也指向了 car1 所指向的对象。两根绳系的是同一只汽球。

String color;

float price;

}

Car bm= new Car();

通常把这条语句的动作称之为创建一个对象，其实，它包含了三个动作。

（6）访问权限修饰符

三大特征：
1. 封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式，提高安全性。
2. 继承：提高代码复用性，是实现多态的前提。
3. 多态：父类或接口定义的引用变量指向子类或具体实现类的实例对象，提高了代码的拓展性。

Java语言有四个权限访问修饰符，权限从大到小依次为：

1）public ：公共权限修饰类、属性、方法。可以在任意类中访问

2）protected：受保护的权限修饰属性、方法。可以在同包类访问，如果

不是同包类，必须是该类的子类才可以访问。

3）default：同包权限修饰类、属性、方法。只能在同包的类访问

4）private：私有权限修饰属性、方法。只能在本类中访问

封装

继承

子承父类，父类通用，子类更具体

继承代码实现

1 /**
2 * 1. 将类中重复的部分提取成为父类
3 */
4 public class Animal {
5 private String name;
6 private String food;
7
8 public Animal(String name, String food) {
9 this.name = name;
10 this.food = food;
11 }
12
13 public void eat() {
14 System.out.println(name + "正在吃" + food);
15 }
16 }
17
18 /**
19 * 2. 子类继承父类，对父类进行扩展
20 */
21 public class Cat extends Animal {
22
23 public Cat(String name, String food) {
24 super(name, food);
25 }
26 }
27 public class Dog extends Animal{
28
29 public Dog(String name, String food) {
30 super(name, food);
31 }
32 }
33
34 /**
35 * 3. 测试
36 */
37 public class TestExtends{
38 public static void main(String[] args) {
39 Animal cat = new Cat("三三", "鱼");
40 cat.eat();
41 Animal dog = new Dog("二哈", "香肠");
42 cat.eat();
43 }
44 }

多态

1、核心：提高代码的的维护性和可扩展性

2、实现多态的三个必要条件：继承、重写、父类引用指向子类对象（向上转型）

3、多态的实现方法：重写、接口、抽象类和抽象方法

多态代码实现

1 /**
2 * 1. 创建动物类，定义动物吃什么的方法
3 */
4 class Animals {
5 private String name;
6 private String food;
7
8 public Animals(String name, String food) {
9 super();
10 this.name = name;
11 this.food = food;
12 }
13
14 public void eat() {
15 System.out.println(this.name + "会吃" + this.food);
16 }
17 }
18
20 /**
21 * 2. 创建Cat类来实现吃的功能
22 */
23 class Cat extends Animals{
24 public Cat(String name, String food) {
25 super(name, food);
26 }
27
28 @Override
29 public void eat() {
30 super.eat();
31 }
32 }
33
35 /**
36 * 3. 通过向上转型和向下转型实现多态
37 */
38 public class Test01 {
39 public static void main(String[] args) {
40 // 向下转型
41 Animals animals = new Cat("三三", "鱼");
42 animals.eat();
43 // 向上转型
44 Cat cat = (Cat) animals;
45 cat.eat();
46 }
47 }

（7）抽象类

核心思想：让代码有更强的可扩展性

特点

抽象类不能实例化对象。
如果一个类包含抽象方法，那么该类必须是抽象类
任何子类必须重写父类的抽象方法(具体实现)，或者声明自身为抽象类
抽象类中的抽象方法只有方法声明，没有方法体
构造方法和static修饰的方法不能声明为抽象方法
代码实现
1 /**
2 * 1. 创建员工抽象类
3 */
4 abstract class Employees {
5 // 成员变量
6 private String name;
7 private String address;
8 private Integer number;
9
10 // 构造方法
11 public Employees(String name, String address, Integer number) {
12 System.out.println("Employees.Employees()");
13 this.name = name;
14 this.address = address;
15 this.number = number;
16 }
17
18 // 定义信息抽象函数
19 public abstract void call();
20
21 // 省略getter 和 setter方法
22 ......
23 }
24 }
25
26 class Salary extends Employees {
27 private Double salary;
28
29 public Salary(String name, String address, Integer number, Double salary) {
30 super(name, address, number);
31 this.salary = salary;
32 System.out.println("Salary.Salary()");
33 }
34
35 // 2. 重写父类的抽象方法
36 @Override
37 public void call() {
38 System.out.println(super.getNumber() + "是" + super.getName() + "的电话，他住在" +
39 super.getAddress() + "他现在的工资是" + this.salary);
40 }
41 }
42
43 public class Test {
44 public static void main(String[] args) {
45 // 3. 抽象类的对象必须由子类去实例化
46 Employees emp = new Salary("孙悟空", "花果山", 1234, 222.66);
47 emp.call();
48 }
49 }

（8）接口

特点：

接口不能实例化对象，没有构造方法
接口中的方法只能是抽象方法，默认使用public abstract修饰
接口中的变量只能是常量，默认使用public static final修饰
接口支持多继承，但接口不是被继承了，而是被实现了
接口和抽象类的区别

接口中的方法只能是抽象方法，而抽象类中的方法可以是普通方法，构造方法和抽象方法
接口中的变量只能是常量，而抽象类中的方法可以是任意类型
接口中不能含有静态代码块和静态方法，而抽象类中可以有
一个类可以实现多个接口，但一个类只能继承一个抽象类
1 /**
2 * 1. 创建Animal接口
3 */
4 interface Animal {
5 // 定义睡觉抽象方法
6 void sleep();
7
8 // 定义吃饭抽象方法
9 void eat();
10 }
11
12 /**
13 * 2. 创建Dog接口继承Animal接口
14 */
15 interface Dog extends Animal {
16 // 定义游泳抽象方法
17 void swim();
18 }
19
20 /**
21 * 3. 创建HaShiQi接口继承Dog和Animal接口，实现多继承
22 */
23 interface HaShiQi extends Dog, Animal {
24 // 定义拆家抽象方法
25 void demolishedFamily();
26 }
27
28 /**
29 * 4. 创建测试类来实现接口，并且复写所有抽象方法
30 */
31 public class TestAnimal implements HaShiQi {
32
33 @Override
34 public void swim() {
35 System.out.println("哈士奇会游泳");
36 }
37
38 @Override
39 public void sleep() {
40 System.out.println("哈士奇会睡觉");
41 }
42
43 @Override
44 public void eat() {
45 System.out.println("哈士奇喜欢吃苦瓜");
46 }
47
48 @Override
49 public void demolishedFamily() {
50 System.out.println("哈士奇会拆家");
51 }
52
53 public static void main(String[] args) {
54 // 使用多态实例化对象
55 HaShiQi dog = new TestAnimal();
56 dog.eat();
57 dog.sleep();
58 dog.demolishedFamily();
59 dog.swim();
60 }
61 }

2.常用类（API）

1、Java API

是对Java预先定义的类或接口功能和函数功能的说明文档，目的是提供给开发人员进行使用帮助说明。

2、Object类

根基类，每个类都使用Object作为超类（父类），所以对象都继承实现了这个类的方法

equals方法，在Object中默认使用==比较，比较的是对象地址，然而在其他类中，对equals方法进行了重写，调用这个方法 x.equals(y) 判断x和y的内容是否相等，而不是比较地址

3、Arrays类

是操作数组工具类，里面定义了常见数组的静态方法

在文章上面有一个Arrays类的代码展示，可以进行翻阅查看，这里就不再重复书写😂😂😂😂

4、基本数据类型分装类

自动装箱：基本类型自动转换为包装类型

自动拆箱：包装类型自动转换为基本类型

5、String类

● 构造方法
public String()
public String(String str)
public String(byte[] bytes)
public String(char[] value)

● 判断功能
boolean equals(Object obj)
boolean equalsIgnoreCase(String str)
boolean contains(String str)
boolean isEmpty()
boolean startsWith(String prefix)
boolean endsWith(String suffix)

●获取功能
int length()
char charAt(int index)
int indexOf(String str)
int indexOf(String str,int fromIndex)
String substring(int start)
String substring(int start,int end)

● 转换功能
byte[] getBytes()
char[] toCharArray()
static String valueOf(char[] chs)
String toLowerCase()
String toUpperCase()
String concat(String str)
Stirng[] split(分割符)

● 替换功能
String replace(char old,char new)
String replace(String old,String new)
replaceAll(String regex, String replacement)
replaceFirst(String regex, String replacement)
● 去除字符串两空格
String trim()

6、StringBuffer类和StringBuilder类

● 添加功能
public StringBuffer append(String str)
public StringBuffer insert(int offset,String str)
● 删除功能
public StringBuffer deleteCharAt(int index)
public StringBuffer delete(int start,int end)
● 替换功能
public StringBuffer replace(int start,int end,String str)
● 反转功能
public StringBuffer reverse()
● 截取功能
public String substring(int start)
public String substring(int start,int end)
● 截取功能和前面几个功能的不同
返回值类型是String类型，本身没有发生改变
● StringBuilder类功能和StringBuffer功能完全一致, StringBuffer是线程
安全的

三者的区别：

String：是字符常量,适用于少量的字符串操作的情况

StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况

StringBuffer ：适用多线程下在字符缓冲区进行大量操作的情况

7、Math类

数学类，常用的数学方法

package com.ffyc.javaapl.Mathdemo;

public class Math1 {
public static void main(String[] args) {
System.out.println(Math.abs(-1));//Math.abs()求求绝对值
System.out.println(Math.sqrt(9.0));//Math.sqrt()开方
System.out.println(Math.max(5,2));//求最大值
System.out.println(Math.floor(9.9));//向下取整9.0
System.out.println(Math.ceil(9.1));//向下取整10.0
System.out.println(Math.round(9.1));//9
System.out.println(Math.round(9.5));//Math.round()四舍五入取整 10
System.out.println(Math.random());//在0-1之间随机数，0<=random<1
System.out.println(Math.pow(2,3));//pow(double a, double b) a^b 8 幂次方
}
}

8、Random类

产生随机数

代码实现

import java.util.Random;

public class Random1 {
public static void main(String[] args) {
Random random=new Random();
System.out.println(random.nextBoolean());//随机产生一个boolean值
System.out.println(random.nextInt());//在int型范围内产生一个随机值
System.out.println(random.nextInt(3));//在0-2内产生一个随机值
}
}

9、Date类/Calender类/SimpleDateFormat类

Date类代表当前系统时间

Date类代码实现

import java.util.Date;

public class Datedemo1 {
public static void main(String[] args) {
Date date=new Date();//创建一个date对象，程序运行是会将当前时刻存入
System.out.println(date);
System.out.println(date.getYear()+1900);//return normalize().getYear() - 1900;
System.out.println(date.getMonth()+1);// return normalize().getMonth() - 1
System.out.println(date.getDate());//
System.out.println(date.getTime());//时间戳，自1970 1.1 0：0：0到程序运行时刻的毫秒值 1708844950270
Date date2=new Date(1708844950270L);
System.out.println(date2);//new Date(long date),传入一个毫秒值，返回一个时刻
}
}
Calender类是一个抽象类，在实际使用时实现特定的子类对象。创建对象过程对程序员来说是透明的，只需要使用getInstance方法创建

Calender类代码实现

import java.util.Calendar;

public class Calenderdemo1 {
public static void main(String[] args) {
Calendar calendar=Calendar.getInstance();//getInstance子类
// System.out.println(calendar);

System.out.println(calendar.get(Calendar.YEAR));//获取年份
System.out.println(calendar.get(Calendar.MONTH)+1);//获取月份
System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
System.out.println(calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH));

}
}

SimpDateFormat类

日期格式化类

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class SimpleDateFormdemo1 {
public static void main(String[] args) throws ParseException {
//把字符串日期转换为date对象
String s="2024-2-29 12:12:12 星期三";
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-mm-dd HH:mm:ss E");
Date date=sdf.parse(s);
System.out.println(date);
// 把date对象转换为字符串日期
Date date1=new Date();
SimpleDateFormat sdf1=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E");
String s1=sdf1.format(date1);
System.out.println(s1);

}
}

10、BigInteger类/BigDecimal类

BigInteger类型的数字范围较Integer，Long类型的数字范围要大得多，它支持任意精度的整数，也就是说在运算中 BigInteger 类型可以准确地表示任何大小的整数值而不会丢失任何信息

import java.math.BigDecimal;
import java.math.BigInteger;

public class BigIntergedemo1 {
public static void main(String[] args) {
BigInteger a1=new BigInteger("11111111111111111111111111111111");
BigInteger a2=new BigInteger("99999999999999999999999999999999");
BigInteger a3=a1.add(a2);
BigInteger a4=a1.multiply(a2);
System.out.println(a1);
System.out.println(a2);
System.out.println(a3);
System.out.println(a4);
}
}
BigDecimal类

比double 和folat精确度要高得多

import java.math.BigDecimal;
import java.math.RoundingMode;

public class BigDecimaldemo1 {
public static void main(String[] args) {
BigDecimal a1=new BigDecimal("0.3");
BigDecimal a2=new BigDecimal("0.1");
System.out.println(a1.add(a2));
BigDecimal a3=new BigDecimal("10");
BigDecimal a4=new BigDecimal("3");
System.out.println(a3.divide(a4,2, RoundingMode.HALF_UP));//a3/a4，a4是除数，scale是保留小数的位数，RoundingMode是舍入模式

}
}

3.集合

1.分类及功能

2.Collectiong接口常用的方法

addAl l(Col lection<? super T> c, T... elements);

binarySearch(List<? extends Comparable<? super T>> l ist, T key)

sort(List<T> l ist)

sort(List<T> l ist, Comparator<? super T> c)

swap(List<?> l ist, int i, int j)

copy(List<? super T> dest, List<? extends T> src) ; 注意 dest size 需大于等于 src.size

fi l l(List<? super T> l ist, T obj)

max(Col lection<? extends T> col l)

min(Col lection<? extends T> col l)

replaceAl l(List<T> l ist, T oldVal, T newVal)

reverse(List<?> l ist)

shuffle(List<?> l ist) 随机排序

copy(dest,src) 集合复制

4.IO

一、简介

流的概念：流是有起点和终点的一组有顺序的字节集合，作用是进行数据传输

流的分类

按照数据流向不同可以分为输入输出流；
按照处理数据单位不同可以分为字节流和字符流
输入流和输出流的作用

输入流：程序从数据源读取数据
输出流：将数据从程序中写入指定文件
字节流和字符流的作用

字节流：以字节为单位处理所有类型数据
字符流：以字符为单位处理纯文本文件

二、体系结构

三.IO常用方法

● InputStream 的基本方法

读取一个字节并以整数的形式返回 (0~255), 如果返回 -1 已到输入流的末尾。

int read() throws IOException

读取一系列字节并存储到一个数组 buffer ，返回实际读取的字节数，如果读取前已到输入流的

末尾返回 -1

int read(byte[] buffer) throws IOException

关闭流释放内存资源

void close() throws IOException

● OutputStream 的基本方法

向输出流中写入一个字节数据 , 该字节数据为参数 b 的低 8 位

void write(int b) throws IOException

将一个字节类型的数组中的从指定位置（ off ）开始的 len 个字节写入到输出流

void write(byte[] b, int off, int len) throws IOException

关闭流释放内存资源

void close() throws IOException

●Reader 的基本方法

读取一个字符并以整数的形式返回 , 如果返回 -1 已到输入流的末尾。

int read() throws IOException

读取一系列字符并存储到一个数组 buffer ，返回实际读取的字符数，如果读取前

已到输入流的末尾返回 -1

int read( char[] cbuf) throws IOException

关闭 void close() throws IOException

• Writer 的基本方法

向输出流中写入一个字符数据 , 该字节数据为参数 b 的 16 位

void write(int c) throws IOException

一个字符类型的数组中的数据写入输出流

void write( char[] cbuf) throws IOException

将一个字符类型的数组中的从指定位置（ off set ）开始的 length 个字符写入到

输出流

void write( char[] cbuf, int off set, int length) throws IOException

关闭 void close() throws IOException

四.序列化和反序列化

对象序列化：把对象转换为字节序列(二进制数据)的过程
对象反序列化：把字节序列恢复为对象的过程

5.异常

1.概述

异常：

指的是程序在执行过程中，出现的非正常情况，如果不处理最终会导致

JVM的非正常停止。

• 异常指的并不是语法错误。语法错了，编译不通过，不会产生字节码文

件，根本不能运行。

2.体系结构

3.常见异常种类

/*int [] a=new int[2];
a[3]=5;//ArrayIndexOutOfBoundsException 数组索引越界*/
/*String s="abc";
s.charAt(3);//StringIndexOutOfBoundsException 字符串索引越界*/
/*int e=9,b=0;
int c=e/b;//ArithmeticException 算数运算异常*/
/* Object s=new Integer(9);
String s1=(String) s;// ClassCastException 类型转换异常*/
//Integer.parseInt("abc"); //NumberFormatException 数字格式化异常
//String s=null;
//s.length();//NullPointerException 使用 null 中的方法或属性，一般有称为空指针
异常

4.异常处理语法

Java的异常处理是通过5个关键字来实现的：try、catch、

finally、throw、throws

语法：

try{

可能会发生异常的代码

}catch(异常类型引用名){

异常处理代码

}finally{

必须执行代码

}

● try

检测不安全的代码块（发现异常）

try块中任何一条语句发生了异常，下面的代码将不会被执行，程序将

跳转到异常处理代码块中，即catch块。因此，不要随意将不相关的代

码放到try块中，因为随时可能会中断执行。

catch

把抓到的类型匹配的异常捕获，保证程序能继续运行下去

catch语句必须紧跟着try语句之后，称为捕获异常，也就是异常处理函数，

一个try后面可以写多个catch，分别捕获不同类型的异常，要从子类往父类

的顺序写，否则有编译错误

finally

finally该内容总是会执行的，只能有一个finally语句

finally{

必须执行的逻辑

}

5.自定义异常

● 自定义异常就是自己定义的异常类，也就是API中的标准异常类的直接或间接的

子类

● 作用：用自定义异常标记业务逻辑的异常，避免与标准异常混淆

● 基本语法

public class 异常类名 extends Exception/RuntimeException{

public 异常类名(String msg){

super(msg);

}

● 自定义异常类中往往不写其他方法，只重载需要使用的构造方法

● 继承Exception,在方法中使用throw抛出后,必须在方法中try-catch或

throws抛出

自定义异常示例：

6.JDBC

jdbc连接数据库步骤:

1.在项目添加jar文件
2.加载驱动类 Class.forName("com.mysql.cj.jdbc.Driver");
3.建立与数据库的连接,获得连接对象
4.发送sql
Statement st = connection.createStatement();
5.如果执行查询操作, 接收包装查询结果

6.关闭与数据库连接
rs.close();
ps.close();
connection.close();

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class Demo {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
Class.forName("com.mysql.cj.jdbc.Driver");//加载驱动类
//建立与数据库的连接，获得连接对象
String url="jdbc:mysql://127.0.0.1:3306/schooldb?serverTimezone=Asia/Shanghai";
String user="root";
String password="root";
Connection connection= DriverManager.getConnection(url,user,password);
//发送sql
Statement st =connection.createStatement();
st.executeUpdate("insert into major(name)values('数学')");
// 关闭
st.close();
connection.close();
}
}

7.mysql数据库

1.数据库的相关概念

（1）DB：数据库（DataBase）：存储数据的容器，它保存了一系列有组织的数据。

（2）DBMS：数据库管理系统（DataBase Management System），又称为数据库软件或数据库产品，用于创建或管理DB。

（3）应用程序与数据库服务器的关系如图所示：

2.MySQL的常用命令

查看当前所有的数据库：show databases;

选择指定的库：use + 库名

查看当前的所有表：show tables;

查看其他库的所有表：show tables from 库名;

查看mysql版本 select version();

3.SQL

(1) 概念：结构化查询语言(Structured Query Language)简称SQL，是一种特殊目的的编程语言，是一种数据库查询和程序设计语言，用于存取数据以及查询、更新和管理关系数据库系统。

（2）优点：几乎所有DBMS都支持SQL，灵活使用可以进行非常复杂和高级的数据库操作。

4.DDL

（1）概念：数据(结构)定义语言DDL(Data Definition Language)，是用于创建和修改数据库表结构的语言。

（2）常用的语句有：create ,alter,drop,rename

部分用法：

创建数据库并设置编码格式

CREATE DATABASE [if not exists] 数据库名 [ CHARSET utf8]

删除数据库

DROP DATABASE 数据库名 / [IF EXISTS数据库名];

修改字符集

ALTER DATABASE 数据库名 CHARSET gbk

（3）数据表概念

1、数据表

表（table）是数据存储的最常见和最简单的形式，是构成关系型数据库的基本元素。

表的最简单形式是由行和列组成，分别都包含着数据。每个表都有一个表头和表体，表头定

义表名和列名 .表中的行被看作是文件中的记录，表中的列被看作是这些记录的字段。

2、字段

字段是表里的一列，用于保存每条记录的特定信息。如客户订单表的字段包括“订单

ID”、“姓名”、“客户ID”、“职务”、“上级”、“地区”、“运货商”、“国家”等。

数据表的一列包含了特定字段的全部信息。

3、记录

记录也被称为一行数据，是表里的一行数据。

（4）设计表的步骤

创建表的步骤:
确定表名: 学生信息 -- 学生表
确定列名: 学生的具体信息姓名,性别,生日....
列的数据类型:
字符串型:
char(n) 长度为n的定长字符串, 例如n=5, 如果我们只存储了2个字符进去,长度依然是5,会补空格
一般用来存储长度固定的数据, 例如性别,电话.
varchar(n) 最大长度为n的变长字符串, 例如n=10,如果我们只存储了3个字符,实际长度为3

日期时间类型
date 日期--年月日
datetime 时间--年月日时分秒

数值
整数
TINYINT 1
SMALLINT 2
MEDIUMINT 3
int 4
bigint 8

浮点:
decimal(M,D)
3,2
1.73

TEXT列字符字符串长文本类型例如存储新闻信息,小说...
列的约束: 列的规则
（4）主键外键及约束

主键：在一张表中代表唯一的一条记录,不能为空,不能重复

约束:

PRIMARY KEY 设置主键约束

NOT NULL 不能为空约束

UNIQUE 唯一性约束

检查约束设置条件： CHECK（条件）

外键约束

主键自动增长,设置为自动增长时,只能为整数类型：AUTO_INCREMENT

默认值：DEFAULT default_value

字段注释: comment '注释'

（5）基本语法操作

<1>创建表

CREATE TABLE 表名(列名数据类型 [约束] [默认值] [ 注释],......)

例如：

CREATE TABLE student(
num INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(10) NOT NULL,
gender CHAR(1) NOT NULL,
birthday DATE,
phone CHAR(11) NOT NULL UNIQUE,
address VARCHAR(30),
height DECIMAL(3,2) CHECK(height<2.60),
reg_time DATETIME
)

<2>删除表

DROP TABLE [if exists ]表名

例如，

DROP TABLE student

<3>修改表名

RENAME TABLE 旧表名 TO 新表名

例如，
RENAME TABLE student TO stu
RENAME TABLE stu TO student

<4> 复制表结构

CREATE TABLE 新表名 LIKE 被复制表名; 例如，
CREATE TABLE stu LIKE student

5.DML

（1）概念：数据操纵语言DML（Data Manipulation Language）

（2）常用语句：insert,delete,update

（3）语句使用方法：

<1>insert插入数据

方式1: INSERT INTO 表名(列1,列2……,列n) VALUES(值1,值2…..,值n);

方式2: INSERT INTO 表名 set 列名1=值1,..列名n=值n;

方式3: INSERT INTO 表名(列1,列2……,列n) VALUES(值1,值2…..,值n),(值1,值2…..,值n);

方式4:INSERT INTO 表名(列1,列2……,列n) 查询语句(查询的列数与插入列数匹配)

<2>update 更新数据

UPDATE 表名 SET 列名 = ‘新值’WHERE 条件

<3>delete 删除数据

DELETE FROM 表名 WHERE 条件

TRUNCATE TABLE 表名;清空整张表

6.DQL

（1）概念：DQL（Data Query Language）数据查询语言查询是使用频率最高的一个操作，可以从一个表中查询数据，也可以从多个表中查询数据。

（2）基本查询：

<1>语法：select 查询列表 from 表名;

<2>特点：查询列表可以是：表中的字段、常量、表达式、函数；查询的结果是一个虚拟的表格

（3）查询结果处理：

特定列查询:select column1,column2 from table

全部列查询: select * from table

算数运算符:+ - * /

排除重复行: select distinct column1,column2 from table

查询函数：select 函数; / 例如version()

（4）函数

<1>定义：类似于java中的方法，将一组逻辑语句事先在数据库中定义好,可以直接调用

<2>分类：

单行函数：如concat、length、ifnull等

分组函数：做统计使用，又称为统计函数、聚合函数、组函数

字符函数:

length()：获取参数值的字节个数

char_length()获取参数值的字符个数

concat(str1,str2,.....)：拼接字符串

upper()/lower()：将字符串变成大写/小写

substring(str,pos,length)：截取字符串位置从1开始

instr(str,指定字符)：返回子串第一次出现的索引，如果找不到返回0

trim(str)：去掉字符串前后的空格或子串,trim(指定子串 from 字符串)

lpad(str,length,填充字符)：用指定的字符实现左填充将str填充为指定长度

rpad(str,length,填充字符)：用指定的字符实现右填充将str填充为指定长度

replace(str,old,new)：替换，替换所有的子串

单行函数功能

<1>逻辑处理语句

case when 条件 then 结果1 else 结果2 end; 可以有多个when

ifnull(被检测值,默认值)函数检测是否为null，如果为null，则返回指定的值，否则返回

原本的值

if函数：if else的效果 if(条件,结果1,结果2)

<2>数学函数

round(数值)：四舍五入

ceil(数值)：向上取整，返回>=该参数的最小整数

floor(数值)：向下取整，返回<=该参数的最大整数

truncate(数值,保留小数的位数)：截断，小数点后截断到几位

mod(被除数,除数)：取余，被除数为正，则为正；被除数为负，则为负

rand()：获取随机数，返回0-1之间的小数

<3>日期函数

now()：返回当前系统日期+时间

curdate()：返回当前系统日期，不包含时间

curtime()：返回当前时间，不包含日期

可以获取指定的部分，年、月、日、小时、分钟、秒

YEAR(日期列),MONTH(日期列),DAY(日期列) ,HOUR(日期列) ,MINUTE(日期列)

SECOND(日期列)

str_to_date(字符串格式日期,格式)：将日期格式的字符转换成指定格式的日期

date_format(日期列,格式)：将日期转换成字符串

datediff(big,small)：返回两个日期相差的天数

分组函数

<1>功能：用作统计使用，又称为聚合函数或统计函数或组函数

<2>分类：

sum 求和、avg 平均值、max 最大值、min 最小值、count 计数

（非空）

注意：

1.sum，avg一般用于处理数值型max，min，count可以处理任何类型

2.以上分组函数都忽略null值

3.count函数的一般使用count（*）用作统计行数

4.和分组函数一同查询的字段要求是group by后的字段

（5）条件查询

<1>where查询

使用WHERE 子句，将不满足条件的行过滤掉，WHERE 子句紧随 FROM 子句。

语法:select <结果> from <表名> where <条件>

比较

=, != 或<>, >, <, >=, <=

逻辑运算

and 与

or 或

not 非

<2>模糊查询

：是否匹配于一个模式一般和通配符搭配使用，可以判断字符型数值

或数值型.

通配符： % 任意多个字符

between and 两者之间,包含临界值；

in 判断某字段的值是否属于in列表中的某一项

IS NULL（为空的）或 IS NOT NULL（不为空的）

<3>UNION 的语法如下：

[SQL 语句 1]

UNION

[SQL 语句 2]

UNION ALL 的语法如下：

[SQL 语句 1]

UNION ALL

[SQL 语句 2]

当使用union 时，mysql 会把结果集中重复的记录删掉，而使用union all ，

mysql 会把所有的记录返回，且效率高于union 。

<4>排序

查询结果排序,使用 ORDER BY 子句排序 order by 排序列 ASC/DESC

asc代表的是升序，desc代表的是降序，如果不写，默认是升序

order by子句中可以支持单个字段、多个字段

<5>数量限制

limit子句：对查询的显示结果限制数目 (sql语句最末尾位置)

SELECT * FROM table LIMIT offset rows;

SELECT * from table LIMIT 0,5;

<6>分组查询

语法：

select 分组函数，列（要求出现在group by的后面）

from 表

[where 筛选条件]

group by 分组的列表

[having 分组后的筛选]

[order by 子句]

注意：查询列表比较特殊，要求是分组函数和group by后出现的字段

分组查询中的筛选条件分为两类:

3.多表设计_关联查询

数据库设计范式

1．第一范式(确保每列保持原子性) ：第一范式是最基本的范式。如果数据库表中的所有字段值都是不可分解的原子值，就说明该数据库表满足了第一范式。

2．第二范式就是要有主键，要求其他字段都依赖于主键。

原因：

（1）没有主键就没有唯一性，没有唯一性在集合中就定位不到这行记录，所以要主键。

（2）其他字段为什么要依赖于主键？因为不依赖于主键，就找不到他们。更重要的是，其

他字段组成的这行记录和主键表示的是同一个东西，而主键是唯一的，它们只需要依

赖于主键，也就成了唯一的。

3.第三范式,确保每列都和主键列直接相关,而不是间接相关,要求一个数据库表中不包含

已在其它表中包含的非主关键字信息

关联查询

<1>内连接（inner join）

把满足了条件的两张表中的交集数据查询出来

语法：Select 结果 from 表1，表2 where 表1.column1 = 表2.column2

多表关联

<2>左外连接（left join）

select 结果 from

表1 left join 表2 on

表1.column1 = 表2.column2