iRoger http://iroger.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 表单验证：使用struts中的validator框架 iRoger 作者: iRoger  链接：http://iroger.javaeye.com/blog/192579  发表时间: 2008年05月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

第一步：

我们在struts-config.xml里： 
<action-mappings > 
<action 
attribute="logForm" 
input="/form/log.jsp" 
name="logForm" 
path="/log" 
scope="request" 
type="com.yourcompany.struts.action.LogAction" 
validate="true" 
<forward name="s" path="/form/MyJsp.jsp" /> 
</action>
里面必须加上validate="true"这么句代码，否则，验证机制将可能不会运行。
另外，配置文件中还须加入以下代码，表示使用插件： 
<plug-in className="org.apache.struts.validator.ValidatorPlugIn">
		<set-property property="pathnames"
			value="/WEB-INF/validator-rules.xml,
                                              /WEB-INF/validation.xml" />
</plug-in>

注意加入<plug-in>标签的位置，该标签应该放在struts配置文件中的最后，具体位置在元素<struts-config></struts-config>内部，在<message-resources parameter="com.blog.struts.ApplicationResources" />之后，切记要注意位置，不然报错。
其次，在写法上，value的内容中/WEB-INF/validator-rules.xml是默认的，因为在项目使用struts框架时该文件已经在此目录层次下面了，那么之后的/WEB-INF/validation.xml"又是什么呢？这里需要我们手动在WEB-INF目录下新建validation.xml文件，这个文件有什么用？先看下其中写的什么。 
<form-validation>
	<global>
	</global>
	<formset>
		<form name="userForm">
			<field property="userName"
				depends="required,minlength,maxlength">
				<arg0 key="userForm.userName" />
				<arg1 name="minlength" key="${var:min}"
					resource="false" />
				<arg1 name="maxlength" key="${var:max}"
					resource="false" />
				<var>
					<var-name>min</var-name>
					<var-value>6</var-value>
				</var>
				<var>
					<var-name>max</var-name>
					<var-value>20</var-value>
				</var>
			</field>
			<field property="password"
				depends="required,minlength,maxlength,mask">
				<arg0 key="userForm.password" />
				<arg1 name="minlength" key="${var:min}"
					resource="true" />
				<arg1 name="maxlength" key="${var:max}"
					resource="true" />
				<var>
					<var-name>min</var-name>
					<var-value>6</var-value>
				</var>
				<var>
					<var-name>max</var-name>
					<var-value>20</var-value>
				</var>
				<var>
					<var-name>mask</var-name>
					<var-value>^\w+$</var-value>
				</var>
			</field>
			<field property="email" depends="required,email">
				<arg0 key="userForm.email" />
			</field>
			<field property="name" depends="required,maxlength">
				<arg0 key="userForm.name" />
				<arg1 name="maxlength" key="${var:max}"
					resource="false" />
				<var>
					<var-name>max</var-name>
					<var-value>20</var-value>
				</var>
			</field>			
			<field property="tel" depends="required,mask">
				<arg0 key="userForm.tel" />
				<var>
					<var-name>mask</var-name>
					<var-value>^\(?(\d{3,4})\)?[-|]?(\d{7,8})$</var-value>
				</var>
			</field>
			<field property="address" depends="required">
				<arg0 key="userForm.address" />
			</field>
		</form>
		<form name="categoryForm">
			<field property="categoryName" depends="required">
				<arg0 key="categoryForm.categoryName" />
			</field>
		</form>
	</formset>
</form-validation>

Validation.xml：该配置文件是专供应用程序使用的，其中所描述的是特定ActionForm会用到validation-rule.xml文件中的哪些验证器。

1.<form-validation>元素
<form-validation>元素是validation.xml文件的根元素，它包含两个子元素：<global>和<formset>元素。其中<global>元素可以出现零次或多次，<formset>元素可以出现一次或多次。

2.<global>元素
<global>元素中通过<constant>子元素来定义常量表达式，每个<constant>子元素定义一个常量表达式，如果有多个常量表达式要定义则可以配置多个<constant>来实现。

3.<formset>元素
<formset>元素包括两个子元素<constant>和<form>。<constant>元素可以出现零次或多次，<form>元素可以出现一次或多次。
这里需要注意的是，在<form>标签中有包括<field>子元素。

4.<field>元素
<field>元素通过property属性指定字段的名字，通过depends属性指定具体的验证规则，验证规则来源于validation-rule.xml中所写的验证方法，这里我们要简单介绍一下validation-rule.xml里面的验证规则是默认，那如果我们有需要定义自己的验证规则也可以写在里面。<field>元素可包含的子元素为<msg>,<arg>,<var>。

第二步
把validator框架使用的消息文本添加到应用的Resource Bundle中，如在ApplicationResources.properties中加入例如： 
errors.header=<b><font color=ff0000><ul>
errors.footer=</ul></font></b>
errors.prefix=<li>
errors.suffix=</li>

error.isexit=\u7528\u6237\u540d\u5df2\u5b58\u5728\uff0c\u8bf7\u91cd\u65b0\u6ce8\u518c\uff01
error.username=\u7528\u6237\u540d\u4e0d\u5408\u6cd5\uff0c\u8bf7\u91cd\u65b0\u586b\u5199\u7528\u6237\u540d\uff01
error.password=\u5bc6\u7801\u4e0d\u5408\u6cd5\uff0c\u8bf7\u91cd\u65b0\u586b\u5199\u5bc6\u7801\uff01

