﻿<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/" xmlns:wfw="http://wellformedweb.org/CommentAPI/" xmlns:slash="http://purl.org/rss/1.0/modules/slash/"><channel><title>语源科技BlogJava-站长www.software8.co</title><link>http://www.blogjava.net/newcnzz/</link><description>热转印www.heatpress123.net</description><language>zh-cn</language><lastBuildDate>Tue, 14 Apr 2026 11:29:38 GMT</lastBuildDate><pubDate>Tue, 14 Apr 2026 11:29:38 GMT</pubDate><ttl>60</ttl><item><title>请问根据这个错误提示，该如何建立库？ </title><link>http://www.blogjava.net/newcnzz/archive/2013/05/04/398787.html</link><dc:creator>文哥哥</dc:creator><author>文哥哥</author><pubDate>Sat, 04 May 2013 06:34:00 GMT</pubDate><guid>http://www.blogjava.net/newcnzz/archive/2013/05/04/398787.html</guid><description><![CDATA[$ ./safe_mysqld &
345
$ Starting mysqld daemon with databases from /usr/local/mysql/data
STOPPING server from pid file /usr/local/mysql/data/xmtt9.pid
051108 16:57:28 mysqld ended


$ ./mysql -u root -p
Enter password: 
ERROR 2002 (HY000): Can't connect to local MySQL server through socket '/tmp/mysql.sock' (2)
在DATA目录下生成xxx.err文件，内容为
051108 16:20:30 mysqld started
InnoDB: The first specified data file ./ibdata1 did not exist:
InnoDB: a new database to be created!
051108 16:20:31 InnoDB: Setting file ./ibdata1 size to 10 MB
InnoDB: Database physically writes the file full: wait...
051108 16:20:31 InnoDB: Log file ./ib_logfile0 did not exist: new to be createdInnoDB: Setting log file ./ib_logfile0 size to 5 MB
InnoDB: Database physically writes the file full: wait...
051108 16:20:31 InnoDB: Log file ./ib_logfile1 did not exist: new to be createdInnoDB: Setting log file ./ib_logfile1 size to 5 MB
InnoDB: Database physically writes the file full: wait...
InnoDB: Doublewrite buffer not found: creating new
InnoDB: Doublewrite buffer created
InnoDB: Creating foreign key constraint system tables
InnoDB: Foreign key constraint system tables created
051108 16:20:32 InnoDB: Started; log sequence number 0 0
051108 16:20:32 [ERROR] Fatal error: Can't open and lock privilege tables: Table 'mysql.host' doesn't exist
051108 16:20:32 mysqld ended

051108 16:57:25 mysqld started
051108 16:57:27 InnoDB: Database was not shut down normally!
InnoDB: Starting crash recovery.
InnoDB: Reading tablespace information from the .ibd files...
InnoDB: Restoring possible half-written data pages from the doublewrite
InnoDB: buffer...
051108 16:57:27 InnoDB: Starting log scan based on checkpoint at
InnoDB: log sequence number 0 36808.
InnoDB: Doing recovery: scanned up to log sequence number 0 43655
051108 16:57:27 InnoDB: Starting an apply batch of log records to the database...
InnoDB: Progress in percents: 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 
InnoDB: Apply batch completed
051108 16:57:27 InnoDB: Started; log sequence number 0 43655
051108 16:57:28 [ERROR] Fatal error: Can't open and lock privilege tables: Table 'mysql.host' doesn't exist
051108 16:57:28 mysqld ended

操作系统为SOLARIS8<img src ="http://www.blogjava.net/newcnzz/aggbug/398787.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/newcnzz/" target="_blank">文哥哥</a> 2013-05-04 14:34 <a href="http://www.blogjava.net/newcnzz/archive/2013/05/04/398787.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>解决XP下iis服务运行asp提示“HTTP 错误 404 - 文件或目录未找到</title><link>http://www.blogjava.net/newcnzz/archive/2012/12/15/393028.html</link><dc:creator>文哥哥</dc:creator><author>文哥哥</author><pubDate>Sat, 15 Dec 2012 02:01:00 GMT</pubDate><guid>http://www.blogjava.net/newcnzz/archive/2012/12/15/393028.html</guid><description><![CDATA[第一步，配置Web服务扩展
 
控制面板 -> 管理工具 ->服务和应用程序 ->Internet 信息服务(IIS)管理器 ->Web服务扩展 -> Active Server Pages -> 允许 -> Internet数据连接器 -> 允许控制面板 -> 管理工具 ->IIS(Internet 服务器)- Web服务扩展 -> 在服务端的包含文件 -> 允许 。
 
运行.NET程序也一样要启用 ASP.NETV2.0
 
第二步,启用父路径支持和启用默认内容文档
 
启用父路径支持：
 
控制面板 -> 管理工具 ->服务和应用程序 ->Internet 信息服务(IIS)管理器 ->网站 ->默认网站 ->右键属性 ->主目录 ->配置 ->选项 ->打勾启用父路径。
 
启用默认内容文档：
 
控制面板 -> 管理工具 ->服务和应用程序 ->Internet 信息服务(IIS)管理器 ->网站 ->默认网站 ->右键属性 ->文档 ->打勾启用默认内容文档 ->添加 ->输入：index.asp ->确定 -> 添加 ->输入：index.aspx ->确定。
 
第三步，更改默认网站路径
 
控制面板 -> 管理工具 ->Internet 信息服务(IIS)管理器 ->网站 ->默认网站 ->右键属性 ->主目录 ->本地路径（本地路径改为自己设置的网站目录） ->确定。
 
如果还不行的话就重启一下IIS
 
