week06手写笔记

本周内容

1.字符流值高效字符流:BufferedReader/BufferedWriter

BufferedReader:字符缓冲输入流,可以高效的读取文本
特有功能	
(1)public String readLine()throws IOException:一次读取一行内容,如果文件已经读完,则返回值是null,来判断读取完毕
(2):还可以作为"键盘录入":
		/* InputStream in2 = System.in ;
        //public InputStreamReader(InputStream in) {
        Reader reader  = new InputStreamReader(in2) ;//字符转换输入流
        BufferedReader br = new BufferedReader(reader) ;*/

       //一步走
        BufferedReader br2 = new BufferedReader(new InputStreamReader(InputStream in)) ;
BufferedWriter:字符缓冲输出流,可以高效的输出字符串
特有功能	
(1)newLine():一个空的终止符号(分隔符--换行),关闭之前一定要刷新

2.其他流中–SequenceInputStream(合并流)

SequenceInputStream:可以同时操作多个文件,表示其他输入流的逻辑串联
SequenceInputStream(Enumeration<? extends InputStream> e) :将两个文件以上的内容一块读取
SequenceInputStream(InputStream s1, InputStream s2) :将两个文件内容一块读取
public class SequenceInputStreamDemo {
    public static void main(String[] args) throws Exception {

        //创建两个文件字节输入流对象
        FileInputStream fis1 = new FileInputStream("BufferedReaderDemo2.java") ;
        FileInputStream fis2 = new FileInputStream("Teacher.java") ;

        //创建合并流对象
        //public SequenceInputStream(InputStream s1,InputStream s2)
        SequenceInputStream sis = new SequenceInputStream(fis1,fis2) ;

        //创建字节缓冲输出流对象或者使用文件字节输出流对象
        FileOutputStream fos = new FileOutputStream("D:\\EE_2113\\day29\\code\\My.java") ;

        //一次读取一个字节数组
        byte[] bytes  = new byte[1024] ;
        int len = 0 ;
        while((len=sis.read(bytes))!=-1){
            //写
            fos.write(bytes,0,len);
        }

        //释放资源
        fos.close();
        sis.close();

    }
}

3.序列化( ObjectOutputStream)和反序列化( ObjectInputStream),后期重点

序列化流:ObjectOutputStream: 将一个Java对象的原始数据转换成流数据(可以在网络中传输)
   前提条件:Java对象所在的类必须实现一个java.io.Serializable :序列化接口
   构造方法:
       public ObjectOutputStream(OutputStream out) throws IOException: 创建序列化流对象
   成员方法:
       public final void writeObject(Object obj) throws IOException
 反序列化:ObjectInputStream:将 网络中传输的这种流数据----->还原成  对象 (Object)
   构造方法:
       public ObjectInputStream(InputStream in) throws IOException
   成员方法:
       public final Object readObject()throws IOException,ClassNotFoundException

public class ObjectStreamDemo {
    public static void main(String[] args) throws Exception {

//        myWrite() ;
        myRead() ;
    }
    //反序列化 读
    private static void myRead()  throws Exception {
        //创建一个反序列化流对象
//         public ObjectInputStream(InputStream in) throws IOException
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt")) ;
        //将这个文件的存储的Java对象的原始数据 "流数据"---->还原成对象
        //public final Object readObject()throws IOException,ClassNotFoundException
        Object o = ois.readObject();
        System.out.println(o);
    }
    //序列化 写
    private static void myWrite() throws Exception {
        //创建一个序列化流对象
        // public ObjectOutputStream(OutputStream out) throws IOException: 创建序列化流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt")) ;
        // public final void writeObject(Object obj) throws IOException
        //创建一个Person类对象
        Person p = new Person("高圆圆",42) ;
        oos.writeObject(p);
        //释放资源
        oos.close();
    }
}

4.重要的java.util.Properties 属性列表

