java中创建线程的四种方法以及区别
 
Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用四种方式来创建线程，如下所示：
 
1）继承Thread类创建线程
 
2）实现Runnable接口创建线程
 
3）使用Callable和Future创建线程
 
4）使用线程池例如用Executor框架
 
下面让我们分别来看看这四种创建线程的方法。
 
 
------------------------继承Thread类创建线程---------------------
 
 
通过继承Thread类来创建并启动多线程的一般步骤如下
 
1】d定义Thread类的子类，并重写该类的run()方法，该方法的方法体就是线程需要完成的任务，run()方法也称为线程执行体。
 
2】创建Thread子类的实例，也就是创建了线程对象
 
3】启动线程，即调用线程的start()方法
 
代码实例
 
public class MyThread extends Thread{//继承Thread类
 
　　public void run(){
 
　　//重写run方法
 
　　}
 
}
 
public class Main {
 
　　public static void main(String[] args){
 
　　　　new MyThread().start();//创建并启动线程
 
　　}
 
}
 
------------------------实现Runnable接口创建线程---------------------
 
通过实现Runnable接口创建并启动线程一般步骤如下：
 
1】定义Runnable接口的实现类，一样要重写run()方法，这个run（）方法和Thread中的run()方法一样是线程的执行体
 
2】创建Runnable实现类的实例，并用这个实例作为Thread的target来创建Thread对象，这个Thread对象才是真正的线程对象
 
3】第三部依然是通过调用线程对象的start()方法来启动线程
 
代码实例：
 
public class MyThread2 implements Runnable {//实现Runnable接口
 
　　public void run(){
 
　　//重写run方法
 
　　}
 
}
 
public class Main {
 
　　public static void main(String[] args){
 
　　　　//创建并启动线程
 
　　　　MyThread2 myThread=new MyThread2();
 
　　　　Thread thread=new Thread(myThread);
 
　　　　thread().start();
 
　　　　//或者    new Thread(new MyThread2()).start();
 
　　}
 
}
 
------------------------使用Callable和Future创建线程---------------------
 
和Runnable接口不一样，Callable接口提供了一个call（）方法作为线程执行体，call()方法比run()方法功能要强大。
 
》call()方法可以有返回值
 
》call()方法可以声明抛出异常
 
Java5提供了Future接口来代表Callable接口里call()方法的返回值，并且为Future接口提供了一个实现类FutureTask，这个实现类既实现了Future接口，还实现了Runnable接口，因此可以作为Thread类的target。在Future接口里定义了几个公共方法来控制它关联的Callable任务。
 
>boolean cancel(boolean mayInterruptIfRunning)：视图取消该Future里面关联的Callable任务
 
>V get()：返回Callable里call（）方法的返回值，调用这个方法会导致程序阻塞，必须等到子线程结束后才会得到返回值
 
>V get(long timeout,TimeUnit unit)：返回Callable里call（）方法的返回值，最多阻塞timeout时间，经过指定时间没有返回抛出TimeoutException
 
>boolean isDone()：若Callable任务完成，返回True
 
>boolean isCancelled()：如果在Callable任务正常完成前被取消，返回True
 
介绍了相关的概念之后，创建并启动有返回值的线程的步骤如下：
 
1】创建Callable接口的实现类，并实现call()方法，然后创建该实现类的实例（从java8开始可以直接使用Lambda表达式创建Callable对象）。
 
2】使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象的call()方法的返回值
 
3】使用FutureTask对象作为Thread对象的target创建并启动线程（因为FutureTask实现了Runnable接口）
 
4】调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
 
代码实例：
 
public static class MyThread3 implements Callable{

    @Override
    public Object call() throws Exception {
        return 5;
    }
}
 
