1.怎么用java编写出座位号(1.0)这样格式？
2.JAVA课程设计 彩票号码产生器
3.Java中Runnable和Thread的区别
4.java火车票售票用到web吗

怎么用java编写出座位号(1.0)这样格式？

       标题中说“写出座位号(1.0)这样格式”，系统我不是影院源码食刻源码购买很理解，只能理解为选座位的售票时候需要输入正确的格式，格式为：[格式：(排.座)，系统例如一排三座请输入(1.3)]。影院源码

       连续售票状态就是售票进入售票后，售完一张票后可以继续售票，系统而不是影院源码退出程序或者返回主菜单，通过while(true)即可实现。售票全球院校库源码连续退票状态也一样。系统

       好了，影院源码上代码：

       首先当然是售票座位初始化，这里定义了5排5座：

       private static final int PAI = 5;//定义座位有几排

       private static final int ZUO = 5;//定义每排有几座

       private static String[][] seat = new String[PAI][ZUO];//定义5排5座的系统座位

       座位初始化，因为你没有说空座位怎么表示，大菠萝棋盘源码我就用“-”来表示空座位，将所有座位初始为空座位：

       public static void main(String[] args) {

       //初始化座位，空位用“-”表示

       for (int i = 0; i < 5; i++) {

       for (int j = 0; j < 5; j++) {

       seat[i][j] = "-";

       }

       }

       printSeat();//显示座位

       先看一下显示座位方法：

       /

       * 显示座位方法

       */

       private static void printSeat() {

       for (int i = 0; i < PAI; i++) {

       System.out.print("|");

       for (int j = 0; j < ZUO; j++) {

       System.out.print(seat[i][j]);

       }

       System.out.println("|");

       }

       }

       接着就是主菜单编写，都写了注释了应该不难理解：

       Scanner in = new Scanner(System.in);

       int input;

       //主菜单连续运行状态

       while (true) {

       System.out.println("请选择操作方法（1-售票、2-退票、职业测评网站源码3-退出）：");

       input = in.nextInt();

       if (input == 1) { //售票

       saleSeat();

       } else if (input == 2) { //退票

       returnSeat();

       } else if (input == 3) { //退出

       System.out.println("退出系统");

       System.exit(-1);

       } else { //错误输入

       System.out.println("输入错误，请选择操作方法（1-售票、2-退票、3-退出）：");

       }

       }

       }

       售票方法：

       /

       * 售票方法

       */

       private static void saleSeat() {

       Scanner in = new Scanner(System.in);

       String input;

       //售票方法连续工作状态

       while (true) {

       printSeat();//显示座位

       System.out.println("\n请输入要购买的座位号[格式：(排.座)，例如一排三座请输入(1.3)]，源码时代教育参观输入[-1]返回主菜单：");

       input = in.nextLine();

       if ("-1".equals(input)) { //返回主菜单

       break;

       }

       try {

       //使用正则表达式“\D”截取字符串，(1.3)的截取结果为：{ "","1","3"}

       String tmp[] = input.split("\\D");

       int pai = Integer.valueOf(tmp[1]) - 1;//取出输入的排号

       int zuo = Integer.valueOf(tmp[2]) - 1;//取出输入的座号

       System.out.println("所选的座位为[" + (pai + 1) + "]排[" + (zuo + 1) + "]座");

       if ("-".equals(seat[pai][zuo])) { //当这个座位没有售卖时，卖出

       seat[pai][zuo] = "*";

       System.out.println("[" + (pai + 1) + "]排[" + (zuo + 1) + "]座已成功售出");

       } else {

       System.out.println("这个位置已经被人买了，换一个吧");

       }

       } catch (Exception e) { //捕获到异常，一般两种情况：座位号格式不对或者排号座号超过了定义的最大值

       System.out.println("错误的座位号：" + input + "[格式：(排.座)，例如一排三座请输入(1.3)]");

       }

       }

       }

       退票方法：

       /

       * 退票方法

       */

       private static void returnSeat() {

       Scanner in = new Scanner(System.in);

       String input;

       while (true) {

       printSeat();//显示座位

       System.out.println("\n请输入要退回的座位号[格式：(排.座)，例如一排三座请输入(1.3)]，输入[-1]返回主菜单：");

       input = in.nextLine();

       if ("-1".equals(input)) {

       break;

       }

       try {

       //使用正则表达式“\D”截取字符串，(1.3)的截取结果为：{ "","1","3"}

       String tmp[] = input.split("\\D");

       int pai = Integer.valueOf(tmp[1]) - 1;//取出输入的排号

       int zuo = Integer.valueOf(tmp[2]) - 1;//取出输入的座号

       System.out.println("待退的座位为[" + (pai + 1) + "]排[" + (zuo + 1) + "]座");

       if ("*".equals(seat[pai][zuo])) { //当这个座位已经售卖时，才可以退回

       seat[pai][zuo] = "-";

       System.out.println("[" + (pai + 1) + "]排[" + (zuo + 1) + "]座已成功退回");

       } else {

       System.out.println("这个位置还没人买，无法退回");

       }

       } catch (Exception e) { //捕获到异常，一般两种情况：座位号格式不对或者排号座号超过了定义的最大值

       System.out.println("错误的座位号：" + input + "[格式：(排.座)，例如一排三座请输入(1.3)]");

       }

       }

       }

       运行结果：

       主菜单：

       选择售票，并购买2排4座：

       继续购买5排5座：

       再次购买5排5座：

       返回主菜单：

       选择退票并退1排1座：

       退2排4座：

       返回主菜单，退出：

       以上。