定义:描述一组属性和属性值,属性和属性值都是String类型,没有泛型,继承自HashMap<K,V>
属性列表-->继承自Hashap<K,V>--->implemenets Map<K,V>,Properties可以使用put方法,删除,判断都可以用
特有功能:
	添加属性列表中的属性名称和属性值--->public Object setProperty(String key,String value)
    遍历获取属性列表中的所有键(属性名称)--->public Set<String> stringPropertyNames()
    通过属性名称获取属性值--->public String getProperty(String key)
    	public class PropertiesDemo {
    	public static void main(String[] args) {
        Properties pop = new Properties();
        pop.setProperty("付新刚","爱打球");
        pop.setProperty("王东磊","爱听戏");
        pop.setProperty("刘宝寿","爱唱歌");
        Set<String> s = pop.stringPropertyNames();
        for (String s1 : s) {
            String v = pop.getProperty(s1);
            System.out.println(s1+"的爱好是"+v);
        }
    }
}

4.1 Properties的特有属性

load(Reader reader/InputStream) :加载,将指定某个文件中的内容加载到属性列表中
store(Writer writer/OutputStream, String comments):将属性列表中内容保存到指定的文件中,参数2:对属性列表在描述信息
		public class PropertiesDemo2 {
    public static void main(String[] args) throws Exception {
//        myload();
        myStore();
    }
    private static void myStore() throws IOException {
        Properties popo = new Properties();
        popo.put("高圆圆","43");
        popo.put("文章","39");
        popo.put("王力宏","40");
        popo.put("王宝强","41");
        FileWriter fw = new FileWriter("name.text");
        popo.store(fw,null);
        fw.close();
    }

    private static void myload() throws IOException {
        Properties pop = new Properties();
        /*(1)获取当前类的字节码文件对象 类名.class
        (2)public ClassLoader getClassLoader():获取当前类的所在的类加载器对象
        *(3)public InputStream getResourceAsStream(String name):获取资源文件所在的输入流对象
        * */
        InputStream inputStream = PropertiesDemo2.class.getClassLoader().getResourceAsStream("name.properties");
        pop.load(inputStream);//加载,将资源类文件内容加载到属性集合列表中
        Set<String> set = pop.stringPropertyNames();//遍历
        for (String s : set) {
            String v = pop.getProperty(s);
            System.out.println(s+"="+v);
        }
    }
}

5.网络编程–了解

 不同的地域位置不同的计算机,通过通信线路连接,就形成 一种"网络"
网络编程,就是某个程序在不同的计算机之间进行数据传输 (数据共享)

5.1 网络编程的三要素

(1):ip
(2):port(端口号)
(3):协议

5.2 TCP和UCP—>之间的区别

1.是否需要建立连接通道
	 UDP协议:不需要建立连接通道
     TCP协议:需要建立连接通道
2.是否需要可靠连接
	UDP协议:是一种不可靠连接
    TCP协议:是一种可靠连接
3.发送的数据是否有限制
	 UDP协议:有限制,因为UDP发送--->以一种 "数据报包-->DatagramPacket"的方式
	 TCP协议:没有限制,连接通道里面-->使用字节流的方式来进行通信(数据写,读)
            客户端--->获取通道的字节输出流--->写数据
            服务端--->获取通道的字节输入流--->读数据

5.3 Socket编程步骤(TCP和UDP):必须会写代码

TCP的三次握手
Socket编程步骤:必须会写代码
UDP的方式:发送不断地录入数据,接收不断的去显示数据!
TCP的方式

5.3.1 UDP发送端和接收端的代码实现

前提 :ip地址对象如何表示!
java.net.InetAddress:此类表示Internet协议（IP）地址。
成员方法:
public static InetAddress getByName(String host)throws UnknownHostException:通过主机名称(计算机的全名)或者ip地址的文本(字符串形式),返回值代表的互联网IP地址
public String getHostAddress():通过ip地址对象获取ip地址的字符串形式
public String getHostName():通过ip地址对象获取主机名称
		public class INetAddressDemo {
    public static void main(String[] args) throws UnknownHostException {
        InetAddress name = InetAddress.getByName("DESKTOP-R24MA41");
        System.out.println(name);
        //通过ip地址对象获取ip地址的字符串形式
        String ip = name.getHostAddress();
        //public String getHostName():通过ip地址对象获取主机名称
        String hostName = name.getHostName();
        System.out.println(hostName);
    }
}

5.3.2 UDP的发送端的步骤

