2010年10月31日

MVC

MVC含义

一种软件构架，简单的说就是在做软件的时候，可以将软件分为不同的模块，不同的模块实现了不同功能。

MVC 组成部分

Model 模型

View 视图

Controller 控制器

MVC就是三种组成部分的缩写。

MVC 不同模块的功能

Model（模型层）程序员编写程序应用的功能，数据库设计等。属于后台操作。

View （视图层）前台界面，也就是用户可以看到的图形见面，一般在web中是一些*.jsp或*.html。

Controller（控制器）处理前台和后台请求。

MVC 优点

采用MVC的优点太多了，说再多不如你在真正的项目中自己体会，在这里不做太多解释。

MVC 包结构

虽然，这并不能说明所有MVC框架所有的包模式，不过我觉得新手对于这个包结构还是比较容易接受的。

DAO 模式

在DAO层，最主要的作用是：完成数据的操作。在这层，你可以完成对任何表的数据操作，不过个人认为DAO层最大的作用是简单了编程人员的编程逻辑，简单的说就是将一个大的问题，分成了几个比较小的问题，这样不管在测试还是在维护都起着很大的方便。

Factory 工厂

Factory 工厂在这里也可以说成是DAO的工厂，这里Factory仅仅产生了DAO。那么Factory工厂模式有什么好处呢？

在MVC中的Factory 层，你完全可以把它想象成现实中的工厂，生产某些东西，如果在程序中使用工厂模式，你可以简化编程代码，相当与现实中你需要某个产品不需要自己去生产，完全可以去工厂“拿”一个，这样程序的编程更加符合现实中的逻辑。

MVC 总结

本节，我仅仅是将MVC的编辑思想简单的介绍了一下，我没有加入一些详细的例子，因为我觉得你在接触MVC的时候，最好先了解MVC的编程思想，如果你要了解MVC的编程思想之后，你再接触MVC的编程时，你就会觉得特别简单。

最后，希望我这篇文章可以让大家简单的了解MVC的编程模式。

posted @ 2011-01-25 09:30 tovep 阅读(2120) | 评论 (9) | 编辑收藏

ForEach 小结

摘要: ForEach小结 <c:forEach>标签具有以下一些属性： var：迭代参数的名称。在迭代体中可以使用... 阅读全文

posted @ 2011-01-24 08:37 tovep 阅读(2347) | 评论 (0) | 编辑收藏

Servlet中web.xml配置

通过以下Servlet程序和web.xml来说明web.xml的配置以及过程

创建一个Login的HTML文件

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
    <title>login.html</title>

    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="this is my page">
    <meta http-equiv="content-type" content="text/html; charset=UTF-8">

</head>
<body>
    <form action="test1" method="post">
      <table border="0" width="379" height="79">
        <tr>
          <td>帐号:</td>
          <td><input type="text" name="username"></td>
        </tr>
        <tr>
          <td>密码:</td>
          <td><input type="password" name="password"></td>
        </tr>
        <tr>
          <td colspan="5" align="center"><input type="submit" value="登录"></td>
        </tr>
      </table>
    </form>
</body>
</html>

以上HTML标签中要说明的是：
<form>标签中的 action="test_Web_xml" 和 method="post" 分别定义了Html将登陆的信息发送给了谁，以及发送信息的方法！

创建一个Servlet程序

public class LoginServlet extends HttpServlet{

    public void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
        String username = null;
        username = request.getParameter("username");
        String password = null;
        password = request.getParameter("password");

        if(username.equals("username")&&password.equals("password")){
            request.getRequestDispatcher("成功登陆！！！").forward(request,response);
        }else{
            request.getRequestDispatcher("登陆失败！！！").forward(request,response);
        }
    }
}

web.xml配置

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">


    <servlet>
    <servlet-name>
    Login
    </servlet-name>

    <servlet-class>
        com.rise.LoginServlet
        </servlet-class>
    </servlet>

    <servlet-mapping>
    <servlet-name>
       Login
    </servlet-name>
    <url-pattern>
    /test1

</url-pattern>

    </servlet-mapping>



<welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>

我理解web.xml的作用就是将页面和后台程序正确连接！！！

通过一张图片说明我理解的web.xml的作用

以上的内容是我自己对web.xml的理解，我觉得很简单，但真正写程序的时候部署程序是非常复杂的！

posted @ 2010-12-11 20:43 tovep 阅读(6289) | 评论 (2) | 编辑收藏

Java连接数据库技术JDBC

什么是JDBC

JDBC是由一组Java语言编写的类和接口组成，用来处理关系数据库！利用JDBC的API，可用Java语法去访问各种各样的SQL数据库。
个人认为：
把JDBC当做是一门连接Java程序连接数据库的技术不如把JDBC当做连接程序和数据库的桥梁。

以下我要写的例子是用纯Java的Driver来连接数据库的方式。连接的数据库是mysql。

JDBC编程步骤

       1.加载数据库驱动(jar文件)
            //需要下载一个数据库的jar包，并导入相应的JDBC项目中，创建路径！
            Class.forName("com.mysql.jdbc.Driver");

       2.获得数据库连接
        DriverManager.getConnection("jdbc:mysql://Database_IP:3306/DATABASE","DATAROOT","PASSWORD");//返回Connection————获得数据库连接

       3.创建语句
        String sql = "SQL_TORUNNING";
        向DATABASE发送一个执行语句
        Statement stmt = conn.createStatement();//创建一个 Statement 对象来将 SQL 语句发送到数据库.
               Statement—————SQL_RUNNING!!!

       4.执行查询
        ResultSet rs = Statement.executeQuery(SQL_RUNNING);//执行SQL_RUNNING命令，返回ResultSet
        //如果执行的数据库语句不是对数据库中的内容进行修改的话，则用 Statement.executeQuery()
            //如果执行的数据库语句是修改数据库中的内容进行修改的话，则用 Statement.executeUpdate()
            //当然他们返回值的类型也不同！
            //根据命令的不同Statement的方法也不同

                创建一个表
                Statement.execute(create a table)

                增删改查Insert、update、delete...
                Statement.executeUpdate()

                    查询语句Select
                Statement.executeQuery(Select);

       5.遍历结果集
        while(ResultSet.next()){
            ResultSet.getInt(int);
            ResultSet.getString(int);
            ......
        }


       6.关闭数据库连接
               Connection.close();

