2008年8月2日随笔档案 - 程序手记

2008年8月2日

JSP基础（文件上传）第二十二天

    把一个指定的文件上传到服务器，通常依靠JSP技术完成，需要使用到两个JSP页面。第一个JSP页面是选择要上传的文件，第二个JSP页面是从客户端获取该文件里面的信息，并把这些信息以客户端相同的格式保存在服务器端，该页面主要为功能处理页面。
    第一个页面的实现必须含有FILE类型的表单，并且表单的enctype的属性必须为"muldtipart/form-data"。
    第二个页面要使用内置对象request调用方法getInputStream()获得一个输入流，通过这个输入流读取客户上传的全部信息，如上传文件的名字，文件的大小，文件的类型。根据request所获得的信息创建一个数据输出流对象，把信息写到一个指定的文件内

    第一个文件内容如下：
        <body>
            <form method="post" action="file_14.jsp" enctype="multipart/form-data">
                <input type="file" name="file1" size="50" /><br>
                <input type="submit" value="上传" />
            </form>

    第二个文件内容如下：
        <%@ page contentType="text/html; charset='utf-8'" %>
        <%@ page import="java.io.*" %>
        <%@ page import ="java.util.*"%>
        <%@ page import="javax.servlet.*"%>
        <%@ page import = "javax.servlet.http.*" %>
        <body>
        <%
            int MAX_SIZE = 102400 * 102400;    //定义上传文件的最大字节
            String rootPath;    //创建跟路径的保存变量
            DataInputStream in = null;    //声明文件读入类
            FileOutpubStream fileOut = null;    //
            String remoteAddr = request.getRemoteAddr();    //取得客户端的网络地址
            String servName = request.getServerName();    //获得服务器的名字
            out.print("serverName=" + serverName + "<br>");
            out.print("request.getServletPath() = " + request.getServletPath() + "<br>")

posted @ 2008-08-22 00:29 程序手记阅读(237) | 评论 (0) | 编辑收藏

JavaBean基础（javabean简介）第二十一天

    JavaBean是一个可重复使用、且跨平台的软件组件(SoftWare Component)，它可以在软件开发工具如：Borland JBuilder \ Oracle JDeveloper 或是 Sun ONE Studio 等等里，以可视化的开发方式来开发。
    首先，你可以将JAVABEAN视为一个黑盒子(Black Box)，虽然知道这个软件组件所具备的功能，却不知其内部是如何运作的。笔者提供给读者一个假象的情况：有一个黑盒子，只知道它上面有一个按钮，你只要按下去经过十分钟，就会掉下一张一千元的钞票，不过你看不见其内部任何的构造，而这就是JAVABEAN最重要的特性，它将许多的信息都封装了起来，用户无需知道黑盒子如何产生出钞票，只需知道按下那个按钮，然后等十分钟，超片就会自动产生出来。
    一般而言，JAVABEAN可分为：有用户接口(user interface)的javabean和没有用户接口的javabean，通常JSP是搭配没有UI的JAVABEAN，因此后面所提到的JAVABEAN都知识单纯处理一些食物，如：数据运算，连接数据库和数据处理，等等，至于有用户接口的JAVABEAN部分，请读者自己参考JAVABEAN的相关书籍。
    通常一个标准的JAVABEAN有如下几项特性：
    (1)javabean是一个公开的(public)类；
    (2)javabean类必须有一个无传入参数(zero-argument)的构造函数(constructor)；
    (3)取得或设置属性时，必须使用getXXX方法或setXXX方法。

例子：
    package tw.com.javaworld.CH8;

    import java.io.*;

    public class SimpleBean{
        public SimpleBean(){
        }
        private String name;
        private String number;

        public void setNumber(String number){
            this.number = number;
        }
        public String getName(){
            return name;
        }
    }

posted @ 2008-08-21 23:09 程序手记阅读(501) | 评论 (0) | 编辑收藏

JSP基础（JSP动作元素）第二十一天

    与JSP指令元素不同的是，JSP动作元素在请求处理阶段起作用。JSP动作元素是试用XML语法写成的，它可以采用以下两种格式：
    <prefix:tag attribute = value attribute-list.../>
或者
    <prefix:tag attribute = value attribute-list.../>
    ...
    </prefix.tag>