1)创建发送端的Socket对象
2)创建一个"数据报包"对象
3)使用UDP发送端的Socket对发送"数据报包"
4)释放资源
				public class UDPsend {
    public static void main(String[] args) throws IOException {
        //1)创建发送端的Socket对象 :DatagramSocket :此类表示用于发送和接收数据报数据包的套接字。
        //构造方法:public DatagramSocket() throws SocketException
        DatagramSocket ds = new DatagramSocket();
        //构造方法:
        //public DatagramPacket(byte[] buf, 发送端数据
        //                      int length,  发送的长度
        //                      InetAddress address,  ip地址对象
        //                      int port)  端口号
        byte[] bytes = "hello,UDP,我来了".getBytes();
        int length=bytes.length;
        InetAddress byName = InetAddress.getByName("10.12.156.40");
        int port = 1314;
        DatagramPacket dm = new DatagramPacket(bytes,length,byName,port);
        //public void send(DatagramPacket p) throws IOException:使用socket发送数据报包
        ds.send(dm);
        ds.close();
    }
}

5.3.3 UDP接收端的步骤

1)创建接收端的Socket对象
2)创建一个"接收容器" 数据报包(数据-->自定义缓冲字节数组 byte[] bytes= new byte[1024]) ,将发送端的数据存储进来
3)接收
4)通过接收端的接收容器:DatagramPacket解析出来的真实数据(数据报包)
5)展示数据
6)释放资源
 * 先运行接收端,然后发送端,而且接收端不能运行多次

public class UDPresrve {
    public static void main(String[] args) throws Exception {
     //(1)创建接受端socket对象--public DatagramSocket(int port)throws SocketException
            DatagramSocket ds = new DatagramSocket(10000);
        while(true) { 
            //(2)创建一个"接收容器" 数据报包(
            byte[] bytes = new byte[1024];
            int length = bytes.length;
            DatagramPacket dp = new DatagramPacket(bytes, length);
            //(3)接受//public void receive(DatagramPacket p)throws IOException
            ds.receive(dp);
            //4)通过接收端的接收容器:DatagramPacket解析出来的真实数据(数据报包)
            //public byte[] getData():获取数据报包的缓冲真实数据
            byte[] bytes2 = dp.getData();
            int length1 = dp.getLength();
            //展示数据: 展示ip地址以及内容
            //DatagramPacket-->方法:public InetAddress getAddress()
            String hostAddress = dp.getAddress().getHostAddress();
            String neirong = new String(bytes2, 0, length1);
            System.out.println("ip地址值来源于" + hostAddress + ",内容是" + neirong);
            ds.close();
        }
    }
}

5.3.4 UDP–优化,多线程:在一个窗口里发送和接收

public class Chatroom {
    public static void main(String[] args) throws Exception {
        //(1)创建发送端和接收端对象
        DatagramSocket  dssend = new DatagramSocket();
        DatagramSocket dsserve = new DatagramSocket(1314);
        //(2)创建资源类对象
        SendDemo sd = new SendDemo(dssend);
        SeverDemo ds = new SeverDemo(dsserve);
        //(3)创建线程
        Thread t1 = new Thread(sd);
        Thread t2 = new Thread(ds);
        //(4)启动线程
        t1.start();
        t2.start();
    }
}
public class SeverDemo implements Runnable {
    private DatagramSocket ds;
    public SeverDemo(DatagramSocket ds){
        this.ds= ds;
    }
    @Override
    public void run() {
        try {
            while (true) {
                //(2)创建一个"接收容器" 数据报包(
                byte[] bytes = new byte[1024];
                int length = bytes.length;
                DatagramPacket dp = new DatagramPacket(bytes, length);
                //(3)接受//public void receive(DatagramPacket p)throws IOException
                ds.receive(dp);
                //4)通过接收端的接收容器:DatagramPacket解析出来的真实数据(数据报包)
                //public byte[] getData():获取数据报包的缓冲真实数据
                byte[] bytes2 = dp.getData();
                int length1 = dp.getLength();
                //展示数据: 展示ip地址以及内容
                //DatagramPacket-->方法:public InetAddress getAddress()
                String hostAddress = dp.getAddress().getHostAddress();
                String neirong = new String(bytes2, 0, length1);
                System.out.println("ip地址值来源于" + hostAddress + ",内容是" + neirong);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
public class SendDemo implements Runnable{
        private DatagramSocket ds;
        public SendDemo(DatagramSocket ds){
            this.ds = ds ;
        }
    @Override
    public void run() {
            try {
                while (true) {
                    Scanner sc = new Scanner(System.in);
                    System.out.println("请您输入一句话");
                    String s = sc.nextLine();
                    if ("886".equals(s)) {
                        break;
                    }
                    byte[] bytes = s.getBytes();
                    int length = bytes.length;
                    InetAddress byName = InetAddress.getByName("10.12.156.68");
                    int port = 1314;
                    DatagramPacket dm = new DatagramPacket(bytes, length, byName, port);
                    //public void send(DatagramPacket p) throws IOException:使用socket发送数据报包
                    ds.send(dm);
                }
            }catch(IOException e){
                e.printStackTrace();
        }
        ds.close();
    }
}

5.3.5TCP协议–>客户端的代码实现

 TCP客户端的操作步骤
1)创建客户端的Socket对象
2)获取客户端所在的通道内字节输出流对象
3)写数据到通道的流中
4)释放资源
public class TCP_Send {
    public static void main(String[] args) throws IOException {
        //(1)创建客户端的Socket对象
        // public Socket(String host,int port)throws UnknownHostException,IOException
        Socket sc = new Socket("10.12.156.68",1314);
        //(2)获取客户端所在的通道内字节输出流对象
        //public OutputStream getOutputStream() throws IOException
        OutputStream ops = sc.getOutputStream();
        //(3)写数据 (写字节数据到通道内的流中)
        ops.write("符新刚是沙比,你同意不?".getBytes());
        //(4)释放资源
        sc.close();
    }
}

