zheman's Blog - Java

如何解决”dllhost进程消耗cpu 100%的问题

zheman@126.com(zheman) — Thu,07 Aug 2008 15:18:58 +0800

转自：www.hdiy.com 2004-2-9 13:42:23 海地资讯

两个地址，做个记录：

http://www.blueidea.com/computer/net/2003/1124.asp
http://www.blueidea.com/computer/system/2007/4559_2.asp

特征：服务器正常CPU消耗应该在75%以下，而且CPU消耗应该是上下起伏的，出现这种问题的服务器，CPU会突然一直处100%的水平，而且不会下降。查看任务管理器，可以发现是DLLHOST.EXE消耗了所有的CPU空闲时间，管理员在这种情况下，只好重新启动IIS服务，奇怪的是，重新启动IIS服务后一切正常，但可能过了一段时间后，问题又再次出现了。

直接原因：
有一个或多个ACCESS数据库在多次读写过程中损坏，微软的MDAC系统在写入这个损坏的ACCESS文件时，ASP线程处于BLOCK状态，结果其他线程只能等待，IIS被死锁了，全部的CPU时间都消耗在DLLHOST中。

解决办法：
安装“一流信息监控拦截系统”，使用其中的“首席文件检查官IIS健康检查官”软件，
启用”查找死锁模块”，设置：
;--wblock=yes
;监控的目录，请指定您的主机的文件所在目录：
;--wblockdir=d:\test
监控生成的日志的文件保存位置在安装目录的log目录中，文件名为：logblock.htm

停止IIS，再启动“首席文件检查官IIS健康检查官”，再启动IIS，“首席文件检查官IIS健康检查官”会在logblock.htm中记录下最后写入的ACCESS文件的。

过了一段时间后，当问题出来时，例如CPU会再次一直处100%的水平，可以停止IIS，检查logblock.htm所记录的最后的十个文件，注意，最有问题的往往是计数器类的ACCESS文件，例如：”**COUNT.MDB”，”**COUNT.ASP”，可以先把最后十个文件或有所怀疑的文件删除到回收站中，再启动IIS，看看问题是否再次出现。我们相信，经过仔细的查找后，您肯定可以找到这个让您操心了一段时间的文件的。
找到这个文件后，可以删除它，或下载下来，用ACCESS2000修复它，问题就解决了！！！

简繁体互换JS版

zheman@126.com(zheman) — Wed,04 Jun 2008 08:29:21 +0800

1.下载js文件: 点击下载此文件
，放至站点根目录.
2.如编码为gb2315加入如下代码:

程序代码



编码为utf-8的加入以下代码：

程序代码

3.在适当的位置加入互换链接:

程序代码

繁体中文
简体中文

4.实例演示打包下载：点击下载此文件

5.支持IE,FIREFOX

用TOMCAT作简单的jsp web开发-开发环境配置

zheman@126.com(zheman) — Mon,26 Mar 2007 14:21:48 +0800

出处：http://bbs.blueidea.com/thread-2729956-1-1.html
许多人做java的web开发还是在windows操作系统下，而要做开发的第一步，就是配置开发环境。Java的开发环境，基本的就是java虚拟机和web服务器，当然，数据库服务器环境也是比较重要的一个环节，但是由于开发时所用的数据库有很多，比如Oracle,MySQL,SQLServer，Access等等，而且对于web开发者来说，只要数据库的服务存在，提供了数据库链接的基本信息（url,username,password,driverClass），利用JDK或者第三方提供的JDBC驱动类的包，很容易链接到数据库。所以现在所说的java web开发环境，主要针对java虚拟机和web服务器来说。而在开发过程中，许多开发者喜欢用的web服务器是tomcat，所以就简单讲讲JDK和TOMCAT的安装配置。
       而开发所用的IDE，只能用我经常用的Eclipse为例了。
       JDK的安装，版本选择。
       JDK有很多版本，J2SE 1.3.1 ,1.4.2 ,1.5 ,1.6。。。下载JDK安装文件，请到sun公司的网站进行下载。
比如，现在JDK1.6的下载页面为http://java.sun.com/javase/downloads/index.jsp
而以前的版本的下载页面为http://java.sun.com/javase/downloads/previous.jsp
这里选择1.4.2版本的JDK。
注：
       开发过程中，JDK版本的选择，如果是由你决定，那么可以根据个人的喜欢下载相应的版本就可以了。同时要注意所选择的web服务器对JDK版本的要求。如果项目统一要求，或者以前已经有了开发好的项目，那么就用指定的版本的JDK。毕竟，不同版本的JDK中类和包的结构可能存在一些差别。
       这里，选择1.4.2版本的JDK。
       在下载页面，（http://java.sun.com/j2se/1.4.2/download.html）可以看到提供了JDK,JRE以及JDK文档的下载。JRE是给操作系统提供Java运行环境，比如IE中的Applet程序的运行支持。开发者要用JDK，JDK安装后，自带JRE。
       PS>建议下栽JDK安装文件的同时下栽JDK文档，这是开发过程中最好的帮手，可以查到各种类，方法的说明和参数，以及可能抛出的异常等基本信息。如果要做Java WEB开发，这个帮助文档是不应该缺少的。
       安装JDK以及JDK版本的管理。
       JDK有不同的版本，开发过程中不同的项目使用的JDK版本可能不同。所以建议安装的时候把JDK安装到某个目录下，并给每个JDK的文件夹用JDK版本命名，同时建议不要安装在系统盘上，安装到别的盘下，避免重装系统等情况下对JDK有影响。（重装系统后原有的JDK能否使用没有确认。）比如，我的JDK都安装在E盘JDK目录下，已有的JDK是1.6版本的和1.3.1_12版本，现在安装的时候，就在同级目录下建了1.4.2_13版本的目录。

设定好安装目录后，开始进行安装，安装目录只是个人喜好，对JDK没有影响。安装完成后，重启，设定生效。重启后，在开始-运行-进入cmd窗口，输入 java –version，正常的情况下会打印出你JDK的版本信息。表明安装成功。

PS>安装了多个版本的JDK，如何更改当前系统使用的JDK?
比如我的机器现在有的JDK分别为1.3.1_12，1.4.2_13，1.6三个版本。
安装的目录分别为：
       1.3.1_12                      C:\jdk1.3.1_12
       1.4.2_13                           E:\JDK\j2sdk1.4.2_13
       1.6                           E:\JDK\jdk1.6
如果我要用1.3.1_12版本的JDK，只要在“我的电脑”点右键进入系统属性界面，详细设定窗口点击环境变量，在系统环境变量中找到path的参数，在参数前输入你的JDK目录\bin;确定后，再打开一个新的cmd窗口，输入java –version，版本信息是不是变了？比如，我想用1.3.1_12版本的JDK，加上C:\jdk1.3.1_12\bin;后，再次查看版本信息，就变成如下的信息了。

注意要打开一个新的cmd窗口，原来的cmd窗口打印不出新的版本信息。
PS>有时候安装了某个程序或者服务后，会发现JDK版本被更改。比较常见的是Oracle9i安装后，发现JDK的版本信息变成了1.3.1的，这是因为安装Oracle过程中，Oracle自己安装了JDK。安装Oracle后，在“我的电脑”点右键进入系统属性界面，详细设定窗口点击环境变量，在系统环境变量中找到path的参数，在这里察看Oracle设定的参数，会发现几个Oracle安装目录下的jre参数，一般有1.3.1，1.1.8，这2个版本，把他们删掉后你自己的JDK就可以正常使用了。
TOMCAT的下栽及安装。
Tomcat要到http://tomcat.apache.org/网站上下载。可以选择不同的版本，选择的时候注意其对JDK版本的要求，如果tomcat对JDK版本有要求的时候，下栽目录会有提示。
在这里选择tomcat4.0.6，exe用的tomcat进行下栽安装。
安装的文件有zip的exe的等。2者都可以，个人感觉zip的解压了就可以用，要方便些。
解压完了，打开tomcat的目录，可以看到以下几个接触比较多的文件夹。Bin,common,里，conf,webapps,work。
Bin：这个文件夹下放着tomcat的批处理文件，tomcat的开始和关闭的批处理文件都在这里。Startup.bat，shutdown.bat
Common,lib：tomcat提供的jar包在这2个文件夹下，开发项目时设定classpath的时候，可以到这里找要用的jar包。
Conf：tomcat的配置文件，其中server.xml可能经常会用到，可以在里面进行配置新的应用，加载数据源等各种配置。
Webapps：正常情况下，用户自己配置的应用是放在这里的。当然，这不是绝对的，可以在刚才说的server.xml里进行设定，那么你的程序放在哪里都可以了。
Work：这个目录还是比较有用的，开发过程中写好的jsp文件，在tomcat中初次运行的时候，会被tomcat解释成java文件并编译成class文件放在这里。有时候jsp文件出异常的时候，报错的文件不是用户自己写的文件，而是和jsp文件名有些相似的java文件，那就到这里来找。
现在，到bin目录下点击startup.bat来启动tomcat服务。如果按照我上面介绍的步骤，可以发现tomcat启动不了。