我遇到的问题解决的方法是用的第三步，一试就成功了
原文：http://www.software8.co/wzjs/czxt/1694.html<img src ="http://www.blogjava.net/newcnzz/aggbug/393028.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/newcnzz/" target="_blank">文哥哥</a> 2012-12-15 10:01 <a href="http://www.blogjava.net/newcnzz/archive/2012/12/15/393028.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>解决 PermGen space Tomcat内存设置</title><link>http://www.blogjava.net/newcnzz/archive/2012/10/21/389963.html</link><dc:creator>文哥哥</dc:creator><author>文哥哥</author><pubDate>Sun, 21 Oct 2012 03:58:00 GMT</pubDate><guid>http://www.blogjava.net/newcnzz/archive/2012/10/21/389963.html</guid><description><![CDATA[在使用Java程序从数据库中查询大量的数据或是应用服务器(如tomcat、jboss,weblogic)加载jar包时会出现java.lang.OutOfMemoryError异常。这主要是由于应用服务器的内存不足引起的。这种异常常有以下几种情况（以下以tomcat环境为例，其它WEB服务器如jboss,weblogic等是同一个道理）： 
　　1. java.lang.OutOfMemoryError: PermGen space 
　　PermGen space的全称是Permanent Generation space，是指内存的永久保存区域OutOfMemoryError: PermGen space。从文字上看就是内存溢出，解决方法是加大内存。为什么会内存溢出，这是由于这块内存主要是被JVM存放Class和Meta信息的，Class在被Load的时候被放入PermGen space区域，它和存放Instance的Heap区域不同,GC(Garbage Collection)不会在主程序运行期对PermGen space进行清理，所以如果你的APP会LOAD很多CLASS的话，就很可能出现PermGen space错误。这种错误常见在web服务器对JSP进行pre compile的时候。如果你的WEB APP下都用了大量的第三方jar, 其大小超过了jvm默认的大小(4M)那么就会产生此错误信息了。 
　　解决方法： 手动设置MaxPermSize大小 
　　a.如果tomcat是以bat方式启动的，则如下设置： 
　　修改TOMCAT_HOME/bin/catalina.sh 
　　在“echo "Using CATALINA_BASE: $CATALINA_BASE"”上面加入以下行： 
　　JAVA_OPTS="-server -XX:PermSize=64M -XX:MaxPermSize=128m 
　　b.如果tomcat是注册成了windows服务，以services方式启动的，则需要修改注册表中的相应键值。 
　　打开注册表，找到目录HKEY_LOCAL_MACHINE\SOFTWARE\Apache Software Foundation\Procrun 2.0\htfty\Parameters\Java，其中目录地址中红色标注的（如htfty）需要根据不同情况作修改，为tomcat服务注册成windows服务的名称。 可以看到JvmMs和JvmMx项，其中JvmMs设置最小的内存使用参数，JvmMx设置最大的内存使用参数。设置好JvmMs和JvmMx项的值，重启tomcat服务器即可生效。 
　　建议：将相同的第三方jar文件移置到tomcat/shared/lib目录下，这样可以达到减少jar 文档重复占用内存的目的。 
　　2. java.lang.OutOfMemoryError: Java heap space 
　　JVM堆的设置是指java程序运行过程中JVM可以调配使用的内存空间的设置。JVM在启动的时候会自动设置Heap size的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)是物理内存的1/4。可以利用JVM提供的-Xmn -Xms -Xmx等选项可进行设置。Heap size 的大小是Young Generation 和Tenured Generaion 之和。在JVM中如果98％的时间是用于GC且可用的Heap size 不足2％的时候将抛出此异常信息。 
　　解决方法：手动设置Heap size 
　　a.如果tomcat是以bat方式启动的，则如下设置： 
　　修改TOMCAT_HOME/bin/catalina.sh 
　　在“echo "Using CATALINA_BASE: $CATALINA_BASE"”上面加入以下行： 
　　JAVA_OPTS="-server -Xms800m -Xmx800m -XX:MaxNewSize=256m" 
　　b.如果tomcat是注册成了windows服务，以services方式启动的，则需要修改注册表中的相应键值。 
　　打开注册表，找到目录HKEY_LOCAL_MACHINE\SOFTWARE\Apache Software Foundation\Procrun 2.0\htfty\Parameters\Java，其中目录地址中红色标注的（如htfty）需要根据不同情况作修改，为tomcat服务注册成windows服务的名称。 可以看到JvmMs和JvmMx项，其中JvmMs设置最小的内存使用参数，JvmMx设置最大的内存使用参数。设置好JvmMs和JvmMx项的值，重启tomcat服务器即可生效。 
　　提示：Heap Size 最大不要超过可用物理内存的80％，一般的要将-Xms和-Xmx选项设置为相同，而-Xmn为1/4的-Xmx值。<img src ="http://www.blogjava.net/newcnzz/aggbug/389963.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/newcnzz/" target="_blank">文哥哥</a> 2012-10-21 11:58 <a href="http://www.blogjava.net/newcnzz/archive/2012/10/21/389963.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>Java__内部类,抽象类,继承,接口,异常的处理...等</title><link>http://www.blogjava.net/newcnzz/archive/2012/10/18/389816.html</link><dc:creator>文哥哥</dc:creator><author>文哥哥</author><pubDate>Thu, 18 Oct 2012 06:31:00 GMT</pubDate><guid>http://www.blogjava.net/newcnzz/archive/2012/10/18/389816.html</guid><description><![CDATA[抽象类的特点：
1，抽象方法一定在抽象类中。
2，抽象方法和抽象类都必须被abstract关键字修饰。
3，抽象类不可以用new创建对象。因为调用抽象方法没意义。
4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。
      
如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
抽象类和一般类没有太大的不同。
抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法。
抽象类不可以实例化。
 
特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
 
abstract 关键字，和哪些关键字不能共存。
final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。
private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。
              而抽象方法出现的就是需要被复写。
static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。
              可是抽象方法运行没意义。
 
抽象类中有构造函数,因为抽象类是一个父类，要给子类提供实例的初始化。
 
继承：
1，提高了代码的复用性。
2，让类与类之间产生了关系。有了这个关系，才有了多态的特性。
 
注：不要为了获取其他类的功能，简化代码而继承。
必须是类与类之间有所属关系才可以继承。所属关系 is a。
 
Java语言中：java只支持单继承，不支持多继承。
因为多继承容易带来安全隐患:当多个父类中定义了相同功能，
当功能内容不同时，子类对象不确定要运行哪一个。
但是java保留这种机制。并用另一种体现形式来完成表示。多实现。
java支持多层继承。也就是一个继承体系
  
子父类中的函数。
当子类出现和父类一模一样的函数时，
当子类对象调用该函数，会运行子类函数的内容。
如同父类的函数被覆盖一样。
 
这种情况是函数的另一个特性：重写(覆盖)
当子类继承父类，沿袭了父类的功能，到子类中，
但是子类虽具备该功能，但是功能的内容却和父类不一致，
这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。
 