步骤分析

(图一)

1.加载数据库驱动

         我们来看图一，工厂和几个农村之间有一条河，不能够直接进行沟通，工厂就相当于一个Java程序，而几个农村就相当于不同的数据库；
   工厂为B村生产一些材料，但是生产出来之后并不能直接交给B村，然后工厂的厂长就想在工厂和B村之间架设一座桥梁来运送生产出来的材料——我们大可把数据库驱动加载当做这个架设桥梁的想法。

   在程序中我们要怎么做呢？
         在加载数据库驱动的时候，必须要将相应的mysql-connector-java-5.0.4-bin.jar包，然后将jar包导入相应的项目中如下图

         在mysql-connector-java-5.0.4-bin.jar右击建立路径，就相当于import的过程——我不确定这么说对不对，但我是这么理解的。
         建立路径后，你的项目将出现一个新的文件，如下图

这样的话，你就可以顺利加载数据库驱动，否则当你在运行的时候会出现找不到Driver.class的异常，也就是无法加载数据库驱动。
Class.forName("com.mysql.jdbc.Driver");

2.获得数据库连接

         既然厂长有想法和B村之间架设一座桥梁，那就要和B村商量一下啊！然后，厂长就要去河的对岸，那条河呢？就是在工厂和B村之间的那条河(这条河就相当于Database_IP),然后去找B村的村长(在这里要明白是B村的村长不是A村的，所以不能找错了！！！)，找到B村村长，“我要在工厂和B村之间建设一座桥，来运输我们的东西”，下一步谈的当然是条件了，工厂老板说“我要B村出资90%，剩下的由工厂出！！”村长当然不干了，这桥当然也就没法建设了！！！所以只有当两者都满意的情况下才可以建设桥梁(比如，各处50%)其实谈条件的过程就相当于验证数据库的"DATAROOT"和"PASSWORD"！！！只有两者都正确的情况下才可以进行下一步的计划——也就是建设桥梁！！！

         在程序中的过程如下:
         Connection conn = null;
         conn = DriverManager.getConnection("jdbc:mysql://Database_IP:3306/DATABASE","DATAROOT","PASSWORD");
         //返回Connection————获得数据库连接

3.创建语句

         桥已经建好了，然后工厂要准备一些卡车来运输生产的货物，然后农村需要根据不同的货物来处理这些货物，有些货物直接卸在B村就可以了，但有些货物卸在B村之后，B村要做一些处理然后运回工厂！！！

         这个过程在程序是怎么体现的呢？
         String sql = "SQL_TORUNNING";
       向DATABASE发送一个执行语句
       Statement stmt = conn.createStatement();//创建一个 Statement 对象来将 SQL 语句发送到数据库.
       Statement—————SQL_RUNNING!!!

4.处理数据库发送来的消息

         如果工厂运输到B村的货物，只要B村的村长给工厂开一张条就行了；但也会有一些货物需要运回工厂！！

         在程序中：
         ResultSet rs = Statement.executeQuery(SQL_RUNNING);//执行SQL_RUNNING命令，返回ResultSet
       //如果执行的数据库语句不是对数据库中的内容进行修改的话，则用 Statement.executeQuery()——需要返回一些货物
         //如果执行的数据库语句是修改数据库中的内容进行修改的话，则用 Statement.executeUpdate()——开张条就行了
         //当然他们返回值的类型也不同！
       //根据命令的不同Statement的方法也不同

             创建一个表
             Statement.execute(create a table)

             增删改查Insert、update、delete...
             Statement.executeUpdate()

                 查询语句Select
             Statement.executeQuery(Select);

5.处理数据库传回的内容

        这个过程由工厂完成，如果是返回的一些货物的话，工厂要做一些处理。

        处理的过程：
                while(ResultSet.next()){
            ResultSet.getInt(int);
            ResultSet.getString(int);
            ......
        }

6.关闭数据库

这样的话，工厂和B村的交易就完成，在现实世界中工厂和B村之间的桥梁不会被拆除，因为建一座桥的代价很大，但在程序和数据库之间架设一座桥梁简直太简单了，所以在这里我们要把这座桥梁拆除。

Connection.close();

简单的举了一个例子来说明数据库和程序之间是怎么连接的，望对大家有所帮助。

posted @ 2010-12-09 18:37 tovep 阅读(1618) | 评论 (1) | 编辑收藏

Java_常用SQL语句

SQL语言是操作数据库的基础语言，对于不同的数据库语言产品，SQL语言大多是通用的，本篇博客旨在介绍一些最常用的SQL语句。希望对大家能有所帮助。
注：
本文中的红色字体黄色背景的内容为SQL语句！！
笨人也是菜鸟，如果我写的有错误，大家一定要指出来啊！！！好了，废话不说了，切入正题：

首先，使用status查看MySQL当前的信息

1.使用show databases;语句查看当前数据库：

2.使用create database DATABASE_NAME;语句来创建DATABASE_NAME数据库

这样，我们创建好了一个名字为database_name的数据库。
注：数据库语句对字母大小写不敏感！