JAVA课程设计 彩票号码产生器

       æˆ‘这有个超级大乐透的代码在控制台输出的 还没有统计奖项概率 希望可以帮到你 ：1.先说下思路 a.声明2个数组和2个变量数组分别放前区的个数和后区的个数,变量分别为这两个数组的长度 b.首先随机获得前区的5个号码：Random .nextInt(前区长度的变量) 获得随机数,找到第一个数组中下标为这个随机数的元素,取出放在变量中. 这　　　儿可以判断格式 的.可以用正则表达式判断是否为各位数,如果是的话就补全0.然后移除数组中这个元素.当然存储数组的变量要减去1的然后重复　　以上的4次这样就获得了1-中5个不重复的数字. c.同上. 2.附代码SuperJoyful.javaimport java.util.ArrayList;

       import java.util.Arrays;

       import java.util.List;

       import java.util.Random;

       import java.util.regex.Matcher;

       import java.util.regex.Pattern;/

        * 以下是模拟一个超级大乐透随机选号功能，严格按概率生成

        * @author Jack

        */

       public class SuperJoyful {

        // 声明一个List用于存放前区号码

        private List<Integer> objFrontList = new ArrayList<Integer>();

        // 声明一个List用于存放后区号码

        private List<Integer> objBackList = new ArrayList<Integer>();

        // 声明一个正则表达式对象，用于匹配是否是一位数字,用于输出时验证

        Pattern objP = Pattern.compile("\\d");

        // 所要操作的字符串

        Matcher objM = null;

        String[] Front = new String[5];

        String[] Back = new String[2]; // 初始化摇奖号码

        public void init() {

        for (int i = 1; i <= ; i++) {

        objFrontList.add(i);

        }

        for (int i = 1; i <= ; i++) {

        objBackList.add(i);

        }

        } // 开始摇奖

        public void beginLottery() {

        Random objRandom = new Random();

        int nFrontCount = ; // 前区号码总数

        int nBackCount = ; // 后区号码总数 // 摇奖前先清空LIST，再初始化

        objFrontList.clear();

        //System.out.println(objFrontList);

        objBackList.clear();

        //System.out.println(objBackList);

        this.init();

        /

        * 产生5个前区号码

        */

        for (int i = 0; i < 5; i++) {

        //System.out.println("nFrontCount:"+nFrontCount);

        // 初始时有个前区号，随机产生一个索引

        int nIndex = objRandom.nextInt(nFrontCount);

        // 将选出的号码暂时存放在变量中，带正则表达式验证

        int nTemp = objFrontList.get(nIndex);

        String strTemp = new Integer(nTemp).toString();

        // 将获得的号码与正则表达式匹配

        objM = objP.matcher(strTemp);

        boolean flag = objM.matches();

        // 如果是一位数，则在前面补零

        if (flag) {

        Front[i] = ("0" + strTemp + " ");

        } else {

        Front[i] = (strTemp + " ");

        }

        // 删除LIST中该索引处的号码，因为选出一个就不再放回

        objFrontList.remove(nIndex);

        // 号码总数减少一个

        nFrontCount--;

        }

        Arrays.sort(Front);

        for (int n = 0; n < Front.length; n++) {

        System.out.print(Front[n] + "\t");

        }

        System.out.print("+ ");

        /

        * 产生2个后区号码

        */

        for (int i = 0; i < 2; i++) {

        //System.out.println("nBackCount:"+nBackCount);

        // 初始时有个后区号，随机产生一个索引

        int nIndex = objRandom.nextInt(nBackCount);

        // 将选出的号码暂时存放在变量中，带正则表达式验证

        int nTemp = objBackList.get(nIndex);

        String strTemp = new Integer(nTemp).toString();

        // 将获得的号码与正则表达式匹配

        objM = objP.matcher(strTemp);

        boolean flag = objM.matches();

        // 如果是一位数，则在前面补零

        if (flag) {

        Back[i] = ("0" + strTemp + " ");

        } else {

        Back[i] = (strTemp + " ");

        }

        // 删除LIST中该索引处的号码，因为选出一个就不再放回

        objBackList.remove(nIndex);

       // for(int n = 0; n<objBackList.size();n++){

       // System.out.println("objBackList:"+objBackList.get( n ));

       // }

        // 号码总数减少一个

        nBackCount--;

        }

        Arrays.sort(Back);

        for (int n = 0; n < Back.length; n++) {

        System.out.print(Back[n] + "\t");

        }

        // 产生一注后回车

        System.out.println("");

        } // 按要求输出多少注彩票

        public void outPutLottery(int vnCount) {

        for (int i = 0; i < vnCount; i++) {

        this.beginLottery();

        }

        } /

        * @param args

        */

        public static void main(String[] args) {

        SuperJoyful objSJ = new SuperJoyful();

        EnterConsole objEC = new EnterConsole();

        // 声明一个正则表达式对象，用于匹配是否是数字

        Pattern objP = Pattern.compile("\\d{ 1,}");

        // 所要操作的字符串

        Matcher objM = null;

        // 接收控制台输入

        String objTemp = (String) objEC.printConsole();

        //String strTemp = (String)objTemp;

        objM = objP.matcher(objTemp);

        boolean flag = objM.matches();

        int nTemp = 0;

        if (flag) {

        nTemp = new Integer(objTemp);

        } else {

        System.out.println("对不起，只能输入数字！");

        }

        objSJ.outPutLottery(nTemp);

        }

       }EnterConsole.javaimport java.io.BufferedReader;

       import java.io.IOException;

       import java.io.InputStreamReader;

       public class EnterConsole

       {

        public Object printConsole(){

        System.out.print("请输入你要随机选取多少注，确认回车即可：");

        BufferedReader objBR = new BufferedReader(new InputStreamReader(System.in));

        String strValue = null;

        try

        {

        strValue = (String)objBR.readLine();

        }

        catch ( IOException e )

        {

        // TODO Auto-generated catch block

        e.printStackTrace();

        }

        return strValue;

        }

       }