覆盖：
1，子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。
2，静态只能覆盖静态。
       重载：只看同名函数的参数列表。
       重写：子父类方法要一模一样。
3，子父类中的构造函数。
在对子类对象进行初始化时，父类的构造函数也会运行，
那是因为子类的构造函数默认第一行有一条隐式的语句 super();
super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();
 
子类一定要访问父类中的构造函数。因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时，要先访问一下父类中的构造函数。
如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。
 
注：super语句一定定义在子类构造函数的第一行。
 
当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。
 
子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。
子类中至少会有一个构造函数会访问父类中的构造函数。
 
final : 最终。作为一个修饰符，
1，可以修饰类，函数，变量。
2，被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。
3，被final修饰的方法不可以被复写。
4，被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，有可以修饰局部变量。
       当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。方便于阅读。而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成。
5，内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。
 
接口：初期理解，可以认为是一个特殊的抽象类
       当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。
class用于定义类
interface 用于定义接口。
 
接口定义时，格式特点：
1，接口中常见定义：常量，抽象方法。
2，接口中的成员都有固定修饰符。
       常量：public static final
       方法：public abstract
记住：接口中的成员都是public的。
 
接口：是不可以创建对象的，因为有抽象方法。
需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。
否则子类是一个抽象类。
 
接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。

内部类的访问规则：
1，内部类可以直接访问外部类中的成员，包括私有。
       之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this
2，外部类要访问内部类，必须建立内部类对象。
 
访问格式：
1,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。
可以直接建立内部类对象。
格式
       外部类名.内部类名  变量名 = 外部类对象.内部类对象;
       Outer.Innerin = new Outer().new Inner();
 
2,当内部类在成员位置上，就可以被成员修饰符所修饰。
       比如，private：将内部类在外部类中进行封装。
              static:内部类就具备static的特性。
              当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。
 
              在外部其他类中，直接访问static内部类的非静态成员
              newOuter.Inner().function();
 
              在外部其他类中，直接访问static内部类的静态成员
              uter.Inner.function();
 
       注：当内部类中定义了静态成员，该内部类必须是static的。
                当外部类中的静态方法访问内部类时，内部类也必须是static的。
 
class Body
{
       privateclass XinZang
       {
 
       }
 
       publicvoid show()
       {
              newXinZang().
       }
}
 
 
 
内部类定义在局部时，
1，不可以被成员修饰符修饰
2，可以直接访问外部类中的成员，因为还持有外部类中的引用。
       但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
 
 
匿名内部类:
1，匿名内部类其实就是内部类的简写格式。
2，定义匿名内部类的前提：
       内部类必须是继承一个类或者实现接口。
3，匿名内部类的格式：  new 父类或者接口(){定义子类的内容}
4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。  可以理解为带内容的对象。
5，匿名内部类中定义的方法最好不要超过3个。
 
class Outer
{
       intx = 3;
       voidmethod(final int a)
       {
              finalint y = 4;
              classInner
              {
                     voidfunction()
                     {
                            System.out.println(y);
                     }
              }
              newInner().function(); 
       }
}
 
class InnerClassDemo3
{
       publicstatic void main(String[] args)
       {
              Outerout = new Outer();
              out.method(9);
              out.method(7);
       }
 
}
 
继承：
       特点：
              1，提高了代码的复用性。
              2，让类与类之间产生关系，是多态性的前提。
 
       Java中的继承。
              1，java只支持单继承，不支持多继承。因为继承了多个父类如果有相同方法时,子                类对象不确定运行哪一个。
              2，Java还支持多层继承。A-->B--->C  原来可以形成继承体系。
                     想要使用体系功能，"查阅父类功能，建立子类对象调用功能。"
                     注：父类的由来其实是由事物中的共性内容不断向上抽取而来的。
                            所以父类中定义的是该体系中的最基本，最共性功能。
      
       继承出现后，代码上特点：
       1，变量。
              当子父类中定义了相同的名称的成员变量，
              子类要使用父类中的同名变量时，需要使用关键字super来区分。
              一般不会出现这种情况，因为父类中有了，子类不需要定义。
              而且父类定义时，一般变量都私有化。
 
       2，函数。
              子类可以直接访问父类中非私有的成员函数。
              特殊情况：当子类中定义了与父类一模一样的方法时，会发生覆盖操作。大多指的是非静态方法。
                              最终会运行子类的方法，父类相当于被覆盖了。
                              函数的另一个特性：覆盖（重写，复写）。
                              什么时候用
                              当父类的功能要被修改时，不建议修改源码。只要通过一个类继承原有类，定义一个新的升级后的功能即可。但是功能是相同的，只是实现方法改变。这是子类可以沿袭父类中的功能定义，
                              并重写功能内容。这就是覆盖。
 
                     注意事项：
                              1，子类覆盖父类时，必须权限要大于等于父类权限。
                              2，静态不能覆盖非静态。
                    
       3，构造函数。
              构造函数可以本类进行对象初始化，也可以给子类对象进行初始化。
              子类对象初始化过程：
              子类中的所有构造方法都会访问父类中空参数的构造函数，
              因为每一个构造函数的第一行，都有一句隐式的super语句。
              为什么要有这条语句？
              因为子类会获取到父类中的数据，必须要先明确父类对数据的初始化过程。
 
              当父类中没有空参数构造函数时，子类构造函数必须通过super句来明确要访问的父类中指定的构造函数。
 
              当时子类构造函数也可以通过this语句访问本类中的构造函数。
              但是子类中肯定，至少有一个构造函数会访问父类。
 
      
抽象类：在分析事物时，事物中的功能有些是不明确的内容的。这些不明确内容就是抽象的。
              可以通过抽象函数来描述。
 
              抽象函数一定要定义在抽象类中，因为，抽象函数所在类，也必须被抽象标识。
 
              写法特点：
              1，抽象函数只对函数进行声明，没有函数主体。
              2，抽象类和抽象函数都需要用abstract修饰。
              3，抽象类不可以进行实例化。
              4，想要使用抽象功能，必须通过子类覆盖了父类中所有的抽象方法后，才可以对子类实例化。
                     如果只覆盖了部分抽象方法，那么子类还是一个抽象类。
 
              也可以理解为：抽象类是一个父类，是不断向上抽取而来的，
              在抽取过程中，只抽取了方法声明，但没有抽取方法实现。
 
              抽象类和一半类差不多。
              区别：
              抽象类可以定义抽象方法。
              抽象类不可以建立对象。
 
              抽象类一样用于描述事物，既可以定义抽象方法，也可以定义非抽象方法。
 
 