errors.required={0}\u4e3a\u5fc5\u586b\u5b57\u6bb5
errors.minlength={0}\u7684\u957f\u5ea6\u4e0d\u80fd\u5c0f\u4e8e{1} 
errors.maxlength={0}\u7684\u957f\u5ea6\u4e0d\u80fd\u5927\u4e8e{1} 
errors.email={0}\u5fc5\u987b\u4e3a\u6709\u6548\u90ae\u4ef6\u5730\u5740

userForm.userName=\u7528\u6237\u540d;
userForm.password=\u5bc6\u7801;
userForm.email=Email;
userForm.name=\u59d3\u540d;
userForm.sex=\u6027\u522b;
userForm.tel=\u8054\u7cfb\u7535\u8bdd;
userForm.address=\u8054\u7cfb\u5730\u5740;
userForm.userType=\u7528\u6237\u7c7b\u522b;

categoryForm.categoryName=\u7c7b\u522b\u540d\u79f0



第三步
将Form的extends ActionForm改为extends ValidatorForm


第四步
在jsp页面当中，如果我们要创建一个在服务器端验证的页面，我们只需要在控件之后添加<html:errors property="password"/>，即：
<tr>
<td>密码：</td>
<td><html:password property="password" /><html:errors property="password"/></td>
</tr>
注意<html:errors property="password"/>之中的property对应的是form中定义的属性。

那么如果我们要创建一个在客户端进行验证的页面，我们需要如下步骤：
1.在<html:form></html:form>的外面加上<html:javascript formName="userForm"/>
2.在<html:form>中加入属性onsubmit=”return validateCardForm(this);”,即;
<html:form action="/save_user" method="post" enctype="multipart/form-data" onsubmit="return validateUserForm(this);">
3.同服务器端验证一样<td><html:password property="password" /><html:errors property="password"/></td>
重点
使用validator进行表单验证的步骤如上，其中最为关键的一步是，validation.xml文件中为表单配置验证规则的写法。
注意事项如下：
<form-validation>
<global>
在<global>中定义的常量表达式，在文件的其余地方可以直接引用。
即，这里配置的常量表达式是全局的
写法为：
<constant>
<constant-name>phone</constant-name>
<constant-value>^\(?(\d{3})\)?[-|]?(\d{8})$<constant-value>
//定义一个名为：phone的正则表达式，3位区号+8位号码
</constant>
</global>
<formset>
<form name="userForm">
<field property="userName"
//这里的property要与form表单属性名对应
depends="required,minlength,maxlength">
//这里的depends用于指定对该属性使用什么验证规则，其规则来自于validator-rule.xml文件中所写的规则。指定多个验证器时，会依次调用，直到该表单通过所有验证。
<arg0 key="userForm.userName" />
//arg0对应的是ApplicationResources.property中的{0},即：
“errors.required={0}不能为空”，其作用是将arg0中key所对应的资源文件中的“userForm.userName=用户名”的文中或者说是值替换到“errors.required={0}不能为空”中的{0}，这样页面输出的是“用户名不能为空”;
下面的arg1同理{1} 
				<arg1 name="minlength" key="${var:min}"
					resource="false" />
				<arg1 name="maxlength" key="${var:max}"
					resource="false" />
				<var>
					<var-name>min</var-name>
					<var-value>6</var-value>
				</var>
				//var对应key="${var:min}"中的min
				<var>
					<var-name>max</var-name>
					<var-value>20</var-value>
				</var>
			</field>
</form>
	</formset>
</form-validation>

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Tue, 13 May 2008 14:13:15 +0800 http://iroger.javaeye.com/blog/192579 http://iroger.javaeye.com/blog/192579 利用File类进行文件上传 iRoger 作者: iRoger  链接：http://iroger.javaeye.com/blog/192578  发表时间: 2008年05月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

第一步：
在jsp页面中，注意负责上传文件的控件要使用html:file标签，在html:form处注意加上enctype=“multipart/form-data” method为post
1、
<html:form method="post" action="/save_user" enctype="multipart/form-data" >
2、
<tr>
<td>头像：</td>
<td><html:file property="image" /></td>
</tr>

第二步：
在对应的表单form中定义private FormFile image属性，当然自动生成set和get方法。

第三步：
在pojo中声明一个属性与上传控件对应。

第四步：
在相应的Action中的方法里加入上传的代码：
例如： 
UserForm userForm = (UserForm) form;
		UserDAO dao = new UserDAO();
		String message = null;
		String basePath = this.getServlet().getServletContext()
				.getRealPath("/");	