Java中Runnable和Thread的区别

       nable和thread的区别（多线程必须用Runable）

       Java中有两种实现多线程的方式以及两种方式之间的区别

       çœ‹åˆ°ä¸€ä¸ªé¢è¯•é¢˜.问两种实现多线程的方法.没事去网上找了找答案.

       ç½‘上流传很广的是一个网上售票系统讲解.转发过来.已经不知道原文到底是出自哪里了.

       Java中有两种实现多线程的方式。一是直接继承Thread类，二是实现Runnable接口。那么这两种实现多线程的方式在应用上有什么区别呢？

       ä¸ºäº†å›žç­”这个问题，我们可以通过编写一段代码来进行分析。我们用代码来模拟铁路售票系统，实现通过四个售票点发售某日某次列车的张车票，一个售票点用一个线程表示。

       é¦–先这样编写这个程序：

       Java代码

       class ThreadTest extends Thread{

        private int ticket = ;

        public void run(){

        while(true){

        if(ticket > 0){

        System.out.println(Thread.currentThread().getName() +

        "is saling ticket" + ticket--);

        }else{

        break;

        }

        }

        }

       }

       æºç æ‰“印？

       class ThreadTest extends Thread{

        private int ticket = ;

        public void run(){

        while(true){

        if(ticket > 0){

        System.out.println(Thread.currentThread().getName() +

        "is saling ticket" + ticket--);

        }else{

        break;

        }

        }

        }

       }

       main测试类:

       Java代码

       public class ThreadDome1{

        public static void main(String[] args){

        ThreadTest t = new ThreadTest();

        t.start();

        t.start();

        t.start();

        t.start();

        }

       }

       æºç æ‰“印？

       public class ThreadDome1{

        public static void main(String[] args){

        ThreadTest t = new ThreadTest();

        t.start();

        t.start();

        t.start();

        t.start();

        }

       }

       ä¸Šé¢çš„代码中，我们用ThreadTest类模拟售票处的售票过程，run方法中的每一次循环都将总票数减1，模拟卖出一张车票，同时该车票号打印出来，直接剩余的票数到零为止。在ThreadDemo1类的main方法中，我们创建了一个线程对象，并重复启动四次，希望通过这种方式产生四个线程。从运行的结果来看我们发现其实只有一个线程在运行，这个结果 告诉我们：一个线程对象只能启动一个线程，无论你调用多少遍start()方法，结果只有一个线程。

        我们接着修改ThreadDemo1，在main方法中创建四个Thread对象：

       Java代码

       public class ThreadDemo1{

        public static void main(String[] args){

        new ThreadTest().start();

        new ThreadTest().start();

        new ThreadTest().start();

        new ThreadTest().start();

        }

       }

       æºç æ‰“印？

       public class ThreadDemo1{

        public static void main(String[] args){

        new ThreadTest().start();

        new ThreadTest().start();

        new ThreadTest().start();

        new ThreadTest().start();

        }

       }

       Java代码

       class ThreadTest extends Thread{

        private int ticket = ;

        public void run(){

        while(true){

        if(ticket > 0){

        System.out.println(Thread.currentThread().getName() +

        " is saling ticket" + ticket--);

        }else{

        break;

        }

        }

        }

       }

       æºç æ‰“印？

       class ThreadTest extends Thread{

        private int ticket = ;

        public void run(){

        while(true){

        if(ticket > 0){

        System.out.println(Thread.currentThread().getName() +

        " is saling ticket" + ticket--);

        }else{

        break;

        }

        }

        }

       }

       è¿™ä¸‹è¾¾åˆ°ç›®çš„了吗？

        从结果上看每个票号都被打印了四次，即 四个线程各自卖各自的张票，而不去卖共同的张票。这种情况是怎么造成的呢？我们需要的是，多个线程去处理同一个资源，一个资源只能对应一个对象，在上面的程序中，我们创建了四个ThreadTest对象，就等于创建了四个资源，每个资源都有张票，每个线程都在独自处理各自的资源。

        经过这些实验和分析，可以总结出，要实现这个铁路售票程序，我们只能创建一个资源对象，但要创建多个线程去处理同一个资源对象，并且每个线程上所运行的是相同的程序代码。在回顾一下使用接口编写多线程的过程。

       Java代码

       public class ThreadDemo1{

        public static void main(String[] args){

        ThreadTest t = new ThreadTest();

        new Thread(t).start();

        new Thread(t).start();

        new Thread(t).start();

        new Thread(t).start();

        }

       }

       æºç æ‰“印？

       public class ThreadDemo1{

        public static void main(String[] args){

        ThreadTest t = new ThreadTest();

        new Thread(t).start();

        new Thread(t).start();

        new Thread(t).start();

        new Thread(t).start();

        }

       }

       Java代码

       class ThreadTest implements Runnable{

        private int tickets = ;

        public void run(){

        while(true){

        if(tickets > 0){

        System.out.println(Thread.currentThread().getName() +

        " is saling ticket " + tickets--);

        }

        }

        }

       }

       æºç æ‰“印？

       class ThreadTest implements Runnable{

        private int tickets = ;

        public void run(){

        while(true){

        if(tickets > 0){

        System.out.println(Thread.currentThread().getName() +

        " is saling ticket " + tickets--);

        }

        }

        }

       }

       ä¸Šé¢çš„程序中，创建了四个线程， 每个线程调用的是同一个ThreadTest对象中的run()方法，访问的是同一个对象中的变量（tickets）的实例，这个程序满足了我们的需求。在Windows上可以启动多个记事本程序一样，也就是多个进程使用同一个记事本程序代码。

        可见， 实现Runnable接口相对于继承Thread类来说，有如下显著的好处：

       (1)适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU（线程）同程序的代码，数据有效的分离，较好地体现了面向对象的设计思想。

       (2)可以避免由于Java的单继承特性带来的局限。我们经常碰到这样一种情况，即当我们要将已经继承了某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么，这个类就只能采用实现Runnable接口的方式了。

       (3)有利于程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码。多个线程操作相同的数据，与它们的代码无关。当共享访问相同的对象是，即它们共享相同的数据。当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。 Java中Runnable和Thread的区别更详细的资料参考：/course/course_id-.html

java火车票售票用到web吗

       ç”¨ã€‚用Java Web实现的火车票售票系统，其中实现了火车票售票系统该有的基础功能，是面向演示开发的课程设计。火车票，是乘客乘坐火车需出示的票据，主要由客票和附加票两部分构成。