接口
        初期理解：接口看上去是一个特殊的抽象类。里面存的都是抽象方法。
 
        特点：
        格式：
              1，通过interface来定义。
              2，接口中常见成员：常量，抽象方法。
                     而且这些成员都有固定的修饰符。
                     常量：public static final
                     方法：public abstract
              3，接口中的成员都是共有的。
              4，一个类可以对接口进行多实现，用多实现方法来体现多继承的特性。
              5，一个类可以继承一个类的同时，实现多个接口。
              6，接口与接口之间是继承关系，而且可以多继承。
 
       应用特点：
              1，接口是对外暴露的规则。
              2，接口是功能的扩展。
              3，接口的出现降低了耦合性。
 
抽象类和接口异同：
相同：
1，都可以在内部定义抽象方法。
2，通常都在顶层。
3，都不可以实例化，都需要子类来实现。
 
不同点：
1，抽象类中可以定义抽象方法和非抽象方法，
       而接口中只能定义抽象方法。
2，接口的出现可以多实现。
       抽象类只能单继承。
       也就是说：接口的出现避免了单继承的局限性。
3，继承和实现的关系不一致。继承：is a，实现：like a

异常：就是程序在运行时出现不正常情况。
异常由来：就是java对不正常情况进行描述后的对象体现。
 
对于问题的划分：两种：一种是严重的问题，一种非严重的问题。
 
对于严重的，java通过Error类进行描述。
       对于Error一般不编写针对性的代码对其进行处理。
 
对与非严重的，java通过Exception类进行描述。
       对于Exception可以使用针对性的处理方式进行处理。
 
无论Error或者Exception都具有一些共性内容。
比如：不正常情况的信息，引发原因等。
 
Throwable
       |--Error
       |--Exception
 
2,异常的处理
 
java 提供了特有的语句进行处理。
try
{
       需要被检测的代码；
}
catch(异常类变量)
{
       处理异常的代码；(处理方式)
}
finally
{
       一定会执行的语句；
}
 
 
3，对捕获到的异常对象进行常见方法操作。
       StringgetMessage()：获取异常信息。
 
class Demo
{
       intdiv(int a,int b)throws Exception//在功能上通过throws的关键字声明了该功能有可能会出现问题。
       {
              returna/b;
       }
}
 
 
class ExceptionDemo
{
       publicstatic void main(String[] args)
       {
              Demod = new Demo();
              try
              {
                     intx = d.div(4,1);
                     System.out.println("x="+x);
              }
              catch(Exception e)//Exception e = new ArithmeticException();
              {
                     System.out.println("除零啦");
                     System.out.println(e.getMessage());//  / by zero;
                     System.out.println(e.toString());//异常名称 ：异常信息。
 
                     e.printStackTrace();//异常名称，异常信息，异常出现的位置。
                                                 //其实jvm默认的异常处理机制，就是在调用printStackTrace方法。
                                                 //打印异常的堆栈的跟踪信息。
              }           
              System.out.println("over");
       }
}
 
 
自定义异常：
必须是自定义类继承Exception。
 
继承Exception原因：
异常体系有一个特点：因为异常类和异常对象都被抛出。
他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。
只有这个体系中的类和对象才可以被throws和throw操作。
 
throws和throw的区别
throws使用在函数上。
throw使用在函数内。
 
throws后面跟的异常类。可以跟多个。用逗号隔开。
throw后跟的是异常对象。
 
自定义异常时：如果该异常的发生，无法在继续进行运算，
就让自定义异常继承RuntimeException。
 
对于异常分两种：
1，编译时被检测的异常。
2，编译时不被检测的异常(运行时异常。RuntimeException以及其子类)<img src ="http://www.blogjava.net/newcnzz/aggbug/389816.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/newcnzz/" target="_blank">文哥哥</a> 2012-10-18 14:31 <a href="http://www.blogjava.net/newcnzz/archive/2012/10/18/389816.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>Socket 多线程，Java C/S 模式 编程（客户端）</title><link>http://www.blogjava.net/newcnzz/archive/2012/09/24/388404.html</link><dc:creator>文哥哥</dc:creator><author>文哥哥</author><pubDate>Sun, 23 Sep 2012 23:43:00 GMT</pubDate><guid>http://www.blogjava.net/newcnzz/archive/2012/09/24/388404.html</guid><description><![CDATA[ [java] view plaincopyprint?

// Fig. 18.5: Client.java  

// Client that reads and displays information sent from a Server.  

import java.awt.event.*;  

import java.awt.*;  

import javax.swing.*;  

  
@SuppressWarnings("serial")  
public class ClientGUI extends JFrame  
{  
   private JTextArea displayArea;  
   private JTextField enterField;  
   private String request="";  
     
     
  
   public ClientGUI()  

   {  
      super( "Client" );  

  
        
      Container container = getContentPane();  

      displayArea = new JTextArea();  

      enterField=new JTextField();  

      container.add(enterField,BorderLayout.NORTH);  

      container.add( new JScrollPane( displayArea ),  

         BorderLayout.CENTER );  
  

      setSize( 300, 150 );  

      setAlwaysOnTop(true);  

      setVisible( true );  
        
  
      Handler handler=new Handler();  

      enterField.addActionListener(handler);  
  
   }  
     
  

   private class Handler implements ActionListener  

   {  
       public void actionPerformed(ActionEvent e)  

       {  
           setRequest(e.getActionCommand());  
           setField("");  

                
       }  
   }  
     
   public JTextField getGUIField()  

   {  
       return enterField;  
   }  
     
   public JTextArea getGUIArea()  

   {  
       return displayArea;  

   }  
     
   public void setRequest(String s)  
   {  

       request=s;  
   }  
     
   public String getRequest()  
   {  

       return request;  
   }  
     
   public void setField(String s)  
   {  
       enterField.setText(s);  

   }  
     
   public void appendArea(String s)  

   {  
       displayArea.append(s+"\n");  
   }  
     