public class Main {
 
　　public static void main(String[] args){
 
　　　MyThread3 th=new MyThread3();
 
　　　//也可以直接使用Lambda表达式创建Callable对象
 
　　   //使用FutureTask类来包装Callable对象
 
　　　FutureTask<Integer> future=new FutureTask<Integer>(
 
　　　　(Callable<Integer>)()->{
 
　　　　　　return 5;
 
　　　　}
 
　　  );
 
　　　new Thread(future,"有返回值的线程").start();//实质上还是以Callable对象来创建并启动线程
 
　　  try{
 
　　　　System.out.println("子线程的返回值："+future.get());//get()方法会阻塞，直到子线程执行结束才返回
 
 　　 }catch(Exception e){
 
　　　　ex.printStackTrace();
 
　　　}
 
　　}
 
}
 
------------------------使用线程池例如用Executor框架---------------------
 
1.5后引入的Executor框架的最大优点是把任务的提交和执行解耦。要执行任务的人只需把Task描述清楚，然后提交即可。这个Task是怎么被执行的，被谁执行的，什么时候执行的，提交的人就不用关心了。具体点讲，提交一个Callable对象给ExecutorService（如最常用的线程池ThreadPoolExecutor），将得到一个Future对象，调用Future对象的get方法等待执行结果就好了。Executor框架的内部使用了线程池机制，它在java.util.cocurrent 包下，通过该框架来控制线程的启动、执行和关闭，可以简化并发编程的操作。因此，在Java 5之后，通过Executor来启动线程比使用Thread的start方法更好，除了更易管理，效率更好（用线程池实现，节约开销）外，还有关键的一点：有助于避免this逃逸问题——如果我们在构造器中启动一个线程，因为另一个任务可能会在构造器结束之前开始执行，此时可能会访问到初始化了一半的对象。
 
 
    Executor框架包括：线程池，Executor，Executors，ExecutorService，CompletionService，Future，Callable等。
 
 
    Executor接口中之定义了一个方法execute（Runnable command），该方法接收一个Runable实例，它用来执行一个任务，任务即一个实现了Runnable接口的类。ExecutorService接口继承自Executor接口，它提供了更丰富的实现多线程的方法，比如，ExecutorService提供了关闭自己的方法，以及可为跟踪一个或多个异步任务执行状况而生成 Future 的方法。 可以调用ExecutorService的shutdown（）方法来平滑地关闭 ExecutorService，调用该方法后，将导致ExecutorService停止接受任何新的任务且等待已经提交的任务执行完成(已经提交的任务会分两类：一类是已经在执行的，另一类是还没有开始执行的)，当所有已经提交的任务执行完毕后将会关闭ExecutorService。因此我们一般用该接口来实现和管理多线程。
 
 
    ExecutorService的生命周期包括三种状态：运行、关闭、终止。创建后便进入运行状态，当调用了shutdown（）方法时，便进入关闭状态，此时意味着ExecutorService不再接受新的任务，但它还在执行已经提交了的任务，当素有已经提交了的任务执行完后，便到达终止状态。如果不调用shutdown（）方法，ExecutorService会一直处在运行状态，不断接收新的任务，执行新的任务，服务器端一般不需要关闭它，保持一直运行即可。
 
 
 
    Executors提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口。   
 
    public static ExecutorService newFixedThreadPool(int nThreads)
 
    创建固定数目线程的线程池。
 
    public static ExecutorService newCachedThreadPool()
 
    创建一个可缓存的线程池，调用execute将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线   程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
 
    public static ExecutorService newSingleThreadExecutor()
 
    创建一个单线程化的Executor。
 
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
 
    创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。
 
 
    这四种方法都是用的Executors中的ThreadFactory建立的线程，下面就以上四个方法做个比较
 
 



 newCachedThreadPool()                                                                                                                                         

 -缓存型池子，先查看池中有没有以前建立的线程，如果有，就 reuse.如果没有，就建一个新的线程加入池中
 -缓存型池子通常用于执行一些生存期很短的异步型任务
  因此在一些面向连接的daemon型SERVER中用得不多。但对于生存期短的异步任务，它是Executor的首选。
 -能reuse的线程，必须是timeout IDLE内的池中线程，缺省     timeout是60s,超过这个IDLE时长，线程实例将被终止及移出池。
   注意，放入CachedThreadPool的线程不必担心其结束，超过TIMEOUT不活动，其会自动被终止。
  


 newFixedThreadPool(int)                                                      