这是因为有些参数我们还没有设定。
打开startup.bat文件。（rem是注释，就不需要去管了，摘出来会被运行的语句）
@echo off
if "%OS%" == "Windows_NT" setlocal
if not "%CATALINA_HOME%" == "" goto gotHome
set CATALINA_HOME=.
if exist "%CATALINA_HOME%\bin\catalina.bat" goto okHome
set CATALINA_HOME=..
:gotHome
if exist "%CATALINA_HOME%\bin\catalina.bat" goto okHome
echo The CATALINA_HOME environment variable is not defined correctly
echo This environment variable is needed to run this program
goto end
:okHome
set EXECUTABLE=%CATALINA_HOME%\bin\catalina.bat
if exist "%EXECUTABLE%" goto okExec
echo Cannot find %EXECUTABLE%
echo This file is needed to run this program
goto end
:okExec
set CMD_LINE_ARGS=
:setArgs
if ""%1""=="""" goto doneSetArgs
set CMD_LINE_ARGS=%CMD_LINE_ARGS% %1
shift
goto setArgs
:doneSetArgs
call "%EXECUTABLE%" start %CMD_LINE_ARGS%
:end
这种语言并不熟悉，不过可以大致看它的意思。在确定操作系统为windows后，判断CATALINA_HOME变量是否定义，如果没有定义，将当前的tomcat目录作为tomcat服务器的目录。如果定义的话，将定义的CATALINA_HOME作为tomcat服务器的目录。
执行catalina.bat批处理，在这个批处理里，我们看到这句话，JAVA_HOME       Must point at your Java Development Kit installation.，这个表明要运行tomcat，我们必须设定JAVA_HOME为某个安装了的JDK。所以，在“我的电脑”点右键进入系统属性界面，详细设定窗口点击环境变量，在系统环境变量中设定JAVA_HOME为自己的JDK目录。

设定完成后，再次点击startup.bat，正常情况下，应该看到如下界面。

表明tomcat服务已经正常启动。这时候打开IE，输入http://localhost:8080/，可以看到tomcat正常启动的画面。

这时候，tomcat安装已经正常完了。
PS>tomcat的默认端口是8080，这个可以在server.xml中进行配置，以后再作介绍。有时候如果别的服务占用了8080的端口，可以去更改tomcat的端口，来让tomcat可以正常运行。
安装好的tomcat的主页面中，有一些链接的信息还是有些用处的。
JSP,Servlet,WebDAV Examples这些，提供了一些简单的jsp和servlet，让你了解tomcat下web开发的一些最基本的方式。
Tomcat Documentation中提供了关于当前版本的Tomcat的各种资料，有些很详细，有些比较潦草。不过看看还是很有帮助的。
如果有兴趣，看看server.xml，web.xml那里边有许多被注释掉的sample。可以了解tomcat的各种配置等信息。
IDE：
我用的IDE是Eclipse，Eclipse的安装比较简单，暂时就不提了。
环境配置好了，我们不妨写出第一个jsp文件，来看看在tomcat下能否正常运行。
文件名：HelloWorld.jsp
文件内容：
[Copy to clipboard]
CODE:
很简单，定义一个字符串，将这个字符串打印出来。
把这个文件拷贝到tomcat下的webapps/examples/文件夹下。
然后在IE中输入以下地址
http://localhost:8080/examples/HelloWorld.jsp
正常的情况下将会看到打印出的字符串。

OK，第一个jsp程序成功运行。
之所以作这样一个页面，是要带出2个小问题点。
一，       JSP以及Java是严格区分大小写的，以前没做过jsp开发的朋友要注意这点。
比如，你输入http://localhost:8080/examples/helloworld.jsp，将无法访问到这个页面。
二，       成功运行后，我们到work目录下去找这个文件，在work\Standalone\localhost\examples目录下，可以看到一个HelloWorld$jsp.java和HelloWorld$jsp.class，这就是tomcat把我们写的jsp文件生成java文件，然后在编译成class文件。Tomcat运行的时候直接调用这个class文件。
打开，看一下源码。
[Copy to clipboard]
CODE:
package org.apache.jsp;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import org.apache.jasper.runtime.*;
public class HelloWorld$jsp extends HttpJspBase {
    static {
    }
    public HelloWorld$jsp( ) {
    }
    private static boolean _jspx_inited = false;
    public final void _jspx_init() throws org.apache.jasper.runtime.JspException {
    }
    public void _jspService(HttpServletRequest request, HttpServletResponse  response)
        throws java.io.IOException, ServletException {
        JspFactory _jspxFactory = null;
        PageContext pageContext = null;
        HttpSession session = null;
        ServletContext application = null;
        ServletConfig config = null;
        JspWriter out = null;
        Object page = this;
        String  _value = null;
        try {
            if (_jspx_inited == false) {
                synchronized (this) {
                    if (_jspx_inited == false) {
                        _jspx_init();
                        _jspx_inited = true;
                    }
                }
            }
            _jspxFactory = JspFactory.getDefaultFactory();
            response.setContentType("text/html;ISO-8859-1");
            pageContext = _jspxFactory.getPageContext(this, request, response,
                        "", true, 8192, true);
            application = pageContext.getServletContext();
            config = pageContext.getServletConfig();
            session = pageContext.getSession();
            out = pageContext.getOut();
            // begin [file="/HelloWorld.jsp";from=(0,2);to=(3,0)]

                String str = "Hello World";
                out.print(str);
            // end
        } catch (Throwable t) {
            if (out != null && out.getBufferSize() != 0)
                out.clearBuffer();
            if (pageContext != null) pageContext.handlePageException(t);
        } finally {
            if (_jspxFactory != null) _jspxFactory.releasePageContext(pageContext);
        }
    }
}
有意思吧。做java开发，可以有点这样的想法，所有的程序，最终都可以看作给java虚拟机运行的一堆类文件。Jsp,开发中要用到的jar包，甚至是tomcat本身，所以，开发中出现问题的时候，其实就是你用错误的方法操作了一堆别人提供的类，所以，1，要知道游戏规则（语法规范），2，要知道你在跟谁玩，并且要了解跟你玩的对象（开发过程中要用到的各种资源），这2点都知道的话，出了问题也很容易找出来了。
[ 本帖最后由 SinNeR 于 2007-3-23 19:29 编辑 ]

图片附件
:
001.gif
(2007-3-23 19:24, 10.74 K)

图片附件
:
002.gif
(2007-3-23 19:24, 9.07 K)

图片附件
:
003.jpg
(2007-3-23 19:24, 71.3 K)

图片附件
:
004.gif
(2007-3-23 19:24, 9.07 K)

图片附件
:
005.jpg
(2007-3-23 19:24, 35.11 K)

图片附件
:
006.gif
(2007-3-23 19:24, 4.39 K)

图片附件
:
007.gif
(2007-3-23 19:24, 5.51 K)

图片附件
:
008.gif
(2007-3-23 19:24, 26.23 K)

图片附件
:
009.gif
(2007-3-23 19:24, 9.44 K)

IDE eclipse的安装
eclipse可以到http://www.eclipse.org/downloads/下载，拿版本3.2.2为例，简单介绍下安装过程。
下载后，解压到指定的目录，发现可以直接运行。初次运行的时候，会弹出窗口，提示设定eclipse的工作空间，选择选择一个工作空间，并勾上以后不再提示，这样以后这个对话创就不会弹出。这样，eclipse就安装完成了，以后会以eclipse为基础，介绍怎么样利用eclipse用tomcat做服务器，开发简单的jsp,servlet程序。
这里先说一点，在操作系统上存在多个版本的JDK的时候，eclipse怎样更改JDK版本。
拿3.2.2版本为例，打开window->preferences，（中文版的是窗口->首选项），有eclipse的各种设置信息，其中java栏中有Installed JRE选项，在这里可以添加和更改当前安装的不同版本的JDK。
比如，现在eclipse识别的JDK是1.4.2_13，已经安装的1.4.2_11没有识别出来，在这里可以手动添加。点击ADD按钮，弹出如下界面，在jre name中填写版本信息，在JRE home directory中选中JDK安装的目录，Eclipse会自动读出可用的jar包和可用的javaDocs。点击OK后，该版本的JDK添加成功。然后可以选中某个你开发需要的JDK版本。
当然，在建立工程开发的过程中也可以更改JDK版本，这个以后再介绍。
到现在，tomcat下的jsp开发只是提了冰山一角。具体开发中还有许多知识。但是看了以上部分后，开发过程中就可以轻松的搭建环境，为开发做好准备工作。（这里没有说数据库的搭建，和第三方技术支持的搭建。因为这些知识本身已经不属于一个web程序员的范畴了，对于一个web开发的程序员来说，只要知道第三方控件的接口或者数据库连接的参数即可，至于数据库搭建的各种知识，则是DBA这类人的任务了。）

图片附件
:
001.gif
(2007-3-24 00:25, 15.84 K)

图片附件
:
002.gif
(2007-3-24 00:25, 12.41 K)

Java面向对象（下）

zheman@126.com(zheman) — Wed,26 Jul 2006 14:44:43 +0800

一。类的继承
1。存在A类与B类，B类继承A类，B类继续所有A类的属性和方法。来看例子：
Student.java
class Person
{
      public String name;
      public int age;
      public Person(String name,int age)
     {
        this.name=name;
        this.age=age;
      }
      public Person() //如果不写这个构造函数，看看对类Student有什么影响。
      {
      }
      public void getInfo()
      {
           System.out.println(name);
          System.out.println(age);
      }
}
class Student extends Person
{
      public void study()
      {
              System.out.println("Studding");
      }

      public static void main(String[] args)
      {
          Person p=new Person();
          p.name="person";
          p.age=30;
          p.getInfo();

          Student s=new Student();
        s.name="student";
        s.age=16;
        s.getInfo();
        s.study();
      }
}
说明：
（1）：继承关键字extends实现，继承可以简化类的定义。
（2）：Java中只允许单继承，一个子类只能有一个父类，一个父类可以有多个子类。
（3）：B类继承A类，C类继承B类，那么C即间接的继承了A类的所有的属性和方法。
（4）：子类继承所有父类属性和行为，但是不继承构造方法。但是可以在子类中使用super调用你类的构造方法。
看例子：
class Student extends Person
{
    public Student(String name,int age,String school)
    {
        super(name,age);
        this.school=school;
    }
}
如果子类没有调用父类的构造方法，也没有使用this关键字调用重载构造方法，则创建的子类的实例对象，系统默认调用父类无参数的构造函数
2:子类可以修改从父类继承来的方法，即为方法的重写
例子：
class Person
{
    public String name;
    public int age;
    public void getInfo()
    {
        System.out.println(name);
        System.out.println(age);
    }
}
class Student1 extends Person
{
    String school = new String();
    public void getInfo()//方法的覆盖
    {
        super.getInfo();//super继承Person类的getInfo方法
        System.out.println(school);
    }
    public static void main(String []args)
    {
        Person p1 = new Person();
        p1.name="Jack";
        p1.age=26;
        p1.getInfo();

        Student1 s1 = new Student1();
        s1.name="Marry";
        s1.age=30;
        s1.school="NanKai University";
        s1.getInfo();
    }
}
3.final关键字
（1）适用于修饰类、属性、方法及变量
（2）final修饰的类不被继承。方法不被子类重写
（3）final标记的变量即为常量，只能进行一次赋值
注：其实理解了final这个单词的意思也就好理解了，final当名词用时为结局的意思，当形容词用的时候为最后的，最终的，：）补充一下外语，要不为什么老外学种语言那么容易！
看几个小例子
final int x=5;//必须显示赋值
x=3;//错误的例子,final标记的变量即为常量，只能进行一次赋值
另外public static final x=5；x即为全局变量
二。抽象类与接口
1。抽象方法：在方法前以abstract修饰的方法即为抽象方法，包括抽象方法的类即为抽象类。抽象类也必须以abstract修饰。
抽象方法的格式：abstract 返回值类型抽象方法（参数列表）
（1）抽象方法和抽象类必须以abstract修饰。
（2）抽象方法只是声明，而不实现。
（3）抽象类不能被实例化，即不能new。
（4）抽象类中所有的抽象方法被子类重写后，抽象类才能被实例化。
（5）抽象类中肯定有抽象方法，但不一定抽象类中全是抽象方法。
例子：
abstract class Test()
{
    abstract void Info()
    {

    }
}
2。接口：一个抽象类的所有方法全是抽象方法即为接口，其实接口也发球属于抽象类中一种比较特殊的格式。
（1）以关键字interface标记
（2）接口中只能包括常量（public static fianl也是属于其中）和抽象方法
（3）也只是声明，而没有实现，需要子类的重写
看一个接口的例子
abstract class Test()
{
    abstract void Info()
    {

    }
    abstract void Mar()
    {

    }

}

Java面向对象（上）

zheman@126.com(zheman) — Wed,26 Jul 2006 14:44:01 +0800

一。面对对象定义：
1。面向对象的三个特征：
a：继续
b：多态
C：封闭
2。相关的说明
引用:
概述面向对象设计（Java）
(如今的程序领域，大家都在说，面向对象OOP,但是真正能理解面向对象的含义的程序员却很少，究竟什么是对象，怎样面向对象)
一．面向对象：
1.何谓对象：在面向对象程序设计中，我们将问题空间中的元素以及他们在方案空间中的的表示物称作对象（object）
Alan Kay总结了smalltalk中对象的5大基本特征：
所有的东西都是对象。
程序是一大堆对象的集合，他们通过消息传递，各个对象之间知道要做些什么。
每个对象都分配有自己的存储空间，可容纳其他对象。
每个对象都有一个类型。
同一类的所有对象能接收相同的消息。
-----而所有的编程语言的最终目的是提供一种抽象方法----
2．对象的接口：我们向对象发出请求是通过它的接口定义的，对象的类型决定了它的接口形式。
3．OOP中唯一关心的：就是接口是什么，就像汽车的发动机一样，我们不必要知道它的结构是什么，只要它能工作就行了。所有的程序是由一定的属性（数据）和行为（方法）组成的，不同的对象访问通过函数调用来完成，对象间的所有交流都是通过方法调用，通过对封装数据对象，很大程度上提高复用率。
4．对象的3个主要特征：
behavior—说明这个对象能做什么。
State—当对象施加方法时对象的反映。
Identity---与其他相似行为对象的区分标志，每一个对象有唯一的indentity, 而这3者是相互影响的。
5．面向对象中最重要的思想就是类，类是模板是蓝图，从类中构造一个对象，即创建了一个类的实例。（类好比一个建材市场，其中有许多子类--各种各样的装饰材料，而我们装修自己的房子就要选择我们需要的材料，（为了建立我们自己的程序，我们必须选择我们需要的类）这个比喻可以很形象的解释类是什么。
6．类之间的关系：
依赖关系：use-a A类中的一个方法操作了另一个类中的对象。
聚合关系：has-a A类中的对象包含B类的对象。
继承关系：is-a A继承了B类，此时A类不仅有了B类的方法，还加入了自己的方法。以便我们创建我们自己需要的对象。
Java中定义的每一个类都必须继承另一个类，使用关键字extends，如果一个类在定义中不现实使用关键字extends,这个类就会隐式继承Object类。Object类又叫根超类，或基类。，我们从根超类继承来的叫子类。Java中每个类都是根超类的子类。
8．接口（interface）规定了可对特定的对象发出哪些请求。
9．继承=重新使用接口：创建出一个数据类型后，当需要新建立一个数据类型去实现相同的功能，是很没有意义的一件事，此时对其克隆后，再根据情况改进实现自己的目的就是继承。
10．封装：就是把数据和行为结合在一起在一个包中，并对对象使用者隐藏数据的实现过程。Java用3个关键字来设置边界，从而进行对数据的隐藏。Public(共有)的定义任何人都可使用.private（私有）意味着除你自己，类型创建者及那个类型的内部函数成员可以访问外其他任何人使用都会产生错误。Friendly（友好）
意味在包(package)中是可以访问的。（以上过程也可叫方案隐藏）
11．引用（Handle）操控对象：
当创建一个引用时必须要对其进行初始化
例: String s=”happy”（未建立连接）
String s=new string(“happy”)与一个新的对象连接使用new 。此句建立了一个引用，并且连接引用并初始化对象赋值字符串“happy”.
12.对象的创建及存在时间：数据存放的地点
1：寄存器-速度快，数量少，在cpu内部，我们对寄存器没有控制权。
2：堆栈：驻留长规内存中，堆栈指针下移建立新的内存，上移释放内存。
3：堆：常用内存池，保存对象，有极大的灵活性，java的数据就存放在此，但是要以时间及效率为代价。Java的对象建立是在程序运行时才决定。而c++是在设计时建立对象。
对象的生存时间（lifetime）java提出的垃圾收集器可以很好的发现无须再用的对象，使用GC（grabage collector）垃圾收集器。清除对象，释放内存。
为此我们就要付出一定的运行期的开销。
13.在此我们就会有这样一个印象,一个程序只是一系列对象的集合,他们的方法将其他对象作为自己的变量使用.
14.主要类型: java的主要类型有:boolean,char,byte,short,int,long,float,double,void.这些主类型的大小都不随机器的结构变化而变化,提供了java很好的可移植性.
15.字段方法:字段又叫数据成员,成员函数又叫方法,java的全部工作就是定义类,制作累得对象及发送消息.
16.一个程序只是一系列对象的集合,他们的方法将其他的对象作为自己的变量使用,而且将消息发给那些对象.
17.名字的可见性:为了使名字不重复,作者可以定义自己的库,一般用自己域名的倒写形式如: COM.:Leeak.utility.foidles
18.static关键字:即使没有创建对象,也需要一愕能调用的方法,此时可以使用static
19.java.lang默认自动的导入每个java程序中
20.OOP中对象使对属性和方法的封装,对象具有信息的隐蔽的性质,对细节的隐藏,对象只需要知道去这样做,而不知道如何做的细节,类的方法应谨慎控制对java数据的访问,可以用get读取方法,用set修改方法.
21:pakage:Java API中每个类和接口属于一个特定的包,包实际上市对类和接口进行组织的目录结构,提供了一种软件复用机制.
22.创建可复用的类得步骤:1.定义一个public类
2.选择一个包名,并把pakage语句加到可复用的类的源码中.
3.编译这个类.
4.把可复用的类导入其他程序中即可.
23.java中提出在类定义的括号外的仅有2个语句,pakage和import.
24.软件的复用性,软件的复用性就是利用紫的已有的,定义良好的的经过仔细测试的文档清晰的可移植的易于获得的软件构件开发新的软件.
2。类和对象
（1）。类（class）是抽象的，概念上的定义，而对象才是实在存在的，也称为类的实例（Instance）；举一个不是很恰当的例子，类相当于模具，而对象才是由于模具生产出来的产品。
（2）。类包括变量和函数，变量定义类的属性，函数定义类的行为。
引用:
class Person
{
    int age;//类成员定义类的属性
    void shout()//类方法定义类的行为
    {
        System.out.println("Person class");
    }
}
3。类对象的产生和作用
（1）对象生成
引用:
Person p1 = new Person();
p1是Person 关的一个引用！产生对象后，成员变量自动赋值：
byte short int 全部为“0”，long为“0.0.L”， float为“0.0F”，char为"\u0000"表示为空，boolean为false。
看一个例子：
引用:
class Person
{
    int age;
    void shout()
    {
        System.out.println(age);
    }
}
class TestPerson
{
    public static void main(String [] args)
    {
        Person p1 = new Person();
        Person p2 = new Person();
        p1.age=30;
        p1.shout();
        p2.shout();//默认赋值为0
    }
}
（2）对象成为垃圾的几种情况
a：代码执行完后，离开作用域外后，成为垃圾
引用:
Person p1 = new Person();
.
.
.
b：p1.null即p1为空成为垃圾
引用:
Person p1 = new Person();
p1.null
.
.
.
c：这情况不成为垃圾
引用:
Person p1 = new Person();
Person p2 = p1;
p1.null;
.
.
.
（3）对象的比较即“==”和“equals”的区别
a：“==”比较内存地址是否为同一地址，而“equals”只是引用的具体内容或者是值。
看例子：
引用:
class Compare
{
     public static void main(String[] args)
     {
            String str1 = new String("abc");
            String str2 = new String("abc");
            String str3 = str1;
            if(str1==str2)
                System.out.println("str1==str2");
            else
                System.out.println("str1!=str2");
            if(str1==str3)
                System.out.println("str1==str3");
            else
                System.out.println("str1!=str3");
    }
}
//str1 == str3
//str1 != str2
//“abc”只是引用变量指向内存地址的值！
引用:
class Compare
{
     public static void main(String[] args)
     {
            String str1 = new String("abc");
            String str2 = new String("abc");
            String str3 = str1;
            if(str1.equals(str2))
                System.out.println("str1 equal str2");
            else
                System.out.println("str1 not equal str2");
            if(str1.equals(str3))
                System.out.println("str1 equal str2");
            else
                System.out.println("str1 not equal str3");
    }
}
//str1 equal str2
//str1 equal str2
//判断引用变量指向存储在内存当中的具体值，而非判断引用变量是否指向为同一内存地址
（4）匿名对象
引用:
Person p1= new Person()
p1.shout()
修改成：
引用:
new Person().shout()
使用匿名对象一般有两种：
a：只调用一次
b：将匿名对象做一个实参传递给函数
4。类的封装
类的封装是指在一个类中将成员变量声明为private，然后通过公用方法来修改和输出这个成员变量，外部类能过这两个函数来操作该成员变量，这就是类的封装。
注：private只是被本类中访问无法被外部类访问
引用:
class Person
{
    private int age;//静态成员变量
    public void setAge(int i)//公用输入函数
    {
        if(i130)
            return;
        age = i;
    }
    public int getAge()//公用输出函数
    {
        return age;
    }
}
public class TestPerson//外部类
{
    public static void main(String args[])
    {
        Person p1 = new Person();
        p1.setAge(3);
        p1.setAge(-6);
        System.out.println(p1.getAge());
    }
}
封闭的作用：
a：隐藏类的细节
b：数据检查
c：便于修改，增加代码可维护性
d：限制对发生不合理的访问
二。构造方法
1。定义
引用:
class Person
{
public Person()//构造方法
{
        System.out.println("the constructor 1 is calling!");
    }
    private int age = 10;
    public void shout()
    {
        System.out.println("age is "+age);
    }
}
class TestPerson
{
    public static void main(String[] args)
    {
        Person p1=new Person();
        p1.shout();
        Person p2=new Person();
        p2.shout();
        Person p3=new Person();
        p3.shout();
    }
}
构造方法的特征：
a：与类名相同的函数并以public修饰
b：不含返回值，不能使用return
2。重载
引用:
class Person
{
    private String name="unknown";
    private int age = -1;
    public Person()
    {
        System.out.println("constructor1 is calling");
    }
public Person(String n)
    {
name = n;
System.out.println("constructor2 is calling");
        System.out.println("name is "+name);
}
    public Person(String n,int a)
    {
name = n;
age = a;
System.out.println("constructor3 is calling");
        System.out.println("name and age is "+name+";"+age);
}
public void shout()
     {
         System.out.println("listen to me!!");
        }
}
class TestPerson
{
    public static void main(String[] args)
    {
        Person p1=new Person();
        P1.shout();
        Person p2=new Person("Jack");
        P2.shout();
        Person p3=new Person("Tom",18);
        P3.shout();
    }
}
注：
定义多个构造方法不要忘记把类默认的构造方法增加上，因为你定义了一个非默认的构造方法，那么java就会忽略掉默认的构造方法，所以要补上
三。this用法
最普遍的情况就是，在你的方法中的某个形参名与当前对象的某个成员有相同的名字，这时为了不至于混淆，你便需要明确使用this关键字来指明你要使用某个成员，使用方法是“this.成员名”，而不带this的那个便是形参。另外，还可以用“this.方法名”来引用当前对象的某个方法，但这时this就不是必须的了，你可以直接用方法名来访问那个方法，编译器会知道你要调用的是那一个。下面的代码演示了上面的用法：
引用:
public class DemoThis{
private String name;
private int age;
DemoThis(String name,int age){
setName(name); //你可以加上this来调用方法，像这样：this.setName(name);但这并不是必须的
setAge(age);
this.print();
}
public void setName(String name){
this.name=name;//此处必须指明你要引用成员变量
}
public void setAge(int age){
this.age=age;
}
public void print(){
System.out.println("Name="+name+" Age="+age);//在此行中并不需要用this，因为没有会导致混淆的东西
}
public static void main(String[] args){
DemoThis dt=new DemoThis("Kevin","22");
}
}
又热又累呀，剩下的周末再说吧！
继续：
四：函数参数传递
来看一个例子：
引用:
class Passvalue
{
    public static void main(String [] args)
    {
        int x = 5;
        change(x);
        System.out.println(x);
    }
    public static void change(int x)
    {
        x = 3;
    }
}
注：结果为5，基本类型的变量做为实参传递时，并不改变这个变量的值
来看一个例子：
引用:
class PassRef
{
    int x ;
    public static void main(String [] args)
    {
        PassRef obj = new PassRef();
        obj.x = 5;
        change(obj);
        System.out.println(obj.x);
    }
    public static void change(PassRef obj)
    {
        obj.x=3;
    }
}
再看这个例子：
引用:
class PassRef
{
    int x;
    public static void main(String [] args)
    {
        PassRef obj = new PassRef();
        obj.x = 5;
        change(obj);//这里的调用并不会改变其自身的值
        System.out.println(obj.x);
    }
    public static void change(PassRef obj)
    {
        obj = new PassRef();//与上一个例子这里不同，创建了一个新的引用.
        obj.x=3;
    }
}
五。static说明
1。static的变量
我们定义了一个类，在定义了属性和行为，此时并没有什么对象的产品，需要new出来的，在变量上加上static不需要new就可直接使用。
看例子：
引用:
class Chinese
{
    static String country="中国";
    String name;
    int age;
    void singOurCountry()
    {
        System.out.println("啊！，亲爱的" + country);
        //类中的成员方法也可以直接访问静态成员变量
    }
}
class TestChinese
{
    public Static void main(String [] args)
    {
        System.out.println("Chinese country is " + Chinese.country);
        //上面的程序代码直接使用了"类名.成员"的格式
        Chinese ch1 = new Chinese();
        System.out.println("Chines country is " + ch1.country);
        //上面的程序代码直接使用了"对象名.成员"的格式
        ch1.singOurCountry();
    }
}
注：方法中不可以使用static
2。static静态方法
引用:
class Chinese
{
    static void Sing()
    {
        System.out.println("啊!");
    }
    void SingourCountry()
    {
        Sing();//直接访问方法名
    }

}
class TestChinese
{
    public static void main(String [] args)
    {
        Chinese.Sing();
        //类名加方法名
        Chinese ch1 = new Chinese();
        ch1.Sing();
        //对象名加方法名
    }
}
注：
a：在静态方法中只能调同类中静态变量
b：静态方法不能以任何方式引用this和super关键字
3。static静态代码
看代码：
引用:
class StaticCode
{
    static String country;
    static
    {
        country = "china";
        System.out.println("StaticCode is loading");
    }
}
class TestStaticCode
{
    static
    {
        System.out.println("TestStaticCode is loading");
    }
    public static void main(String [] args)
    {
        System.out.println("begin executing main method");
        new StaticCode();
        new StaticCode();
    }
}
注：
静态代码只被执行一次
六。单态设计模式
单态设计模式就是在通过一些方法，保证一个类中只产生一个一个对象
代码如下：
引用:
class TestSingle
{
    private static final TestSingle onlyone = new TestSingle();
    public static TestSingle getTestSingle()
    {
        return onlyone;
    }
    private TestSingle()
    {

    }
}
六：内部类
1：类中定义内部类
代码：
引用:
class Outer
{
    int outer_i = 100;
    void test()
    {
        Inner in = new Inner();
        in.display();
    }
    class Inner
    {
        void display()
        {
        System.out.println("display: outer_i = " + outer_i);
        }
    }
}
class InnerClassDemo
{
    public static void main(String[] args)
    {
        Outer outer = new Outer();
        outer.test();
    }
}
注：
a：
存在A类与B类
A->使用B类的实例对象
B->A类使用B类的成员变量
b：
B类可以访问到A类的成员，反之不成
c：
内部类只需要以public修饰将会被外部类所调用
d：
方法中定义内部类只能访问方法中final，final定义的局部变量相当于定义了一个常量

Java中static、this、super、final用法

zheman@126.com(zheman) — Wed,26 Jul 2006 14:43:11 +0800

转自：http://www.nihaoblog.com/1_6747.html
感觉写的相当不错，也是Java面向对象的几个基本元素，大家感兴趣的好好看看
一、static
　　请先看下面这段程序：
引用:
public class Hello{
public static void main(String[] args){ //(1)
System.out.println("Hello,world!"); //(2)
}
}
看过这段程序，对于大多数学过Java 的从来说，都不陌生。即使没有学过Java，而学过其它的高级语言，例如C，那你也应该能看懂这段代码的意思。它只是简单的输出“Hello,world”，一点别的用处都没有，然而，它却展示了static关键字的主要用法。
　　在1处，我们定义了一个静态的方法名为main，这就意味着告诉Java编译器，我这个方法不需要创建一个此类的对象即可使用。你还得你是怎么运行这个程序吗？一般，我们都是在命令行下，打入如下的命令(加下划线为手动输入)：
javac Hello.java
java Hello
Hello,world!
　　这就是你运行的过程，第一行用来编译Hello.java这个文件，执行完后，如果你查看当前，会发现多了一个Hello.class文件，那就是第一行产生的Java二进制字节码。第二行就是执行一个Java程序的最普遍做法。执行结果如你所料。在2中，你可能会想，为什么要这样才能输出。好，我们来分解一下这条语句。（如果没有安装Java文档，请到Sun的官方网站浏览J2SE API）首先，System是位于java.lang包中的一个核心类，如果你查看它的定义，你会发现有这样一行：public static final PrintStream out;接着在进一步，点击PrintStream这个超链接，在METHOD页面，你会看到大量定义的方法，查找println，会有这样一行：
public void println(String x)。
　　好了，现在你应该明白为什么我们要那样调用了，out是System的一个静态变量，所以可以直接使用，而out所属的类有一个println方法。
静态方法
　　通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法。如下所示：
引用:
class Simple{
static void go(){
System.out.println("Go...");
}
}
public class Cal{
public static void main(String[] args){
Simple.go();
}
}
调用一个静态方法就是“类名.方法名”,静态方法的使用很简单如上所示。一般来说，静态方法常常为应用程序中的其它类提供一些实用工具所用，在Java的类库中大量的静态方法正是出于此目的而定义的。
静态变量
　　静态变量与静态方法类似。所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间，当然对于final则另当别论了。看下面这段代码：
引用:
class value{
static int c=0;
static void inc(){
c++;
}
}
class Count{
public static void prt(String s){
System.out.println(s);
}
public static void main(String[] args){
value v1,v2;
v1=new value();
v2=new value();
prt("v1.c="+v1.c+" v2.c="+v2.c);
v1.inc();
prt("v1.c="+v1.c+" v2.c="+v2.c);
}
}
　结果如下：
v1.c=0 v2.c=0
v1.c=1 v2.c=1
　　由此可以证明它们共享一块存储区。static变量有点类似于C中的全局变量的概念。值得探讨的是静态变量的初始化问题。我们修改上面的程序：
引用:
class value{
static int c=0;
value(){
c=15;
}
value(int i){
c=i;
}
static void inc(){
c++;
}
}
class Count{
public static void prt(String s){
System.out.println(s);
}
value v=new value(10);
static value v1,v2;
static{
prt("v1.c="+v1.c+" v2.c="+v2.c);
v1=new value(27);
prt("v1.c="+v1.c+" v2.c="+v2.c);
v2=new value(15);
prt("v1.c="+v1.c+" v2.c="+v2.c);
}
public static void main(String[] args){
Count ct=new Count();
prt("ct.c="+ct.v.c);
prt("v1.c="+v1.c+" v2.c="+v2.c);
v1.inc();
prt("v1.c="+v1.c+" v2.c="+v2.c);
prt("ct.c="+ct.v.c);
}
}
运行结果如下：
v1.c=0 v2.c=0
v1.c=27 v2.c=27
v1.c=15 v2.c=15
ct.c=10
v1.c=10 v2.c=10
v1.c=11 v2.c=11
ct.c=11
　　这个程序展示了静态初始化的各种特性。如果你初次接触Java，结果可能令你吃惊。可能会对static后加大括号感到困惑。首先要告诉你的是，static定义的变量会优先于任何其它非static变量，不论其出现的顺序如何。正如在程序中所表现的，虽然v出现在v1和v2的前面，但是结果却是v1和v2的初始化在v的前面。在static{后面跟着一段代码，这是用来进行显式的静态变量初始化，这段代码只会初始化一次，且在类被第一次装载时。如果你能读懂并理解这段代码，会帮助你对static关键字的认识。在涉及到继承的时候，会先初始化父类的static变量，然后是子类的，依次类推。非静态变量不是本文的主题，在此不做详细讨论，请参考Think in Java中的讲解。
静态类
　　通常一个普通类不允许声明为静态的，只有一个内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类。如下代码所示：
引用:
public class StaticCls{
public static void main(String[] args){
OuterCls.InnerCls oi=new OuterCls.InnerCls();
}
}
class OuterCls{
public static class InnerCls{
InnerCls(){
System.out.println("InnerCls");
}
}
}
输出结果会如你所料：
InnerCls
　　和普通类一样。内部类的其它用法请参阅Think in Java中的相关章节，此处不作详解。
二、this & super
　　在上一篇拙作中，我们讨论了static的种种用法，通过用static来定义方法或成员，为我们编程提供了某种便利，从某种程度上可以说它类似于C语言中的全局函数和全局变量。但是，并不是说有了这种便利，你便可以随处使用，如果那样的话，你便需要认真考虑一下自己是否在用面向对象的思想编程，自己的程序是否是面向对象的。好了，现在开始讨论this&super这两个关键字的意义和用法。
　　在Java中，this通常指当前对象，super则指父类的。当你想要引用当前对象的某种东西，比如当前对象的某个方法，或当前对象的某个成员，你便可以利用this来实现这个目的，当然，this的另一个用途是调用当前对象的另一个构造函数，这些马上就要讨论。如果你想引用父类的某种东西，则非super莫属。由于this与super有如此相似的一些特性和与生俱来的某种关系，所以我们在这一块儿来讨论，希望能帮助你区分和掌握它们两个。
在一般方法中
　　最普遍的情况就是，在你的方法中的某个形参名与当前对象的某个成员有相同的名字，这时为了不至于混淆，你便需要明确使用this关键字来指明你要使用某个成员，使用方法是“this.成员名”，而不带this的那个便是形参。另外，还可以用“this.方法名”来引用当前对象的某个方法，但这时this就不是必须的了，你可以直接用方法名来访问那个方法，编译器会知道你要调用的是那一个。下面的代码演示了上面的用法：
引用:
public class DemoThis{
private String name;
private int age;
DemoThis(String name,int age){
setName(name); //你可以加上this来调用方法，像这样：this.setName(name);但这并不是必须的
setAge(age);
this.print();
}
public void setName(String name){
this.name=name;//此处必须指明你要引用成员变量
}
public void setAge(int age){
this.age=age;
}
public void print(){
System.out.println("Name="+name+" Age="+age);//在此行中并不需要用this，因为没有会导致混淆的东西
}
public static void main(String[] args){
DemoThis dt=new DemoThis("Kevin","22");
}
}
这段代码很简单，不用解释你也应该能看明白。在构造函数中你看到用this.print(),你完全可以用print()来代替它，两者效果一样。下面我们修改这个程序，来演示super的用法。
引用:
class Person{
public int c;
private String name;
private int age;
protected void setName(String name){
this.name=name;
}
protected void setAge(int age){
this.age=age;
}
protected void print(){
System.out.println("Name="+name+" Age="+age);
}
}
public class DemoSuper extends Person{
public void print(){
System.out.println("DemoSuper:");
super.print();
}
public static void main(String[] args){
DemoSuper ds=new DemoSuper();
ds.setName("kevin");
ds.setAge(22);
ds.print();
}
}
在DemoSuper中，重新定义的print方法覆写了父类的print方法，它首先做一些自己的事情，然后调用父类的那个被覆写了的方法。输出结果说明了这一点：
DemoSuper:
Name=kevin Age=22
　　这样的使用方法是比较常用的。另外如果父类的成员可以被子类访问，那你可以像使用this一样使用它，用“super.父类中的成员名”的方式，但常常你并不是这样来访问父类中的成员名的。
在构造函数中
　　构造函数是一种特殊的方法，在对象初始化的时候自动调用。在构造函数中，this和super也有上面说的种种使用方式，并且它还有特殊的地方，请看下面的例子：
引用:
class Person{
public static void prt(String s){
System.out.println(s);
}
Person(){
prt("A Person.");
}
Person(String name){
prt("A person name is:"+name);
}
}
public class Chinese extends Person{
Chinese(){
super(); //调用父类构造函数（1）
prt("A chinese.");//(4)
}
Chinese(String name){
super(name);//调用父类具有相同形参的构造函数（2）
prt("his name is:"+name);
}
Chinese(String name,int age){
this(name);//调用当前具有相同形参的构造函数（3）
prt("his age is:"+age);
}
public static void main(String[] args){
Chinese cn=new Chinese();
cn=new Chinese("kevin");
cn=new Chinese("kevin",22);
}
}
在这段程序中，this和super不再是像以前那样用“.”连接一个方法或成员，而是直接在其后跟上适当的参数，因此它的意义也就有了变化。super后加参数的是用来调用父类中具有相同形式的构造函数，如1和2处。this后加参数则调用的是当前具有相同参数的构造函数，如3处。当然，在Chinese的各个重载构造函数中，this和super在一般方法中的各种用法也仍可使用，比如4处，你可以将它替换为“this.prt”(因为它继承了父类中的那个方法）或者是“super.prt”（因为它是父类中的方法且可被子类访问），它照样可以正确运行。但这样似乎就有点画蛇添足的味道了。
　　最后，写了这么多，如果你能对“this通常指代当前对象，super通常指代父类”这句话牢记在心，那么本篇便达到了目的，其它的你自会在以后的编程实践当中慢慢体会、掌握。另外关于本篇中提到的继承，请参阅相关Java教程。
三、final
　　final在Java中并不常用，然而它却为我们提供了诸如在C语言中定义常量的功能，不仅如此，final还可以让你控制你的成员、方法或者是一个类是否可被覆写或继承等功能，这些特点使final在Java中拥有了一个不可或缺的地位，也是学习Java时必须要知道和掌握的关键字之一。
final成员
　　当你在类中定义变量时，在其前面加上final关键字，那便是说，这个变量一旦被初始化便不可改变，这里不可改变的意思对基本类型来说是其值不可变，而对于对象变量来说其引用不可再变。其初始化可以在两个地方，一是其定义处，也就是说在final变量定义时直接给其赋值，二是在构造函数中。这两个地方只能选其一，要么在定义时给值，要么在构造函数中给值，不能同时既在定义时给了值，又在构造函数中给另外的值。下面这段代码演示了这一点：
引用:
import java.util.List;
import java.util.ArrayList;
import java.util.LinkedList;
public class Bat{
final PI=3.14; //在定义时便给址值
final int i; //因为要在构造函数中进行初始化，所以此处便不可再给值
final List list; //此变量也与上面的一样
Bat(){
i=100;
list=new LinkedList();
}
Bat(int ii,List l){
i=ii;
list=l;
}
public static void main(String[] args){
Bat b=new Bat();
b.list.add(new Bat());
//b.i=25;
//b.list=new ArrayList();
System.out.println("I="+b.i+" List Type:"+b.list.getClass());
b=new Bat(23,new ArrayList());
b.list.add(new Bat());
System.out.println("I="+b.i+" List Type:"+b.list.getClass());
}
}
此程序很简单的演示了final的常规用法。在这里使用在构造函数中进行初始化的方法，这使你有了一点灵活性。如Bat的两个重载构造函数所示，第一个缺省构造函数会为你提供默认的值，重载的那个构造函数会根据你所提供的值或类型为final变量初始化。然而有时你并不需要这种灵活性，你只需要在定义时便给定其值并永不变化，这时就不要再用这种方法。在main方法中有两行语句注释掉了，如果你去掉注释，程序便无法通过编译，这便是说，不论是i的值或是list的类型，一旦初始化，确实无法再更改。然而b可以通过重新初始化来指定i的值或list的类型，输出结果中显示了这一点：
I=100 List Type:class java.util.LinkedList
I=23 List Type:class java.util.ArrayList
　　还有一种用法是定义方法中的参数为final，对于基本类型的变量，这样做并没有什么实际意义，因为基本类型的变量在调用方法时是传值的，也就是说你可以在方法中更改这个参数变量而不会影响到调用语句，然而对于对象变量，却显得很实用，因为对象变量在传递时是传递其引用，这样你在方法中对对象变量的修改也会影响到调用语句中的对象变量，当你在方法中不需要改变作为参数的对象变量时，明确使用final进行声明，会防止你无意的修改而影响到调用方法。
另外方法中的内部类在用到方法中的参变量时，此参变也必须声明为final才可使用，如下代码所示：
引用:
public class INClass{
void innerClass(final String str){
class IClass{
IClass(){
System.out.println(str);
}
}
IClass ic=new IClass();
}
public static void main(String[] args){
INClass inc=new INClass();
inc.innerClass("Hello");
}
}
final方法
　　将方法声明为final，那就说明你已经知道这个方法提供的功能已经满足你要求，不需要进行扩展，并且也不允许任何从此类继承的类来覆写这个方法，但是继承仍然可以继承这个方法，也就是说可以直接使用。另外有一种被称为inline的机制，它会使你在调用final方法时，直接将方法主体插入到调用处，而不是进行例行的方法调用，例如保存断点，压栈等，这样可能会使你的程序效率有所提高，然而当你的方法主体非常庞大时，或你在多处调用此方法，那么你的调用主体代码便会迅速膨胀，可能反而会影响效率，所以你要慎用final进行方法定义。
final类
　　当你将final用于类身上时，你就需要仔细考虑，因为一个final类是无法被任何人继承的，那也就意味着此类在一个继承树中是一个叶子类，并且此类的设计已被认为很完美而不需要进行修改或扩展。对于final类中的成员，你可以定义其为final，也可以不是final。而对于方法，由于所属类为final的关系，自然也就成了final型的。你也可以明确的给final类中的方法加上一个final，但这显然没有意义。
　　下面的程序演示了final方法和final类的用法：
引用:
final class final{
final String str="final Data";
public String str1="non final data";
final public void print(){
System.out.println("final method.");
}
public void what(){
System.out.println(str+"\n"+str1);
}
}
public class FinalDemo { //extends final 无法继承
public static void main(String[] args){
final f=new final();
f.what();
f.print();
}
}
从程序中可以看出，final类与普通类的使用几乎没有差别，只是它失去了被继承的特性。final方法与非final方法的区别也很难从程序行看出，只是记住慎用。
final在设计模式中的应用
　　在设计模式中有一种模式叫做不变模式，在Java中通过final关键字可以很容易的实现这个模式，在讲解final成员时用到的程序Bat.java就是一个不变模式的例子。如果你对此感兴趣，可以参考阎宏博士编写的《Java与模式》一书中的讲解。
　　到此为止，this,static,supert和final的使用已经说完了，如果你对这四个关键字已经能够大致说出它们的区别与用法，那便说明你基本已经掌握。然而，世界上的任何东西都不是完美无缺的，Java提供这四个关键字，给程序员的编程带来了很大的便利，但并不是说要让你到处使用，一旦达到滥用的程序，便适得其反，所以在使用时请一定要认真考虑。
　　请先看下面这段程序：
引用:
public class Hello{
public static void main(String[] args){ //(1)
System.out.println("Hello,world!"); //(2)
}
}
看过这段程序，对于大多数学过Java 的从来说，都不陌生。即使没有学过Java，而学过其它的高级语言，例如C，那你也应该能看懂这段代码的意思。它只是简单的输出“Hello,world”，一点别的用处都没有，然而，它却展示了static关键字的主要用法。
　　在1处，我们定义了一个静态的方法名为main，这就意味着告诉Java编译器，我这个方法不需要创建一个此类的对象即可使用。你还得你是怎么运行这个程序吗？一般，我们都是在命令行下，打入如下的命令(加下划线为手动输入)：
javac Hello.java
java Hello
Hello,world!
　　这就是你运行的过程，第一行用来编译Hello.java这个文件，执行完后，如果你查看当前，会发现多了一个Hello.class文件，那就是第一行产生的Java二进制字节码。第二行就是执行一个Java程序的最普遍做法。执行结果如你所料。在2中，你可能会想，为什么要这样才能输出。好，我们来分解一下这条语句。（如果没有安装Java文档，请到Sun的官方网站浏览J2SE API）首先，System是位于java.lang包中的一个核心类，如果你查看它的定义，你会发现有这样一行：public static final PrintStream out;接着在进一步，点击PrintStream这个超链接，在METHOD页面，你会看到大量定义的方法，查找println，会有这样一行：
public void println(String x)。
　　好了，现在你应该明白为什么我们要那样调用了，out是System的一个静态变量，所以可以直接使用，而out所属的类有一个println方法。
静态方法
　　通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法。如下所示：
引用:
class Simple{
static void go(){
System.out.println("Go...");
}
}
public class Cal{
public static void main(String[] args){
Simple.go();
}
}
调用一个静态方法就是“类名.方法名”,静态方法的使用很简单如上所示。一般来说，静态方法常常为应用程序中的其它类提供一些实用工具所用，在Java的类库中大量的静态方法正是出于此目的而定义的。
静态变量
　　静态变量与静态方法类似。所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间，当然对于final则另当别论了。看下面这段代码：
引用:
class value{
static int c=0;
static void inc(){
c++;
}
}
class Count{
public static void prt(String s){
System.out.println(s);
}
public static void main(String[] args){
value v1,v2;
v1=new value();
v2=new value();
prt("v1.c="+v1.c+" v2.c="+v2.c);
v1.inc();
prt("v1.c="+v1.c+" v2.c="+v2.c);
}
}
结果如下：
v1.c=0 v2.c=0
v1.c=1 v2.c=1
　　由此可以证明它们共享一块存储区。static变量有点类似于C中的全局变量的概念。值得探讨的是静态变量的初始化问题。我们修改上面的程序：
引用:
class value{
static int c=0;
value(){
c=15;
}
value(int i){
c=i;
}
static void inc(){
c++;
}
}
class Count{
public static void prt(String s){
System.out.println(s);
}
value v=new value(10);
static value v1,v2;
static{
prt("v1.c="+v1.c+" v2.c="+v2.c);
v1=new value(27);
prt("v1.c="+v1.c+" v2.c="+v2.c);
v2=new value(15);
prt("v1.c="+v1.c+" v2.c="+v2.c);
}
public static void main(String[] args){
Count ct=new Count();
prt("ct.c="+ct.v.c);
prt("v1.c="+v1.c+" v2.c="+v2.c);
v1.inc();
prt("v1.c="+v1.c+" v2.c="+v2.c);
prt("ct.c="+ct.v.c);
}
}
运行结果如下：
v1.c=0 v2.c=0
v1.c=27 v2.c=27
v1.c=15 v2.c=15
ct.c=10
v1.c=10 v2.c=10
v1.c=11 v2.c=11
ct.c=11
　　这个程序展示了静态初始化的各种特性。如果你初次接触Java，结果可能令你吃惊。可能会对static后加大括号感到困惑。首先要告诉你的是，static定义的变量会优先于任何其它非static变量，不论其出现的顺序如何。正如在程序中所表现的，虽然v出现在v1和v2的前面，但是结果却是v1和v2的初始化在v的前面。在static{后面跟着一段代码，这是用来进行显式的静态变量初始化，这段代码只会初始化一次，且在类被第一次装载时。如果你能读懂并理解这段代码，会帮助你对static关键字的认识。在涉及到继承的时候，会先初始化父类的static变量，然后是子类的，依次类推。非静态变量不是本文的主题，在此不做详细讨论，请参考Think in Java中的讲解。
静态类
　　通常一个普通类不允许声明为静态的，只有一个内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类。如下代码所示：
引用:
public class StaticCls{
public static void main(String[] args){
OuterCls.InnerCls oi=new OuterCls.InnerCls();
}
}
class OuterCls{
public static class InnerCls{
InnerCls(){
System.out.println("InnerCls");
}
}
}
输出结果会如你所料：
InnerCls
　　和普通类一样。内部类的其它用法请参阅Think in Java中的相关章节，此处不作详解。
二、this & super
　　在上一篇拙作中，我们讨论了static的种种用法，通过用static来定义方法或成员，为我们编程提供了某种便利，从某种程度上可以说它类似于C语言中的全局函数和全局变量。但是，并不是说有了这种便利，你便可以随处使用，如果那样的话，你便需要认真考虑一下自己是否在用面向对象的思想编程，自己的程序是否是面向对象的。好了，现在开始讨论this&super这两个关键字的意义和用法。
　　在Java中，this通常指当前对象，super则指父类的。当你想要引用当前对象的某种东西，比如当前对象的某个方法，或当前对象的某个成员，你便可以利用this来实现这个目的，当然，this的另一个用途是调用当前对象的另一个构造函数，这些马上就要讨论。如果你想引用父类的某种东西，则非super莫属。由于this与super有如此相似的一些特性和与生俱来的某种关系，所以我们在这一块儿来讨论，希望能帮助你区分和掌握它们两个。
在一般方法中
　　最普遍的情况就是，在你的方法中的某个形参名与当前对象的某个成员有相同的名字，这时为了不至于混淆，你便需要明确使用this关键字来指明你要使用某个成员，使用方法是“this.成员名”，而不带this的那个便是形参。另外，还可以用“this.方法名”来引用当前对象的某个方法，但这时this就不是必须的了，你可以直接用方法名来访问那个方法，编译器会知道你要调用的是那一个。下面的代码演示了上面的用法：
引用:
public class DemoThis{
private String name;
private int age;
DemoThis(String name,int age){
setName(name); //你可以加上this来调用方法，像这样：this.setName(name);但这并不是必须的
setAge(age);
this.print();
}
public void setName(String name){
this.name=name;//此处必须指明你要引用成员变量
}
public void setAge(int age){
this.age=age;
}
public void print(){
System.out.println("Name="+name+" Age="+age);//在此行中并不需要用this，因为没有会导致混淆的东西
}
public static void main(String[] args){
DemoThis dt=new DemoThis("Kevin","22");
}
}
这段代码很简单，不用解释你也应该能看明白。在构造函数中你看到用this.print(),你完全可以用print()来代替它，两者效果一样。下面我们修改这个程序，来演示super的用法。
引用:
class Person{
public int c;
private String name;
private int age;
protected void setName(String name){
this.name=name;
}
protected void setAge(int age){
this.age=age;
}
protected void print(){
System.out.println("Name="+name+" Age="+age);
}
}
public class DemoSuper extends Person{
public void print(){
System.out.println("DemoSuper:");
super.print();
}
public static void main(String[] args){
DemoSuper ds=new DemoSuper();
ds.setName("kevin");
ds.setAge(22);
ds.print();
}
}
在DemoSuper中，重新定义的print方法覆写了父类的print方法，它首先做一些自己的事情，然后调用父类的那个被覆写了的方法。输出结果说明了这一点：
DemoSuper:
Name=kevin Age=22
　　这样的使用方法是比较常用的。另外如果父类的成员可以被子类访问，那你可以像使用this一样使用它，用“super.父类中的成员名”的方式，但常常你并不是这样来访问父类中的成员名的。
在构造函数中
　　构造函数是一种特殊的方法，在对象初始化的时候自动调用。在构造函数中，this和super也有上面说的种种使用方式，并且它还有特殊的地方，请看下面的例子：
引用:
class Person{
public static void prt(String s){
System.out.println(s);
}
Person(){
prt("A Person.");
}
Person(String name){
prt("A person name is:"+name);
}
}
public class Chinese extends Person{
Chinese(){
super(); //调用父类构造函数（1）
prt("A chinese.");//(4)
}
Chinese(String name){
super(name);//调用父类具有相同形参的构造函数（2）
prt("his name is:"+name);
}
Chinese(String name,int age){
this(name);//调用当前具有相同形参的构造函数（3）
prt("his age is:"+age);
}
public static void main(String[] args){
Chinese cn=new Chinese();
cn=new Chinese("kevin");
cn=new Chinese("kevin",22);
}
}
在这段程序中，this和super不再是像以前那样用“.”连接一个方法或成员，而是直接在其后跟上适当的参数，因此它的意义也就有了变化。super后加参数的是用来调用父类中具有相同形式的构造函数，如1和2处。this后加参数则调用的是当前具有相同参数的构造函数，如3处。当然，在Chinese的各个重载构造函数中，this和super在一般方法中的各种用法也仍可使用，比如4处，你可以将它替换为“this.prt”(因为它继承了父类中的那个方法）或者是“super.prt”（因为它是父类中的方法且可被子类访问），它照样可以正确运行。但这样似乎就有点画蛇添足的味道了。
　　最后，写了这么多，如果你能对“this通常指代当前对象，super通常指代父类”这句话牢记在心，那么本篇便达到了目的，其它的你自会在以后的编程实践当中慢慢体会、掌握。另外关于本篇中提到的继承，请参阅相关Java教程。
三、final
　　final在Java中并不常用，然而它却为我们提供了诸如在C语言中定义常量的功能，不仅如此，final还可以让你控制你的成员、方法或者是一个类是否可被覆写或继承等功能，这些特点使final在Java中拥有了一个不可或缺的地位，也是学习Java时必须要知道和掌握的关键字之一。
final成员
　　当你在类中定义变量时，在其前面加上final关键字，那便是说，这个变量一旦被初始化便不可改变，这里不可改变的意思对基本类型来说是其值不可变，而对于对象变量来说其引用不可再变。其初始化可以在两个地方，一是其定义处，也就是说在final变量定义时直接给其赋值，二是在构造函数中。这两个地方只能选其一，要么在定义时给值，要么在构造函数中给值，不能同时既在定义时给了值，又在构造函数中给另外的值。下面这段代码演示了这一点：
引用:
import java.util.List;
import java.util.ArrayList;
import java.util.LinkedList;
public class Bat{
final PI=3.14; //在定义时便给址值
final int i; //因为要在构造函数中进行初始化，所以此处便不可再给值
final List list; //此变量也与上面的一样
Bat(){
i=100;
list=new LinkedList();
}
Bat(int ii,List l){
i=ii;
list=l;
}
public static void main(String[] args){
Bat b=new Bat();
b.list.add(new Bat());
//b.i=25;
//b.list=new ArrayList();
System.out.println("I="+b.i+" List Type:"+b.list.getClass());
b=new Bat(23,new ArrayList());
b.list.add(new Bat());
System.out.println("I="+b.i+" List Type:"+b.list.getClass());
}
}
此程序很简单的演示了final的常规用法。在这里使用在构造函数中进行初始化的方法，这使你有了一点灵活性。如Bat的两个重载构造函数所示，第一个缺省构造函数会为你提供默认的值，重载的那个构造函数会根据你所提供的值或类型为final变量初始化。然而有时你并不需要这种灵活性，你只需要在定义时便给定其值并永不变化，这时就不要再用这种方法。在main方法中有两行语句注释掉了，如果你去掉注释，程序便无法通过编译，这便是说，不论是i的值或是list的类型，一旦初始化，确实无法再更改。然而b可以通过重新初始化来指定i的值或list的类型，输出结果中显示了这一点：
I=100 List Type:class java.util.LinkedList
I=23 List Type:class java.util.ArrayList
　　还有一种用法是定义方法中的参数为final，对于基本类型的变量，这样做并没有什么实际意义，因为基本类型的变量在调用方法时是传值的，也就是说你可以在方法中更改这个参数变量而不会影响到调用语句，然而对于对象变量，却显得很实用，因为对象变量在传递时是传递其引用，这样你在方法中对对象变量的修改也会影响到调用语句中的对象变量，当你在方法中不需要改变作为参数的对象变量时，明确使用final进行声明，会防止你无意的修改而影响到调用方法。
另外方法中的内部类在用到方法中的参变量时，此参变也必须声明为final才可使用，如下代码所示：
引用:
public class INClass{
void innerClass(final String str){
class IClass{
IClass(){
System.out.println(str);
}
}
IClass ic=new IClass();
}
public static void main(String[] args){
INClass inc=new INClass();
inc.innerClass("Hello");
}
}
final方法
　　将方法声明为final，那就说明你已经知道这个方法提供的功能已经满足你要求，不需要进行扩展，并且也不允许任何从此类继承的类来覆写这个方法，但是继承仍然可以继承这个方法，也就是说可以直接使用。另外有一种被称为inline的机制，它会使你在调用final方法时，直接将方法主体插入到调用处，而不是进行例行的方法调用，例如保存断点，压栈等，这样可能会使你的程序效率有所提高，然而当你的方法主体非常庞大时，或你在多处调用此方法，那么你的调用主体代码便会迅速膨胀，可能反而会影响效率，所以你要慎用final进行方法定义。
final类
　　当你将final用于类身上时，你就需要仔细考虑，因为一个final类是无法被任何人继承的，那也就意味着此类在一个继承树中是一个叶子类，并且此类的设计已被认为很完美而不需要进行修改或扩展。对于final类中的成员，你可以定义其为final，也可以不是final。而对于方法，由于所属类为final的关系，自然也就成了final型的。你也可以明确的给final类中的方法加上一个final，但这显然没有意义。
　　下面的程序演示了final方法和final类的用法：
引用:
final class final{
final String str="final Data";
public String str1="non final data";
final public void print(){
System.out.println("final method.");
}
public void what(){
System.out.println(str+"\n"+str1);
}
}
public class FinalDemo { //extends final 无法继承
public static void main(String[] args){
final f=new final();
f.what();
f.print();
}
}
从程序中可以看出，final类与普通类的使用几乎没有差别，只是它失去了被继承的特性。final方法与非final方法的区别也很难从程序行看出，只是记住慎用。
final在设计模式中的应用
　　在设计模式中有一种模式叫做不变模式，在Java中通过final关键字可以很容易的实现这个模式，在讲解final成员时用到的程序Bat.java就是一个不变模式的例子。如果你对此感兴趣，可以参考阎宏博士编写的《Java与模式》一书中的讲解。
　　到此为止，this,static,supert和final的使用已经说完了，如果你对这四个关键字已经能够大致说出它们的区别与用法，那便说明你基本已经掌握。然而，世界上的任何东西都不是完美无缺的，Java提供这四个关键字，给程序员的编程带来了很大的便利，但并不是说要让你到处使用，一旦达到滥用的程序，便适得其反，所以在使用时请一定要认真考虑。

Java编程编程基础（3）

zheman@126.com(zheman) — Wed,26 Jul 2006 14:41:42 +0800

呵呵，昨天一休息就下班了，今天补上，下面来看数组与函数重载。
一：一维数组
1。数组的概念不说了，大家应该都明白，举个例子：
假如定义100个变量，我不可能这样做吧x1 x2 .....x100，即使你有耐心那10000个呢？在Java中可以这样实现
引用:
int x[] =new int[100];
x[]是一个数组变量的引用，new int[100]创建一个100个int变量的数组对象。
也可写成这样：
引用:
int x[];
x=new int[100];
还可以这样定义：
引用:
int [] x;
x=new int[100];
定义了一个int型的数组，分别有x[0] x[1]....x[100]组成。
至于用种办法因人而异，但不要弄混了就可以了。
以下为数组所有变量的求和方法：
引用:
int sum;
for (int i=0;i
数组中可使用x=null,这样数组也就成为了垃圾！直至垃圾回收器来收走了，关于垃圾回收器的解释如下：
注：
在Java中内在的划分为：堆内存与栈内存。所有的基本类型变量与引用变量，全部是栈内存，离开作用范围后，这些内存马上被释放掉。new与数组存放在堆内存，由垃圾回收器自行处理。
关于垃圾回收器的说明引用一篇文章程：
引用:
JAVA使用垃圾回收器进行对象的内存空间回收，而且垃圾回收器是自动调用的，不需要用户的干预。一般情况下，用户只需要垃圾回收器就可以处理完所有对象的回收工作，但是在有些情况下，例如：用户需要把对象在创建过程中创建的图形擦除，打开的文件关闭，或者对象在创建过程中使用外部程序（如C++）创建了非JAVA对象（非JAVA对象不能用垃圾回收器自动回收）等等，则这些情况都需要用户使用另外的方法进行清除，JAVA中这个方法叫 finalize()，这个方法可以在类中定义，然后垃圾回收器在自动回收该类的对象前，会自动调用该类的finalize()，先进行其定义的特殊清除工作。
在 Java 中，所有对象都驻留在堆内存，因此局部对象就不存在。当你创建一个对象时，Java 虚拟机（JVM）为该对象分配内存、调用构造器并开始跟踪你使用的对象。当你停止使用一个对象（就是说，当没有对该对象有效的引用时），JVM 通过垃圾回收器将该对象标记为释放状态。
当垃圾回收器要释放一个对象的内存时，它首先调用该对象的finalize() 方法（如果该对象定义了此方法的话）。垃圾回收器以独立的低优先级的方式运行，所以只有当其他线程都挂起等待内存释放的情况出现时，它才开始释放对象的内存。（理论上，你还可以调用System.gc() 方法强制垃圾回收器来释放这些对象的内存。）
在以上的描述中，有一些重要的事情需要注意。首先，只有当垃圾回收器释放该对象的内存时，才会执行finalize()。如果在 Applet 或应用程序退出之前垃圾回收器没有释放内存，垃圾回收器将不会调用finalize()。
其次，除非垃圾回收器认为你的Applet或应用程序需要额外的内存，否则它不会试图释放不再使用的对象的内存。换句话说，有可能出现这样的情况：一个 Applet 给少量的对象分配了内存，但没有造成严重的内存需求，于是垃圾回收器没有释放这些对象的内存程序就退出了。
显然，如果你为某个对象定义了finalize() 方法，JVM可能不会调用它，因为垃圾回收器不曾释放过那些对象的内存。即使调用System.gc() 也可能不会起作用，因为它仅仅是给 JVM 的一个建议而不是命令，所以finalize()方法的作用也就不是那么明显。Java 1.1中有一个System.runFinalizersonExit()方法部分地解决了这个问题。（不要将这个方法与 Java1.0中的System.runFinalizations()方法相混淆。）不象System.gc() 方法那样，System.runFinalizersonExit()方法并不立即试图启动垃圾回收器。而是当应用程序或 Applet 退出时，它调用每个对象的finalize()方法。
结论：你不应当依靠垃圾回收器或finalize() 来执行你的 Applet 和应用程序的资源清除工作。取而代之，你应当使用确定的方法来清除那些资源或创建一个try...finally 块（或类似的机制）来实现
我们来看一个具体的例子：
引用:
public class TestArray
{
    public static void main(String [] args)
    {
        int x[];
        x=new int[100];

        for(int i=0;i        {
            System.out.println("x"+i+"="+x[i]);
        }
    }
}
2。数组静态初始化
数组的静态初始化就是定义数组的同时赋值给数姐。
例如：
引用:
int ia[]={1,2,3,4};
也可这样写：
引用:
int ia[]=new int[]{1,2,3,4};
关于数组使用就注意的几个问题：
a：数组不进行初始化，赋值默认为0。
b：如果数组等于null，那么就不能再对数组进行任何操作，否则会引起数组异常。
c：数组不能指定长度，int ia[5]=new int[]这是一个错误的例子。
d：关于下标越界问题，就是你定义了4个长度的数组，非要输入第5个数组变量的值，这样肯定是不可以的，借此说一下length的应用：
引用:
public class TestArray
{
    public static void main(String [] args)
    {
        int a[]=new int[]{1,2,3,4,5,6};
        for (int i=0;i        System.out.println("a"+i+"="+a[i]);
    }
}
大家应该明白length的用法了吧，不多说了
二：多维数组
1。多维数组的定义
有了上面一维数组的基础，多维数组就应该是好理解多了，其实Java中不存在真正的多维数组而只是数组的数组，从而开成一个x*y的矩阵，来看多维数组的定义：
引用:
int [][]x=new int[2][3]
其数组变量为：x[0][0] x[0][1] x[0][2] x[1][0] x[1][1] x[1][2]
2。多维数组的静态初始化
引用:
int [][]x={{3,2},{1,2},{1,2,5}};
3。两个常用的函数
a：System.arraycopy(source,0,dest,0,x)
应用实例：
引用:
public class TestArrayCopy
{
    public static void main(String [] args)
    {
int ia[]=new int[]{1,2,3,4,5};
int ib[]=new int[]{9,8,7,6,5,4,3};
System.arraycopy(ia,0,ib,0,3);
// 复制源数组中从下标0开始的3个元素到目的数组，从下标0的位置开始存储。
for(int i=0;i         System.out.println();
for(int j=0;j            System.out.println();
    }
}
b:Arrays.sort不多了排序详情查找jdk文档
数组说完了，下面看一下函数的重载，其实就是子函数的应用。
二：函数
1。函数
函数的就是把重复用到的代码做成一个公用的代码块，每次用到这个代码块直接调用就可以了，看例子：
引用:
public class Func1
{
    public static void main(String [] args)
    {
/* 下面是打印出第一个矩形的程序代码*/
        for(int i=0;i        {
            for(int j=0;j            {
                System.out.print("*");
            }
            System.out.println(); //换行
        }
        System.out.println();
        //下面是打印出第二个矩形的程序代码
        for(int i=0;i        {
            for(int j=0;j            {
                System.out.print("*");
            }
            System.out.println();
        }
        System.out.println();//换行
        //下面是打印出第三个矩形的程序代码
        for(int i=0;i        {
            for(int j=0;j            {
                System.out.print("*");
            }
            System.out.println();
        }
        System.out.println();
    }
}
改成函数：
引用:
public class Func2
{
public static void drawRectangle(int x,int y)
    {
        for(int i=0;i        {
            for(int j=0;j            {
                System.out.print(" * ");
            }
            System.out.println(); //换行
        }
        System.out.println();
    }

    public static void main(String [] args)
    {
     drawRectangle(3,5);
        drawRectangle(2,4);
        drawRectangle(6,10);
    }
}
2。return的应用
来看例子：
引用:
public class Func3
{
public static int getArea(int x,int y)
    {
        return x*y;
    }

    public static void main(String [] args)
    {
        int area = getArea(3,5);
     System.out.println("first Acreage is " + area);
     System.out.println("second Acreage is "+ getArea(2,4));
     getArea(6,10);
    }
｝
上面例子是返回x*y的值
再看一个无返回值的例子，通常做安全检测使用
引用:
public class Func4
{
        public static int getArea(int x,int y)
        {
            if(x            {
                 return -1;
            }
            return x*y;
        }

        public static void main(String [] args)
        {
            int area = getArea(3,5);
            System.out.println("first Acreage is " + area);
            System.out.println("second Acreage is "+ getArea(2,4));
            getArea(6,10);
        }
}
三：函数的重载
来看一个例子我们再做说明：
引用:
public class Test
{
    public static void main(String [] args)
    {
        int isum;
        double fsum;
        isum=add(3,5);
        isum=add(3,5,6);
        fsum=add(3.2,6.5);
    }
    public static int add(int x,int y)
    {
        reutrn x+y;
    }
    public static int add(int x,int y,int z)
    {
        return x+y+z;
    }
    public static double add(double x,double y)
    {
        return x+y;
    }
}
通过上面例子大家看到的情况是在同一个类中允许多个同名函数存在，只是函数的形参个数不同，或者类型不同！这就是函数的重载。
题外话：
前面我们配置了Java运行环境及环境变量的设置，才可以做到Java的运行。
我们调试到了第一个Java程序：helloworld.java至于public staitc void main(String [] args)是意思，在后面马上就会说到，大家先背下来吧。然后又说了常量、变量、流程、函数及函数的重载！接下就是面向对象。比较难理解！有时间再整理出来！
另外整理读书笔记真是一件很辛苦的活，不过这样做的的确确是有益于理解书本中的知识，想起了csdn中有个哥们译think in java真是了不起，更想象不到，他对java理解的深入，所以给大家学习的一个建议，多总结！想象把你掌握的东西让别人也撑握到，那才是了不起的一件事！

Java编程编程基础（2）

zheman@126.com(zheman) — Thu,20 Jul 2006 10:23:54 +0800

公司服务器被入侵，数以百计网站瘫痪，依靠网络系统办公的我们也只能停止了，有些时间，把这两天看的循环和函数重构整理出来！
一。流程控制
先说程序流程控制，程序有三种结构：
顺序结构
选择结构
循环结构
1。顺序结构
顺序结构就不用说了，就是程序逐行的执行。先看一下选择结构。
2。选择结构
选择结构语句主要包括：if语句与switch语句。
a：if语句的几种形式
第一种形式：
引用:
if(条件语句)
{
程序代码
}
第二种形式：
引用:
if(条件语句)
{
程序代码1
}
else
{
程序代码2
}
第三种形式：
引用:
if(条件语句)
{
程序代码1
}
else if
{
程序代码2
}
else if
{
程序代码3
}
else
{
程序代码4
}
另外还有一种if嵌套
引用:
if(条件1)
{
                        if(条件a)
                        {
                        执行语句a
                        }
                        else
                        {
                        执行语句b
                        }
}
else
{
                        if(条件c)
                        {
                        执行语句c
                        }
                        else
                        {
                        执行语句d
                        }
}
b：switch语句
格式：
引用:
        switch(表达式)
        {
            case 取值1:
            语句块
            break;

            case 取值2:
            语句块
            break;
            .
            .
            .
            .

            case 取值n:
            语句块
            break;

            default:
            取值n+1
            break;

        }
来看具体的例子：
引用:
class Test
{
    public static void main(String [] args)
    {
        int x=2;
        switch(x)
        {
            case 1:
            System.out.println("星期一");
            break;

            case 2:
            System.out.println("星期二");
            break;

            default:
            System.out.println("不知道星期了");
            break;

        }

    }
}
注：
a：case与default后为分号。
b：break为退当前循环。
3。循环结构
循环包括三种结构：
for
while
do ...while
a：for语句
格式：
for(初始化表在式;循环表达式;循环后的操作表达式)
{
执行语句
}
一个例子：
引用:
class Test
{
    public static void main(String [] args)
    {
        for(int x=0;x        {
            System.out.println(x);
        }

    }
}
4：break与continue
a：break中止循环体中语句与switch，如有标号则返回标号处语句。
标号的例子：
引用:
        st:while(ture)
        {
            while(ture)
            {
                break st;
            }
        }
b：continue只能适用了（for, while, do ）无标号的情况下跳出当前循环的剩余语句块。
前一个输出十内所有奇数的一个小例子：
引用:
public class PrintOddNum
{
    public static void main(String [] args)
    {
        for (int x=0;x        {
            if (x%2==0)
            continue;//continue的应用
            System.out.println(x);
        }
    }
}
hoho~~~着实有些累呀！还剩下数组与函数重构。休息会再写吧。

Java编程编程基础（1）

zheman@126.com(zheman) — Thu,20 Jul 2006 10:22:57 +0800

一：关于类与标识符的说明
1。类的定义
引用:
修饰符 class 类名
{
CODE
}
注：a:Java是严格区分大小写的!
b:执行语句以“；”结尾。
2。程序的注释
（1）：//单行注释
（2）：/*
多行注释
*/
注：a：（2）可与（1）嵌套。
b：（2）与（2）不可嵌套。
3。标识符的定义
以大小写字母、数字、下划线与美元符号组成！但是首字母不能为数字开头，并且不能以Java关键字命名,如class等！
　　关键字列表：
引用:
　　abstract boolean break byte case
　　catch char class continue default
　　do double else extends false
　　final finally float for if
　　implements import instanceof int interface
　　long native new null package
　　private protected public return short
　　static super switch synchronized this
　　throw throws transient true try
　　void volatile while
二：常量的说明
1。关于常量的讲解
（1）：整形
整形长量可由以下格式表现形式：
a：十六进制 0123456789abcdefABCDEF 以0x打头，例如：Ox12311abce。
b：八进制 01234567 以0打头，例如：054656。
c：十进制 0123456789 首字母为不能为0除非是0本身，例如：456
d：长整型结尾以L表示，例如：145L
（2）浮点型常量
浮点型常量可分两种，float（32位）与double（64位）分别为单精度浮点小数和双精度浮点小数，以f或d结尾表现。但是小数默认为double格式，所以float结尾必须以f结尾加以区分
例如：
1.23f
1.23d
（3）布尔常量
只有ture和false两个值
（4）字符串与字符变量
字符吕以""而字符''，主要区别，注意的是英文情况下的""和''
（5）null
只有一个值用null，表现对象引用为空。
三：关于变量
1。变量的数据类型
（1）：Java的基本变量与8种组成，分别为byte short char int long float double bloean
取值范围在此不一一列出，如需要可以查看JDK文档。默认的情况下byte short char int 参与运算自动提升为int型，低位与高位参与运算则低位自动提升成高位类型。
（2）：数据类型的转换
a：自动类型转换
通常是低位转高位例如：byte b=3; int x=b
b：强制类型转换
看一个错误的例子：
byte a=6;
a=a-3;
上面代码是错误的，因为a为byte类型，当参与a-3时自动提升为int型，一个int类型符值给byte类型显然要报错的。
就改为：
byte a=6;
a=(byte)a-3;//强制转换
表达式的提升规律：
a：byte short char int 自动提升为int
b：int和long提升为long
c：long和float提升为float
d:float和double提升为double
总之一句话：“低位类型与高位类型参与运算时，将提升低位为高位类型”。
1。变量的作用域
所谓的作用域就是在变量在什么时候是可见在什么是不可见的！作用域决定变量“可见性”与“存在时间”。
看一个例子：
引用:
class TestScope
{
    public static void main(String [] args)
    {
        int x=5;
        {
            int q=12;
            System.out.println(x);
            System.out.println(q);
        }
        System.out.println(x);
        //System.out.println(q);//q不可见
    }
}
再看一个例子：
引用:
{
int x=0;
        {
        int x=1;
        x++;
        }
x++;
}
在c与c++是允许的，但是Java是不允许的，Java认为这样使程序产生了混淆了。
2。局部变量的初始化
局部变量不多说了，就是一定作用域下有效，失去这个作用域也就消失了，值得注意的是局部变量在参与取值时必须进行初始化，所谓初始化也就是赋值的过程。
看一个例子
引用:
class Testvar
{
    public static void main(String [] args)
    {
        int x=0;//初始化
        x=x+1;
        System.out.println(x);
    }
}
四：Java运算符
Java运算符共分为以下几种：
算术运算符
赋值运算符
比较运算符
逻辑运算符
移位运算符
（1）：算术运算符
包括以下：
“+”，“-”“*”，“/”“%”，“++”“--”，“+”“+”，“-”
+与-比较特殊，可以表示正负号与加、减的运算，另外+还有字符串相联的作用。
（2）：赋值运算符
“=”，“+=”“*=”，“/=”“%=”，“-=”
例：
x+=3等价于x=x+3
（3）：比较运算符
“==”，“!=”“”“=”
（4）：逻辑运算符
“&&”，“||”“!”，“&”“|”，“^”
&&与&，||与|的不同前者只判断一方为flash就停止判断后面的表达式，而后者前后表达式都要做运算！
（5）：移位运算符
“>>”，“>>”
>>>无符号右移
四：Java运算符优先级
　按从高到低的优先级列出了运算符。同一行中的运算符优先级相同。
引用:
. [] ()
++ -- ! ~
* / %
+ -
> >>>
=
== !=
&
^
&&
||
?:
=
不用背的！当你拿不准的时候注意括号的使用!
中午吃饭了！下午有空再把流程控制与函数的重载补上来。

Java第一个例子

zheman@126.com(zheman) — Thu,20 Jul 2006 10:02:39 +0800

配置好了系统，看一下最为精典的helloworld.java程序
代码如下：
引用:
class hellworld
{
public static void main(String [] args)
{
System.out.println("Helloworld");
}
}
进行命令提示符，运行javac helloworld.java
再运行java helloworld 屏幕上打印出“Helloworld”
好了，我们的程序运行完了，说一下注意事项！
1。java语言区分大小写。
2。java helloworld 执行的是helloworl类非helloworld.java文件。
3。class前有public 修饰，则java文件名要与主类名保持一致。