   public void setArea(String s)  
   {  
       displayArea.setText(s);  
   }  
  
  
} // end class Client  
  
  
import java.io.*;  
import java.net.*;  
  
  
public class Client extends Thread  
{  
   private ClientGUI g;  
     
   private String time="";  
     
  
   private Socket client;  
   private ObjectInputStream in;  
   private ObjectOutputStream out;  
  
   public Client( ClientGUI gui)  

   {  
      super( "Client" );  
  
      g=gui;  
      g.setRequest("get");  
  
   }  
     
     
   public  void run()  
   {      

      try  
      {  
          Thread.sleep(500);  

          client = new Socket( InetAddress.getLocalHost(), 24680 );  

  
          out=new ObjectOutputStream(client.getOutputStream());  
          in=new ObjectInputStream(client.getInputStream());  
          Thread.sleep(500);  
  
          while(true)  
          {  
              Thread.sleep(500);  
            
              if(!g.getRequest().equals(""))  

              {  
                  out.writeObject(g.getRequest());  

                  out.flush();  
                  Thread.sleep(500);  
              
                  if(g.getRequest().equals("get"))  

                  {  
                      time=in.readObject().toString();  

                      g.setArea(time);  
                  }  
                  else  
                      if(g.getRequest().equals("close"))  

                      {  
                          out.close();  
                          in.close();  

                          client.close();  

                      }  
                      else  
                          continue;  
                    
              }  
                
  
          }  
            
      }  
      catch ( IOException ioException )  
      {  

         ioException.printStackTrace();  

      }  
      catch(InterruptedException e)  
      {  
            
      }  
      catch (ClassNotFoundException e)  
      {  
        e.printStackTrace();  
      }  
  
   }  
  
} // end class Client  

  
// Fig. 18.5: Client.java  

// Client that reads and displays information sent from a Server.  

import javax.swing.*;  

  
public class ClientRun  
{  
   //private String request;  
     
     
  
   public static void main( String args[] )  
   {  
       ClientGUI app;  
         app = new ClientGUI( );  

  
      app.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );  

        
        
      Client client=new Client(app);  
      client.start();  
        
   }  

  
} // end class Client  
 <img src ="http://www.blogjava.net/newcnzz/aggbug/388404.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/newcnzz/" target="_blank">文哥哥</a> 2012-09-24 07:43 <a href="http://www.blogjava.net/newcnzz/archive/2012/09/24/388404.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>Socket 多线程，Java C/S 模式 编程（服务器端）</title><link>http://www.blogjava.net/newcnzz/archive/2012/09/24/388403.html</link><dc:creator>文哥哥</dc:creator><author>文哥哥</author><pubDate>Sun, 23 Sep 2012 22:31:00 GMT</pubDate><guid>http://www.blogjava.net/newcnzz/archive/2012/09/24/388403.html</guid><description><![CDATA[[java] view plaincopyprint?
//Fig. 18.4: ServerGUI.java  
//Set up a Server that will receive a connection from a client, send  
//a string to the client, and close the connection.  
import java.io.*;  
import java.awt.*;  
import javax.swing.*;  
  
@SuppressWarnings("serial")  
public class ServerGUI extends JFrame  
{  
      
    private JTextArea displayArea;  
    private JTextField list;  
      
    private String time="";  
      
      
      
    public ServerGUI( )throws IOException  
    {  
        super("Server");  
  
        Container container=getContentPane();  
        list=new JTextField();  
        container.add(list,BorderLayout.NORTH);  
        displayArea=new JTextArea();  
        container.add(new JScrollPane(displayArea),BorderLayout.CENTER);  
          
        setSize(300,150);  
        setVisible(true);  
        setAlwaysOnTop(true);  
    }  
          
    public void setField()  
    {  
        list.setText(time);  
    }  
      
    public void appendArea(String s)  
    {  
        displayArea.append(s+"\n");  
    }  
      
    public void setTime(String t)  
    {  
        time=t;  
    }  
      
    public String getTime()  
    {  
        return time;  
    }  
}  
  
//ServerUpdate.java  
  
import java.util.*;  
  
    public class Update extends Thread  
    {  
        private ServerGUI g;  
        public Update(ServerGUI gui)  
        {  
            g=gui;  
        }  
          
        public void run()  
        {  
            try  
            {  
                String time="";  
                while(true)  
                {  
                    Thread.sleep(1000);  
                    time=getLocalTime();  
                    g.setTime(time);  
                    g.setField();  
                    g.appendArea(time);  
                }  
            }  
            catch(Exception e)  
            {  
                  
            }  
        }  
          
  
        public String getLocalTime()  
        {  
            return (Calendar.getInstance().getTime().toString());  
        }  
          
    }  
  
   
  
//Server.java   
  
import java.io.*;  
import java.net.*;  
  
  
    public class Server extends Thread  
    {  
  
        private ServerGUI g;  
          
        private ServerSocket server;  
          
        public Server(ServerGUI gui)throws IOException  
        {  
            server=new ServerSocket(24680);  
            g=gui;  
        }  
          
        public void run()  
        {  
              
        }  
        public ServerSocket getServerSocket()  
        {  
            return server;  
        }  
          
        public ServerGUI getServerGUI()  
        {  
            return g;  
        }  
          
    }  
  
//Service.java  
  
import java.io.*;  
import java.net.*;  
  
  
    public class Service extends Thread  
    {  
  
        private ServerGUI g;  
        private Server listen;  
          
        private String request="";  
          
        private    Socket con;  
        private ObjectOutputStream out;  
        private    ObjectInputStream in;  
          
        public Service(ServerGUI gui,Server s)throws IOException  
        {  
            g=gui;  
            listen=s;  
        }  
          
        public void run()  
        {  
  
                try  
                {  
                    con=listen.getServerSocket().accept();  
                      
                    in=new ObjectInputStream(con.getInputStream());  
                    out=new ObjectOutputStream(con.getOutputStream());  
                    out.flush();  
                      
                    Thread.sleep(500);  
                      
                    while(true)  
                    {  
                        Thread.sleep(1000);  
                    request=(String)in.readObject();  
                            System.out.println("Server Got Request: " +request+"\n");  
  
                        if(!request.equals(""))  
                        {  
                            if(request.equals("get"))  
                            {  
                                sendData(getTime(g));  
  
                            }  
                            else  
                                if(request.equals("close"))  
                                {  
                                    in.close();  
                                    out.close();  
                                    con.close();  
                                    break;  
                                }  
                                else  
                                {  
                                    System.out.println("Request not Acceptable!.....\n");  
                                }  
                              
                        }  
                        else  
                            continue;  
                    }  
                      
                      
                }  
                catch(Exception e)  
                {  
                      
                }  
              
        }  
          
        public String getTime(ServerGUI gui)  
        {  
            return g.getTime();  
        }  
          
        public void sendData(String s)  
        {  
            try  
            {  
                String str=s;  
                out.writeObject(str);  
                out.flush();  
            }  
            catch(IOException e)  
            {  
                  
            }  
        }  
    }  
  
  
  