3.使用use DATABASE_NAME;切换到使用DATABASE_NAME数据库模式。

4.在database_name数据库创建一个表：

create table if not exists table_name      -- 如果表table_name不存在则创建
     (id int primary key auto_increment,     -- 创建int类型为主键，且自动增长
      name varchar(200) not null,            -- 创建字符类型的列，最大长度是200字节
      age int(3),                            -- 创建int类型，长度为3个字节
      sex varchar(2),                        -- 创建字符类型，长度是2个字节
      salary float(11,2),                    -- 创建float类型的列，长度为2个字节
      address varchar(50),                   -- 创建字符类型，长度为50个字节
      birthday date                          -- 创建日期类型
     );

这样就创建好了一张表，可以用 describe 或则 desc来查看表的结构
describe table_name;
desc table_name;

这样数据就创建好了一张表，我们可以用show tables; 来查看数据库中所有表

然后，我们就可以看见我们创建的表
====================================================================================
数据库最具核心的用法——对数据库表的数据的增删改查。

向表中增加数据(要了加入表的结构，看哪项可以为空)
insert table_name (name,age,sex) values ('tovep',22,'男');

向表中加入数据的时候，并不是要把所有的信息都要写近期，只要表中结构设置为可以为空的都
可以不写！！
id不用写，因为它是自动增长的！

要想查看表中的内容，可以用select语句———为了说明下面的情况，我加入了多条信息
select * from table_name; -- 将table_name表中的所有数据都打印出来

select name from table_name; --查看所有人的名字

select * from table_name where id<5; --将表中id小于100的都打印出来

在使用select 语句查询的时，常常用到别名
select t.name,t.id,t.age from table_name as t;

select 语句中的where表示查询的条件
where中还可以使用like与"%"对字符类型的列进行模糊查询
select * from table_name where name like 't%';

update语句：修改数据

update 表名 set 字段名 = '修改的值'

update table_name set name='tvoep1' where id>2;

删除用
delete from 表名 where 判断信息
delete from table_name where id=5;

这样的话就删除了id=5的信息

====================================================================================

使用drop 来删除表或者数据库
drop table table_name;

drop database database_name;

posted @ 2010-12-06 11:04 tovep 阅读(2295) | 评论 (2) | 编辑收藏

Java_一失足成千古恨

经过一个多月的Java学习，我们慢慢深入了解了Java中的一些比较高级的方法！但这些方法在你调试的时候一定要慎重！！不要等待失去了整个硬盘，才后悔莫及！！！如果你在编程的时候多长个心眼，这些小的错误是可以避免的！！！

下面我们来看一下一个让人很崩溃的错误，这个错误让我感到不可思议！！代码如下：

import java.io.File;

public class KillBackServer {

public static void main(String[] args){
  File f = new File("C:\\");
  fun(f);
}

//定义一个静态函数，用来实现对一盘文件的遍历
public static void fun(File f)
    {
   if(f.isDirectory())
    {
      File file[] = f.listFiles();
      try
      {
        for(int i = 0 ; i <file.length ; i++)
        {
             fun(file[i]);
        }
      }
             catch(Exception e){}
    }
   else
   {
        if("我是病毒.exe".equals(f.getName()))
               System.out.println(f);
              //仅仅当程序找到"我是病毒.exe"的时候才执行这一句代码
               //f.delete();
               System.out.println("该病毒已被查杀");}
               System.out.println(f.getPath() + "***********************");
    }

}

}

大家一定要注意红色字体的代码！！！我之所以注释了，就是怕直接复制我的代码，然后运行……
如果这样后果你是知道的……

本来这段代码是用来扫描C盘，找到"我是病毒.exe"文件，并把它删除，判断一个文件名，用的是equals这是对的！！！
错就错在：if()判断，大家都明白了吧！
希望大家以后不要因为犯了这个低级错误，而把自己的硬盘给了格了= = |||

其实，有很多方法可以避免这种错误！！！比如，你可以在f.delete(); 后面加上一句打印语句，这样的话，在你测试的时候就会发现，原来if语句后面少一个大括号……

这个错误写出来仅仅为了提醒大家规范的重要性！！！

posted @ 2010-11-17 21:29 tovep 阅读(2658) | 评论 (16) | 编辑收藏

Java实现自动化_Robot类简单应用

/**
    *         Robot类   ：
    *
    *             exec 函数声明：
    *                 public Process exec (String command) throws IOException ,参数及功能说明：
    *                     command: 一条指定的系统命令
    *                     功能：在单独的进程中执行指定的字符串命令
    *
    *             keyPress 函数说明：
    *                 public void keyPress(int keycode),参数及功能说明：
    *                     keycode：要按下的键（例如，KeyEvent.VK_A）
    *                     功能：模拟按下指定键
    *
    *             keyRelease 函数说明：
    *                 public void keyRelease(int keycode),参数及功能说明：
    *                     keycode：要释放的键
    *                     功能：模拟释放指定键
    *
    * @param tovep
    */
import java.awt.Robot;
import java.awt.event.KeyEvent;

public class Exce {

    public static void main(String[] args) {
        try{
            //创建自动操作类
            Robot robot = new Robot();


            /**
            *
            *         利用Runtime类运行Word程序的方法为：
            *             Runtime.getRuntime().exec("cmd /c start winword");
            *                                         括号里的是系统命令
            *
            */

            //启动记事本程序
            Runtime.getRuntime().exec("cmd /c start notepad");

            //延缓几秒钟，等待记事本程序启动成功
            robot.delay(3000);

            //模拟按下"Ctrl + Space" 组合键，启动输入法
            pressKeyWithCtrl(robot,KeyEvent.VK_SPACE);

            //模拟随机按下100个字母，输入汉字
            for(int i=0;i<100;i++){
                pressKey(robot, (int) (Math.random()* 25) + 'A');
                pressKey(robot,KeyEvent.VK_SPACE);
            }

            //延缓5秒钟，一共观察
            robot.delay(5000);

            //关闭记事本
            //closeApplication(robot);
        }catch (Exception e){
            System.out.println(e.getMessage());
        }

    }