//获取项目根路径	
		try {
			dao.getSession().beginTransaction();
User temp = (User) dao.findByUserName(userForm.getUserName());
			if (temp == null) {
				User user = new User();
				userForm.fillToUserBean(user);
				if (userForm.getImage().getFileName().length() > 0) {
		//判断是否有选择上传文件，如果有则文件长度>0
String path = "/uploadImages/" + 
//这里的"/uploadImages/"指的是什么？它是我们自行在WebRoot下面创建的用于存放上传文件的文件夹的名称，即：如果我们将上传的文件存放在uploadfile中，我们要做的是在WebRoot下新建一个名为uploadfile的文件夹，并且这里的代码要改为："/uploadfile/"
dao.picturePath(userForm.getImage());
//这里我们用到了一个自己在DAO中写的名为picturePath的方法，其目的是为了将上传的文件跟换一个不会和数据库已有数据重复的文件名称，这样的好处是即使上传的多个文件实质上一个，但有需要将其区分开时比较方便。再介绍完Action的写法之后我们再来讲解DAO中方法的写法。
					String endstring = userForm.getImage().getFileName()
							.substring(
									userForm.getImage().getFileName()
											.lastIndexOf(".") + 1);
if ("jpg".equals(endstring) || "png".equals(endstring)
					|| "gif".equals(endstring)) {
						try {
dao.saveFile(userForm.getImage(), basePath, path);
						} catch (IOException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
						user.setHeaderImg(path);
					} else {
						user.setHeaderImg("");
					}
				}
				dao.save(user);
				dao.getSession().getTransaction().commit();
				return mapping.findForward("index");


第五步
在DAO中我们需要修改saveFile，添加picturePath方法，具体代码如下：
saveFile 
public void saveFile(FormFile formfile, String basePath, String path)
			throws IOException {
		FileOutputStream fos = null;
		BufferedInputStream in = null;
		BufferedOutputStream out = null;
		try {
			fos = new FileOutputStream(basePath + path);
			in = new BufferedInputStream(formfile.getInputStream());
			out = new BufferedOutputStream(fos);
			byte[] buf = new byte[8192];
			int readsize;
			while ((readsize = in.read(buf)) != -1) {
				out.write(buf, 0, readsize);
				out.flush();
			}

		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if (fos != null)
				try {
					fos.close();
				} catch (Exception err) {
					err.printStackTrace();
				}
			if (in != null)
				try {
					in.close();
				} catch (Exception err) {
					err.printStackTrace();
				}
			if (out != null)
				try {
					out.close();
				} catch (Exception err) {
					err.printStackTrace();
				}

		}
	}

picturePath
public String picturePath(FormFile formfile) {
		String filename = "";
		UUIDGenerator g = new UUIDGenerator();
// UUIDGenerator是我们自行编写的一个自动生成名字的一个类，之后会给出具体代码。
		filename = formfile.getFileName();
		if (filename.length() > 0) {
			filename = filename.substring(filename.lastIndexOf("."));
		}
		filename = (String) g.generate() + filename;
		return filename;
	}





第六步：
编写工具类：UUIDGenerator 
import java.io.Serializable;
import java.net.InetAddress;

public class UUIDGenerator {

	 private static final int IP;
	 public static int IptoInt( byte[] bytes ) {
	  int result = 0;
	  for (int i=0; i<4; i++) {
	   result = ( result << 8 ) - Byte.MIN_VALUE + (int) bytes[i];
	  }
	  return result;
	 }
	 static {
	  int ipadd;
	  try {
	   ipadd = IptoInt( InetAddress.getLocalHost().getAddress() );
	  }
	  catch (Exception e) {
	   ipadd = 0;
	  }
	  IP = ipadd;
	 }
	 private static short counter = (short) 0;
	 private static final int JVM = (int) ( System.currentTimeMillis() >>> 8 );

	 public UUIDGenerator() {
	 }
	 protected int getJVM() {
	  return JVM;
	 }
	 protected short getCount() {
	  synchronized(UUIDGenerator.class) {
	   if (counter<0) counter=0;
	   return counter++;
	  }
	 }
	 protected int getIP() {
	  return IP;
	 }
	 protected short getHiTime() {
	  return (short) ( System.currentTimeMillis() >>> 32 );
	 }
	 protected int getLoTime() {
	  return (int) System.currentTimeMillis();
	 }
	 
	 private final static String sep = "";

	 protected String format(int intval) {
	  String formatted = Integer.toHexString(intval);
	  StringBuffer buf = new StringBuffer("00000000");
	  buf.replace( 8-formatted.length(), 8, formatted );
	  return buf.toString();
	 }

	 protected String format(short shortval) {
	  String formatted = Integer.toHexString(shortval);
	  StringBuffer buf = new StringBuffer("0000");
	  buf.replace( 4-formatted.length(), 4, formatted );
	  return buf.toString();
	 }

	 public Serializable generate() {
	  return new StringBuffer(36)
	   .append( format( getIP() ) ).append(sep)
	   .append( format( getJVM() ) ).append(sep)
	   .append( format( getHiTime() ) ).append(sep)
	   .append( format( getLoTime() ) ).append(sep)
	   .append( format( getCount() ) )
	   .toString();
	 }

	}

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Tue, 13 May 2008 14:08:41 +0800 http://iroger.javaeye.com/blog/192578 http://iroger.javaeye.com/blog/192578 利用jspSmartUpload进行上传下载 iRoger 作者: iRoger  链接：http://iroger.javaeye.com/blog/192576  发表时间: 2008年05月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

第一步：
首先将jspSmartUpload.jar包文件放到项目中/WEBROOT/WEB-INF/lib/下，将包文件放到tomcat安装目录中的/lib/下，jsp表单中form一定要是post提交方式。

第二步：（理清思路）
新建一个jsp页面，注意该页面上将采用JavaScript动态控制要上传的文件数量，同时注意表单的enctype属性值要设定为：“multipart/form-data”，表单提交后，交由相应的servlet处理或者是Action处理。Servlet和Action会调用jspSmartUpload组件实现文件的上传下载。

第三步：（编写jsp页面）
创建uploadFile.jsp页面，其中：
1） 注意在相应报头中设定请求编码方式，不然会出现乱码。
request.setCharacterEncoding(“UTF-8”);
2） 在body中编写相应的选择上传文件个数的控件，设置表单form，这里需要注意：标签<form>中的enctpye属性要设置为”multipart/form-data” method=”post”
这是一定要这么写的。
3）在<form>元素中要定义一个子元素<div id=”files”></div>

第四步：（在servlet或者action中编写处理上传文件的代码）
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Tue, 13 May 2008 14:04:00 +0800 http://iroger.javaeye.com/blog/192576 http://iroger.javaeye.com/blog/192576 FCKeditor在线编辑器 iRoger 作者: iRoger  链接：http://iroger.javaeye.com/blog/192573  发表时间: 2008年05月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

FCKeditor在线编辑器
FCKeditor 这个开源的HTML 文本编辑器可以让web 程序拥有如MS Word 这样强大的编辑功
FCKeditor官司方网址：http://www.fckeditor.net/

FCKeditor在线DEMO：http://www.fckeditor.net/demo

FCKeditor下载直址：http://www.fckeditor.net/download 最新版已经是2.6了。

在项目中使用FCKeditor在线编辑器：
(1) 新建一个WEB工程；
(2) 解压FCKeditor_2.6.zip包，将其中的editor文件夹复制到项目中去；
(3) 解压FCKeditor_2.6.zip包，将其中的fckconfig.js、fckeditor.js、fckstyles.xml、fcktemplates.xml赋值到项目中的WebRoot目录下面；
(4) 将FCKeditor.jar文件复制到WebRoot\WEB-INF\lib目录；
(5) 将FCKeditor.tld文件复制到WEB-INF下面；
(6) 修改web.xml配置文件中的信息，如下;
<!-- fckeditor start --> 
<servlet>
		<servlet-name>Connector</servlet-name>
		<servlet-class>
			com.fredck.FCKeditor.connector.ConnectorServlet
		</servlet-class>
		<init-param>
			<param-name>baseDir</param-name>
			<param-value>/UserFiles/</param-value>
		</init-param>
		<init-param>
			<param-name>debug</param-name>
			<param-value>true</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet>
		<servlet-name>SimpleUploader</servlet-name>
		<servlet-class>
			com.fredck.FCKeditor.uploader.SimpleUploaderServlet
		</servlet-class>
		<init-param>
			<param-name>baseDir</param-name>
			<param-value>/UserFiles/</param-value>
		</init-param>
		<init-param>
			<param-name>debug</param-name>
			<param-value>false</param-value>
		</init-param>
		<init-param>
			<param-name>enabled</param-name>
			<param-value>true</param-value>
		</init-param>
		<init-param>
			<param-name>AllowedExtensionsFile</param-name>
			<param-value></param-value>
		</init-param>
		<init-param>
			<param-name>DeniedExtensionsFile</param-name>
			<param-value>
				php|php3|php5|phtml|asp|aspx|ascx|jsp|cfm|cfc|pl|bat|exe|dll|reg|cgi
			</param-value>
		</init-param>
		<init-param>
			<param-name>AllowedExtensionsImage</param-name>
			<param-value>jpg|gif|jpeg|png|bmp</param-value>
		</init-param>
		<init-param>
			<param-name>DeniedExtensionsImage</param-name>
			<param-value></param-value>
		</init-param>
		<init-param>
			<param-name>AllowedExtensionsFlash</param-name>
			<param-value>swf|fla</param-value>
		</init-param>
		<init-param>
			<param-name>DeniedExtensionsFlash</param-name>
			<param-value></param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
  <servlet>
    <description>This is the description of my J2EE component</description>
    <display-name>This is the display name of my J2EE component</display-name>
    <servlet-name>PostArticle</servlet-name>
    <servlet-class>servlet.PostArticle</servlet-class>
  </servlet>


	<servlet-mapping>
		<servlet-name>Connector</servlet-name>
		<url-pattern>
			/FCKeditor/editor/filemanager/browser/default/connectors/jsp/connector
		</url-pattern>
	</servlet-mapping>
	<servlet-mapping>
		<servlet-name>SimpleUploader</servlet-name>
		<url-pattern>
			/FCKeditor/editor/filemanager/upload/simpleuploader
		</url-pattern>
	</servlet-mapping>
  <servlet-mapping>
    <servlet-name>PostArticle</servlet-name>
    <url-pattern>/servlet/post</url-pattern>
  </servlet-mapping>
<!-- fckeditor end -->


(7) 在JSP页面中使用，如：test.jsp
首先要在报头中加入
<%@ taglib uri="http://fckeditor.net/tags-fckeditor" prefix="f"%>
还要注意basepath及path的设置 
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

  <body>
    <form action="servlet/post" method="post">
    	title:<input type="text" name="title"><br>
    	<f:editor id="content"  basePath='<%=path + "/FCKeditor/"%>'
				imageBrowserURL='<%=path
							+ "/FCKeditor/editor/filemanager/browser/default/browser.html?Type=Image&Connector=connectors/jsp/connector"%>'
				linkBrowserURL='<%=path
							+ "/FCKeditor/editor/filemanager/browser/default/browser.html?Connector=connectors/jsp/connector"%>'
				flashBrowserURL='<%=path
							+ "/FCKeditor/editor/filemanager/browser/default/browser.html?Type=Flash&Connector=connectors/jsp/connector"%>'
				imageUploadURL='<%=path
							+ "/FCKeditor/editor/filemanager/upload/simpleuploader?Type=Image"%>'
				linkUploadURL='<%=path
							+ "/FCKeditor/editor/filemanager/upload/simpleuploader?Type=File"%>'
				flashUploadURL='<%=path
							+ "/FCKeditor/editor/filemanager/upload/simpleuploader?Type=Flash"%>'>
		
		
			</f:editor>
			<input type="submit">
    </form>
  </body>


后面的附件是实例。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Tue, 13 May 2008 13:55:59 +0800 http://iroger.javaeye.com/blog/192573 http://iroger.javaeye.com/blog/192573 JAVA基础课件 iRoger 作者: iRoger  链接：http://iroger.javaeye.com/blog/192572  发表时间: 2008年05月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

我自己写的课件，希望有的朋友需要
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Tue, 13 May 2008 13:51:02 +0800 http://iroger.javaeye.com/blog/192572 http://iroger.javaeye.com/blog/192572 类与对象 iRoger 作者: iRoger  链接：http://iroger.javaeye.com/blog/178850  发表时间: 2008年04月02日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

一． 理解类与对象
1. 类与对象
1.）什么是类？类的定义？
答：简而言之，类就是创建对象的模板。把可以生成对象的框架称做类，把特定的
值赋给它的属性，就可以创建出具体的对象。
类体定义的一般格式：
　　
class className
　　{ 　　[public | protected | private ] [static] 
　　　　　[final] [transient] [volatile] type
　　　　　variableName; 　　　　　　　　　　　//成员变量
　　　　　[public | protected | private ] [static]
　　　　　[final | abstract] [native] [synchronized]
　　　　　returnType methodName([paramList])
　　　　　[throws exceptionList]
　　　　　{statements} //成员方法
　　}

2.）什么是对象？对象的创建和销毁？
答：对象（Object）是指具有属性和动作的实体。对象封装了一个客观实体的属
性与行为。
对象的创建：
创建对象必须首先有类，假设我们已经定义好了一个Man类，然后创建Man类的对象，在创建对象前，我们先给对象起个名字（命名），下面就是命名对象名为man1；
Man man1；
现在man1只是一个对象的名字而不是一个对象。
有了对象的名字之后，下一步就实实在在地生成一个对象了，尽量使用“创建”来代替“生成”二字。创建对象的代码如下：
man1 = new Man（）；
在这行代码中，new是“新建”的意思，整条语句的含义就是创建新的Man的对象。创建一个对象页需要一个行为动作，我们将这个行为动作称为构造函数，上面代码中的Man（）就是构造函数。
若将声明对象（对象命名）与创建对象可以同时进行，其代码如下：
Man man1 = new Man（）；
对象销毁是指对象释放内存，从内存中清除。
3.）什么是引用？
答：我们将对象名称称为引用（变量）。因为引用代表对象，所以也可以把引用称
为对象。

2. 成员方法，方法的定义格式
将类的行为动作称做类的成员方法（Member Method）或成员函数。
1.）无参方法？多参方法？
答：无参方法是指形式参数为空，即没有形式参数的方法。
多参方法是指多个形式参数的方法，这多个形式参数之间使用逗号分隔。
2. )方法声明的一般性语法： 
<method modifiers><return type><method name>(<formal parameter list>)
				<throws clause>// method prototype
	{	//  Method  body
	<local variable declarations>
	<nested local class declarations>
	<statements>
}

3. 局部变量和成员变量
答：我们通常将类的属性称作类的成员变量（Member Variable）或域（Field）。局部变量在方法内部声明，并且也只能在方法内部使用。局部变量在外层的方法被调用时被分配内存，并且在方法执行完毕后自动释放内存而消亡。方法中的形式参数就是局部变量的一种。
在使用局部变量之前，必须首先对其进行初始化。初始化就是指在声明它们的同时就给他们赋值。
4. 静态变量和静态方法
答：静态成员变量在不创建类的对象的情况下，也可以使用，它是所有对象共有的变量。普通成员变量只有在创建可类的对象后才能被使用。与此相反，静态变量可以不先创建对象而直接使用。静态方法的使用方式与之相同。
5. 成员与静态方法的关系
答：只有在对象存在的条件下，我们才可以使用成员变量和成员方法。然而，静态方法则不需要首先创建对象，可以直接调用它。
6. 访问控制符
答：java语言中有四种不同的访问限制符，提供了四种不同的访问权限。

　　1） private
　　类中限定为private的成员，只能被这个类本身访问。
　　如果一个类的构造方法声明为private,则其它类不能生成该类的一个实例。
　　2） default
　　类中不加任何访问权限限定的成员属于缺省的（default）访问状态，可以被这个类本身和同一个包中的类所访问。
　　3） protected
　　类中限定为protected的成员，可以被这个类本身、它的子类（包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问。
　　4） public
　　类中限定为public的成员，可以被所有的类访问。
java中类的限定词的作用范围比较
    同一个类 同一个包 不同包的子类 不同包非子类
    private *
    default * *
    protected * * *
    public * * * *

7. 什么是重载？
答：重载（overload）是指在同一个类中定义多个同名但内容不同的成员方法。
方法名相同，但是他们的形式参数的个数及数据类型都不同。我们把这称为方法的重载。返回值类型相不相同无关紧要。
8. 什么是构造函数？
答：Java使用一种称为构造函数的特殊函数来创建对象，并在创建它们时对它们进行 不同的初始化，从而生成不同的对象。
构造函数的名字与类名一致，它没有任何返回值，并且其前也不允许有void关键字。
9. 类的初始化？
答：对类的成员变量进行初始化，即在定义类的同时给成员变量赋值，也可以说是在定义类的同时初始化成员变量。
public class Sayhello{
int a=10;
}
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 02 Apr 2008 15:05:14 +0800 http://iroger.javaeye.com/blog/178850 http://iroger.javaeye.com/blog/178850 JAVA中的继承 iRoger 作者: iRoger  链接：http://iroger.javaeye.com/blog/178849  发表时间: 2008年04月02日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

二．继承
1. 什么是继承？子类对象的创建？
答：通过继承实现代码复用。Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。继承而得到的类称为子类，被继承的类称 为父类。子类不能继承父类中访问权限为private的成员变量和方法。子类可以重写父类的方法，及命名与父类同名的成员变量。但Java不支持多重继 承，即一个类从多个超类派生的能力。
◇ 创建子类
　　格式：
　　
class SubClass extends SuperClass {
　　…
　　}
2. this和super的用法？
◇ super
　　java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。Super 的使用有三种情况：
　　1）访问父类被隐藏的成员变量，如：
　　　　
super.variable;
　　2）调用父类中被重写的方法，如：
　　　　
super.Method([paramlist]);
　　3）调用父类的构造函数，如：
　　　　
super([paramlist]);
例：
　
import java.io.*;
　　class SuperClass{
　　　　int x;
　　　　SuperClass( ) {
　　　　　x=3;
　　　　　System.out.println("in SuperClass : x=" +x);
　　　　}
　　　　　void doSomething( ) {
　　　　　System.out.println("in SuperClass.doSomething()");
　　　　}
　　}
　　class SubClass extends SuperClass {
　　　　int x;
　　　　SubClass( ) {
　　　　　super( ); 　　　//调用父类的构造方法
　　　　　x=5;　　　　　　//super( ) 要放在方法中的第一句
　　　　　System.out.println("in SubClass :x="+x);
　　　　}
　　　　　void doSomething( ) {
　　　　　super.doSomething( ); //调用父类的方法
　　　　　System.out.println("in SubClass.doSomething()");
　　　　　System.out.println("super.x="+super.x+" sub.x="+x);
　　　　}
　　}
　　public class Inheritance {
　　　　　public static void main(String args[]) {
　　　　　SubClass subC=new SubClass();
　　　　　subC.doSomething();
　　　　}
　　}
◇ this
this与this()用来引用对象自身的成员。
This 的使用有三种情况：
　　1）访问自身对象被隐藏的成员变量，如：
　　　　
this.variable;

　　2）调用自身对象中被重写的方法，如：
　　　　
this.Method([paramlist]);
　　3）调用自身的构造函数，如：
　　　　
this ([paramlist]);
注意：在定义构造函数时，应将调用父类构造函数的代码super(…)置于最上部。因为必须首先初始化继承自父类的成员。
继承中的访问控制符？
3. 什么是覆盖？
答：我们把子类拥有与父类相同成员的情况称为覆盖(override)。
访问控制符要使用与父类相同或比父类权限更大的控制符。
覆盖父类成员的目的在于通过在子类中重新定义扩展父类功能。
4. 什么是多态？
在java语言中，多态性体现在两个方面：由方法重载实现的静态多态性（编译时多态）和方法重写实现的动态多态性（运行时多态）。
　　1） 编译时多态
　　在编译阶段，具体调用哪个被重载的方法，编译器会根据参数的不同来静态确定调用相应的方法。
　　2） 运行时多态
　　由于子类继承了父类所有的属性（私有的除外），所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方，都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方法。
◇ 重写方法的调用原则：java运行时系统根据调用该方法的实例，来决定调用哪个方法。对子类的一个实例，如果子类重写了父类的方法，则运行时系统调用子类的方法；如果子类继承了父类的方法（未重写），则运行时系统调用父类的方法。
5. 什么是实例成员，什么是类成员？
答：实例成员和类成员
　　用static 关键字可以声明类变量和类方法，其格式如下：
　　
static type classVar;
　　static returnType classMethod({paramlist}) {
　　…
　　}
　
　　如果在声明时不用static 关键字修饰，则声明为实例变量和实例方法。
　　1） 实例变量和类变量
　　每个对象的实例变量都分配内存，通过该对象来访问这些实例变量，不同的实例变量是不同的。
　　类变量仅在生成第一个对象时分配内存，所有实例对象共享同一个类变量，每个实例对象对类变量的改变都会影响到其它的实例对象。类变量可通过类名直接访问，无需先生成一个实例对象，也可以通过实例对象访问类变量。

　　2） 实例方法和类方法
　　实例方法可以对当前对象的实例变量进行操作，也可以对类变量进行操作，实例方法由实例对象调用。
　　但类方法不能访问实例变量，只能访问类变量。类方法可以由类名直接调用，也可由实例对象进行调用。类方法中不能使用this或super关键字。

6. 引用的范围？
7. 引用变量的类型转换？
8. 什么是Object类？Object型引用变量？
答：类java.lang.Object处于java开发环境的类层次的根部，其它所有的类都是直接或间接地继承了此类。该类定义了一些最基本的状态和行为。下面，我们介绍一些常用的方法。

　　equals() ：比较两个对象(引用)是否相同。
　　getClass()：返回对象运行时所对应的类的表示，从而可得到相应的信息。
　　toString()：用来返回对象的字符串表示。
　　finalize()：用于在垃圾收集前清除对象。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 02 Apr 2008 15:05:03 +0800 http://iroger.javaeye.com/blog/178849 http://iroger.javaeye.com/blog/178849 instanceof是什么？ iRoger 作者: iRoger  链接：http://iroger.javaeye.com/blog/178848  发表时间: 2008年04月02日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

instanceof是什么？

　　instanceof是Java的一个二元操作符，和==，>，<是同一类东东。由于它是由字母组成的，所以也是Java的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。举个例子：

String s = "I AM an Object!";
boolean isObject = s instanceof Object;

　　我们声明了一个String对象引用，指向一个String对象，然后用instancof来测试它所指向的对象是否是Object类的一个实例，显然，这是真的，所以返回true，也就是isObject的值为True。

　　instanceof有一些用处。比如我们写了一个处理账单的系统，其中有这样三个类：

public class Bill {//省略细节}
public class PhoneBill extends Bill {//省略细节}
public class GasBill extends Bill {//省略细节}

　　在处理程序里有一个方法，接受一个Bill类型的对象，计算金额。假设两种账单计算方法不同，而传入的Bill对象可能是两种中的任何一种，所以要用instanceof来判断：

public double calculate(Bill bill) {
if (bill instanceof PhoneBill) {
//计算电话账单
}
if (bill instanceof GasBill) {
//计算燃气账单
}
...
}

　　这样就可以用一个方法处理两种子类。

　　然而，这种做法通常被认为是没有好好利用面向对象中的多态性。其实上面的功能要求用方法重载完全可以实现，这是面向对象变成应有的做法，避免回到结构化编程模式。只要提供两个名字和返回值都相同，接受参数类型不同的方法就可以了：

public double calculate(PhoneBill bill) {
//计算电话账单
}

public double calculate(GasBill bill) {
//计算燃气账单
}

所以，使用instanceof在绝大多数情况下并不是推荐的做法，应当好好利用多态。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 02 Apr 2008 15:04:45 +0800 http://iroger.javaeye.com/blog/178848 http://iroger.javaeye.com/blog/178848 抽象类与接口 iRoger 作者: iRoger  链接：http://iroger.javaeye.com/blog/178847  发表时间: 2008年04月02日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

三．抽象类与接口
1. 抽象类
“abstract”的字典解释为：抽象。所谓抽象就是指不具体或无实体。
注意下面的方法：
public abstract void noAction（）；
此方法无方法体，并且void前面出现abstract关键字。由于此方法没有方法体，因而就没有具体的动作，我们将此方法称为抽象方法，并且此类方法前冠以abstract关键字。
包含抽象方法的类叫做“抽象类”。如果一个类包含一个或多个抽象方法，该类必须被限定为抽象的。（否则，编译器就会报错），即该类被称为抽象类（abstract class）。
包含抽象方法的类，即抽象类无法创建其对象，因为其抽象方法未定义任何具体的动作。
如果从一个抽象类继承，并想创建该新类的对象，那么就必须为基类中的所有抽象方法提供方法定义。如果不这样做（可以选择不这样做），那么导出类便也是抽象类，且编译器将会强制我们用abstract关键字来限定这个类。
能不能产生一个不包含任何抽象方法的抽象类呢？
可以！我们可以创建一个没有任何抽象方法的抽象类。考虑这种情况：如果有一个类，让其包含任何abstract方法都显得没有实际意义，而且我们页想要阻止产生这个类的任何对象，那么这时这样做就很有用了。




2. Final关键字
final 关键字可以修饰类、类的成员变量和成员方法，但final 的作用不同。
　　
　　1） final 修饰成员变量：
　　final修饰变量,则成为常量，例如
　　final type variableName;
　　修饰成员变量时，定义时同时给出初始值，而修饰局部变量时不做要求。

　　2） final 修饰成员方法：
　　final修饰方法，则该方法不能被子类重写
　　final returnType methodName(paramList){
　　…
　　}
　　3） final 类：
　　final修饰类，则类不能被继承
　　final class finalClassName{
　　…
　　}


3. 接口
顶级接口的一般语法如下： 
<accessibility  modifier> interface <interface name>
							<extends  interface  clause>//interface  header
{//interface  body
	<constant  declarations>//常量声明
	<method  prototype  declarations>//方法原型声明
	<nested  class  declarations>//嵌套类声明
	<nested  interface  declarations>//嵌套接口声明
}
接口头部的接口名之前是关键词interface。另外，接口头部还可以规定如下信息：
1》 作用域修饰符或可访问性修饰符
2》 它所扩展的接口
接口主体可以包含如下成员声明：
1》 常量声明
2》 方法原则声明
3》 嵌套类声明以及嵌套接口声明
接口没有提供任何实现，因此从定义上讲，它就是抽象的。这意味着无法实例化接口，不过类可以实现接口（通过提供其方法原型的实现）。声明接口为abstract纯属多余，而且也很少这么做。
Java接口中，所有方法都是抽象的，所有变量也都是static常量，接口本身就是一种约束。
接口中的所有变量都是静态的（static）和最终的（final）。若在程序中没有明确标示，编译器会自动为我们添加这两个关键字。
成员声明可以以任意次序出现在接口主体中。由于接口打算由类来实现，因此接口成员隐含地具有public可访问性，于是会省略掉public修饰符。
主体为空的接口通常用做一种标记，以此标明类具有一定的属性或行为。这类接口也叫做能力接口。Java API提供了很多这类标记接口的例子：java.lang.Cloneable、java.io.Serializable、java.util.EventListener。
接口通过规定一组方法原型（但是没有实现）而定义了一种契约。根据定义，接口中的方法隐含地全部都是抽象的、公共的。方法原型和抽象方法有着同样的语法。但是，方法原型中只允许用abstract、public这两个修饰符，而这些修饰符也总会被省略掉。
<return type><method name>(<parameter list>)<throws clause>;
接口中的方法不能使用private与protected关键字修饰。不能使用private关键字是因为接口方法必须要被覆盖，被private修饰后该方法即为私有方法，除了声明该方法的类本身可以访问到，其他类不能访问，那么覆盖更是无从谈起。protected关键字修饰的方法只允许子类进行访问，但是接口不能通过继承进行实现（注意这里说的是不能通过继承来实现，不是说接口不可以被继承，接口可以直接继承接口，详细说明请参见“课程实例”），所以我们不能使用protected关键字来修饰接口方法。



4.实现接口
可以选择任何类来实现(部分或全部)0个或多个接口。利用类头部的一条impements子句，类可以指出自己所实现的接口，这在形式上是一系列由逗号隔开的、惟一的接口名。
类（或其子类）中实现的接口方法必须都具有public可访问性。类不能窄化接口方法的可访问性，也不能在接口方法的throws子句中规定新的异常；因为企图这么做就是想改变接口的契约，而这是非法的。方法的覆盖准则同样也适用于接口方法的实现。
类可以对接口中声明的方法提供实现，但这时它无法掠取接口的好处——除非类在其implements子句中明确指出了该接口名。
类可以选择只实现接口中的某些方法（即，给出接口的部分实现）。这时类必须声明为abstract。注意，接口方法不能声明为static，因为它们遵从实现该接口的类对象所履行的契约。接口方法总是作为实例方法加以实现的。
类所实现的接口和类所扩展的类（直接的或间接的）都叫做该类的超类型。反过来，一个类也是超类型的子类型。实现了接口的类在其线性实现继承层次中引入了多重接口继承。但是请注意，不管类直接地或间接地实现了多少接口，它只会对成员提供一种实现，尽管该成员也许在多个接口中有着多种声明。



5.扩展接口
接口利用extends子句可以扩展其他接口。和类的扩展不同，接口可以扩展多个接口。被其他接口扩展的接口（直接的或间接的）叫做超接口。反过来，一个接口也是其超接口的子接口。由于接口定义了新的引用类型，因此超接口、子接口也分别对应着超类型、子类型。
由于接口的方法声明全部隐含地为public，因此子接口会继承其超接口中的所有方法。子接口可以覆盖其超接口中的方法原型声明。被覆盖方法无法再被继承。方法原型声明也可以被重载，这类似于类中的方法重载。
注意，在定义类/接口之间的继承时，呈现出3种不同的继承关系：
1. 类之间的线性实现继承层次：一个类扩展了另一个类（子类——超类）
2. 接口之间的多重继承层次：一个接口扩展了其他多个接口（子接口——超接口）
3. 接口/类之间的多重接口继承层次：一个类实现了多个接口。
虽然接口不能被实例化，但却可以声明接口类型的引用。指向类对象的引用可以赋予给该类超类型的引用。

思考下面的例子： 
interface  interface1{
	int  VAL_A=1;
	int  VAL_B=2;
void  f();
void  g();
}
interface  interface2{
	int	 VAL_B=3;
	int  VAL_C=4;
	void  g();
	void  h();
}
Abstract  class  MyClass  implements  Interface1,  Interface2{
	Public void f(){}
	Public void g(){}
}

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 02 Apr 2008 15:04:24 +0800 http://iroger.javaeye.com/blog/178847 http://iroger.javaeye.com/blog/178847