//Fig. 18.4: ServerRun.java  
//Set up a Server that will receive a connection from a client, send  
//a string to the client, and close the connection.  
import java.io.*;  //www.heatpress123.net
import javax.swing.*;  
  
public class ServerRun  
{  
      
    public static void main(String args[])throws IOException  
    {  
        ServerGUI app=new ServerGUI();  
  
        app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
          
        Update update=new Update(app);  
        update.start();  
        Server server=new Server(app);  
        server.start();  
        Service service1=new Service(app,server);  
        service1.start();  
        Service service2=new Service(app,server);  
        service2.start();  
          
                  
    }  
}  
<img src ="http://www.blogjava.net/newcnzz/aggbug/388403.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/newcnzz/" target="_blank">文哥哥</a> 2012-09-24 06:31 <a href="http://www.blogjava.net/newcnzz/archive/2012/09/24/388403.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>web入门之tomcat配置</title><link>http://www.blogjava.net/newcnzz/archive/2012/09/24/388402.html</link><dc:creator>文哥哥</dc:creator><author>文哥哥</author><pubDate>Sun, 23 Sep 2012 22:27:00 GMT</pubDate><guid>http://www.blogjava.net/newcnzz/archive/2012/09/24/388402.html</guid><description><![CDATA[一、修改默认的8080改成80端口。

操作方法：在conf目录中，找到server.xml文件，打开找到
<Connector port="8080" protocol="HTTP/1.1" 
               connectionTimeout="20000" 
               redirectPort="8443" />
并将port="8080"  修改成 port="80"  即可。重启下tomcat服务即可。

二、给应用指定一个默认主页的方法。

操作方法：在应用的WEB-INF目录中，找到web.xml打开，并添加如下元素。
<welcome-file-list>
        <welcome-file>index.html</welcome-file>  <!--  默认主页index.html，找不到时会再去找index.jsp -->
         <welcome-file>index.jsp</welcome-file>
 </welcome-file-list>

三、虚拟目录的配置(不改变虚拟主机，不添加虚拟主机情况)。

方式一：打开conf目录中的server.xml，并<Host name="localhost" .... host元素下面添加子元素<Context ... 具体举例如下：
<Context path="/MyApp" docBase="c:\MyApp"/>     path：虚拟目录名称。必须以/开头 docBase:应用的真实的存放路径。若path=""，默认根即http://域名或ip 即可访问docBase指定的应用了。不需要加虚拟目录名了。  但一般这种方式需要修改server.xml，修改server.xml都需要重启tomcat服务器所以不建议使用。
方式二：在tomcat中的Catalina\localhost  新建一个xml，命名虚拟目录名.xml如  doc.xml。那么访问时需要用http://域名或ip:端口号/doc  。 注意前面提到的Catalina，是conf中的server.xml中Engine元素的name属性名，localhost为Host元素的name属性名。  具体举例如下

在K:\tomcat6.0.35\apache-tomcat-6.0.35\conf\Catalina\localhost文件下，新建了一文件doc.xml。xml中具体内容如下：

<?xml version="1.0" encoding="utf-8"?>
<Context docBase="K:\b\myapp" />               <!--  代表http://域名或ip:端口号/doc 访问的是 k盘中的b文件夹下的myapp应用。
 
四、虚拟主机的配置

在conf目录server.xml文件中，找到Engine元素，并在此元素下面添加 Host元素。Host元素有两个重要的属性，一个是name属性虚拟主机名/域名，另一个是appBase属性是此虚拟主机域名指定的应用部署根目录，相当于localhost名称的Host元素中的 webapps文件夹。 具体举例如下：

可以在Engine元素下面添加多个Host元素

 <Host name="www.demo1.com"  appBase="K:\c"
            unpackWARs="true" autoDeploy="true"
            xmlValidation="false" xmlNamespaceAware="false" />  <!-- demo1域名 应用集根目录是k盘中的c文件夹，此文件夹中比如有myapp1应用  -->
<Host name="www.demo2.com"  appBase="K:\d"
            unpackWARs="true" autoDeploy="true"
            xmlValidation="false" xmlNamespaceAware="false" /> <!-- demo2域名 应用集根目录是k盘中的d文件夹，此文件夹中比如有myapp2应用  -->

指定了两个虚拟主机host，为了使域名有效果，在本机中可以在C:\Windows\System32\drivers\etc目录中打开hosts文件，并添加如下元素：
 127.0.0.1 www.demo1.com
 127.0.0.1 www.demo2.com
接下来，重启tomcat服务器即可以轻松的如下进行访问的:
http://www.demo1.com/myapp1
http://www.demo2.com/myapp2   (这样访问是不是还有点烦，要输入虚拟目录名？嗯，下面引用五、虚拟主机与虚拟目录结合来配置)
五、虚拟主机与虚拟目录结合配置

如何达到访问虚拟主机域名时，不输入目录名直接访问呢？比如访问http://www.demo1.com/，默认就是访问http://www.demo1.com/myapp1呢？
操作方法： 其实很简单，上面的虚拟主机配置中，谈到了要在Engine元素添加新Host元素。那么只需要在Host元素下面添加新的<Context元素 具体举例如下：
<Host name="www.demo1.com"  appBase="K:\c"

            unpackWARs="true" autoDeploy="true"
            xmlValidation="false" xmlNamespaceAware="false" />
   <Context path="" docBase="K:\d\myapp" />              <!-- 注意这里，path属性，不能输入名称，直接空白即可，也不能删除 -->