5.3.6 TCP协议–>服务器端的代码实现

1)创建服务端的Socket对象
2)监听客户端连接
3)获取通道内的字节输入流
4)读取通道内的数据(客户端写的过来的数据)
5)展示数据,释放资源
public class TCP_Receive {
    public static void main(String[] args) throws Exception {
        // 1)创建服务端的Socket对象
        //public ServerSocket(int port)throws IOException :将指定的端口号绑定在服务器上
        ServerSocket ss = new ServerSocket(1314) ;
        //2)监听客户端连接
        //public Socket accept() throws IOException :返回客户端对象
        Socket socket = ss.accept();
        //3)获取通道内的字节输入流 (获取监听到的客户端的通道内输入流对象)
        //public InputStream getInputStream() throws IOException
        InputStream is = socket.getInputStream();
        //(4)读取通道内字节输入流的数据
        byte[] bytes = new byte[1024];
        int len =is.read(bytes);
        //(5)展示数据
        String string = new String(bytes,0,len);
        String ip = socket.getInetAddress().getHostAddress();
        System.out.println("来源于"+ip+",对你说了"+string);
    }
}

5.3.7 三次握手–客户端发送数据并且接受服务端的信息反馈

public class TCP_Send {
    public static void main(String[] args) throws IOException {
        //(1)创建客户端的Socket对象
        // public Socket(String host,int port)throws UnknownHostException,IOException
        Socket sc = new Socket("10.12.156.68",1314);
        //(2)获取客户端所在的通道内字节输出流对象
        //public OutputStream getOutputStream() throws IOException
        OutputStream ops = sc.getOutputStream();
        //(3)写数据 (写字节数据到通道内的流中)
        ops.write("符新刚是沙比,你同意不?".getBytes());
        //获取服务端所在的通道内字节输入流的对象
        InputStream inputStream = sc.getInputStream();
        //展示
        byte[] bytes = new byte[1024];
        int len = inputStream.read(bytes);
        String string = new String(bytes,0,len);
        System.out.println(string);
        //(4)释放资源
        sc.close();
    }
}
public class TCP_Receive {
    public static void main(String[] args) throws Exception {
        // 1)创建服务端的Socket对象
        //public ServerSocket(int port)throws IOException :将指定的端口号绑定在服务器上
        ServerSocket ss = new ServerSocket(1314) ;
        //2)监听客户端连接
        //public Socket accept() throws IOException :返回客户端对象
        Socket socket = ss.accept();
        //3)获取通道内的字节输入流 (获取监听到的客户端的通道内输入流对象)
        //public InputStream getInputStream() throws IOException
        InputStream is = socket.getInputStream();
        //(4)读取通道内字节输入流的数据
        byte[] bytes = new byte[1024];
        int len =is.read(bytes);
        //(5)展示数据
        String string = new String(bytes,0,len);
        String ip = socket.getInetAddress().getHostAddress();
        System.out.println("来源于"+ip+",对你说了"+string);
        //获取客户端输出字节流的对象
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("我觉得你说太对了".getBytes());//写数据
        socket.close();//释放资源
    }
}

