一：網絡編程三要素+UDP協議
1.1
1.網絡通信介紹
2.tcp/ip
3.udp/ip
1.2
Socket通信
*網絡編程三要素：
ip:
一個計算的標示（找到這個計算機）
端口：
應用程序都會對應一個端口，用來進行通信，有效端口：0~65535，其中0~1024系統使用或保留端口（360查看端口）。
協議：
總共有2種協議（TCP,UDP）
*舉例說明：
1.找到劉詩詩(ip)
2.對着劉詩詩的而耳朵說話(端口)
3.協議
1.3
三要素詳解：
特殊的IP地址:
127.0.0.1 本地迴環地址 用來做一些本地測試
ping IP地址 ; 用來檢測本機是否可以和指定的IP地址的計算機可以進行正常通訊
ipconfig 用來查看IP地址
xxx.xxx.xxx.255廣播地址
端口號:
物理端口 物理設備對應的端口 , 網卡口
邏輯端口 用來標示我們的計算機上的進程 , 端口號的有效範圍應該是 0-65535 ,
其中0-1024被系統佔用或者保留
協議:
UDP
把數據打成一個數據包 , 不需要建立連接
數據包的大小有限制不能超過64k
因爲無連接,所以屬於不可靠協議(可能丟失數據)
因爲無連接 ,所以效率高
TCP
需要建立連接,形成連接通道
數據可以使用連接通道直接進行傳輸,無大小限制
因爲有鏈接,所以屬於可靠協議
因爲有鏈接,所以效率低
1.4 （InetAddress）
*
/*
* InetAddress:IP地址的描述類
*
A:InetAddress類的概述
爲了方便我們對IP地址的獲取和操作，java提供了一個類InetAddress供我們使用
此類表示互聯網協議(IP) 地址。
B:InetAddress類的常見功能
publicstatic InetAddress getByName(String host)（ host: 可以是主機名,也可以是IP地址的字符串表現形式）
publicString getHostAddress()返回 IP 地址字符串（以文本表現形式）。
publicString getHostName()獲取此 IP 地址的主機名。
C:案例演示: InetAddress類的常見功能
*/
package com.edu_01;
import java.net.InetAddress;
import java.net.UnknownHostException;
/*
* InetAddress:IP地址的描述類
*
A:InetAddress類的概述
爲了方便我們對IP地址的獲取和操作，java提供了一個類InetAddress供我們使用
此類表示互聯網協議(IP) 地址。
B:InetAddress類的常見功能
publicstatic InetAddress getByName(String host)（ host: 可以是主機名,也可以是IP地址的字符串表現形式）
publicString getHostAddress()返回 IP 地址字符串（以文本表現形式）。
publicString getHostName()獲取此 IP 地址的主機名。
C:案例演示: InetAddress類的常見功能
*/
public class InetAddressDemo {
publicstatic void main(String[] args) throws Exception {
//通過主機ip獲取InetAddress對象
InetAddressaddress = InetAddress.getByName("192.168.20.25");
//publicString getHostAddress()返回 IP 地址字符串（以文本表現形式）。
System.out.println(address.getHostAddress());
//publicString getHostName()獲取此 IP 地址的主機名。
System.out.println(address.getHostName());
}
}
1.5（也叫socket編程，套接字編程，網絡編程，叫法不一樣都是一個東西）
* Socket套接字：（利用qq聊天的案例畫圖進行講解）
網絡上具有唯一標識的IP地址和端口號組合在一起才能構成唯一能識別的標識符套接字。
Socket原理機制：
通信的兩端都有Socket。
網絡通信其實就是Socket間的通信。
數據在兩個Socket間通過IO傳輸。
packagecom.edu_02;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
/**
*UDP協議特點：
* 1.數據通過打包之後進行發送
* 2.不需要進行連接
* 3.數據大小有限制
* 4.協議屬於不安全協議
* 5.效率比較高
*/
public class UdpClient {
publicstatic void main(String[] args) throws Exception {
//1.創建udp協議發送端的socket對象
//publicDatagramSocket() throws SocketException
DatagramSocketds = new DatagramSocket();
byte[]buf = "hello".getBytes();
intlength = buf.length;
InetAddressaddress = InetAddress.getByName("192.168.20.254");
intport = 8888;
//2.創建數據包
//publicDatagramPacket(byte[] buf, int length,InetAddress address,int port)
DatagramPacketdp = new DatagramPacket(buf, length, address, port);
/**
* 1.你要發送的數據
* 2.發送的數據的長度
* 3.你要發送給的電腦ip
* 4.端口
*/
//發送數據
ds.send(dp);
//釋放資源
ds.close();
}
}
package com.edu_02;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
public class UdpServer {
publicstatic void main(String[] args) throws Exception {
//創建接收端的socket對象
DatagramSocketds = new DatagramSocket(8888);
//創建一個數據包，用來接收來自發送端的數據,是一個空的數據包
byte[]buf = new byte[1024];
intlength = buf.length;
DatagramPacketdp = new DatagramPacket(buf, length);
//接受來自發送端的數據
//publicvoid receive(DatagramPacket p)throws IOException
//程序在這裏接收到來自發送端的數據之前一直處於阻塞狀態
ds.receive(dp);
//解析一下數據包中的數據
//publicbyte[] getData()返回數據緩衝區
byte[]data = dp.getData();
//publicint getLength()返回將要發送或接收到的數據的長度
intlen = dp.getLength();
System.out.println(newString(data,0,len));
//釋放資源
ds.close();
}
}
1.6
分協議進行講解網絡編程
*UDP協議：（寫一個標準demo）
特點：1.把數據打包
2.不需要建立連接，也稱爲面向無連接協議
3.數據需打包，數據大小有限制64k
4.無需建立連接，所以不可靠
5.速度快
UDP通信步驟：
發送端步驟：
/*
* UDP發送數據的步驟:
* A:創建UDP發送數據端Socket對象
* B:創建數據包,並給出數據,把數據打包
* C:通過Socket對象發送數據包
* D:釋放資源
*/
接收端步驟：
/*
* UDP協議接收數據步驟：
* A:創建UDP接收數據端Socket對象
* B:創建一個接收數據的數據包
* C:接收數據,數據在數據包中
* D:解析數據包，並把數據顯示在控制檯
* E:釋放資源
*/
1.8 鍵盤錄入數據實現數據的動態發送
package com.edu_03;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.Scanner;
/**
*1.8 鍵盤錄入數據實現數據的動態發送
*
*/
public class UdpClient {
publicstatic void main(String[] args) throws Exception {
//1.創建發送端的socket對象
DatagramSocketds = new DatagramSocket();
InetAddressaddress = InetAddress.getByName("192.168.20.254");
intport = 9999;
//2.創建鍵盤錄入對象
Scannersc = new Scanner(System.in);
Stringline;
while((line=sc.nextLine())!=null) {
//鍵盤錄入的數據line
byte[]buf = line.getBytes();
intlength = buf.length;
DatagramPacketdp = new DatagramPacket(buf, length, address, port);
//發送數據包
ds.send(dp);
}
//釋放資源
ds.close();
}
}
package com.edu_03;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
public class UdpServer {
publicstatic void main(String[] args) throws Exception {
//創建接收端的socket對象
DatagramSocketds = new DatagramSocket(9999);
//接受來自客戶端的數據
while(true) {
//創建數據包
byte[]buf = new byte[1024];
intlength = buf.length;
DatagramPacketdp = new DatagramPacket(buf, length);
//接受來自客戶端的數據
ds.receive(dp);
//解析數據包中的數據
byte[]data = dp.getData();
intlen = dp.getLength();
System.out.println(newString(data, 0, len));
}
}
}
1.10 多線程實現聊天室（相當於是將發送數據端和接收數據端合併）
package com.edu_04;
import java.net.DatagramSocket;
import java.net.SocketException;
public class ChatRoom {
publicstatic void main(String[] args) throws Exception {
//啓動發送線程和接收縣城
//啓動發送線程
newThread(new UdpCilent(new DatagramSocket())).start();
//啓動接收線程
newThread(new UdpServer(new DatagramSocket(9999))).start();
}
}
package com.edu_04;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;
public class UdpCilent implements Runnable{
DatagramSocketds ;
publicUdpCilent(DatagramSocket ds){
this.ds= ds;
}
@Override
publicvoid run() {
try{
InetAddressaddress = InetAddress.getByName("192.168.20.255");
intport = 9999;
//2.創建鍵盤錄入對象
Scannersc = new Scanner(System.in);
Stringline;
while((line=sc.nextLine())!=null) {
//鍵盤錄入的數據line
byte[]buf = line.getBytes();
intlength = buf.length;
DatagramPacketdp = new DatagramPacket(buf, length, address, port);
//發送數據包
ds.send(dp);
}
//釋放資源
ds.close();
}catch (Exception e) {
//TODO Auto-generated catch block
e.printStackTrace();
}
}
}
package com.edu_04;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
public class UdpServer implements Runnable{
DatagramSocketds ;
publicUdpServer(DatagramSocket ds){
this.ds= ds;
}
@Override
publicvoid run() {
try{
//接受來自客戶端的數據
while(true) {
//創建數據包
byte[]buf = new byte[1024];
intlength = buf.length;
DatagramPacketdp = new DatagramPacket(buf, length);
//接受來自客戶端的數據
ds.receive(dp);
//獲取發送信息的人的ip地址
Stringip = dp.getAddress().getHostAddress();
//解析數據包中的數據
byte[]data = dp.getData();
intlen = dp.getLength();
System.out.println(ip+":"+newString(data, 0, len));
}
}catch (Exception e) {
//TODO Auto-generated catch block
e.printStackTrace();
}
}
}
二：TCP協議要點
2.1
*TCP協議：（寫一個demo）
特點：1.需要建立通道
2.傳送大量數據無限制
3.面向連接
4.可靠
5.速度慢
TCp協議書寫步驟：
發送端：
/*
* TCP協議發送數據步驟：
* A:創建TCP協議發送端Socket對象
* 指定服務器IP及端口
Socket sk = newSocket("192.168.3.120" , 9527) ;
* B:獲取輸出流,並寫數據
OutputStream outputStream =sk.getOutputStream() ;
outputStream.write("hello,TCP我來了".getBytes());
* C:釋放資源
sk.close() ;
*
* java.net.ConnectException: Connectionrefused: connect
* TCP協議是不能直接運行客戶端的，必須先運行服務器。因爲他是一種可靠的協議。
*/
接收端：
/*
* TCP協議接收數據步驟：
* A:創建TCP協議接收端Socket對象
ServerSocket ss = new ServerSocket(9527) ;
* B:監聽客戶端連接
Socket sk = ss.accept() ;
* C:獲取輸入流,並讀取數據,顯示在控制檯
// 讀取數據
byte[]bytes = new byte[1024] ;
intlen = inputStream.read(bytes) ;
//public InetAddress getInetAddress()獲取IP地址
InetAddressinetAddress = sk.getInetAddress() ;
Stringip = inetAddress.getHostAddress() ;
//輸出
System.out.println(ip+ "發來數據是: " + new String(bytes , 0 , len));
* D:釋放資源
sk.close() ;
*/
package com.edu_05;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
/**
*tcp:
* 1.必須建立鏈接，這個協議又被稱爲面向鏈接協議
* 2.發送數據沒有大小限制
* 3.協議比較安全
* 4.效率低
*
* 先運行客戶端的時候拋出異常：
*java.net.ConnectException: Connection refused: connect
* 因爲服務器端還沒有準備好跟你的客戶端建立連接呢，你就來了，所以拋出異常，因爲tcp
* 協議是面向連接的一個協議
*
*/
public class TcpClient {
publicstatic void main(String[] args) throws Exception {
//創建tcp協議發送端的socket對象
//publicSocket(String host,int port)
Socketsk = new Socket("192.168.20.254", 10086);
//2.publicOutputStream getOutputStream()throws IOException
//從通道中獲取輸出流對象
OutputStreamos = sk.getOutputStream();
//3.給通道中寫數據
os.write("hello".getBytes());
//4.釋放資源
sk.close();
}
}
package com.edu_05;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServer {
publicstatic void main(String[] args) throws Exception {
//1.創建服務器端的sokeck對象
//publicServerSocket(int port)throws IOException
ServerSocketss = new ServerSocket(10086);
//2.堅挺來自客戶端的連接
//publicSocket accept()throws IOException偵聽並接受到此套接字的連接。此方法在連接傳入之前一直阻塞。
Socketsk = ss.accept();
//3.從通道中讀取來自客戶端的數據
InputStreamis = sk.getInputStream();
//4.讀取is
byte[]buf = new byte[1024];
intlen = is.read(buf);
System.out.println(newString(buf, 0, len));
//5.釋放資源
sk.close();
}
}
2.2
用TCP協議寫一個數據的發送和接收，接收端接收到數據之後給發送端一個反饋
package com.edu_06;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
public class TcpClient {
publicstatic void main(String[] args) throws Exception {
//創建tcp發送端的sockt對象
Socketsk = new Socket("192.168.20.254", 10000);
//從通道中獲取輸出流
OutputStreamos = sk.getOutputStream();
//網通道中寫數據
os.write("今晚約嗎".getBytes());
//接受來自服務器端的反饋
InputStreamis = sk.getInputStream();
//解析is
byte[]buf = new byte[1024];
int len = is.read(buf);
System.out.println(newString(buf, 0, len));
//釋放資源
sk.close();
}
}
package com.edu_06;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServer {
publicstatic void main(String[] args) throws Exception {
//創建服務器端的socket對象
ServerSocketss = new ServerSocket(10000);
//監聽來自客戶端的連接
Socketsk = ss.accept();
//從通道中獲取輸入流讀取數據
InputStreamis = sk.getInputStream();
//解析is
byte[]buf = new byte[1024];
intlen = is.read(buf);
System.out.println(newString(buf, 0, len));
//給客戶端一個反饋
OutputStreamos = sk.getOutputStream();
os.write("不約".getBytes());
//釋放資源
sk.close();
}
}
2.4
需求: 客戶端鍵盤錄入數據,服務器端接收數據在控制檯輸出
package com.edu_07;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
/**
* 2.4
需求: 客戶端鍵盤錄入數據,服務器端接收數據在控制檯輸出
*
*/
public class TcpClient {
publicstatic void main(String[] args) throws Exception {
//創建tcp發送端socket對象
Socketsk = new Socket("192.168.20.254", 20000);
//創建鍵盤錄入對象
Scannersc = new Scanner(System.in);
Stringline;
while((line=sc.nextLine())!=null) {
//將line這個數據寫如通道
OutputStreamos = sk.getOutputStream();
os.write(line.getBytes());
}
sk.close();
}
}
package com.edu_07;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServer {
publicstatic void main(String[] args) throws Exception {
//創建服務器端的socket對象
ServerSocketss = new ServerSocket(20000);
//監聽來自客戶端的連接
Socketsk = ss.accept();
while(true) {
InputStreamis = sk.getInputStream();
byte[]buf = new byte[1024];
intlen = is.read(buf);
System.out.println(newString(buf, 0, len));
}
}
}
2.5
需求：客戶端鍵盤錄入數據，服務端將數據寫入文件
package com.edu_08;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
public class TcpClient {
publicstatic void main(String[] args) throws Exception {
/**
* 2.5
需求：客戶端鍵盤錄入數據，服務端將數據寫入文件
客戶端
一次寫一行
服務端：
一次讀取一行，將讀取到的內容寫入文件
*/
//創建tcp客戶端socket對象
Socketsk = new Socket("192.168.20.254", 10010);
BufferedWriterbw = new BufferedWriter(new OutputStreamWriter(sk.getOutputStream()));
//創建鍵盤錄入對象
Scannersc = new Scanner(System.in);
Stringline;
while((line=sc.nextLine())!=null) {
//往通道中寫數據，一次寫一行
bw.write(line);
bw.newLine();
bw.flush();
}
sk.close();
}
}
package com.edu_08;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServer {
publicstatic void main(String[] args) throws Exception {
//創建服務器端的socket對象
ServerSocketss = new ServerSocket(10010);
//監聽客戶端連接
Socketsk = ss.accept();
//從sk的通道中讀取數據，一次讀取一行
BufferedReaderbr = new BufferedReader(new InputStreamReader(sk.getInputStream()));
BufferedWriterbw = new BufferedWriter(new FileWriter("a.txt"));
//一次讀取一行數據
Stringline;
while((line=br.readLine())!=null) {
//line就是已經讀取到的數據，我們現在需要將line這個數據寫入文件
bw.write(line);
bw.newLine();
bw.flush();
}
sk.close();
bw.close();
br.close();
}
}
2.6
需求：客戶端讀取文本文件中的內容發送給服務端，服務端將內容控制檯輸出 packagecom.edu_09;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;
/**
*2.6
需求：客戶端讀取文本文件中的內容發送給服務端，服務端將內容控制檯輸出
* 客戶端：
* 1.讀取文本文件，一次讀取一行
* 2.將讀取到的內容寫入通道，一次寫一行
* 3.釋放資源
* 服務器端：
* 1.從通道中讀取數據，一次讀取一行
* 2.輸出
*/
public class TcpClient {
publicstatic void main(String[] args) throws Exception {
//創建socket對象
Socketsk = new Socket("192.168.20.254", 2000);
BufferedWriterbw = new BufferedWriter(new OutputStreamWriter(sk.getOutputStream()));
//讀取文本一次讀取一行
BufferedReaderbr = new BufferedReader(new FileReader("a.txt"));
Stringline;
while((line=br.readLine())!=null) {
//line就是我讀取到的數據，我需要將這個數據寫入通道，一次寫一行
bw.write(line);
bw.newLine();
bw.flush();
}
//釋放資源
br.close();
bw.close();
sk.close();
}
}
package com.edu_09;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServer {
publicstatic void main(String[] args) throws Exception {
//創建服務器端的socket對象
ServerSocketss = new ServerSocket(2000);
//蔣婷來自於客戶端的連接
Socketsk = ss.accept();
//創建BufferedReader一次讀取一行數據
BufferedReaderbr = new BufferedReader(new InputStreamReader(sk.getInputStream()));
Stringline;
while((line=br.readLine())!=null) {
System.out.println(line);
}
//釋放資源
br.close();
sk.close();
}
}
2.7
* 需求: 上傳文本文件
*
* 客戶端:
* a: 讀取文本文件中的數據
* b: 發送到服務器端
*
* 服務器:
* a: 讀取流通道中的數據
* b: 把數據寫入到文本文件中
2.9
提問：我們以後倒是使用udp協議還是tcp協議呢？
在咱們以後使用的軟件當中基本都是udp和tcp混用的
MySql數據庫：
-- 寫sql語句，發送給服務端執行
-- 在後面可以寫註釋
-- 創建庫，day16
CREATE DATABASEday16 DEFAULT CHARACTER SET utf8;
-- 使用day16這個數據庫
USE day16;
-- 查詢day16這個庫中的所有的表
SHOW TABLES;
-- 需求：創建學生表(id,name,age)
CREATE TABLEstudent(
-- 字段名稱字段類型
id INT,
NAME VARCHAR(20),
age INT
);
-- 查詢表中的數據
SELECT * FROMstudent;
-- 查詢一個表結構
DESC student;
-- 刪除student表
DROP TABLEstudent;
-- 添加一個地址字段(gender varchar(2))
ALTER TABLEstudent ADD COLUMN gender VARCHAR(2);
-- 修改gender字段類型爲varchar(3)
ALTER TABLEstudent MODIFY COLUMN gender VARCHAR(3);
-- 將gender字段修改爲sex字段 varchar(2)
ALTER TABLEstudent CHANGE COLUMN gender sex VARCHAR(2);
-- 添加一個地址字段
ALTER TABLEstudent ADD COLUMN address VARCHAR(20);
-- 刪除sex和address字段
ALTER TABLEstudent DROP COLUMN sex,DROP COLUMN address;
-- 將student這個表的表名改爲stu
ALTER TABLE stuRENAME TO student;
-- 查看錶的數據
-- select 字段名稱(如果查詢所有字段*) from student;
-- 查看錶數據
SELECT * FROMstudent;
-- 給表中插入3條數據（插入所有字段）
INSERT INTOstudent VALUES(1,'劉德華',50,'中國香港');
INSERT INTOstudent VALUES(2,'陳奕迅',40,'中國香港');
INSERT INTOstudent VALUES(3,'韓紅',50,'河北');
-- 當需要插入所有字段的時候我們可以直插入部分字段嗎？插入不了
INSERT INTOstudent VALUES(1,'成龍',60,'中國香港');
-- 指向給表中只想插入id字段和name字段，請問怎麼辦？
INSERT INTOstudent(id,NAME) VALUES(4,'郭德綱');
-- 將所有學生的年齡改爲50歲,修改所有學生的年齡，用的非常少
UPDATE student SETage=50;
-- 將id爲3的學生姓名改爲房祖名
UPDATE student SETNAME='房祖名' WHERE id=3;
-- 修改多個字段，修改id爲2的學生姓名爲張學友，年齡改爲60
UPDATE student SETNAME='張學友',age=60 WHERE id=2;
-- 刪除全表數據,本質上是一條一條進行刪除的，效率比較慢
DELETE FROMstudent;
-- 刪除id爲3的數據
DELETE FROMstudent WHERE id=3;
-- 使用truncate table 表名，刪除全表數據，並不是一條條刪，而是直接將全表數據刪除，效率比較快
TRUNCATE TABLEstudent;
-- delete from和truncate table 這兩種刪除全表的方式有什麼區別呢？
-- 1.delete from一條條刪除，truncate table直接將全表數據幹掉
-- 2.delete from可以按條件刪除一條數據，truncate table只能刪除全表數據，不能按照條件刪除
-- 3.delete from無法重置自增長主鍵，truncate table可以重置自增長主鍵
-- 查詢數據
-- 查詢所有列
SELECT * FROMstudent;
-- 查詢指定字段，查詢id,name
SELECT id,NAMEFROM student;
-- 查詢時指定別名，name--姓名，address--住址
SELECT NAME AS '姓名',address AS '住址' FROM student;
-- 上面指定別名的as是可以省略的
SELECT NAME '姓名' FROM student;
-- 添加servlet,jsp字段
ALTER TABLEstudent ADD COLUMN servlet INT,ADD COLUMN jsp INT;
-- 給每條學生數據添加上servlet和jsp的成績
UPDATE student SETservlet=50,jsp=60 WHERE id=1;
UPDATE student SETservlet=60,jsp=70 WHERE id=2;
UPDATE student SETservlet=70,jsp=80 WHERE id=3;
-- 合併servlet和jsp這兩個列進行查詢，查詢每個學生的servlet和jsp的成績總和
-- 合併列查詢有一個特點：只能合併數值類型的字段
SELECT NAME '姓名',(servlet+jsp) '總成績' FROM student;
-- 查詢時添加常量列，給student表添加一個常量列 班級--java001
SELECT NAME '姓名',address '地址','java001' AS '班級' FROM student;
-- 查詢你們班的學生都來自於哪裏
SELECT NAME '姓名',address '地址' FROM student;
-- 去除重複值來查詢每一個學生來自於哪裏
SELECT DISTINCTaddress FROM student;
-- 去除重複值的另一種寫法
SELECTDISTINCT(address) FROM student;
-- 查詢id爲1並且，並且servlet成績等於50的學生(交集 and)
SELECT * FROMstudent WHERE id=1 AND servlet=50;
-- 查詢id爲1或者來自中國香港的學生（並集 or）
SELECT * FROMstudent WHERE id=1 OR address='中國香港';
-- 查詢servlet成績大於60分的學生
SELECT * FROMstudent WHERE servlet>60;
-- 查詢jsp成績小於等於70的學生
SELECT * FROMstudent WHERE jsp<=70;
-- 另一種寫法
SELECT * FROMstudent WHERE jsp<70 OR jsp=70;
-- 查詢jsp的成績大於等於70並且小於等於80的學生
SELECT * FROMstudent WHERE jsp<=80 AND jsp>=70;
-- 上面寫法的另一種語法,between...and...包前也包後
SELECT * FROMstudent WHERE jsp BETWEEN 70 AND 80;
-- 查詢學生年齡不等於30歲的學生
SELECT * FROMstudent WHERE age<>30;
-- 給student表中添加一個數據
INSERT INTOstudent VALUES(4,'郭德綱',NULL,'',80,90);
-- 查詢age字段爲null的學生(IS NULL)
SELECT * FROMstudent WHERE age IS NULL;
-- 查詢address字段爲空字符串的學生(='')
SELECT * FROMstudent WHERE address='';
-- 查詢age字段不爲null的學生(is not null)
SELECT * FROM student WHERE age IS NOT NULL;
-- 查詢address字段不爲''的學生(<>'')
SELECT * FROMstudent WHERE address<>'';
-- 模糊查詢(like),like後面跟的是符號
-- %任意多個字符
-- _一個字符
-- 查詢姓劉的學生(like '劉%')
SELECT * FROMstudent WHERE NAME LIKE '劉%';
-- 查詢姓名中含有劉這個字的學生
SELECT * FROMstudent WHERE NAME LIKE '%劉%';
-- 查詢姓劉，且姓名有3個字的學生
SELECT * FROMstudent WHERE NAME LIKE '劉__';
-- 聚合函數
-- 查詢servlet的總成績(sum -- 求和函數)
SELECTSUM(servlet) FROM student;
-- 查詢每個學生的servlet平均分（avg,平均函數）
SELECTAVG(servlet) FROM student;
-- 查詢學生的servlet的最高成績(max ,最大值函數)
SELECTMAX(servlet) FROM student;
-- 查詢所有學生的servlet的最低成績(min,求取最小值函數)
SELECTMIN(servlet) FROM student;
-- 求取這張學生表中有多少條數據(count(*))
-- 效率比較低
SELECT COUNT(*)FROM student;
-- 根據某一個字段求取學生表中的數據條數,當一個字段數值爲null的時候，是不予計算的
-- 但是這種方式求取得統計值的時候效率會更高，但是有時候數據不夠準確
SELECT COUNT(age)FROM student;
-- 求取本班中香港和河北的學生分別有多少人
-- 1.給學生使用address這個字段進行分組（group by） 2.求取每一組中的學生人數
-- address count
-- 香港 2
-- 河北 1
SELECTaddress,COUNT(*) FROM student GROUP BY address;
-- 查詢人數大於1的地域(group by 分組字段 having 篩選條件)
SELECTaddress,COUNT(*) FROM student GROUP BY address HAVING COUNT(*)>1;
-- 分頁查詢 limit 起始行數,查詢的條數 注意：起始行數從0開始
-- 假設我的表中有20條數據，分爲4也顯示
-- 第一頁：limit 0,5
-- 第二頁：limit 5,5
-- 第三頁：limit 10,5
-- 第四頁：limit 15,5
-- 結論：查詢某一頁要現實的數據的時候可以利用如下公式 limit (當前頁數-1)*每頁顯示的條數,每頁現實的條數
-- student表中目前有4條數據，分爲2頁顯示，每頁顯示2條
-- 查詢第一頁的顯示數據：
SELECT * FROMstudent LIMIT 0,2;
-- 查詢第二頁現實的數據
SELECT * FROMstudent LIMIT 2,2;
-- 按照id字段的升序進行排序
-- asc,升序，數字從小到大，字母a-z
-- desc,降序，數字從大到小，字母z-a
SELECT * FROMstudent ORDER BY id DESC;
-- 按照servlet的成績的降序進行排序
SELECT * FROMstudent ORDER BY servlet DESC;
-- 當有多個排序條件的時候，先按照第一個條件排序，如果第一個條件相同則按照第二個條件進行排序
-- 先按照學生的年齡升序進行排序，年齡相同按照學生的servelt成績的升序進行排序
SELECT * FROMstudent ORDER BY age ASC,servlet ASC;
DESC student;
SELECT * FROMstudent;
--------------------------------------------------------------------
-- 數據約束：給表添加一些數據約束從而可以達到約束用戶操作數據的效果
-- 1：默認值約束（default）
-- :當給這個字段沒有添加值的時候，會給一個默認值,如果給默認值約束的字段添加的值爲null的時候，那麼他的字段值就爲null
-- 創建一個stu表
CREATE TABLE stu(
id INT,
NAME VARCHAR(20),
-- 給性別gender這個字段添加一個默認值約束
gender VARCHAR(2)DEFAULT '男'
);
-- 給stu表中添加幾個數據
INSERT INTO stuVALUES(1,'張三','男');
INSERT INTOstu(id,NAME) VALUES(2,'李四');
-- 給stu表中插入數據，性別爲null
INSERT INTO stuVALUES(3,'劉詩詩',NULL);
-- 2.非空約束(not null),插入的字段不爲null，而且必須插入數據
CREATE TABLE stu(
-- 給stu表中的id字段添加一個非空約束
id INT NOT NULL,
NAME VARCHAR(20),
gender VARCHAR(2)
);
-- 給這張表中添加一個元素，不插入id字段的值
INSERT INTOstu(NAME,gender) VALUES('郭德綱','男');
-- 給這張表添加一條數據，id字段的值直接給成null,這樣的話是插入不進去的。。
-- 唯一約束(unique)
-- 給stu表添加一個唯一約束
CREATE TABLE stu(
-- 給stu表中的id字段添加唯一約束
id INT UNIQUE,
NAME VARCHAR(20),
gender VARCHAR(2)
);
-- 給表中插入兩條id相同的數據
INSERT INTO stuVALUES(1,'劉德華','男');
INSERT INTO stuVALUES(1,'張學友','男');-- Duplicate entry '1' for key 'id',無法插入重複的id值
-- 給表中插入一條id爲null的數據，當給id添加了唯一約束之後，依然可以給他插入多條null值，不會出現重複
INSERT INTO stuVALUES(NULL,'吳奇隆','男');
INSERT INTO stuVALUES(NULL,'劉詩詩','女');
-- 經過我們的分析，我們認定我們的這個id字段(唯一+非空)--主鍵(primary key)
-- 注意：
-- 1.一般來說我們需要給每一張表都設定一個主鍵字段(非空+唯一)，用來標示一條信息的唯一性
-- 2.我們一般不會將業務字段設定爲主鍵字段，比如name字段，一般我們會給每一張表添加一個id字段作爲主鍵字段
-- 3.建議給每張表添加一個主鍵字段，用來標示每一條數據的唯一性
CREATE TABLE stu(
-- 給stu表中的id字段設置爲主鍵（唯一+非空）
id INT PRIMARYKEY,
NAME VARCHAR(20),
gender VARCHAR(2)
);
-- 給表中插入兩條id爲1的學生信息
INSERT INTO stuVALUES(1,'華仔','男');
INSERT INTO stuVALUES(1,'華建','男');-- Duplicate entry '1' for key 'PRIMARY'
-- 給表中插入id爲null的元素
INSERT INTO stuVALUES(NULL,'杰倫','男');-- Column 'id' cannot be null
-- 上面的實驗我們可以得出結論，當我們給id字段設置了主鍵約束後，這個id字段就非空+唯一了
-- 自增長約束(auto_increment)
-- 給stu表中的id字段添加一個主鍵自增長約束
CREATE TABLE stu(
-- 給stu表中的id字段設置主鍵自增長約束，我們其實就將id這個字段交給了數據庫自己去維護，我們自己不需要去動他
id INT PRIMARY KEYAUTO_INCREMENT,
NAME VARCHAR(20),
gender VARCHAR(2)
);
-- 給stu表中添加兩條數據
INSERT INTOstu(NAME,gender) VALUES('華仔','男');
INSERT INTOstu(NAME,gender) VALUES('周杰倫','男');
INSERT INTOstu(NAME,gender) VALUES('周杰倫','男');
INSERT INTO stu(NAME,gender)VALUES('周杰倫','男');
-- 刪除id爲4的數據
DELETE FROM stuWHERE id=4;
-- 給表中添加一條數據
INSERT INTOstu(NAME,gender) VALUES('張學友','男');
-- delete from 這種刪除數據的方式，無法重置自增長的主鍵
-- 刪除stu的全表數據
DELETE FROM stu;
-- 添加一條數據
INSERT INTOstu(NAME,gender) VALUES('張學友','男');
-- 刪除全表數據的truncate table 表名，刪除全表數據，這種刪除全表數據的方式可以重置主鍵
TRUNCATE TABLEstu;
-- 給表中添加一條數據
INSERT INTOstu(NAME,gender) VALUES('華仔','男');十八、十九天筆記總結
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.