</Host>
www.dgbalance.com <img src ="http://www.blogjava.net/newcnzz/aggbug/388402.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/newcnzz/" target="_blank">文哥哥</a> 2012-09-24 06:27 <a href="http://www.blogjava.net/newcnzz/archive/2012/09/24/388402.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>那些年JavaWeb的各种中文乱码终极解决方法！！</title><link>http://www.blogjava.net/newcnzz/archive/2012/09/23/388395.html</link><dc:creator>文哥哥</dc:creator><author>文哥哥</author><pubDate>Sun, 23 Sep 2012 15:04:00 GMT</pubDate><guid>http://www.blogjava.net/newcnzz/archive/2012/09/23/388395.html</guid><description><![CDATA[一、Servlet输出乱码

1. 用servlet.getOutStream字节流输出中文，假设要输出的是String str ="钓鱼岛是中国的，无耻才是日本的"。

          1.1 若是本地服务器与本地客户端这种就不用说了，直接可以out.write(str.getBytes())可以输出没有问题。因为服务器中用str.getBytes()是采用默认本地的编码，比如GBK。而浏览器也解析时也用本地默认编码，两者是统一的，所以没有问题。

         1.1 若服务器输出时用了, out.write(str.getBytes("utf-8"))。而本地默认编码是GBK时(比例在中国)，那么用浏览器打开时就会乱码。因为服务器发送过来的是utf-8的1010数据，而客户端浏览器用了gbk来解码，两者编码不统一，肯定是乱码。当然，你也可以自己将客户端浏览器的编码手工调用下(IE菜单是：查询View->编码encoding->utf-8)，但是这种操作很烂，最好由服务器输出响应头告诉，浏览器用哪种编码来解码。所以要在服务器的servlet中，增加response.setHeader("content-type","text/html;charset=utf-8")，当然也可直接用简单的response.setContentType("text/hmtl;charset=utf-8")。两种的操作是一样一样的。

2. 用servlet.getWirter字符流输出中文，假设要输出的是String str ="钓鱼岛是中国的，无耻才是日本的"。
       2.1 若写成out.print(str)输出时，客户端浏览器显示的将全是多个?????的字符，代表在编码表中肯定就找不到相应的字符来显示。原因是：servlet.getWriter()得到的字符输出流，默认对字符的输出是采用ISO-8859-1，而ISO-8859-1肯定是不支持中文的。所以肯定要首先要做的第一件事：是要将服务器对象输出字符能支持中文的。其次服务器向客户端写回的响应头要告诉客户端是用了哪种编码表进行编码的。而实现这两个需求，只需要response.setContentType("text/hmtl;charset=utf-8")。就搞定了。特别注意：response.setContentType("text/html;charset=utf-8")要放在PrintOut out = response.getWriter()代码的前面，否则只是有告诉客户端用什么码表编码的功能，而服务器端还是用ISO-8859-1编码了。再特别提示下：在同一Servlet中的doGet或doPost方法中，不能既用response.getOutputStream又用response.getWriter，因为这两种response的响应输出字节流与字符流是冲突的，只能用其一。

二、Servlet文件下载，中文乱码情况。

  关键是下载时响应头 content-disposition中attachment;filename=文件名。这个文件名filename不能是含有中文字符串的，要用URLEncoding编码进行编码，才能进行进行http的传输。如下代码示例：
[java] view plaincopy
//获取文件的URL地址  
String realPath = getServletContext().getRealPath("/钓鱼岛是中国的无耻才是日本的历史证据.jpg");  
//获取文件名： 钓鱼岛是中国的无耻才是日本的历史证据.jpg  
String fileName = realPath.substring(realPath.lastIndexOf("\\")+1);  
//指示响应流的类型不是text/html而是二进制流数据以指示下载  
response.setContentType("application/octet-stream");  
//注意这里一般都用URLEncoder的encode方法进行对文件名进行编码  
String enFileName = URLEncoder.encode(fileName, "utf-8");    
//enFileName文件名若含有中文必须用URLEncoding进行编码  
response.setHeader("content-disposition", "attachment;filename="+enFileName);  
//文件读取与输出，模板代码了...  
InputStream in = new FileInputStream(realPath);  
OutputStream out = response.getOutputStream();  
int len = -1;  
byte[] buf = new byte[1024];  
while((len=in.read(buf))!=-1){  
    out.write(buf, 0, len);  
}  
in.close();  

三、Servlet的response增加addCookie，cookie中value的中文码问题解决方法。
关于cookie的原理，见http://blog.csdn.net/chenshufei2/article/details/8009992。  若想将cookie中存放中文的值，必须用Base64编码后，发给客户浏览器端进入存储。而下次客户端浏览访问是带回来的cookie中的值，是经过Base64编码的，所以需要用Base64解码即可。 Base64编码主要是解决将特殊字符进行重新编码，编码成a-b、A-B、0-9、+与/，字符52，10个数字与一个+，一个/ 共64个字符。它的原理是将原来3个字节的内容编码成4个字节。主要是取字节的6位后，在前面补00组成一个新的字节。所以这样原来的3个字节共24，被编码成4个字节32位了。
具体代码示例如下：
[java] view plaincopy
response.setContentType("text/html;charset=utf-8");  
request.setCharacterEncoding("utf-8");  
String getUserName = request.getParameter("username");  
PrintWriter out = response.getWriter();  
String username = null;  
//获取客户端提交过来的cookie数组。  
Cookie[] cookies = request.getCookies();  
for (int i = 0; cookies != null && i < cookies.length; i++) {  
    //遍历cookie数组，找到含有username的key的cookie。  
    if (Constant.USER_INFO.equals(cookies[i].getName())) {  
        username = cookies[i].getValue();  
        //得到cookie的值后必须，进行Base64解码，因为前次生成cookie时，value是经过Base64编码。  
        username = Base64Coder.decode(username);  //进行Base64解码  
    }  
}  
  