5.3.8 常见问题

1)在读写复制文件是,当加入了服务器反馈的时候,发现两端都处于互相等待状态使用字符缓冲输入李读取文件的结束条件--null,复制的源文件已经复制完毕,但是通道内流不知道文件已经读完了,所以服务器端等待客户端的消息,客户端等到服务端反馈信息,陷入赋值读写死循环
解决办法:1)自定义一个结束条件,如果服务器端读到了这个语句,则结束!
		弊端:如果文件中存在"自定义标记值",则会直接结束
2)public void shutDown:禁用此套接字的输出流

5.3.0 获取字节码文件的三种方式

(1)Object类中的Class getClass(); P P = NEW P; P.getclass();
(2)任意java类型的Class属性
		class clazz = 类名.class
(3)反射里面有一个静态功能
public static class forname()

6 什么是反射(目前了解–>二阶段"Servlet")

6.1 反射的核心思想

定义:反射就是通过获取类或者接口的字节码文件(正在运行的)class类对象,然后获取类中的构造方法在对象java.lang.reflect.Constructor<T> ,创建当前类实例,还可以获取类中的成员变量所在jvava.lang.reflect.Filed对象,然后去给成员变量赋值,还可以获取类中的成员方法所在的java.lang.reflect.Method对象,可以调用成员方法了!

(1)就是通过获取某个类的字节码文件对象,然后去通过构造器对象Construtor,创建该类的实例
(2)也可以通过成员变量对象Filed,给成员变量赋值
(3)也可以获取成员方法所在的Method类对象,调用方法
java代码经历三个阶段:SOURCE CLASS  RUNTIME(运行阶段)

6.2 如何通过反射获取类的字节码文件对象呢?

public static class forname(String classname):参数是全限定名称(包名.类名)
public String getName():获取字节码文件中的全限定名称 

6.3 通过反射的方式创建实体类的实例

1)获取实体类的字节码对象Class
	public static class forname(String classname):参数是全限定名称(包名.类名)
2)获取构造方法Construtor的构造器类对象
//public Constructor<?>[] getConstructors() throws SecurityException:获取类中所有的公共的构造方法的类对象
//public Constructor<?>[] getDeclaredConstructors() throws SecurityException:获取当前类中所有的构造方法的类对象(包括私有)
//public Constructor<T>getConstructor(Class<>..parameterTypes)throws NoSuchMethodException,SecurityException
	获取制定的公共类构造方法,参数是参数类型的class类对象(字节码文件对象-->包名.类名)
(推荐,万能类型的构造器)publicConstructor<T>getDeclaredConstructor(<>.parameterTypes)throws NoSuchMethodException,SecurityException
	获取指定的构造方法,参数是参数类型的class对象
3)通过构造方法construtor类对象来创建当前类的实例
//public T newInstance(Object... initargs):创建当前类的实例 ,参数可变参数, 描述给构造方法的实际参数,返回值是object类
4)输出对象名称
注:当创建非公共构造方法类的construtor构造器对象时,会出现非法访问异常,因为是非公共的,不能访问,需要加载器对象取消语言访问检查,用到public void setAccessible(boolean flag)throws SecurityException ,参数为true;

public class Person {
    private  String name ;
    private  String gender;
    private  int age ;

    public Person() {
    }

    private Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                '}';
    }
}
public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取person类字节码文件
        Class<?> person = Class.forName("com.classword.Person");
        //创建构造construord对象,公共
        //public Constructor<T>getConstructor(Class<>..
        // parameterTypes)throws NoSuchMethodException,SecurityException
        Constructor<?> cons = person.getDeclaredConstructor(String.class,String.class,int.class);
        //加载器对象创建p构造方法实例
        ///public T newInstance(Object... initargs):
        //取消语言访问检查,参数是true
        cons.setAccessible(true);
        Object o = cons.newInstance("高圆圆","女",42);
        //输出构造方法对象,
        System.out.println(o);
    }
}