    //模拟按下键盘字符键
    public static void pressKey(Robot robot, int keyvalue){
        //模拟按下
        robot.keyPress(keyvalue);

        //模拟弹起
        robot.keyRelease(keyvalue);
    }

    //模拟同时按下"Ctrl"键和字符键
    public static void pressKeyWithCtrl(Robot robot, int keyvalue){
        //模拟按下
        robot.keyPress(KeyEvent.VK_CONTROL);
        robot.keyPress(keyvalue);

        //模拟弹起
        robot.keyPress(keyvalue);
        robot.keyRelease(KeyEvent.VK_CONTROL);

    }

    //模拟按下"Alt + F4"组合键，关闭当前应用程序
    public static void closeApplication(Robot robot){
        //模拟按下"Alt + F4"组合键
        //模拟按下
        robot.keyPress(KeyEvent.VK_ALT);
        robot.keyPress(KeyEvent.VK_F4);

        //模拟弹起
        robot.keyRelease(KeyEvent.VK_ALT);
        robot.keyRelease(KeyEvent.VK_F4);

        //模拟按下"N"，不保存文件退出记事本程序
        //模拟按下
        robot.keyPress(KeyEvent.VK_N);

        //模拟弹起
        robot.keyRelease(KeyEvent.VK_N);
    }


}

posted @ 2010-11-17 00:14 tovep 阅读(5406) | 评论 (1) | 编辑收藏

IO流_Java_File类总结

在Java中，Everything is Object！所以在文件中，要不例外！

在Java中，可以用File类来表示一个文件！！！（注意这里的文件可以是所有文件，包括文件夹）

下面的代码表示一个文件：

public class Demo {

    public static void main(String[] args){

        File f = new File("e:\\file");

        if(f.isDirectory()){
            System.out.println(f.getPath());
        }
    }
}

运行结果是：

代码中isDirectory()方法是判断文件是文件夹还是一个文件（这里可能有点迷糊），也可以这么理解，我所说的文件夹就是一个目录，
getPath()方法是打印文件(这里指的是file文件夹)的路径！！！

看看下面的代码还有注释：

/**
*
*          File.speparator的作用是判断在不同的系统中斜杠的方向
*
* 在windows中斜杠的方向是向右斜的\\
* 在Linux 中斜杠的方向是向左斜的//
*
*
*         File中createNewFile方法：
*          当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
*          检查文件是否存在，若不存在则创建该文件，这是单个操作，对于其他所有可能影响该文件的文件系统活动来说，该操作是不可分的。
*
*            注：此方法不应该用于文件锁定，因为所得协议可能无法可靠地工作。应该使用 FileLock 机制替代。
*
*
*/

import java.io.File;

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

        File f;

        f = new File("e:" + File.separator + "file" + File.separator + "io.txt");
        System.out.println(f.createNewFile());
    }

}
===================================
运行结果是：

大家注意，如果你的直接复制这些代码的话，可能会出现以下异常

看看大家都明白了吧！系统找不到指定的文件，就是在e盘下新建一个file文件夹就可以啦！！！

下面代码详细的介绍了File类中的createNewFile()方法：

/**
*
*         File中createNewFile方法：
*          当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
*          检查文件是否存在，若不存在则创建该文件，这是单个操作，对于其他所有可能影响该文件的文件系统活动来说，该操作是不可分的。
*
*            注：此方法不应该用于文件锁定，因为所得协议可能无法可靠地工作。应该使用 FileLock 机制替代。
*        返回：是布尔型
*
*/

import java.io.File;

public class Demo02 {
    public static void main(String[] args) throws Exception{
        File f = new File("f:\\demo.txt");
        System.out.println(f.createNewFile());
    }

}

运行结果如下：

下面介绍一下File类中delete()方法，代码如下：

/**
*
*             要操作一个文件，必须要找到这个文件
*             在Java中，只有File类能表示一个文件，所有用File表示一个文件
*             File的属性就是文件的路径，虚拟机会根据File类的参数找到指定的文件
*             找到问及那后可以用File类的方法进行操作！
*
*             delete()方法可以删除一个文件或者一个整个文件夹（整个目录），返回结果是布尔类型！！
*
* */

import java.io.File;

public class Demo11 {

    public static void main(String[] args) {

        File f = new File("f:\\demo.txt");

        f.delete();
        if(boo){
            System.out.println("成功删除文件");
        }
    }
}

这个程序运行的结果：

下面的代码是介绍查看一个文件的目录，以及判断这个文件是否是文件夹，代码如下：

/**
*
*         File的一个方法File.getPath()
*                     是将此抽象路径名转换为一个路径名字符串。
*
*         File的exists方法
*                     是测试此抽象路径名表示的文件或目录是否存在。
*
*
*         File的getParent()方法
*                     是返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null
*
* */

import java.io.File;

public class Demo21 {

    public static void main(String[] args) {

        File f = new File("f:" + File.separator + "demo.txt");
        System.out.println(f.getPath());
        System.out.println(f.getParent());
        if(f.exists()){
            f.delete();
        }
        else{
            try{
                System.out.println(f.createNewFile());
            }catch(Exception e){}
        }

    }

}
运行结果：

再看一个判断目录的方法：