-newFixedThreadPool与cacheThreadPool差不多，也是能reuse就用，但不能随时建新的线程
-其独特之处:任意时间点，最多只能有固定数目的活动线程存在，此时如果有新的线程要建立，只能放在另外的队列中等待，直到当前的线程中某个线程终止直接被移出池子
-和cacheThreadPool不同，FixedThreadPool没有IDLE机制（可能也有，但既然文档没提，肯定非常长，类似依赖上层的TCP或UDP IDLE机制之类的），所以FixedThreadPool多数针对一些很稳定很固定的正规并发线程，多用于服务器
-从方法的源代码看，cache池和fixed 池调用的是同一个底层 池，只不过参数不同:
 fixed池线程数固定，并且是0秒IDLE（无IDLE）    
cache池线程数支持0-Integer.MAX_VALUE(显然完全没考虑主机的资源承受能力），60秒IDLE  
  
newScheduledThreadPool(int)

 -调度型线程池
 -这个池子里的线程可以按schedule依次delay执行，或周期执行
  
newSingleThreadExecutor()

-单例线程，任意时间池中只能有一个线程
 -用的是和cache池和fixed池相同的底层池，但线程数目是1-1,0秒IDLE（无IDLE）
  
 
 
    一般来说，CachedTheadPool在程序执行过程中通常会创建与所需数量相同的线程，然后在它回收旧线程时停止创建新线程，因此它是合理的Executor的首选，只有当这种方式会引发问题时（比如需要大量长时间面向连接的线程时），才需要考虑用FixedThreadPool。（该段话摘自《Thinking in Java》第四版）
 
 
                         
 
Executor执行Runnable任务
 
    通过Executors的以上四个静态工厂方法获得 ExecutorService实例，而后调用该实例的execute（Runnable command）方法即可。一旦Runnable任务传递到execute（）方法，该方法便会自动在一个线程上
 
 
 
[java] view pl
 
import java.util.concurrent.ExecutorService;   
import java.util.concurrent.Executors;   
  
public class TestCachedThreadPool{   
    public static void main(String[] args){   
        ExecutorService executorService = Executors.newCachedThreadPool();   
//      ExecutorService executorService = Executors.newFixedThreadPool(5);  
//      ExecutorService executorService = Executors.newSingleThreadExecutor();  
        for (int i = 0; i < 5; i++){   
            executorService.execute(new TestRunnable());   
            System.out.println("************* a" + i + " *************");   
        }   
        executorService.shutdown();   
    }   
}   
  
class TestRunnable implements Runnable{   
    public void run(){   
        System.out.println(Thread.currentThread().getName() + "线程被调用了。");   
    }   
}  
 
 
 
 
 
   某次执行后的结果如下：
 
 
 
 
 
   从结果中可以看出，pool-1-thread-1和pool-1-thread-2均被调用了两次，这是随机的，execute会首先在线程池中选择一个已有空闲线程来执行任务，如果线程池中没有空闲线程，它便会创建一个新的线程来执行任务。
 
 
 
Executor执行Callable任务
 
    在Java 5之后，任务分两类：一类是实现了Runnable接口的类，一类是实现了Callable接口的类。两者都可以被ExecutorService执行，但是Runnable任务没有返回值，而Callable任务有返回值。并且Callable的call()方法只能通过ExecutorService的submit(Callable<T> task) 方法来执行，并且返回一个 <T>Future<T>，是表示任务等待完成的 Future。
 
 
    Callable接口类似于Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常而Callable又返回结果，而且当获取返回结果时可能会抛出异常。Callable中的call()方法类似Runnable的run()方法，区别同样是有返回值，后者没有。
 
 
    当将一个Callable的对象传递给ExecutorService的submit方法，则该call方法自动在一个线程上执行，并且会返回执行结果Future对象。同样，将Runnable的对象传递给ExecutorService的submit方法，则该run方法自动在一个线程上执行，并且会返回执行结果Future对象，但是在该Future对象上调用get方法，将返回null。
 
 
    下面给出一个Executor执行Callable任务的示例代码：
 
 
 
import java.util.ArrayList;   
import java.util.List;   
import java.util.concurrent.*;   
  
public class CallableDemo{   
    public static void main(String[] args){   
        ExecutorService executorService = Executors.newCachedThreadPool();   
        List<Future<String>> resultList = new ArrayList<Future<String>>();   
  
        //创建10个任务并执行   
        for (int i = 0; i < 10; i++){   
            //使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中   
            Future<String> future = executorService.submit(new TaskWithResult(i));   
            //将任务执行结果存储到List中   
            resultList.add(future);   
        }   
  
        //遍历任务的结果   
        for (Future<String> fs : resultList){   
                try{   
                    while(!fs.isDone);//Future返回如果没有完成，则一直循环等待，直到Future返回完成  
                    System.out.println(fs.get());     //打印各个线程（任务）执行的结果   
                }catch(InterruptedException e){   
                    e.printStackTrace();   
                }catch(ExecutionException e){   
                    e.printStackTrace();   
                }finally{   
                    //启动一次顺序关闭，执行以前提交的任务，但不接受新任务  
                    executorService.shutdown();   
                }   
        }   
    }   
}   
  
  
class TaskWithResult implements Callable<String>{   
    private int id;   
  
    public TaskWithResult(int id){   
        this.id = id;   
    }   
  
    /**  
     * 任务的具体过程，一旦任务传给ExecutorService的submit方法， 
     * 则该方法自动在一个线程上执行 
     */   
    public String call() throws Exception {  
        System.out.println("call()方法被自动调用！！！    " + Thread.currentThread().getName());   
        //该返回结果将被Future的get方法得到  
        return "call()方法被自动调用，任务返回的结果是：" + id + "    " + Thread.currentThread().getName();   
    }   
}  
 
 
 
 
    某次执行结果如下：
 
 
   
 
 
    从结果中可以同样可以看出，submit也是首先选择空闲线程来执行任务，如果没有，才会创建新的线程来执行任务。另外，需要注意：如果Future的返回尚未完成，则get（）方法会阻塞等待，直到Future完成返回，可以通过调用isDone（）方法判断Future是否完成了返回。
 
 
 
 
自定义线程池
 
    自定义线程池，可以用ThreadPoolExecutor类创建，它有多个构造方法来创建线程池，用该类很容易实现自定义的线程池，这里先贴上示例程序：
 
 
import java.util.concurrent.ArrayBlockingQueue;   
import java.util.concurrent.BlockingQueue;   
import java.util.concurrent.ThreadPoolExecutor;   
import java.util.concurrent.TimeUnit;   
  
public class ThreadPoolTest{   
    public static void main(String[] args){   
        //创建等待队列   
        BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(20);   
        //创建线程池，池中保存的线程数为3，允许的最大线程数为5  
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3,5,50,TimeUnit.MILLISECONDS,bqueue);   
        //创建七个任务   
        Runnable t1 = new MyThread();   
        Runnable t2 = new MyThread();   
        Runnable t3 = new MyThread();   
        Runnable t4 = new MyThread();   
        Runnable t5 = new MyThread();   
        Runnable t6 = new MyThread();   
        Runnable t7 = new MyThread();   
        //每个任务会在一个线程上执行  
        pool.execute(t1);   
        pool.execute(t2);   
        pool.execute(t3);   
        pool.execute(t4);   
        pool.execute(t5);   
        pool.execute(t6);   
        pool.execute(t7);   
        //关闭线程池   
        pool.shutdown();   
    }   
}   
  