SERVLET容器在处理JSP时，每当遇到这种动作元素，都根据它的标记进行特殊处理。
JSP规范定义了一系列的标准动作，它用JSP作为前缀。这些标准的动作不去惯容器是如何实现的，但是每个WEB容器都必须提供这些操作类型。标准动作为网页设计者提供了基本的功能，其他的厂商可以自由提供其他的非标准动作以增强功能。
    标准动作有：
<jsp:useBean>
<jsp:setProperty>
<jsp:getProperty>
<jsp:param>
<jsp:include>
<jsp:forward>
<jsp:plugin>
<jsp:fallback>
<jsp:attribute>
<jsp:body>
<jsp:invoke>
<jsp:doBody>
<jsp:element>
<jsp:output>
<jsp:scriptelet>
<jsp:declaration>等
在标准动作中，有许多是XML语法的动作元素，比如<jsp:scriptelet> <jsp:declaration>但他们的使用并不广泛，下面介绍JSP中主要的动作元素。

文件导入标记<jsp:include>
include用于允许在请求时间内在县城的JSP页面里包含静态或者动态资源。被包含的对象只有对JSPWRITER对象的访问权，并且它不能设置头或者COOKIE，如果页面输出是缓冲的，那么缓冲区的刷新要有限于包含的刷新。此指令在运行的效率上比<%@ page include %>指令的效率低，但是可以动态增加内容。用户可以通过一下的格式来使用文件导入标记
    <jsp:include page="{relativeURL | <%=expression%>}" flush="true" />
    <jsp:include page="{relativeURL | <%=expression%>}" flush = "true" >
        <jsp:param name="parameterName" value="{parameterValue | <%=expression%>}"
    </jsp:include>

    例如:
    <jsp:include page="admin/login.jsp" />
    <jsp:include page="copyright.html" />
    <jsp:include page="admin/login.jsp">
        <jsp:parame name = "username" value="JackLong" />
    </jsp:include>

页面转向标记<jsp:forward />
实例：
    <jsp:forword page="showinfo.jsp" >
        <jsp:param name = "username" value = "<%=request.getParameter("username")%>"/>
        <jsp:param name = "telephone" value = "<%=request.getParameter("telephone")%>"/>
    </jsp:forword>

posted @ 2008-08-21 05:20 程序手记阅读(476) | 评论 (0) | 编辑收藏

JSP基础 (获取当前时间) 第二十一天

    下面的代码用于显示当前时间，并根据当前是几点输出相应的提示信息，其中，使用java.util.Date thisday=new java.util.Date();语句来取得当前时间，然后通过相应的方法取得年，月，日，时和分的信息并输出：