6.4 如何通过类的字节码文件获取成员变量所在的Filed类对象,并且给成员变量赋值

(1)获取实例类的无参构造方法的对象(步骤如上)
(2)通过字节码文件获取当前字段(成员变量)的类对象Filed
public Field[] getDeclaredField(String filed) throws SecurityException:获取当前类的指定的字段类对象(包括公共的,私有的,受保护的,默认修饰符的)
(3)Field:有一个方法:给成员变量赋值,作用在指定的实例上,
public void set(Object obj,Object value)throws IllegalArgumentException,IllegalAccessException
 //参数1:当前指定的实例(无参构造的对象),参数2:给成员变量实际参数
(4)输出成员变量
public Field[] getFields()throws SecurityException:获取所有公共的成员变量
public Field[] getDeclaredFields()throws SecurityException:获取所有的成员变量

6.5 如何通过反射方式获取一个类中的成员方法的类对象Method,并去调用这个方法

(1)获取构造方法的对象
	/public T newInstance()throws InstantiationException,IllegalAccessException:先获取实例类的字节码文件对象,再直接newInstance,获得无参构造方法对象
(2)获取指定的单个的成员方法类对象
//public Method getDeclaredMethod(String name,Class<?>... parameterTypes):参数一:方法名,参数二:参数2:可变参数, 如果无参,就不需要参数,如果带参,需要写上的参数类型的Class
(3)调用方法(是否有返回值,有返回值需要返回再输出)
public Object invoke(Object obj,Object... args)参数1:当前类的实例,参数2:给方法的形式参数赋值的实际参数
		

public class ReflectDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, NoSuchFieldException, InvocationTargetException {
        Class<?> c = Class.forName("com.classword.Person");
       /* Constructor<?> cons = c.getDeclaredConstructor();
        Object o = c.newInstance();*/
        Object o = c.newInstance();
        //通过字节码文件获取当前字段(成员变量)的类对象Filed
        Field namefiled = c.getDeclaredField("name");
        //取消语言访问检查
        namefiled.setAccessible(true);
        //给成员变量赋值,作用在指定的实例上,参数1:无参构造对象 参数2:赋值
        namefiled.set(o,"高圆圆");
        System.out.println(o);
        System.out.println("-------------------------------");
        Method show = c.getDeclaredMethod("show", String.class);
        show.setAccessible(true);
        show.invoke(o,"付新刚");
    }
}

7.什么是数据库?–>能够存储数据的仓库,简称DB

7.1 mysqlde DDL基本命令(数据库的定义语句)

show databases;	--查看当前所有的数据库
use 数据库名;	--打开指定的数据库
create database 数据库名;	--创建一个数据库
show tables;	--查看所有的表
describe/desc 表名;	--显示表的信息
exit	--退出连接

7.2 操作数据库

CREATE DATABASE [IF NOT EXISTS] 数据库名; //创建数据库
DROP DATABASE [if EXISTS] 数据库名;//删除数据库
select DATABASE():查询当前数据库
use 数据库名;//使用数据库
SHOW DATABASES;//查看所有数据库
show create database 库名:查看新建的数据库的字符集
show variables like '%character%';查询当前整体musql中的所有的带字符集的相关编码格式

7.3 关系型数据库–RDBMS

概念:建立在关系模型基础上,由多张相互连接的二维表组成的数据库
特点:使用表存储数据,格式统一
	2)使用SQL语言操作,标准统一,操作方便

7.4 DDL-表操作-查询

show tables:查询当前数据库的所有表
desc 表名:查询表结构

7.4.1 DDL-表操作-创建表结构

 create table 表名(
     字段1 字段1类型[comment 字段1注释]
     字段2 字段1类型[comment 字段2注释]
     字段3 字段1类型[comment 字段3注释]
 )[comment 表注释]
 注意:每一行字段用,+回车确认,最后一行字段不要加逗号
 --普通当行注释
 /*
 客户端使用多行注释
 */

7.5 DDL数据类型

数据类型分为数值类型,字符串类型,日期类型
字符串类型中,char[]:表示固定的字符长度
			verchar[]:表示根据字符实际长度开辟空间 