class MyThread implements Runnable{   
    @Override   
    public void run(){   
        System.out.println(Thread.currentThread().getName() + "正在执行。。。");   
        try{   
            Thread.sleep(100);   
        }catch(InterruptedException e){   
            e.printStackTrace();   
        }   
    }   
}  
 
  运行结果如下：
 
 
 
 
    从结果中可以看出，七个任务是在线程池的三个线程上执行的。这里简要说明下用到的ThreadPoolExecuror类的构造方法中各个参数的含义。   
 
 
public ThreadPoolExecutor (int corePoolSize, int maximumPoolSize, long         keepAliveTime, TimeUnit unit,BlockingQueue<Runnable> workQueue)
 
 
corePoolSize：线程池中所保存的线程数，包括空闲线程。
 
maximumPoolSize：池中允许的最大线程数。
 
keepAliveTime：当线程数大于核心数时，该参数为所有的任务终止前，多余的空闲线程等待新任务的最长时间。
 
unit：等待时间的单位。
 
workQueue：任务执行前保存任务的队列，仅保存由execute方法提交的Runnable任务。
 
 
--------------------------------------四种创建线程方法对比--------------------------------------
 
实现Runnable和实现Callable接口的方式基本相同，不过是后者执行call()方法有返回值，后者线程执行体run()方法无返回值，因此可以把这两种方式归为一种这种方式与继承Thread类的方法之间的差别如下：
 