/**
*
*         File的一个方法File.getPath()
*                     是将此抽象路径名转换为一个路径名字符串。
*
*         File的isDirectory()的方法
*                     是测试此抽象路径名表示的文件是否是一个目录。
*         当且仅当此抽象路径名表示的文件存在且是一个目录时，返回 true；否则返回 false。
*
*
* */

import java.io.File;

public class Demo51 {

    public static void main(String[] args){
        File f = new File("f:" + File.separator + "aa");
        System.out.println(f.getPath());
        System.out.println(f.isDirectory());
    }

}

运行结果：

注意下一个代码，可能对你很有帮助啊！！

/**
*
*             File的list()方法可以：
*             返回一个字符串数组，
*             这些字符串指定此抽象路径名表示的目录中的文件和目录。
*
* */

import java.io.File;

public class Demo61 {

    public static void main(String[] args) {

        File f = new File("f:\\book");


        //使用list列出
        //列出的只是一个名称
        String[] str = f.list();
        for(int i=0;i<str.length;i++){
            System.out.println(str[i]);
        }

    }

}
这个程序的运行结果是你目录下的文件：

下面的程序你可能会很感兴趣！因为你想玩HK，或者你想给别人整个恶作剧，你必须要扫描下他的电脑，以下方法就实现了怎样去扫描一个电脑里的所有文件(我的代码选择的是扫描C盘下的所有文件，如果你想扫描其他盘，只要把文件改一下就OK啦)

import java.io.File;

public class Demo81 {

    public static void main(String[] args) {

        String str = "C:\\";
        File f = new File(str);
        fun(f);
    }

    //要不断列出，因为给出的File类对象可能是一个目录
    public static void fun(File f){
        //判断给定的路径是否是目录，如果是目录在列出
        if(f.isDirectory()){
            File[] file = f.listFiles();
            //再依次循环进行判断
            try{
                for(int i = 0;i < file.length;i++){
                    //继续把内容传入到fun方法之中进行验证
                    fun(file[i]);
                }
            }catch(Exception e){}
        }
        else{
            System.out.println(f);
        }
    }

}

运行结果我就不贴出来了，因为C盘的文件太多啦！！！如果你想知道，自己把代码带下看看，你会很吃惊的！你会想原来扫描的原理这么简单！！！

posted @ 2010-11-07 23:05 tovep 阅读(59624) | 评论 (2) | 编辑收藏

Java_线程类两种创建方式的区别

        Java线程类有两种实现方式，第一种就是继承Thread类，另一种是现实Runnable接口。这两种实现方式的区别很大，下面就说一下它们之间到底有什么区别。

我们首先用第一种方式写一个线程类：
代码如下：

package Ticket;

public class Extends {

public static void main(String[] args){
          //实例化进程并准备执行
          new Thread(new MyThread(),"001窗口").start();
          new Thread(new MyThread(),"001窗口").start();
          new Thread(new MyThread(),"001窗口").start();

         }

}

class MyThread extends Thread{
         //定义一个变量
          private int ticket = 10;

          public void run(){

          //这里之所以要循环300次，就是为了让所有的车票都卖出去！可能你会想，为什么不是30呢？
          //嘿嘿。。。聪明的你肯定明白这个循环的次数为什么会多出票数很多？=====其实我开始也不知道！！！ ==|||

          for(int i=0;i<300;i++){
               try {
                    //调用sell()方法
                    this.sell();
                    Thread.sleep(10);
                 } catch (InterruptedException e) {
                            e.printStackTrace();
                 }
}

}
           public void sell(){
                  if(ticket>0){
                           System.out.println(Thread.currentThread().getName() + " ===> 还剩下" + (ticket--) + "车票");
                  }
}
}

看看这个程序的运行结果你就明白为什么继承Thread类实现线程类的一个弊端

------------------------------------------------
大家都发现了吧！输出的结果和预想的不一样！！！

我们来分析一下代码，查看main函数：
          new Thread(new MyThread(),"001窗口").start();
          new Thread(new MyThread(),"001窗口").start();
          new Thread(new MyThread(),"001窗口").start();

我们可以看出，实例化了三个MyThread类，这样的话，private int ticket = 10；就运行了三次，所以ticket打印出来的也就是30张；在这里注意一下并不是ticket赋值为30，而是ticket赋值为10，但赋值了三次！！！也就是现在有三个ticket！！！
这样并不能实现资源共享！
我们知道我们利用多线程就是为了将多个线程去处理一个数据的集合！！！他们是同时处理的！！！如果向上面的话，并没有将数据的集合（ticket）进行共享，而是将每一个类都从新建了一个数据的集合，分别对自己的集合进行处理！！！！
如果想解决这个问题，其实也很简单，不过如果当数据的类型和种类比较多的时候，这样写就太麻烦了！！！！

那实现Runnable接口的线程类可不可以呢！！？？？

下面来看一看：

代码如下：

package IO;

public class Inter {

    public static void main(String[] args){
        //声明并实例化一个MyThread01类
        MyThread01 mt = new MyThread01();
        new Thread(mt,"001窗口").start();
        new Thread(mt,"002窗口").start();
        new Thread(mt,"003窗口").start();

    }

}

class MyThread01 implements Runnable{