精度:指的是数字的长度包括小数位
标度:小数位的长度

7.6DML-表操作-增删改

alter table 表明 add 字段名 类型(长度) [comment注释][约束];----添加字段
alter table 表名 modify 字段名 类型(长度) [comment注释][约束];----修改数据类型
alter table 表名 change 旧字段名 新字段名 类型(长度) [comment注释];-----修改指定表中的指定字段名和字段类型
alter table 表名 drop 字段名----;删除指定表中的制定字段;
alter table 表名 rename to 新表名;-----修改表名
create table 新表名 like 旧表名;---赋值一张新的表
drop table 表名;----删除一张表

8. DML语句–增删改

8.1 DML数据库操作语句-操作表的记录

insert into 表名 values(值1,值2..);----插入全表数据
insert into 表名(字段名称1,字段名称2,...) values(值1,值2...) ;-----插入部分字段
select 字段名称(平时可以用*代表全部字段) from 表名;查询全表数据

8.2 DQL基本查询功能

8.2.1 带条件where关键字的条件查询

update 表名 set 指定某个字段名称 = 值 where 条件; --------带条件进行修改
	update如果不带where 条件,就是批量修改 (不建议);
update 表名 set 字段名称1 = 值1,字段名称2= 2,..where 条件; ----同时修改多个字段
delete from 表名 where 条件;带条件删除,如果有多个条件 where 条件1 and 条件2;---全表删除满足条件的字段(同时满足所有条件)
truncate from 表名 where 条件;带条件删除,如果有多个条件 where 条件1 and 条件2;---全表删除满足条件的字段
//全表删除---区别
delete from 表名;
truncate from 表名:
delete from 表名:只是删除了当前表中的所有记录数据,但是表的结构还存在,不影响数据库数据约束"自增长约束"的id值
TRUNCATE TABLE 表名;不仅将全表数据了,表也删了(直接影响自增长约束的值了),重新创建一张摸一样的空表;

基本运算符(>,>=,<,<=)
赋值运算符(=,!=)
并列关系 and  
或 or 
不等于 <>
多个或者的关系 in集合语句:in(值1,值2,值3..)		字段名称 in(值1,值2,值3..)
判断某个值为null		is null		is not null
	sql的非null判断ifnull(指定字段数据,预期值):当指定字段的数据为null时,默认该值为预期值
在两个值的范围内,包括两端	between 值1 and 值2

8.2.2 模糊查询-like

like
elect 指定的字段列表 from 表名 where 字段名称 like '%xx%':模糊检索指定字段有XX的信息

8.2.3 聚合函数查询

聚合函数不能放在where条件语句中;
count(字段):通过指定字段:查询总记录数
avg(字段):针对某个字段求平均分
sum(字段):针对某个字段求和
max(字段):针对某个字段获取里面的最大值
min(字段):针对某个字段获取里面的最小值
查询当前表中记录数(开发中都是使用的非业务字段:
		一般情况每一张表主键自增长的id值),业务字段不去使用它

8.2.4 排序查询

asc 升序
desc 降序

8.2.5 分组查询-group by

where语句必须置于分组查询之前,后面不能跟聚合函数;
SELECT
	*
FROM student
GROUP BY math,IFNULL(english,0) DESC;-----group by后面没有跟排序时,默认升序排序
group by 的后面可以跟的分组字段,

----- select 分组字段 ,聚合函数 from 表名 group by 分组字段;
SELECT
   sex '性别', -- 查询的分组字段
   AVG(math) '数学平均分' 
FROM student3 GROUP BY sex -- 分组查询; 
注意事项:group by 后面不能跟聚合函数

8.2.6 筛选查询-having

筛选查询必须置于分组查询之后
SELECT
	sex '性别',
	AVG(math) '数学平均分',
	COUNT(id) 人数
FROM student
WHERE
	math>80
	GROUP BY sex
	HAVING 人数>2;

8.2.7 分页查询-limit

分页查询 关键字 limit
-- select 字段列表 from 表名 limit 起始行数,每页显示的条数
-- 起始行数从0开始 ---计算=(当前页码-1)*每页显示的条数
---查询第二页数据
select
	*
from
	student
limit
	2,2;