1、线程只是实现Runnable或实现Callable接口，还可以继承其他类。
 
2、这种方式下，多个线程可以共享一个target对象，非常适合多线程处理同一份资源的情形。
 
3、但是编程稍微复杂，如果需要访问当前线程，必须调用Thread.currentThread()方法。
 
4、继承Thread类的线程类不能再继承其他父类（Java单继承决定）。
 
5、前三种的线程如果创建关闭频繁会消耗系统资源影响性能，而使用线程池可以不用线程的时候放回线程池，用的时候再从线程池取，项目开发中主要使用线程池
 
注：在前三种中一般推荐采用实现接口的方式来创建多线程
 
创建线程本质只有1种，即创建Thread类，以上的所谓创建方式其实是实现run方法的方式：
 
 
 
 
 
实现run方法的方式分为两类，你所看到的其他的都是对这两类的封装：
 
1、实现runnable接口的run方法,并把runnable实例作为target对象，传给thread类，最终调用target.run
 
2、继承Thread类，重写Thread的run方法,Thread.start会执行run方法

 
 
Anaconda创建环境：
 
//下面是创建python=3.6版本的环境，取名叫py36
 
conda create -n py36 python=3.6 
 
 
 
删除环境（不要乱删啊啊啊）
 
conda remove -n py36 --all
 
 
 
激活环境
 
//下面这个py36是个环境名
 
conda activate py36      (conda4之前的版本是：source activate py36 )
 
 
 
退出环境
 
conda deactivate    (conda4之前的版本是：source deactivate )

由于不同的项目需要用不同的python版本，于是使用Anaconda来进行版本管理，现记录一下经验：
 
在Anaconda官网下载并安装好Anaconda以后（非常简单，此处不赘述）：
 
1. 查看Python环境
 
conda info --env可以看到所有python环境，前面有个‘*’的代表当前环境：
 
 
2.创建Python环境
 
conda create --name python35 python=3.5  代表创建一个python3.5的环境，我们把它命名为python35
 
 
 
安装成功后的消息：
 
 
现在我们再用conda info --env看看环境：
 
 
出现了，创建成功了，没毛病。
 
3.管理和使用python环境
 
使用conda activate python35 来激活刚才创建的环境：
 
 
尝试使用pip install numpy来给这个环境安装一个常用的包：
 
 
当然也可以用conda install numpy来安装，但是会同时安装很多相关的包，在此就不演示了。
 
在简单的熟悉了以后，就会发现用anaconda来进行python环境的控制真的是非常方便，其实anaconda环境是有物理路径的，如下，你会发现这和我们之前conda info --env的list是一样的：
 
 
之后我们删除python35 ： conda remove -n python35 --all
 
 
再看文件夹，果然已经被删除了：
 

MySQL 创建数据库和创建数据表
 
MySQL 是最常用的数据库，在数据库操作中，基本都是增删改查操作，简称CRUD。
 
在这之前，需要先安装好 MySQL ，然后创建好数据库、数据表、操作用户。
 
一、数据库操作语言
 