    private int ticket = 10;
    public void run(){
        for(int i=0;i<200;i++){
            try {
                this.sell();
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
    public void sell(){
        if(ticket>0){
            System.out.println(Thread.currentThread().getName() + " ===> 还剩下" + (ticket--) + "车票");
        }

    }
}


---------------------------------------------
这段程序的运行结果：

看看这个结果是不是和自己想的一样啊！！！这样就可以了！！！用这个方法去创建一个线程类是不是可以达到资源共享啊！！！
其实啊！我看来，所谓的资源共享也就是将一个数据的集合让多个线程去处理！！！
我们看一下代码！！！
        MyThread01 mt = new MyThread01();
        new Thread(mt,"001窗口").start();
        new Thread(mt,"002窗口").start();
        new Thread(mt,"003窗口").start();

我们可以看出这个过程中，我们只声明并实例化了一个MyThread01类，也就是说在这里过程中，给ticket进行了初始化！！！
但大家要注意的是：真正创建处理数据的线程是
        new Thread(mt,"001窗口").start();
        new Thread(mt,"002窗口").start();
        new Thread(mt,"003窗口").start();
因此，这样可以将一个ticket的数据集由三个线程来处理！！！
这样就是所谓的资源共享！！！
ok？？？

=====================================================================

总结一下这两种方式的特点：

1.继承Thread来创建线程类的方法，在继承了Thread后，不能再继承其他类，这样灵活性就不如实现Runnable接口来创建线程类的方法了！！！
2.正如上面所说的使用实现Runnable接口来创建线程类的方法可以达到资源共享！！！（在这里说明一下：继承Thread类来创建线程类的方法也可以实现资源共享，只不过比较麻烦！！！因此，在创建线程类的时候，应优先选择实现Runnable接口来创建线程类的方法！！！）

posted @ 2010-11-07 20:30 tovep 阅读(5940) | 评论 (8) | 编辑收藏

Java框架_简单实现学生系统管理

今天写一个具有简单功能的学生管理系统！不过，这个系统的构建基于现实中的Java程序开发框架！所有的代码全部自己去写，并且要在程序中体现出面向对象的细想和程序开发中的框架实现原理。

首相，对问题进行分析：

程序要完成的功能很简单，当程序运行的时候出现以下信息

--------图1--------
然后程序等待用户输入

如果用户选择1，那么进入增加人员的信息(

下面来分析增加人员的过程：

首先，要新建一个Person类，当用户选择1的时候就实例化Person类，并将Person进行初始化，这并没有结束此次的操作，最后的操作是将Person类存储到文件中，这个文件名我定义为Person.ser。这样这个过程才算结束，但这里的结束并不是程序结束，而是完成了1操作，整个程序并没有结束，除非用户选择4退出程序，否则程序一直执行。
)

如果用户选择2，那么程序查看所有人员的信息(
在这个过程中，程序要将Person.ser文件中的内容写入到程序中，并打印到控制台显示，执行完这一步之后，程序返回上一步操作，在这里程序仍然没有退出。
)

如果用户选择3，程序进入的是对信息进行修改的页面(
这个过程相对来说比较复杂，因为这个过程涉及到Person.ser文件内容的写入和写出过程，也就是先把文件中的内容输出到控制台显示当前用户的信息，等待用户输入新的信息，当用户输入信息后，要将原来的信息进行覆盖，也就是将信息从新写到Person.ser中——这里我们仅仅考虑Person.ser中只有一个Person的情况。
)

通过以上分析，我们可以很清楚的知道，这个程序需要一个循环来做支撑，并且这个循环每执行一次都要输出图1的内容。

首先新建一个Persion类

package Object;

import java.io.Serializable;

//要想将类存储在文件中必须实现Serializable接口！！！

public class Person implements Serializable{
private String name;
private int age;
private float score;

public Person(String name, int age, float score){
  this.name = name;
  this.age = age;
  this.score = score;
}

public String getName() {
  return name;
}
public void setName(String name) {
  this.name = name;
}
public int getAge() {
  return age;
}
public void setAge(int age) {
  this.age = age;
}
public float getScore() {
  return score;
}
public void setScore(float score) {
  this.score = score;
}

public String toString(){
  return "NAME: " + this.name + " AGE: " + this.age + " SCORE: " + this.score;
}

}

Text类中包含了程序中所有的text信息

package Text;

/**
*
* 这个类是用来输出整个程序中要输出的所有的Text信息！！！
* Text类中没有任何属性，只有几个输出文本的方法！！！
*
*
* */

public class Text {

//这个方法用来显示用户运行程序时的信息
public String mainText(){
  return "\n\t\t1.增加人员的信息" + "\n\t\t2.浏览人员的信息" + "\n\t\t3.修改人员的信息" + "\n\t\t4.退出系统" + "\n\n请选择要使用的操作：";
}

//输入有误信息
public String errText(){
  return "您所输入的信息有误，请重新输入！！！";
}

//增加信息显示
public String addText(){
  return "请输入您要增加的学生的信息";
}
public String addName(){
  return "请输入学生的姓名：";
}
public String addAge(){
  return "请输入学生的年龄：";
}
public String addScore(){
  return "请输入学生的成绩：";
}
//修改的内容Modify

public String modifyText(){
  return "请输入您要修改的内容";
}
public String edd(){
  return "操作成功";
}

}

Methods类中包含了所有的方法：

package Methods;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Scanner;

import Object.Person;
import Text.Text;

/**
*
*   这个方法中包括了整个程序所要用到的方法，包括：
*    从控制台写入(Input)信息方法；
*    向控制台写出(Output)信息的方法；
*    基本上包含了所有的方法
*
*
* */
public class Methods {

private static Person obj;
//用户从控制台向程序写入数据，用来选择用户想要的操作
public int InputSelect(){
  Scanner inputSelect = new Scanner(System.in);
  int select = inputSelect.nextInt();
  return select;
}

//增加Person信息方法
public Person InputPerson(){
  Text text = new Text();
  Scanner str = new Scanner(System.in);

  System.out.println(text.addText() + "\n" + text.addName());
  String name = str.next();
  System.out.println(text.addAge());
  int age = str.nextInt();
  System.out.println(text.addScore());
  float score = str.nextFloat();

  Person p = new Person(name, age, score);
  return p;
}

//将类从程序中写出，写到文件中
public void Output(Person p) throws Exception{
  ObjectOutputStream out = null;
  out = new ObjectOutputStream(new FileOutputStream(new File("e:\\person.ser")));
  out.writeObject(p);
  out.close();
}

//从文件中读入信息
public Person Output() throws Exception{
  ObjectInputStream in = null;
  in = new ObjectInputStream(new FileInputStream(new File("e:\\person.ser")));
  obj = (Person)in.readObject();
  Person p = obj;
  in.close();
  return p;
}

//修改类的方法
public void ModifyPerson() throws Exception{
  Text text = new Text();
  Scanner str = new Scanner(System.in);

  //先从文件中读入信息
  Person p = this.Output();
  System.out.println(text.modifyText());
  System.out.println("修改前的内容为： \n" + p);
  this.Output(this.InputPerson());
  text.edd();
}
}

Main用来调用这些方法，完成想要的结果

package Main;

import Methods.Methods;
import Object.Person;
import Text.Text;

/**
*
*   这里是程序的入口，当执行这个程序的时候首先打印了图1的内容，为了表现面向对象的思想，我将程序中首先要打印的信息
*   放入到一个Text类中。
*   因为仅仅当用户选择了退出程序的时候才能退出程序，所以这个程序必须用一个‘死’循环，只有当用户选择了4的时候，用户
*   才退出程序！
*
* */

public class Main {
final static Text text = new Text();
static Methods m = new Methods();
public static void main(String[] args) throws Exception{

  boolean mainCycle = true;

  //有一个循序
  while(mainCycle){
   //只有当用户输入的是4的时候程序才退出循环
   System.out.println( text.mainText());
   //捕获控制台用户输入的选择信息
   int select = m.InputSelect();

   if(select == 4)//这里的判断是——用户输入的信息等于4的时候程序结束循环
   {
    mainCycle = false;
   }
   else
   {
    switch(select)//用户选择的数据
    {
    case 1 : {
     Person pp = m.InputPerson();
     m.Output(pp);
     System.out.println(text.edd());
     {}//利用输入方法
    };break;//用户增加人员信息方法
    case 2 : {
     System.out.println(m.Output());
    };break;//浏览人员的信息

    case 3 : {
     Person p = m.Output();
     System.out.println(text.modifyText());
     p = m.InputPerson();
     m.Output(p);
     System.out.println(text.edd());
    };break;//修改人员的信息

    default : {
     System.out.println(text.errText());
    }
    }
   }

  }


}

}

这个程序的运行结果如下：

posted @ 2010-11-06 17:15 tovep 阅读(350) | 评论 (0) | 编辑收藏

Java_模拟挂号系统

======================================================================================

这仅仅是一个很简单的医院挂号系统，虽然涉及到一些C/S架构思想，但并没有按照C/S架构去实现

还请大家见谅！！！

======================================================================================

**************************************************************************************

首先，新建一些辅助的类。
       比如：Patients类，用于存放挂号的病人；Init类，用于预先存储一些病人，这样就可以方
便的测试Doctor类；还有一个Server类，相当于一个服务器。

**************************************************************************************

Patients类

package Queue;
        /**

                定义一个Patients类,这个类从写了toString方法，可以方便的进行输出！

        */

public class Patients {


    private String name;
    private String id;


    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    //这里从写了toString方法
    public String toString(){
        return "病人的ID是: " + this.id + " \n\n病人的姓名是: " + this.name;
    }
}

Init类：

package Queue;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;

        /**
        *
        * @author toveping
        * 向一个队列中加入一些病人,对医生的客户端进行测试！！！
        *
        *
        */
public class Init {
    public Map init(String no){
        Map<String, LinkedList<Patients>> queueSystem = new HashMap<String, LinkedList<Patients>>();
        LinkedList<Patients> patQueue = new LinkedList<Patients>();
        for(int i =0;i<20;i++){
            Patients p = new Patients();
            p.setId(i + "");
            p.setName("A" + i);
            patQueue.add(p);
        }
        queueSystem.put(no, patQueue);
        return queueSystem;
    }
}

Server类：

package Queue;

        /**

                定义一个Server类相当于服务器,挂号客户端增加一个病人的话,相应的存储在这里,可以供Doctor调用！！！

        */

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;

public class Server {


    //这是病人的队列
    Queue<Patients> patQueue = new LinkedList<Patients>();
    //String 是医生的代号；Queue 是病人的队列
    Map<String, Queue> queueSystem = new HashMap<String, Queue>();


    public int serverAdd(String no){
        Map<String, LinkedList<Patients>> queueSystem = new HashMap<String, LinkedList<Patients>>();
        LinkedList<Patients> patQueue = new LinkedList<Patients>();
        Patients p = new Patients();
        p.setId(patQueue.size()+"");
        patQueue.add(p);
        queueSystem.put(no, patQueue);


        return patQueue.size();
    }
}

**************************************************************************************

下面是挂号客户端：

**************************************************************************************

package Queue;

        /**

                这是一个挂号客户端,对会诊的病人进行挂号,以及方便挂号的病人容易的挂到自己想要的专家！！！

        */

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

public class Client {
    public static void main(String[] args){
        Display display = new Display();
        Shell shell = new Shell(display);
        shell.setLayout(new FillLayout());
        shell.setText("专家挂号系统");
        shell.open();
        shell.setBounds(190, 100, 800, 600);

        final Text txt = new Text(shell,SWT.MULTI);
        txt.setBounds(200, 50, 400, 300);

        Button firstButton = new Button(shell,SWT.NULL);
        firstButton.setText("一号专家");
        firstButton.setBounds(100, 400, 120, 65);

        firstButton.addSelectionListener(new SelectionAdapter() {
                Server ser = new Server();
                int i = ser.serverAdd("1");
            public void widgetSelected(SelectionEvent e) {

                txt.setText("挂号成功\n" + "您选的专家是一号专家\n" + "您前面有" + i + "\n请耐心等待！！");
                i++;
                }
        });


        Button secondButton = new Button(shell,SWT.NULL);
        secondButton.setText("二号专家");
        secondButton.setBounds(250, 400, 120, 65);

        secondButton.addSelectionListener(new SelectionAdapter() {
                Server ser = new Server();
                int i = ser.serverAdd("2");
            public void widgetSelected(SelectionEvent e) {

                txt.setText("挂号成功\n" + "您选的专家是二号专家\n" + "您前面有" + i + "\n请耐心等待！！");
                i++;

                }
        });


        Button thirdButton = new Button(shell,SWT.NULL);
        thirdButton.setText("三号专家");
        thirdButton.setBounds(400, 400, 120, 65);

        thirdButton.addSelectionListener(new SelectionAdapter() {
                Server ser = new Server();
                int i = ser.serverAdd("3");
            public void widgetSelected(SelectionEvent e) {

                txt.setText("挂号成功\n" + "您选的专家是三号专家\n" + "您前面有" + i + "\n请耐心等待！！");
                i++;

                }
        });


        Button fourthButton = new Button(shell,SWT.NULL);
        fourthButton.setText("四号专家");
        fourthButton.setBounds(550, 400, 120, 65);


        fourthButton.addSelectionListener(new SelectionAdapter() {
            Server ser = new Server();
            int i = ser.serverAdd("4");
            public void widgetSelected(SelectionEvent e) {


                txt.setText("挂号成功\n" + "您选的专家是四号专家\n" + "您前面有" + i + "\n请耐心等待！！");
                i++;

                }
        });




        while (!shell.isDisposed()) {
            if (!display.readAndDispatch())
            display.sleep();
       }

        display.dispose();
    }

}

运行结果如下图：

**************************************************************************************

最后是Doctor的客户端：

**************************************************************************************

package Queue;

        /**

                这里定义了Doctor使用的客户端,用来显示会诊的一些基本信息！

        */

import java.util.LinkedList;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

public class Doctor {
    public static void main(String[] args){
        Display display = new Display();
        Shell shell = new Shell(display);
        shell.setLayout(new FillLayout());
        shell.setText("医生会诊系统");
        shell.open();
        shell.setMaximized(true);

        final Text firsttxt = new Text(shell,SWT.MULTI);
        firsttxt.setBounds(100, 50, 200, 300);

        Button firstButton = new Button(shell,SWT.NULL);
        firstButton.setText("下一个(一号专家)");
        firstButton.setBounds(150, 400, 120, 65);

        firstButton.addSelectionListener(new SelectionAdapter() {
                Init aInit = new Init();
                LinkedList lin = (LinkedList) aInit.init("1").get("1");
            public void widgetSelected(SelectionEvent e) {

                firsttxt.setText("\n您正在诊断的病人信息：\n\n" + lin.remove());
                }
        });

        final Text secondtxt = new Text(shell,SWT.MULTI);
        secondtxt.setBounds(400, 50, 200, 300);

        Button secondButton = new Button(shell,SWT.NULL);
        secondButton.setText("下一个(二号专家)");
        secondButton.setBounds(450, 400, 120, 65);

        secondButton.addSelectionListener(new SelectionAdapter() {
                Init aInit = new Init();
                LinkedList lin = (LinkedList) aInit.init("2").get("2");
            public void widgetSelected(SelectionEvent e) {
                secondtxt.setText("\n您正在诊断的病人信息：\n\n" + lin.remove());
                }
        });

        final Text thirdtxt = new Text(shell,SWT.MULTI);
        thirdtxt.setBounds(750, 50, 200, 300);

        Button thirdButton = new Button(shell,SWT.NULL);
        thirdButton.setText("下一个(三号专家)");
        thirdButton.setBounds(800, 400, 120, 65);

        thirdButton.addSelectionListener(new SelectionAdapter() {
            Init aInit = new Init();
            LinkedList lin = (LinkedList) aInit.init("3").get("3");
            public void widgetSelected(SelectionEvent e) {
                thirdtxt.setText("\n您正在诊断的病人信息：\n\n" + lin.remove());
                }
        });

        final Text fourthtxt = new Text(shell,SWT.MULTI);
        fourthtxt.setBounds(1050, 50, 200, 300);

        Button fourthButton = new Button(shell,SWT.NULL);
        fourthButton.setText("下一个(四号专家)");
        fourthButton.setBounds(1100, 400, 120, 65);


        fourthButton.addSelectionListener(new SelectionAdapter() {
            Init aInit = new Init();
            LinkedList lin = (LinkedList) aInit.init("4").get("4");
            public void widgetSelected(SelectionEvent e) {
                fourthtxt.setText("\n您正在诊断的病人信息：\n\n" + lin.remove());
                }
        });




        while (!shell.isDisposed()) {
            if (!display.readAndDispatch())
            display.sleep();
       }

        display.dispose();
    }
}

运行的结果如下图：

**************************************************************************************

让大家见笑了！

posted @ 2010-10-31 21:10 tovep 阅读(376) | 评论 (0) | 编辑收藏

常用链接

留言簿(2)

随笔分类

随笔档案

文章分类

文章档案

51CTO

搜索

最新评论

阅读排行榜

评论排行榜

MVC