<% page contentType="text/html; charset=utf-8" import="java.util.*" %>
<body>
<%
//获取当前的时间
java.util.Date thisday = new java.util.Date();
%>
当前时间：
<%=thisday.getYear()+1900%>年
<%=thisday.getMonth()+1%>月
<%=thisday.getDate()%>日
<%=thisday.getHours()%>时
<%=thisday.getMinutes()%>分
<%
String str = "欢迎访问："
int num = this.getHours();
switch(num){
    case 8:
    case 9:
    case 10:
    case 11:
    {
        out.print("欢迎你的访问，上午好！");
        break;
    }
    case 12:
    {
        out.print("中午好!");
        break;
    }
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    {
        out.print("下午好!");
        break;
    }
</body>

posted @ 2008-08-21 04:23 程序手记阅读(1252) | 评论 (0) | 编辑收藏

JSP基础 (高级计数器实例) 第二十天

                                                                           countFile.java
public class countFile{
    public static void writeFile(String filename,long count){
        PrintWriter out = new PrintWriter(new FileWriter(filename));
        out.println(count);
        out.close();
    }
    public static void readFile(String filename){
        File f = new File(filename);
        if(!f.exists()){
            writeFile(filename,0);
        }
        BufferedReader in = new BufferedReader(new FileReader(f));
        long count = Long.parseLong(in.readline());
        return count;
    }
    public static String tranform(long count){
        String countNumber = ""+count;
        String newstring = "";
        for(int i=0;i<countNumber.length;i++){
            newstring+="<img src='images/"+countNumber.charAT(i)+".gif' >";
        }
        return newstring;
    }
}

posted @ 2008-08-20 05:19 程序手记阅读(173) | 评论 (0) | 编辑收藏

TOMCAT基础 (设定站点) 第十三天

在Tomcat 上建立一个 JSPBook站点时，我们需要修改Tomcat的server.xml文件，server.xml位于{Tomcat_Install}\conf\server.xml（例如：e:\apache software foundation\tomcat 5.0\conf\server.xml）。

    server.xml

    ......

<Context path="/JSPBook" docBase="JSPBook" debug="0" crosscontext = "true" reloadable="true" >
    </Context>
    </Host>
    </Engine>
    </Service>
    </server>

    这部分主要是设定JSPBOOK站点，其中 path="/jspbook"代表网站名称，即 http://ip_domainName/jspbook;
docBase = "jspbook" 代表站点的目录位置，debug则是设定debug lerel,0表示提供最少的信息，9表示提供最多的信息； reloadable则表示tomcat在执行时，当class ,web.xml被更新过时，都会自动重新加载，不需要重新启动tomcat。

posted @ 2008-08-13 17:36 程序手记阅读(156) | 评论 (0) | 编辑收藏

JAVA基础（JAVA中的STATIC块）第十三天（对浪费的前10天表示悔恨）

Java 程序中时常用些 static{}这样的结构。
这样的结构叫 static块，一般是一个类初始化时运行的代码。注意，是类的初始化，不是对象的初始化。
也就是你在定义对象时，他运行的初始化代码，并且只有第一次定义时才运行。之后就不再运行初始化了。
一个类中可以有很多static块。static块按顺序执行。

看以下代码：
public class TestStatic{
    static{
        System.out.println(1);
    }
    static {
        System.out.println(2);
    }
    static {
        Stystem.out.println(3);
    }
    public static void main(String args[]){
        System.out.println(5);
    }
    static {
        System.out.println(4);
    }
}
执行结果是：
1
2
3
4
5
一目了然，首先调用的是static静态块的代码，然后调用启动方法，而STATIC块的执行顺序是由代码的编写顺序执行的过程，STATIC块大家用的比较少，其实就是在对象生成之际产生的一系列的STATIC变量。

posted @ 2008-08-13 16:22 程序手记阅读(337) | 评论 (0) | 编辑收藏

JAVA WEB开发（First Servlet Samlet Code）第四天

HelloServlet.java

package tw.com.javaworld.CH2;

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;

public class HelloServlet extends HttpServlet{
    //Initialize global variables
    public void init(ServletConfig config) throws ServletException{
        super.init(config);
    }

    //Process the HTTP Get request
    public void doGet(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html;charset=GB2312");
        PrintWrite out = response.getWrite();
        out.println("<html>");
        out.println("<body>");
        out.println("Hello World<br>");
        out.println("大家好");
        out.println("</body>");
        out.println("</html>");
        out.close();
    }

    //Get Servlet information
    public String getServletInfo(){
        return "tw.com.javaworld.CH2.HelloServlet Information";
    }
}

posted @ 2008-08-04 18:15 程序手记阅读(233) | 评论 (0) | 编辑收藏

Java WEB开发（TomCat配置）第四天

Tomacat是一个WEB容器，所有的J2EE WEB程序可以在此处运行。常见的WEB容器还有WebLogic、WebSphere。

Tomcat的默认端口号是8080，这个数值可以在安装过程中修改也可以在conf/server.xml中修改。

Tomcat是根据系统的%JAVA_HOME%变量值选择系统中的JDK。

Tomcat目录主要文件夹作用

bin目录：存放启动和关闭Tomcat的脚本
conf目录：存放不同配置文件，其中比较重要的是server.xml（Tomcat的主要配置文件）和web.xml
work目录：存放JSP编译后的.class文件
webapps目录：存放WEB应用程序
lib目录：存放所有需要的各种jar包

配置Tomcat方式有两种：手工配置--修改conf/server.xml文件、管理控制台配置

注意：修改server.xml之后要重新启动Tomcat服务器才能使配置生效

配置虚拟目录的要求

修改server.xml文件
虚拟目录的结构要符合要求
- WebRoot
  - WEB-INF
    - web.xml
- 其中web.xml的内容一般为：
  
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
  version="2.4">
  
  Welcome to Tomcat
  
  Welcome to Tomcat
创建好虚拟目录之后要在server.xml中之前添加一句 (大小写敏感，修改完之后应该重新启动Tomcat服务器使配置生效)

若设置虚拟目录后访问目录提示404错误而可以运行目录下的jsp文件则说明是目录权限被禁用，可以修改conf/web.xml文件找到将下面一行中的false改成true

jsp文件的运行过程： *.jsp --> *.java --> *.class --> 运行显示

*.class是第一次运行生成后存放在work目录下的，所以jsp文件第一次或者修改后首次运行比较慢而后来再运行的速度很快

posted @ 2008-08-04 16:39 程序手记阅读(312) | 评论 (0) | 编辑收藏

JAVA基础（嵌套类）第四天

    Java允许将类的定义方在其他类的内部，形成嵌套类。嵌套类使逻辑关系紧密的类组成一个整体，嵌套类可以用于访问其所在的类的作用域。

嵌套类可以访问外部类似有成员。
    // OuterNested1.java
public class OuterNested1{
    private int size;
    public class Nested{
        public int doStuff(){
            //嵌套类可以访问OuterNested1类的似有成员 size 变量
            return(size++);
        }
    }
    public int testTheNested(){
        Nested i = new Nested();
        return(i.doStuff());
    }
}

//TestOuterNested1.java
public class TestOuterNested1 {
    public static void main(String[] args){
        outerNested1 outer = new OuterNested1();
        System.out.println(outer.testTheNested());
    }
}

posted @ 2008-08-04 15:21 程序手记阅读(171) | 评论 (0) | 编辑收藏

JAVA基础（包与 Java API）第二天第四天

    建立Java包，布局源文件和设置classpath参数之间相互影响。也相互关联。正确建立和导入JAVA包，合理布局源文件，准确设置CLASSPATH参数，才能保证应用程序顺利执行，并有效管理应用程序。

包的建立方法
    Java包通过package语句建立，基本语法是：
        package cn.edu.jmu.graphis;
    在定义类或接口的源文件开始处，通过package语句，可以将相应的类或接口放入package所声明的包里。包是相关类和接口的集合，提供了访问级别控制和命名控件管理。

包的使用方法
    每个源文件只能有一个包声明，并且一定要求放在源文件的开始位置。如果一个源文件没有包语句，则源文件所定义的类或接口呗系统放入默认包中。包有层次，层次间由点分隔。
    例如有一组与图形相关的类，包括Circles,Rectangles,Lines和points类等，描述了画图所用到的各种图形组件，另有抽象类Graphic标识图形组件的共性，接口Draggable表示用户可以通过鼠标拖拽成图的图形组件。在这种情况下，我们不仅需要，而且也应该将这些相关类和接口组成包，可命名为graphics如：

//Graphics.java
package graphics;
public abstract class Graphic{
    ...
}

//Circle.java
package graphics;
public class Circle extends Graphic implements Draggable {
    ...
}

//Rectangle.java
package graphics;
public class Rectangle extends Graphic implements Draggable {
    ...
}

//Draggable.java
package graphics;
public interface Draggable{
    ...
}
    通过创建和使用包，程序员不仅可以很容易地确定哪些类和接口是相关的，也可以很容易地找到提供特定功能的类和接口，例如，与画图有关的类和接口在graphics包中。

包的访问权限
    通过声明类的访问级别，可以控制对类的访问权限。
    类的访问级别分为默认级和public级。定义类的默认访问级别不需要任何关键字，呗声明为默认级的类只对同一个包中的类是可视的。也就是说只有同一个包内的类实例可以访问这个类，外界不能访问它。如果用关键字public定义类，不但同一个包里的其他类可以访问这个类，其他包中的类也可以访问它。换句话说，同一个包中的类，相互之间有不受限制的访问权限。而在不同包中，只有public类可以被访问。
    public修饰符不知用于定义类的访问控制级别，也可以应用于接口，方法或变量。public 接口同public类一样，可以由应用程序中的任何类访问。而public方法或public属性对任何可以访问他的类或接口都是可视的。
    除public修饰符之外，用于访问控制的修饰符还有protected 和 private。
protected 或 private 仅用来定义方法或变量的访问控制级别。protected 方法或protected变量仅对同一个包内的类或不同包中的子类来说是可视的。
private方法和pvivate变量对外部定义的类均不可视。

包的命名方式
    包提供了心的命名控件，即使所定义的类使用与其他包中的类相同的名字，只要包类所属的包不同名，就不会引起冲突。原因是这些类的全程限定名称不同。类的全程限定包含了类的各层包名。这实质上是应用了面向对象的概念，将类封装入包中。

包的访问权限
    通过声明类的访问级别，可以控制对类的访问权限。
    类的访问级别分为默认级和public级。定义类的默认访问级别不需要任何关键字，贝声明为默认级的类只对同一个包中的类是可视的。也就是说，只有同一个包内的类实例可以访问这个类，外界不能访问它。如果用关键字public 定义类，不但同一个包里的其他类可以访问这个类，其他包中的类也可以访问它。换句话说，同一个包中的类，相互之间有不受限制的访问权限。而在不同的包中，只有public类可以被访问。
    public 修饰符不只用于定义类的访问控制级别，也可以应用于接口，方法和变量。public接口同public类一样，可以由应用程序中的任何类访问。而public方法或public变量对任何可以访问他的类或接口都是可视的。
    除public 修饰符之外，用于访问控制的修饰符还有 protected 和private 。 protected或private仅用来定义方法或变量的访问控制级别。protected方法或protected变量仅对同一个包内的类或不同包中的子类来说是可视的。private方法和private变量对外部定义的类均不可视。需要说明的是，通常不建议用默认方式定义方法或成员变量的访问级别。

    对于没有指定包名的java源文件，系统认为他们都属于同一个默认的包。如果没有把自己的Java类放入某个包中，那么任何默认包里的对象都可以访问它，并且不局限于同一个子目录下，因此通常应该在每个Java源文件的项目顶部使用 package语句，指明它所属的包。

访问包成员
    对于包来说，只有它的public成员可贝外界访问。若外界想要访问包的public类，有3种方式可以实现。
    (1)通过类的全程限定名访问该类。
    (2)通过import语句导入该类。
    (3)通过import语句导入整个包。
    如果某个类只贝访问一次，那么可以直接使用类的全名。例如访问cn.edu.jmu.graphics.Graphic类可以用一下方式：
    cn.edu.jmu.graphics.Graphic aGraph = new cn.edu.jmu.graphics.Graphic();
    这条语句创建了 cn.edu.jmu.graphics.Graphic类型的对象 aGraph。
    可以看到，即是指创建一个对象，在变量定义和初始化时也用到两次全名。当使用Java约定的包命名方式时，包名可能过长，此时用起来就更显得繁琐，容易出错，也影响可读性。
    通常都应该使用import语句直接导入所需类，或者导入该类所在的包。导入之后，程序中设计的这个类的地方就可以直接用类名访问。
    import 的基本语法形式为：
    import <包名>[.<子包名>].<类名>;    //导入指定类
或者：
    import <包名>[.<子包名>].*;    //导入整个包
例如:
    import cn.edu.jmu.javaprogs.Timel;
    import cn.edu.jmu.javaprogs.*;
    import java.awt.*;
    import java.awt.event.*;

    import语句在package 语句之后，所有的类声明之前。由于集中在程序首部，宜于直观地了解程序所需的包，有助于维护程序的可移植性。
    import 语句中的 * 用来匹配包中的所有类，但并不能用来匹配包中的所有类的某个子集。如语句
    import java.awt.*;
    导入java.awt包中的所有类。如果这样的语句
    import java.awt.A*;
    它无法导入java.awt句中首字母为A的所有子类，相反还会出现编译错误，也就是说，使用import语句一次只能导入包的单一成员，或者导入整个包。
    还有语句
    import java.awt.*;
    所导入的是java.awt包中的所有类，它包括接口。但不包括java.awt包中的子包。如果需要访问java.awt.event子包中的类，仍需要用 import语句导入 java.awt.event子包。所以常常使用如下形式：
    import java.awt.*;
    import java.awt.event.*;



包的布局
    类的全程受名称与类所在目录一一对应，例如：
    import graphics.Rectangle    等同于文件路径名：
    Graphics\Rectangle.java

classpath参数
    classpath参数用于设置Java包所在的顶级目录。也就是说，通过classpath可以为Java包建立所依存的目录列表。编译和运行Java 程序时，系统会自动从classpath环境变量中读取包所在的目录，文件所在目录由系统通过classpath中的目录和package语句中定义的目录合成。
    下面通过一个完整的实例程序，说明classpath参数的作用，同时展示源文件和字节码文件的一种建议布局模式。
    程序包含两个类 Time 和 TestTime,TestTime为主类。程序对用户输入的表示小时、分钟和秒钟的3个整型数，经过数据正确性验证，分别转换为通用时间表示格式和标准时间表示格式，通过对话框显示给用户，运行后如图：


    文件布局方式如下：创建 d:\javaSample 目录存放java程序，创建 d:\javaSample\src 子目录存放源文件，创建d:\javaSample\class 子目录存放编译后的字节码文件。具体实现方式是将文件 TestTime.java 存放在 D:\javaSample\src 子目录下，为使 src 子目录的结构与 class 子目录结构相对应，创建 D:\javaSample\src\cn\edu\jmu\timer 子目录存放 Time.java文件。类Time和类TestTime的布局如图：

    Time.java中的语句
    package cn.edu.jmu.timer;
    将Time类放入包cn.edu.jmu.timer中，源文件Time.java存放在与包相对应的目录结构下。在类TestTime.java中通过语句   import cn.edu.jmu.timer.Time;   导入Time类。
    需要设置classpath参数，规定程序中的包    cn.edu.jmu.timer 编译所依存的顶级目录为 d:\javaSample\class,如：
                set classpath = d:\javaSample\class;
    编译：
        javac -d d:\javaSample\class
        d:\javaSample\src\cn\edu\jmu\timer\Time.java
        javac -d d:\javaSample\class d:\javaSample\src\TestTime.java
    运行：
        java TestTime

posted @ 2008-08-03 00:40 程序手记阅读(354) | 评论 (0) | 编辑收藏

JAVA面向对象编程（接口）第二天

    接口是JAVA语言中非常重要的概念，回调是软件设计中常用的模式。JAVA的接口不仅可以用来实现多继承关系，也用来实现回调机制。 java.lang.Comparable 接口和 java.util.Comparator 接口是进行数据对象比较和排序中需要实现的接口，他们在功能和使用方法上都有所不同。

    当类只从一个类继承时称为单继承，JAVA语言只允许单继承。如果需要多继承关系，可以通过JAVA语言中的接口实现。
    抽象方法只有方法定义，没有方法体，如果一个类包含任何抽象方法，包括直接的和继承所得，则这个类必须是抽象的。如果一个类是抽象的，则不能创建此类的对象。抽象类强制要求他的所有子类重写自己的方法以覆盖抽象方法。
    如果存在超类 Animal，显然cat同时具有 Animal和pet的特性，就是说，cat不只是一个animal还是一个pet，除需要继承animal类，还期望能实现pet类。因为JAVA只允许单继承，CAT不能继承animal又继承pat，解决这个问题的方法是定义接口，并通过接口实现多继承。

定义接口
    我们把只有抽象方法和常量的抽象类称为接口，接口形式化定义了一组相互有关系的未实现的方法。接口的定义包括接口声明和接口体。
接口声明的语法为：[public] interface 接口名 [extends 父接口名] {。。。。。。}
    EXTENDS子句与类声明的extends子句基本相同，不同的是：一个接口可以有多个父接口，用逗号隔开，而一个类只能有一个父类。
    接口体包括常量和抽象方法。

接口Pet示例：

    interface Pet{
        public abstract void speak();
    }
    public class Dog implements Pet{
        public void speak(){
            System.out.println("Woof");
        }
    }
    public class Cat implements Pet{
        public void speak(){
            System.out.println("Meow");
        }
    }
    public class Bird implements Pet{
        public void speak(){
            System.out.println("Tweedle");
        }
    }
    public class TestAnimals{
        public static void main(String args[]){
            Pet myPets = new Pet[4];
            myPets[0] = new Bird();
            myPets[1] = new Cat();
            myPets[2] = new Bird();
            myPets[3] = new Dog();

            for(int index = 0; index<4; index++){
                myPets[index].speak();
            }
        }
    }

    类Bird ,Cat 和 Dog 与 Pet 不再具有父子关系，而分别是实现了接口Pet的类。
    一个接口的定义由关键字 interface 开始，包括一套 public ,abstract 方法，接口也可以包含 public ,final,static数据。一个期望使用接口的类必须将自己声明为 implements 接口，并重写接口定义的每个方法，保证参数列表及返回类型与接口中所定义的相一致。简单说，强制要求实现接口的类覆盖接口的方法。
    如果一个类没有覆盖接口定义中的全部方法，那么这个类就称为抽象类，必须贝声明为 abstract。

用Cat类继承Animal 类和定义Pet接口的示例：
public class Cat extends Animal implements Pet{
    public void speak(){//实现
}
}

posted @ 2008-08-02 18:01 程序手记阅读(247) | 评论 (0) | 编辑收藏

JAVA (继承，封装，多态，接口) 第二天

    面向对象的分析与设计（OOA&D）方法是一种非常成熟的技术。也是当前商业公司经常使用的一种技术，因为JAVA语言本身就是一种面向对象的语言，所以掌握面向对象这种技术对于JAVA语言的应用具有重要意义。

继承(inheritance)
    继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。比如可以先定义一个类叫车，车有以下属性：车体大小，颜色，方向盘，论坛，而又由车这个类派生出教程和卡车两个类，为轿车添加一个小后备箱，而为卡车添加一个大货箱。

封装(encapsulation)
    类使得数据和对数据的操作集成在一起，从而对使用该类的其他人来说，可以不管它的实现方法，而只管用它的功能，从而实现所谓的信息隐藏。

多态(polymorphism)
    多态又分为设计时多态和运行时多态，例如重载又被称为设计时多态，而对于覆盖或继承的方法，JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。总而言之，面向对象的设计的典型特点就是继承，封装和多态，这些特点也是面向对象之所以能如此盛行的关键所在。

单继承与多继承
    JAVA不支持多重继承，单继承使JAVA的继承关系很简单，一个类只能有一个父类，易于管理程序，同时一个类可以实现多个接口，从而克服单继承的缺点。

    接口的定义和类的定义很相似，只是关键字不同，关键字为interface。生命格式如下：
interface 接口名
{
}
    上面的大括号中为接口体。接口体中包含成员变量定义和方法定义两部分。
    接口体中只进行方法的声明，不允许提供方法的实现。所以在格式上只存在方法声明，实际上没有方法体，而方法体要在实现的类中再去具体定义。
    还有一点需要说明的是：如果一个类使用了某个接口，就必须要实现这个接口的所有方法，即使实在没有内容只是一个空的方法体也不许要写。而且每个方法都默认是public的，所以实现时代码一定要用public做修饰，参数个数，类型以及返回值的类型都必须与接口中的声明相一致。
例如：
    interface Runable
    {
    }
    当某个类要实现这个接口时，就用 imlements 来声明。
    例如，我们相做一个多线程的例子，那么就可有两种实现方式，一种是通过定义一个Thread类的子类来实现，另一种是通过实现Runable接口来实现。代码如下（这里的PrintHello类就是通过实现Runable接口来实现的，而不是扩展Thread称为他的子类）：

import java.lang.*;

class TestThread
{
    public static void main(String args[])
    {
        try{
            printHello ph = new PrintHello();
            Thread Tph = new Thread(ph);
            for(;;){
                System.out.println("I'm main");
                Thread.sleep(100);
            }
        }
        catch(Exception e){
            e.printStackTrace();
        }
    }
}

class PrintHello implements Runnable
{
    public void run(){
        try{
            for(;;){
                System.out.println("I'm hello");
            }
        }
        catch(Exception e){
            e.printStackTrace();
        }
    }
}

posted @ 2008-08-02 16:34 程序手记阅读(7205) | 评论 (0) | 编辑收藏

JAVA基础（数据类型转换）第二天

    很多场合都要用到类型转换，JAVA的类型转换有下列两种。

自动类型转换

    整型，实型，字符型数据可以混合运算。在运算过程中，不同类型的数据会自动转换为同一类型，然后进行运算。自动转换按低级类型数据转换成高级类型数据的规则进行，
转换规则为：
(1)(byte 或 short)op int -> int
(2)(byte 或 short 或 int) op long -> long
(3)(byte 或 short 或 int 或 long) op float -> float
(4)(byte 或 short 或 int 或 long 或 float)op double ->double
(5)char op int ->int

其中，箭头左边表示参与运算的数据类型，op为运算符如加减乘除等，右边表示运算结果的数据类型。
如： 3+4.5 是 double型，所以3贝转换为double型，然后再与4.5相加，其结果也为double型。

强制类型转换

    高级数据类型你个要转换成低级数据类型，需要用到强制类型转换。其一般形式为：
（类型名）表达式
例如：
    int i;
    byte b;
    i = 356;
    b=(byte)i; //强制转换吼丢失一部分数据，使得b的值为100
    一般使用强制类型转换可能会导致数值溢出或精度下降，应尽量避免。

posted @ 2008-08-02 15:18 程序手记阅读(158) | 评论 (0) | 编辑收藏

JAVA类型（String类和 StringBuffer类）第二天

String 类

    String 类提供了几种字符串创建方法。

    String s = "abcd" 使用字符串常量自动创建String实例。
    String s = new String(String s)通过String 对象或字符串常量传递给构造方法。
    public String (char value[],int offset, int count)将字符数组一部分赋给String 构造方法，offset 为起始下表, count 为数组长度。

    String 类提供了丰富的字符串操作方法，其中重要的例举如下。

    public int lenght() 返回字符串的长度。
    public char charAt(int index) 返回字符串位置index处的字符。
    public boolean equals(Object o) 比较两个字符串对象，相等则返回true;反之返回false。
    public int compareTo(String s) 比较两个字符串字典顺序，相等返回0，s大于当前字符串返回一个负值，s小于当前串返回一个正值。
    public boolean regionMatches(int toffset,String other,int ooffset,int len)从当前字符串位置toffset开始寻找字符串other中起始位置为ooffset 长度为len 的子串。如发现匹配，返回true; 否则，返回false。
    public boolean startsWith(String prefix) 从当前字符串的起始位置开始寻找字符串 prefix。如发现匹配，返回true;否则，返回false。
    public boolean endsWith(String suffix) 如当前字符串的结尾子串与 suffix 匹配，返回true;否则，返回false。
    public int indexOf(String str) 在当前字符串中寻找与str匹配的子串，返回首次匹配的起始下表值；无匹配返回-1。
    public String substring(int beginIndex,int endIndex) 在当前字符串中，求从起始位置 beginIndex 到结束位置 endIndex 的子串。
    public String concat(String str) 将当前字符串与str连接，返回连接后的字符串。
    public String toLowerCase() 将当前字符串全转换为小写形式。
    public String toUpperCase() 将当前字符串转换为大写形式。
    public char toCharArray() 将当前字符串转换为字符数组。
    public Static String valueOf(type variable) 把variable 转换为字符串，其中 type 表示 variable 的数据类型。

StringBuffer类

    String类实现一种不能改变的静态字符串，StringBuffer类实现一种动态可以改变的字符串。StringBuffer类可以用于创建String类，StringBuffer一旦建立，可以用toString()方法将其转换为String类，以后，就可以使用String 类方法来操作。

    StringBuffer 类提供了三种创建方法。

    public StringBuffer()    创建一个空的StringBuffer类。
    public StringBuffer(int length)    创建一个大小为length的StringBuffer类。
    public StringBuffer(String str)    按str创建一个动态可变的StringBuffer类。

    StringBuffer    类提供的方法主要用于把输入的数据转换为String类。输入数据可来自键盘或其他数据源。类型可以是字符，字符数组，证书，浮点数和Object类型等。

    public int length()    返回缓冲区的字符数
    public int capacity()    返回缓冲区的容量大小，其值为：字符串长度+16。
    public synchronized StringBuffer append(type variable)    把variable转换为字符串，然后与当前字符串连接。
    public synchronized StringBuffer append(Char(char ch))    把字符ch连接到当前串尾。
    public synchronized StringBuffer insert(int offset,type variable)    把variable转换为字符串,然后插入到当前串中由offset指定的位置。
    public synchronized StringBuffer insert(int offset,char ch)    把字符 ch 插入到当前串由ofset指定的位置。
    public synchronized String toString()    把StringBuffer转换为字符串String。各个方法的使用，具体请参阅 JAVA API文档。

posted @ 2008-08-02 11:57 程序手记阅读(704) | 评论 (0) | 编辑收藏

JAVA程序的执行（OBJECT类）第二天

    Object类是JAV类库中的一个特殊的类，它是类库中所有类的父类，也是用户自定义的所有类的直接或间接父类。也就是说，用户定义的所有类在默认情况下都是Object类的子类，无论用户是否显示生命Object类作为自己定义的类的父类。这是系统自动完成的，由此，通过把Object类称为通用超类。
    Object类中的成员方法恰好都是方法，其中有7个public类型的，2个protected类型的。用户自定义的所有类都将继承这些方法。Object类中的7个public类型的方法分别是tostring(0方法，equals（）方法，getclass（）方法，含水层哦的（）方法，notify（）方法，notifyall（）方法，和wait（）方法，2个protected类型的方法是clone（）方法和finalize（）方法。
    其中toString()方法和equals()方法较为常用
toString()方法较为简单，略过。
equals()方法
    Object类的equals()方法用户比较以参数传过来的对象和当前对象，如果他们是相同的对象（不仅是相等，而且必须是同一个对象），则返回true；如果他们是不同的对象，即使两者的数据成员相等，也将返回false。

equals()方法的格式
test t = new test();
test t2 = new test();

if(t.equals(t2)){
    true;
}else{
    false;
}

posted @ 2008-08-02 11:18 程序手记阅读(157) | 评论 (0) | 编辑收藏

程序手记