out.print(username + "，恭喜您登录成功......"+getUserName); //username从Cookie中得出来,getUserName从请求参数中  
System.out.println(username+"------------");  
String remember = request.getParameter("remember");  
//中文必须要进行 base64进行加码，才能作为cookie的值  
getUserName = Base64Coder.encode(getUserName);   
//将编码后的中文username的作为cookie的value  
Cookie cookie = new Cookie(Constant.USER_INFO, getUserName);  
cookie.setPath(getServletContext().getContextPath());  
if(null != remember){  //若选择中了，则将Cookie写进去，若没有选择中，则将以前的Cookie都置成空  
    cookie.setMaxAge(Integer.MAX_VALUE); //设置Cookie是Integer最大数，好似有70多年的存效吧。呵呵  
}else{  
    cookie.setMaxAge(0); //设置成cookie马上失效，maxAge是cookie的存活时间  
}  
response.addCookie(cookie);  

四、获取请求参数乱码
GET方式的乱码：
如<a href=”/demo5/servlet/RD2?name=中国”>CN</a>，直接用request.getParameter得到的字符串strCN将会乱码，这也是因为GET方式是用http的url传过来的默认用iso-8859-1编码的，所以首先得到的strCn要再用iso-8859-1编码得到原文后，再进行用utf-8(看具体页面的charset是什么utf-8或gbk)进行解码即可。new String(strCn.getBytes(“ISO-8859-1”),“UTF-8”);
[java] view plaincopy
String strCn = request.getParameter("name");  
String name = new String(strCn.getBytes(“ISO-8859-1”),“UTF-8”);  
这种方式操作比较麻烦的是，有一个参数要用iso-8859-1编码一次再解码一次。
POST方式的乱码：只需要request.setCharacterEncoding("UTF-8"):即可。
[java] view plaincopy
request.setCharacterEncoding("UTF-8");  
String name = request.getParameter("name");  
个人小站 www.software8.co      
<img src ="http://www.blogjava.net/newcnzz/aggbug/388395.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/newcnzz/" target="_blank">文哥哥</a> 2012-09-23 23:04 <a href="http://www.blogjava.net/newcnzz/archive/2012/09/23/388395.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>JAVA--第四周实验--任务2--求任意整数降序数的程序</title><link>http://www.blogjava.net/newcnzz/archive/2012/09/23/388378.html</link><dc:creator>文哥哥</dc:creator><author>文哥哥</author><pubDate>Sun, 23 Sep 2012 08:58:00 GMT</pubDate><guid>http://www.blogjava.net/newcnzz/archive/2012/09/23/388378.html</guid><description><![CDATA[ [java] view plaincopy
/* (程序头部注释开始) 
 * 程序的版权和版本声明部分 
 * Copyright (c) 2011, 烟台大学计算机学院学生  
 * All rights reserved. 
 * 文件名称：对于一个大于3位数的任意整数，输出其降序数。例如，整数82319，则其降序数是98321. 
 * 算法提示：将整数的各位数分解到一维数组a中，再将a数组中的元素按降序排序，最后输出a数组元素值。 
 * 作 者： 雷恒鑫  
 * 完成日期： 2012 年 09 月 19 日 
 * 版 本 号： V1.0  
 * 对任务及求解方法的描述部分 
 * 输入描述： 
 * 问题描述： 
 * 程序输出： 
  
 * 程序头部的注释结束 
  
 */  
  
import javax.swing.JOptionPane;  
  
public class Task_one {  
  
    /** 
     * @param args 
     */  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        String str = JOptionPane.showInputDialog("输入一个任意整数");  
        int number = Integer.parseInt(str);  
  
        sort(number);  
    }  
  
    static void sort(int n) {  
  
        int i = 0, j, k;  
        boolean b = true;  
        int[] a = new int[10];  
        // int x=n;  
        while (b) {  
            a[i] = n % 10; // 分解出个位数  
            n = n / 10; // 去掉已分解出的数  
            i++;  
            if (n == 0) {  
                b = false;  
            }  
        }  
        k = i;  
        for (i = 0; i < 10; i++)  
            // 冒泡降序  
            for (j = 0; j < 10 - i - 1; j++) {  
                if (a[j] < a[j + 1]) {  
                    int t = a[j];  
                    a[j] = a[j + 1];  
                    a[j + 1] = t;  
                }  
            }  
        for (i = 0; i < k; ++i) {  
            // String str=JOptionPane.showInputDialog(a[i]+"  ");  
            System.out.print(a[i] + "  ");  
        }  
    }  
}  

 
运行结果：
  
 <img src ="http://www.blogjava.net/newcnzz/aggbug/388378.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/newcnzz/" target="_blank">文哥哥</a> 2012-09-23 16:58 <a href="http://www.blogjava.net/newcnzz/archive/2012/09/23/388378.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>JAVA--实现类似C#输入功能的Console类</title><link>http://www.blogjava.net/newcnzz/articles/388377.html</link><dc:creator>文哥哥</dc:creator><author>文哥哥</author><pubDate>Sun, 23 Sep 2012 08:56:00 GMT</pubDate><guid>http://www.blogjava.net/newcnzz/articles/388377.html</guid><description><![CDATA[  [java] view plaincopy
/* (程序头部注释开始) 
 * 程序的版权和版本声明部分 
 * Copyright (c) 2011, 烟台大学计算机学院学生  
* All rights reserved. 
 * 文件名称：实现类似C#输入功能的Console类 
* 作 者： 雷恒鑫  
* 完成日期： 2012 年 09 月 20 日 
 * 版 本 号： V1.0  
* 对任务及求解方法的描述部分 
 * 输入描述： 
 * 问题描述： 
 * 程序输出： 
  
* 程序头部的注释结束 
  
*/  
  
  
  
  
import java.util.Scanner;  
  
public class Console  
{  
  
    public static String readLine(){  
        Scanner sc=new Scanner(System.in);  
        return sc.next();  
    }  
    public static char readLine_char(){  
        Scanner sc=new Scanner(System.in);  
        String str=sc.next();  
        return str.charAt(0);  
    }
    public static int readInt(){  
        Scanner sc=new Scanner(System.in);  
        String str=sc.next();  
        return Integer.parseInt(str);  
    }  
      
    public static double readDouble(){  
        Scanner sc=new Scanner(System.in);  
        String str=sc.next();  
        return Double.parseDouble(str);  
    } 
}<img src ="http://www.blogjava.net/newcnzz/aggbug/388377.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/newcnzz/" target="_blank">文哥哥</a> 2012-09-23 16:56 <a href="http://www.blogjava.net/newcnzz/articles/388377.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item></channel></rss>