数据库在操作时，需要使用专门的数据库操作规则和语法，这个语法就是 SQL(Structured Query Language) 结构化查询语言。
 
SQL 的主要功能是和数据库建立连接，进行增删改查的操作。SQL是关系型数据库管理系统的标准语言。
 
SQL 语言的作用：
 
1. 数据定义语言 DDL(Data Definition Language) 。用于创建数据库，数据表。
 
2. 数据操作语言 DML(Data Manipulation Language) 。用于从数据表中插入、修改、删除数据。
 
3. 数据查询语言 DQL(Data Query Language) 。用于从数据表中查询数据。
 
4. 数据控制语言 DCL(Data Control Language) 。用来设置或修改数据库用户或角色的权限。
 
使用 SQL 操作数据库时，所有的 SQL 语句都以分号结束。(切换数据库时可以不用分号)
 
在 SQL 语句中，不区分大小写，编写 SQL 语句时可以根据情况用大小写的区别来增加可读性。
 
二、创建数据库
 
1. 连接 MySQL
 
输入 mysql -u root -p 命令，回车，然后输入 MySQL 的密码(不要忘记了密码)，再回车，就连接上 MySQL 了。
 
mysql -u root -p
 
 
最初，都是使用 root 用户登录，工作中如果一直用 root 用户登录，因为权限太大，风险是很大的，所以等创建好权限适合的用户后，就不要经常登录 root 用户了。
 
2. 查看当前的数据库
 
使用 show databases; 查看当前安装的 MySQL 中有哪些数据库。
 
show databases;
 
 
刚安装 MySQL 时，默认有四个数据库，information_schema，mysql，perfomance_schema，sys 。通常情况下，我们不会直接使用这四个数据库，但千万不要把这四个数据库删了，否则会带来很多不必要的麻烦。如果不小心删了，建议是重新安装 MySQL ，在重装之前把自己的数据迁移出来备份好，或者从其他服务器上迁移一个相同的数据库过来。
 
3. 创建数据库
 
使用 create database 数据库名; 创建数据库。
 
create database MyDB_one;
 
 
创建数据库成功后，数据库的数量变成了5个，多了刚才创建的 MyDB_one 。
 
4. 创建数据库时设置字符编码
 
使用 create database 数据库名 character set utf8; 创建数据库并设置数据库的字符编码。
 
create database MyDB_two character set utf8;
 
 
直接创建的数据库，数据库的编码方式是 MySQL 默认的编码方式 latin1 (单字节编码) ，通常我们会在数据库中存放中文数据，所以最好把数据库的编码方式设置成 utf-8 ，这样中文才能正常显示。
 
create database MyDB_three charset utf8;
 
character set 可以缩写成 charset ，效果是一样的。
 
5. 查看和显示数据库的编码方式
 
使用 show create database 数据库名; 显示数据库的创建信息。
 
show create database MyDB_one;
show create database MyDB_two;
 
 
如果不知道一个数据库的编码方式是什么，可以使用 show create database 数据库名 来查看数据库的编码方式。可以看到刚才创建的 MyDB_one 的编码方式是 MySQL 的默认编码 latin1 ，MyDB_two 的编码方式是 utf-8 。
 
当然，这种方式不能在创建的同时显示，只能查看一个已经存在的数据库的编码方式。
 
6. 使用 alter database 数据库名 character set utf8； 修改数据库编码
 
alter database MyDB_one character set utf8;
 
 
如果一个数据库的编码方式不符合使用需求，可以进行修改。刚才创建的 MyDB_one 经过修改后，编码方式也变成了 utf-8 。
 
7. 进入或切换数据库
 
使用 use 数据库名 进入或切换数据库。
 
use MyDB_one
use MyDB_two;
 
 
刚连接上 MySQL 时，没有处于任何一个数据库中，如果要使用某一个数据库，就需要进入到这个数据库中。
 
use 数据库名 这个命令后面的分号可以省略，这是 SQL 语句中唯一可以省略分号的语句。
 
8. 显示当前数据库 select database();
 
select database();
 
 
进入数据库中，可以使用 select database(); 来查看当前处于哪个数据库中。长时间操作数据库时，在很多数据库中来回切换后，查看当前的数据库，避免操作错了数据库。
 
三、创建数据表
 
1. 查看当前数据库中的表
 
使用 show tables；查看当前数据库中有哪些表。
 
show tables;
 
 
在刚才创建的数据库 MyDB_one 中，还没有创建任何表，所以当前是空的。
 
2. 创建表
 
使用 create table 表名(字段1 字段类型,字段2 字段类型,字段3 字段类型,…); 来创建一张表。
 
create table Phone_table(pid INT, name CHAR(20), price INT);
 
 
在 MyDB_one 中创建了一个叫 Phone_table 的数据表，这张表有三个字段 pid，name，price 。为了增加 SQL 的可读性，字段名我用的是小写，字段类型用大写。
 
3. 显示表信息
 
用 show create table 表名; 来显示已创建的表的信息。
 
show create table Phone_table;
 
 
使用 show create table 表名;  可以显示表的字段信息， MySQL 的引擎，和默认的字符编码等信息。与显示数据库信息一样，show 只能显示已经创建了的数据表的信息，不能在创建的同时显示信息。
 
 
如果想更好地展示表的字段信息，可以使用 desc 表名; 来显示表的字段信息。
 
4. 给表增加字段
 
使用 alter table 表名 add 字段名 数据类型; 为已存在的表添加一个新字段。
 
alter table Phone_table add color CHAR(20);
 
 
添加后，刚才的表中多了一个字段，新增成功。
 
5. 删除表的字段
 
使用 alter table 表名 drop 字段名; 删除一个表中已存在的字段。
 
alter table Phone_table drop price;
 
 
删除字段后，表中不再有该字段。
 
6. 修改字段的数据类型
 
使用 alter table 表名 modify 字段名 数据类型; 修改表中现有字段的数据类型。
 
alter table Phone_table modify name VARCHAR(12);
 
 
修改之后，该字段的数据类型发生改变。
 
7. 修改字段的数据类型并且改名
 
使用 alter table 表名 change 原字段名 新字段名 数据类型; 修改表中现有字段的字段名和类型。
 
alter table Phone_table change name pname CHAR(18);
 
 
现在，将表的 name 改成了 pname ，同时修改了 pname 的数据类型。
 
四、MySQL 常用字段类型
 
一个数据表是由若干个字段组成的，一个表十几个字段也很正常，每个字段表示不同的信息，需要使用不同类型的数据。
 
所以在创建表的时候，要为每个字段指定适合的数据类型。
 
MySQL 中常用的字段类型有以下这些：
 
1. 整数类型
 
数据类型
数据范围
TINYINT
-128 -- 127
SMALLINT
-32768 -- 32767
MEDIUMINT
-2^23 -- 2^23-1
INT
-2^31 -- 2^31-1
BIGINT
-2^63 -- 2^63-1
2. 字符串类型
 
数据类型
字节范围
用途
CHAR(n)
0 -- 255字节
定长字符串
VARCHAR(n)
0 -- 65535字节
变长字符串
TEXT
0 -- 65535字节
长文本数据
LONGTEXT
0 -- 2^32-1字节
极大文本数据
BLOB
0 -- 65535字节
二进制长文本数据
LONGBLOB
0 -- 2^32-1字节
二进制极大文本数据
3. 小数类型
 
m 表示浮点数的总长度，n 表示小数点后有效位数。
 
数据类型
数据用法
数据范围
Float
Float(m,n)
7位有效数
Double
Double(m,n)
15位有效数
Decimal
Decimal(m,n)
28位有效数
4. 时间类型
 
数据类型
格式
用途
DATE
YYYY-MM-DD
日期
TIME
HH:MM:SS
时间
YEAR
YYYY
年份
DATETIME
YYYY-MM-DD HH:MM:SS
日期和时间
TIMESTAMP
10位或13位整数（秒数）
时间戳
5. 枚举类型
 
enum(枚举值1,枚举值2,...)
 
枚举类型只能在列出的值中选择一个，如性别。