2.controller (如ask_controller.rb)

def show
@user = User.find(params[:id])
@queue_items = @user.queue_items.with_state(:pending).paginate(:page => params[:queue_page] || 1, :per_page => 1)
respond_to do |format|
format.html
format.js
end
end

3.js template

$(‘#queue’).html(‘< %=escape_javascript render :partial => “queue” %>’);
$(‘.pagination a’).attr(‘data-remote’, ‘true’);

还有一种在Rails3中的方法也一并记录如下。(via:火哥的零碎)

class RemoteLinkRenderer < WillPaginate::ViewHelpers::LinkRenderer
def prepare(collection, options, template)
@remote = options.delete(:remote) || { }
super
end

def link(text, target, attributes = {})
if target.is_a? Fixnum
attributes[:rel] = rel_value(target)
target = url(target)
end
attributes[:href] = target
# page_attr = { :page => target }
@template.link_to( text.to_s.html_safe, target, :remote => true )
end
end

上周我的这个BLOG已经升级到Wordpress2.1版本，由于网络的原因很多插件及需要修改的东西没有来得及修正。这段时间有必要将之做一次全面的调整及优化，同时BLOG也会正常更新…….

什么是BlogDay
BlogDay 起源于博客们（Bloggers）认为自己应该有一个专属的节日，用以认识其它来自于不同国度或拥有各种不同嗜好、兴趣的博客。在 BlogDay当天，所有参与活动的博客们应该在自己的站上推荐五个具有特色的博客（Blogs）给所有来访的朋友，藉此和大家分享更多崭新而有趣的博客。

谁提出BlogDay
你有否注意日期3108（8月31日）这样的写法看起来很像“Blog”这个词。是的，Nir Ofir首先在以色列的一次Blog会议上一边涂鸦一边发现到这个象形，并由此产生出将象形与节日结合的创意，设立一个庆祝日——Blogday，作为博客群体的节日，甚至希望它能成为今后全球的传统节日。这个创意不亚于n年前同样因创意而诞生的Blog，而且创意者的本意不仅仅是单纯设立一个节日，而是号召大家在8月31日这一天都发表一篇网志，让人们发现一些优秀的Blog，并相互推广。

在BlogDay做什么
在八月三十一日这一天内，全世界参与活动的网民都会发表一篇帖子推荐五个新颖的博客，而且最好这五个部落格的内容可能是来自不同的文化、观点和型态。而所有造访的朋友都可以在八月三十一日当天发现自己前所未知的博客，藉此认识更多博客并为这些新发现而庆祝。

1. 找出五个你觉得有趣的新鲜博客。
2. 在2005年的BlogDay当天，留言给这五位博客的主人，告知你推荐了他们的博客。
3. 为推荐的博客写下简短的介绍，并在文中放置这些链结。
4. 在8月31日当天张贴上推荐的帖子。5. 並且加上BlogDay的標籤（Tag）： http://technorati.com/tag/BlogDay2006/ ，同時連結到BlogDay 官方網站http://www.blogday.org/

这是个特别的日子，是我们所有BLOGGER共同的节日，写下此文时已经是8.31:2点45分了，没有做什么准备不打算做推荐了，就以此文和众BLOGER同庆吧。
BTW:不知道BLOGDAY是怎么了，打开时出现Error establishing a database connection的错误….

public static final int ADAPT = -1;

public XYConstraints(int x, int y, int width, int height) {
this.x = x;
this.y = y;
this.width = width;
this.height = height;
}
[/CODE_LITE]
适应常数可能被使用为宽度和高度以便布局经理使用宽度并且高度定义由组分(got from get…..Size()).必须实施LayoutManager2 和所有方法被定义:
首先我们假设我们的布局不需要任何特别对准线, 对上部左角落总将被排列:
[CODE_LITE]
public float getLayoutAlignmentX(Container arg0) {
return 0;
}

public float getLayoutAlignmentY(Container arg0) {
return 0;
}
[/CODE_LITE]
1) 审阅所有分组和增加他们的X 和W 座标和Y 和H 座标。
2) 如果分组使用适应常数, 使用对应的方法在分组(得到..大小) 。
[B]E.g. the getPreferredSize method:[/B]
[CODE_LITE]
public Dimension preferredLayoutSize(Container arg0) {
int rightBound = 0;
int bottomBound = 0;

for (Iterator iter = constraints.keySet().iterator(); iter.hasNext();) {
Component comp = (Component) iter.next();
XYConstraints constraint = (XYConstraints) constraints.get(comp);
Dimension size = comp.getPreferredSize();
int width = constraint.getWidth();
if (width == XYConstraints.ADAPT) {
width = size.width;
}
if ((constraint.getX() + width) > rightBound) {
rightBound = constraint.getX() + width;
}
int height = constraint.getHeight();
if (height == XYConstraints.ADAPT) {
height = size.height;
}
if ((constraint.getY() + height) > bottomBound) {
bottomBound = constraint.getX() + height;
}
}
return new Dimension(rightBound, bottomBound);
}
[/CODE_LITE]
因为我们不存储什么, 我们不需要实施其它的invalidateLayout:
[CODE_LITE]
public void invalidateLayout(Container arg0) {
// No information cached
}
[/CODE_LITE]
现在我们来到有趣的部份,首先我们需要实施方法增加分组以限制来布局。
有二个方法: 一以限制代表作为对象和其他作为串。 串一个, 我们将解码串对对象和将要求第一方法:
[CODE_LITE]
public void addLayoutComponent(String constraintString, Component component) {
XYConstraints constraint = new XYConstraints(0, 0, XYConstraints.ADAPT, XYConstraints.ADAPT);
String[] args = constraintString.split(“;”);
for (int i = 0; i
暂存，待整理！
定义座标作为限制(x,y) and (w,h) coordinates:
[CODE_LITE]
private int x, y, width, height;

public static final int ADAPT = -1;

public XYConstraints(int x, int y, int width, int height) {
this.x = x;
this.y = y;
this.width = width;
this.height = height;
}
[/CODE_LITE]
适应常数可能被使用为宽度和高度以便布局经理使用宽度并且高度定义由组分(got from get…..Size()).必须实施LayoutManager2 和所有方法被定义:
首先我们假设我们的布局不需要任何特别对准线, 对上部左角落总将被排列:
[CODE_LITE]
public float getLayoutAlignmentX(Container arg0) {
return 0;
}

public float getLayoutAlignmentY(Container arg0) {
return 0;
}
[/CODE_LITE]
1) 审阅所有分组和增加他们的X 和W 座标和Y 和H 座标。
2) 如果分组使用适应常数, 使用对应的方法在分组(得到..大小) 。
[B]E.g. the getPreferredSize method:[/B]
[CODE_LITE]
public Dimension preferredLayoutSize(Container arg0) {
int rightBound = 0;
int bottomBound = 0;

for (Iterator iter = constraints.keySet().iterator(); iter.hasNext();) {
Component comp = (Component) iter.next();
XYConstraints constraint = (XYConstraints) constraints.get(comp);
Dimension size = comp.getPreferredSize();
int width = constraint.getWidth();
if (width == XYConstraints.ADAPT) {
width = size.width;
}
if ((constraint.getX() + width) > rightBound) {
rightBound = constraint.getX() + width;
}
int height = constraint.getHeight();
if (height == XYConstraints.ADAPT) {
height = size.height;
}
if ((constraint.getY() + height) > bottomBound) {
bottomBound = constraint.getX() + height;
}
}
return new Dimension(rightBound, bottomBound);
}
[/CODE_LITE]
因为我们不存储什么, 我们不需要实施其它的invalidateLayout:
[CODE_LITE]
public void invalidateLayout(Container arg0) {
// No information cached
}
[/CODE_LITE]
现在我们来到有趣的部份,首先我们需要实施方法增加分组以限制来布局。
有二个方法: 一以限制代表作为对象和其他作为串。 串一个, 我们将解码串对对象和将要求第一方法:
[CODE_LITE]
public void addLayoutComponent(String constraintString, Component component) {
XYConstraints constraint = new XYConstraints(0, 0, XYConstraints.ADAPT, XYConstraints.ADAPT);
String[] args = constraintString.split(“;”);
for (int i = 0; i

http://dev.csdn.net/article/27/27140.shtm

http://dev.csdn.net/article/27/27142.shtm

* [URL=http://www.chedong.com/tech/hello_unicode.html]Java中文处理学习笔记——Hello Unicode[/URL]
* [URL=http://www-900.ibm.com/developerWorks/cn/java/java_chinese/]Java编程技术中汉字问题的分析及解决 [/URL]
* [URL=http://www-900.ibm.com/developerWorks/cn/java/l-javachinese/index.shtml]关于Java中文问题的几条分析原则[/URL]
* [URL=http://gceclub.sun.com.cn/NASApp/sme/jive/thread.jsp?forum=8&thread=13425]
Java中文问题及最优解决方法[/URL]

       在JSP和java的开发中乱码问题有时候是非常让人头疼的，今天朋友就出了这个问题，发来信息让我帮忙看看。其实java开发者都知道，出现乱码问题有 很多种原因，需要具体问题具体分析，从他和我说的配置环境是JSP（视图）+Tomcat（模型）+Servlet（业务处理），在本地的调试环境 （Tomcat+Resin）下出现乱码问题。通常我们使用的编码方式都是为GB2312，因为页面中所有的中文都是乱码，所以通过简单的分析出问题的最 有可能出问题的地方就是JSP视图，其次是业务处理部分部分，作为Bean只是用来存储数据的，不可能出现问题。所以得先从下面几种方式开始检查(我不是 高手，一下看不出根本问题的所在)：
第一：
1:在jsp页面加入：  
<%@  page  contentType="text/html;  charset=gb2312"  %>
2.在JSP页面的最上面<%@的下面添加request.setCharacterEncoding("gb2312")，JSP页面接收数据的统一为GB2312编码格式；
3:在servlet里面:  
   public  void  doGet(HttpServletRequest  request,  HttpServletResponse  response)  throws  ServletException,  IOException  {  
       response.setContentType("text/html;  charset=gb2312"); 
4:以上如果还不行就用如下的方法在数据入库前进行调用：
[CODE_LITE]
public static String UnicodeToChinese(String s){
try{
if(s==null ¦ ¦s.equals(“”)) return “”;
String newstring=null;
newstring=new String(s.getBytes(“ISO8859_1″),”gb2312″);
return newstring;
}
catch(UnsupportedEncodingException e)
{
return s;
}
}
public static String ChineseToUnicode(String s){
try{
if(s==null ¦ ¦s.equals(“”)) return “”;
String newstring=null;
newstring=new String(s.getBytes(“gb2312″),”ISO8859_1″);
return newstring;
}
catch(UnsupportedEncodingException e)
{
return s;
}
}
[/CODE_LITE]
第二、朋友用的是MYsql，如果是连接数据库出现乱码问题得先下载mysql jdbc驱动，并解压到JDK目录下的lib文件夹和resin安装目录下的lib目录，当然这时的系统变量CLASSPATH别忘了加上,重启resin，加上连接文件。
第三、以上如果问题任然存在可能就是从数据库中取出来的时候就不是gb2312的编码格式，还有就是Servlet的传输数据的时候出的问题,根据这种情 况先从数据库原因查起,没有看到他的数据库配置，不过如果编码方式为GBK，就没有问题，那么问题就出在Servlet上了，JSP在执行时首先要编译成 Servlet，通过上面的方法可以进行下面的检查:
1.response.setContentType(CONTENT_TYPE)，CONTENT_TYPE是一个常量，默认是“text/html; charset=ISO-8859-1”(这里朋友给我的代码中是ISO8859-1，明显是个错误),看来这里是有问题了，应该把“charset=ISO-8859-1”改为“charset=gb2312”；
2.request.setCharacterEncoding("gb2312");在doGet或者doPost方法的最上面是否有这个设置。
通过这些方法朋友解决了他的乱码问题，其实在开发JSP时遇到乱码问题很常见，很多时候是因我们在一些细节上不规范，从而导致不一致，当然这只是乱码问题其中的一个。
BTW：早期的IBM网站有关于乱码问题的资料，这里也贴出来以便大家了解乱码的根本原因，以及下面有关乱码问题的文章一起放上来吧~~~~
 Web应用中的中文乱码问题
* [URL=http://www.javaworld.com.tw/jute/post/view?bid=9&id=44042&st]解决 Tomcat 5.0.19 中文参数传递问题[/URL]
* [URL=http://togetherj.blogdriver.com/togetherj/253018.html]Tomcat中文问题[/URL]
* [URL=http://www.knowsky.com/5352.html]深入剖析JSP和Servlet对中文的处理[/URL]
* [URL=http://www.knowsky.com/list.asp?id=2702]用XMLHTTP Post/Get HTML页面时的中文乱码之完全Script解决方案 [/URL]
* [URL=http://www.javaworld.com.tw/jute/post/view?bid=11&id=57879&sty=1&tpg=1&age=-1]修正上传 attachement file时的中文档名乱码问题[/URL] (修改mvnforum-1.0.0-rc3)
* 深入剖析Java编程中的中文问题及建议最优解决方法

http://dev.csdn.net/article/27/27140.shtm

http://dev.csdn.net/article/27/27142.shtm

* [URL=http://www.chedong.com/tech/hello_unicode.html]Java中文处理学习笔记——Hello Unicode[/URL]
* [URL=http://www-900.ibm.com/developerWorks/cn/java/java_chinese/]Java编程技术中汉字问题的分析及解决 [/URL]
* [URL=http://www-900.ibm.com/developerWorks/cn/java/l-javachinese/index.shtml]关于Java中文问题的几条分析原则[/URL]
* [URL=http://gceclub.sun.com.cn/NASApp/sme/jive/thread.jsp?forum=8&thread=13425]
Java中文问题及最优解决方法[/URL]

"真正地简单的历史框架包括二个开源Javascript组, DhtmlHistory 与 HistoryStorage. 这两类使AJAX 应用支持按书签自由翻动按钮。首先,我们将创造一个AJAX 网页应用一系列的题目链接; 当题目被选择, 他们的内容将被装载并且显示在页的右边而没有执行整页刷新:
图：最后实现的效果.

这里有完成后的效果，大家可以看看….

这个例子比较简单且可以创造其它的简单的技术，譬如使用iframe 的iframe 和hyperlinks 。然而,这足够说明怎么使用简单的历史API控制的先进方式, 提供按书签, 和存贮过程的服务器的声明。它提供剪贴代码这样的比较先进的AJAX 应用。
例子应用包括四个主要文件: advanced.html advanced.css advanced.js 和 topics.xml。我们并且使用三个框架加速发展 : DhtmlHistory 和HistoryStorage APIs; X DHTML topics (DHTML 的一个开放来源工具箱; ) Sarissa (一个开源API 为提供 XmlHttpRequest 和XML.这里作用的就是这个开源的API)
我们先从XML 文件开始, 命名topics.xml 我们将使用这个文件创造我们最初的用户界面:
[CODE_LITE]

[/CODE_LITE]
这是记录各个可得到的topics的一个简单XML 文件。我们分配各个题目几个属性, 譬如id 和 title 我们以后将提取使用Javascript加强这份菜单sidebar 。
其次, 我们创造advanced.html文件。
[CODE_LITE]

[/CODE_LITE]

接着建立一个advanced.js文件。
[CODE_LITE]
/*
Copyright (c) 2005, Brad Neuberg,

Permission is hereby granted, free of charge,
to any person obtaining a copy of this software
and associated documentation files (the
“Software”), to deal in the Software without
restriction, including without limitation
the rights to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons
to whom the Software is furnished to do so,
subject to the following conditions:

The above copyright notice and this
permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT
WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT
OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR
THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

// initialize ourselves when the page is finished
// loading
window.onload = initialize;

// an array of our topics
var topics = new Array();

function initialize() {
// initialize the DhtmlHistory
// framework
dhtmlHistory.initialize();

// if this is the first time the page
// has loaded, fetch the list of
// topics remotely
if (dhtmlHistory.isFirstLoad()) {
topics = loadTopics();
historyStorage.put(“topics”, topics);
}
else {
// else, simply extract it from our
// history storage
topics = historyStorage.get(“topics”);
}

// display our topics list
displayTopicsList();

// initialize our initial state from
// the browser location after the hash
var currentTopic =
dhtmlHistory.getCurrentLocation();
displayTopic(currentTopic);

// catch when a user clicks on a new
// topic
var menu =
document.getElementById(“menu”);
xAddEventListener(menu, “click”,
handleTopicChange,
false);

// set ourselves up to listen to
// history events
dhtmlHistory.addListener(
handleHistoryEvent);
}

function handleHistoryEvent(newLocation,
historyData) {
var topicID = newLocation;

// display this topic
displayTopic(topicID);
}

function handleTopicChange(e) {
var evt = new xEvent(e);
var target = evt.target;
var topicID = target.getAttribute(“topicID”);

// display this topic
var content = displayTopic(topicID);

// add this to our history
dhtmlHistory.add(topicID, content);

// cancel the default behavior of hyperlinks
return evt.cancel();
}

function displayTopic(topicID) {
var topic;

// if no topic passed in then get the
// default topic
if (topicID == null ||
topicID == “”) {
for (var i = 0; i initialize(), 当第一页装载, 我们必须使用dhtmlHistory .getCurrentLocation() 方法得到当前地点在散列值以;  

下面建立页面显示的内容，分别为topic1.html、topic2.html、topic3.html,这里的文字可以随便写了！

topic1.html
[CODE_LITE]
Hello Topic 1 World!

-Ajax
-advanced.css
-advanced.html
-advanced.js
-topic1.html
-topic2.html
-topic3.html
-topics.xml
-Lib
--history
---dhtmlHistory.js
---historyStorage.js
---serializer.js
--sarissa
---sarissa.js
---sarissa_dhtml.js
---sarissa_ieemu_xpath.js
---sarissa_ieemu_xslt.js
--x
---x_core.js
---x_dom.js
---x_event.js
[/CODE_LITE]

topic2.html
[CODE_LITE]
Hello Topic 2 World!
This is a simple two column layout with a left menu box. By modifying the stylesheet, this layout can serve as the basis for many standard two column layouts. As is the case with most layouts in the Reservoir, the order of elements (header, content, menu) in the HTML source is friendly and accessible to mobile computers, text-based browsers, and alternative/accessible devices.
[/CODE_LITE]

topic3.html
[CODE_LITE]
Hello Topic 3 World!
[/CODE_LITE]
再有就是建立一个advanced.css样式表!
[CODE_LITE]
body {
margin:0px;
padding:0px;
font-family:verdana, arial, helvetica,
sans-serif;
color:#333;
background-color:white;
}
h1 {
margin:0px 0px 15px 0px;
padding:0px;
font-size:28px;
line-height:28px;
font-weight:900;
color:#ccc;
}
p {
font:11px/20px verdana, arial, helvetica,
sans-serif;
margin:0px 0px 16px 0px;
padding:0px;
}

a {
display:block;
color:#09c;
font-size:11px;
text-decoration:none;
font-weight:600;
font-family:verdana, arial, helvetica,
sans-serif;
}
a:link {color:#09c;}
a:visited {color:#07a;}
a:hover {background-color:#eee;}

#content {
margin:50px 50px 50px 220px;
padding:10px;
}

#menu {
position:absolute;
top:55px;
left:20px;
width:172px;
padding:10px;
background-color:#eee;
border:1px dashed #999;
line-height:17px;
}
[/CODE_LITE]
至此一个简单的Ajas应用就实现了，当然X DHTML topics 与 Sarissa 的API是必不可少的，主要的目录文件大家可以去相关的网站下载，这里我给出目录结构:
些Ajax应该的目录结构如下：
-Ajax
-advanced.css
-advanced.html
-advanced.js
-topic1.html
-topic2.html
-topic3.html
-topics.xml
-Lib
--history
---dhtmlHistory.js
---historyStorage.js
---serializer.js
--sarissa
---sarissa.js
---sarissa_dhtml.js
---sarissa_ieemu_xpath.js
---sarissa_ieemu_xslt.js
--x
---x_core.js
---x_dom.js
---x_event.js

[B]finalize() [/B]
-在 Java 中，当你创建一个对象时，Java 虚拟机（JVM）为该对象分配内存、调用构造函数并开始跟踪你使用的对象。当你停止使用一个对象（就是说，当没有对该对象有效的引用时），JVM 通过垃圾回收器将该对象标记为释放状态。
-当垃圾回收器将要释放一个对象的内存时，它调用该对象的finalize() 方法（如果该对象定义了此方法）。垃圾回收器以独立的低优先级的方式运行，只有当其他线程挂起等待该内存释放的情况出现时，它才开始运行释放对象的内存。（事实上，你可以调用System.gc() 方法强制垃圾回收器来释放这些对象的内存。）
-在以上的描述中，有一些重要的事情需要注意。首先，只有当垃圾回收器释放该对象的内存时，才会执行finalize()。如果在 Applet 或应用程序退出之前垃圾回收器没有释放内存，垃圾回收器将不会调用finalize()。
-再者，除非垃圾回收器认为你的 Applet 或应用程序需要额外的内存，否则它不会试图释放不再使用的对象的内存。换句话说，这是完全可能的：一个 Applet 给少量的对象分配内存，没有造成严重的内存需求，于是垃圾回收器没有释放这些对象的内存就退出了。
-显然，如果你为某个对象定义了finalize() 方法，JVM 可能不会调用它，因为垃圾回收器不曾释放过那些对象的内存。调用System.gc() 也不会起作用，因为它仅仅是给 JVM 一个建议而不是命令。
-且finalize()还有一个用处就是[B]死亡条件[/B](The death condition)检查.
如果你在类中定义了finalize() ，它将不会自动调用基类中的方法。在我们讨论了finalize() 与 C++ 的析构函数的不同点后，对这个结论不会惊讶，因为为某个类定制的清除代码另一个类不一定会需要。
-如果你决定要通过派生一个类的finalize() 方法来调用基类中的finalize() 方法，你可以象其他继承方法一样处理。
protected void finalize()
{
super.finalize();
// other finalization code…
}
除了允许你控制是否执行清除操作外，这个技术还使你可以控制当前类的finalize() 方法何时执行。
Java 的自动垃圾回收器不会失去平衡。作为代价，你不得不放弃对系统资源释放的控制。Java Applet 不会自动执行你的类中的finalize() 方法。因此，你不应当依靠finalize() 来执行你的 Applet 和应用程序的资源清除工作。取而代之，你应当明确的清除那些资源或创建一个try…finally 块（或类似的机制）来实现。

[CODE_LITE]
//A: final_things.java
import java.applet.*;
import java.awt.*;
class thing
{
public static int thingcount = 0;
public static int thingfinal = 0;
public thing(){
++thingcount;
}
protected void finalize(){
++thingfinal;
}
}
public class final_things extends Applet{
public final_things(){
}
public String getAppletInfo(){
return “Name: final_thing\r\n” +
“Author: Tim Gooch\r\n” +
“Created with Microsoft ” +
“Visual J++ Version 1.1″;
}
public void init(){
resize(320, 240);
}
public void destroy(){
}
public void paint(Graphics g){
g.drawString(“Created with Microsoft” +
“Visual J++ Version 1.1″, 10, 20);
}
public void start(){
while(thing.thingfinal

[CODE_LITE]1． /**
2． *MyClass.java
3． *www.blueclassic.net
4． *2005.08.31
5． */
6．
7． class MyClass {
8． static int statInt = 4;
9． static Double statDouble = 16.0;
10． int instInt;
11． double instDouble;
12．
13． public static void statMethod(){
14． System.out.println (“statInt=”+statInt+
15． “;statdouble=”+statDouble);
16． }
17． public static void instMethod(){
18． System.out.println(“instInt=”+instInt+
19． “;instdouble=”+instDouble);
20． }
21． public MyClass(int intArg, double doubleArg){
22． instInt = intArg;
23． instDouble = doubleArg;
24． }
25． public static void main(string args[]){
26． MyClass instance1 = new MyClass(1,2.0);
27． MyClass instance2 = new MyClass(3,4.0);
28．
29． MyClass.statMethod(); //Outputs:statInt=4;
30． //statDouble=16.0
31．
32． instance1.instMethod(); //Outputs:instInt=1;
33． //instDouble=2.0
34． instance1.statMethod(); //Outputs:statInt=4;
35． //statDouble=16.0
36．
37． instance2.instMethod(); //Outputs:instInt=3;
38． //instDouble=4.0
39． instance2.statMethod(); //Outputs:statInt=4;
40． //statDouble=16.0
41． }
42． } [/CODE_LITE]

[ALIGN-CENTER][IMG]upload/myclass.gif[/IMG]
MyClass的框架图[/ALIGN-CENTER]
从图中Static方法和数据的单个（共享）副本是因为类和该类的所有实例而存在。通过一个实例或通过类本身可以访问static成员。

====类(static)变量=====

[CODE_LITE]public class Count {
private int serialNumber;
private static int counter = 0;
public Count() {
counter++;
serialNumber = counter;
}
}[/CODE_LITE]
在这个例子中，被创建的每个对象被赋于一个独特的序号，从1开始并继续往上。变量counter在所有实例中共享，所以，当一个对象的构造函数增加counter时，被创建的下一个对象接受增加过的值。
Static变量在某种程度上与其它语言中的全局变量相似。Java编程语言没有这样的全局语言，但static变量是可以从类的任何实例访问的单个变量。
如果static变量没有被标记成private，它可能会被从该类的外部进行访问。要这样做，不需要类的实例，可以通过类名指向它。
[CODE_LITE]public class StaticVar {
public static int number;
}
public class OtherClass {
public void method() {
int x = StaticVar.number;
}
}[/CODE_LITE]

[B]======类(static)方法======[/B]

[CODE_LITE] public class GeneralFunction {
public static int addUp(int x, int y) {
return x + y;
}
}
public class UseGeneral {
public void method() {
int a = 9;
int b = 10;
int c = GeneralFunction.addUp(a, b);
System.out.println(“addUp() gives ” + c);
}
}[/CODE_LITE]
因为static方法不需它所属的类的任何实例就会被调用，因此没有this值。结果是，static方法不能访问与它本身的参数以及static变量分离的任何变量。访问非静态变量的尝试会引起编译错误。

[CODE_LITE]public class Wrong {
int x;
public static void main(String args[]) {
x = 9; // COMPILER ERROR!
}
}[/CODE_LITE]

Main()是静态的，因为它必须在任何实例化发生前被顺序地访问，以便应用程序的运行。
静态方法不能被覆盖成非静态。

[FLASH=128,15,]http://doubleaf.com/wp-content/plugins//AsySound.swf?http://blog.ekoala.net/music/newage/era/the.mass/05.MP3[/FLASH]

[CODE_LITE]对象是一些相关的变量和方法的软件集,对象是理解面向对象技术的关键。现实生活中的对象，比如狗、桌子、电视、自行车等等。你可以发现现实世界中的对象有两个共同特征：它们都有状态和行为。比如狗有自己的状态（比如名字、颜色、生育以及饥饿等等）和行为（比如摇尾巴等等）。而Reference就是提供行为的方法 [/CODE_LITE]
1.OOP中唯一关系的是对象的接口是什么，就像计算机的销售商她不管电源内部结构是怎样的，他只关系能否给你提供电就行了，也就是只要知道can or not而不是how and why.所有的程序是由一定的属性和行为对象组成的，不同的对象的访问通过函数调用来完成，对象间所有的交流都是通过方法调用，通过对封装对象数据，很大限度上提高复用率。

2.OOP中最重要的思想是类，类是模板是蓝图，从类中构造一个对象，即创建了这个类的一个实例(instance)。

3.对象的3个主要特性
　　behavior—说明这个对象能做什么.
　　state—当对象施加方法时对象的反映.
　　dentity—与其他相似行为对象的区分标志.
　　每个对象有唯一的indentity 而这3者之间相互影响.

4、fields和methods
JAVA其实要做的事情无非就是：定义CLASS、产生对像、将消息发送给对像。
每个对像有会有数据成员（fields）和成员函数（methods），不同的对像彼此之间并不共享数据成员。
如：class Date{
int m;
float n;
boolean o;
}
为上面的class产生一个对像
Date s=new date();

5.类之间的关系:
　　use-a :依赖关系
　　has-a :聚合关系
　　is-a :继承关系–例:A类继承了B类，此时A类不仅有了B类的方法，还有其自己的方法.(个性存在于共性中)

6.Reference:
《Thinking In Java》切入Java就提出“Everything is Object”。在Java这个充满Object的世界中，reference是一切谜题的根源，所有的故事都是从这里开始的。
[FONT-COLOR=Green]没有null reference，reference必须有初值。[/FONT-COLOR]
使用reference要比使用指针效率高。因为reference不需要测试其有效性。指针可以重新赋值，而
reference总是指向它最初获得的对象。
用一段代码表达：
[CODE_LITE]
/*
* 创建日期 2005-8-31
*ReferenceTest.java
*www.blueclassic.net
*/
public class ReferenceTricks
{
public static void main(String[] args)
{
ReferenceTricks r = new ReferenceTricks();
// reset integer
r.i = 0;
System.out.println
(“Before changeInteger:” + r.i);
changeInteger(r);
System.out.println
(“After changeInteger:” + r.i);

// just for format
System.out.println();

// reset integer
r.i = 0;
System.out.println
(“Before changeReference:” + r.i);
changeReference(r);
System.out.println
(“After changeReference:” + r.i);
}

private static void
changeReference(ReferenceTricks r)
{
r = new ReferenceTricks();
r.i = 5;
System.out.println
(“In changeReference: ” + r.i);
}

private static void
changeInteger(ReferenceTricks r)
{
r.i = 5;
System.out.println
(“In changeInteger:” + r.i);
}

public int i;
}[/CODE_LITE]

运行结果如下：
[CODE_LITE]Before changeInteger:0
In changeInteger:5
After changeInteger:5

Before changeReference:0
In changeReference: 5
After changeReference:0[/CODE_LITE]
这里，我们关注的是两个change，changeReference和changeInteger。从输出的内容中，我们可以看出，两个方法在调用前和调用中完全一样，差异出现在调用后的结果。

7.构造对象使用构造器:构造器的提出，构造器是一种特殊的方法，构造对象并对其初始化。
　　例:Data类的构造器叫Data
　　new Data()—构造一个新对象，且初始化当前时间.
　　Data happyday=new Data()—把一个对象赋值给一个变量happyday，从而使该对象能够多次使用，此处要声明的使变量与对象变量二者是不同的.new返回的值是一个引用。

　　构造器特点:构造器可以有0个，一个或多个参数
　　构造器和类有相同的名字
　　一个类可以有多个构造器
　　构造器没有返回值
　　构造器总是和new运算符一起使用.　　

[FONT-COLOR=Red]b_article_comment.html[/FONT-COLOR]
[CODE_LITE]

• “>.
  “>
• | ” rel=”nofollow” target=”_blank”>HOME

[/CODE_LITE]

2、增加了友情连接的插件，不用来回的折腾文件，现在后台直接添加。这个插件省了不少事！

[MEDIA]http://www.worldtone.cn/long/0509_a.wma[/MEDIA]

[IMG]upload/0509_a.jpg[/IMG]

AIR – cherry Blossom Girl

I don’t want to be shy
Can’t stand it anymore
I just want to say ‘Hi’
To the one I love
Cherry blossom girl

I feel sick all day long
From not being with you
I just want to go out
Ever night for a while
Cherry blossom girl

Tell me why can’t it be true

I never talk to you
People say that I should
I can pray everyday
For the moment to come
Cherry blossom girl

I just want to be sure
When I will come to you
When the time will be gone
You will be by my side
Cherry Blossom Girl

Tell me why can’t it be true

I’ll never love again
Can I say that to you
Will you run away
If I try to be true
Cherry blossom girl

Cherry blossom girl
I’ll always be there for you
That means no time to waste
Whenever there’s a chance
Cherry blossom girl

Tell me why can’t it be true

[MEDIA]http://www.supernb.com/try/cherry_blossom_girl.mp3[/MEDIA]

　　[B]自信心[/B]

　　自信为个体在逆境中开拓、创新提供了信心和勇气，也为怀疑和批评提供了信心和勇气，自信常常使自己的好梦成真。没有信心的人会变得平庸、怯懦、顺从。喜欢挑战、战胜失败、突破逆境是自信心强的特点。

　　[B]自我力量感[/B]

　　虽然人的能力存在差别，但只要个体具有中等程度的智力，再加上善于总结经验、教训，善于改进方法和策略，那么，经过主观努力之后，许多事情是能够完成的。因此，可以把成功和失败归因于努力水平的高低和工作方法的优劣。

[B]自我认识自我调节[/B]

　　了解自己的优势和短处，与组织环境的关系，善于调节自己的生涯规划、学习时间等。

　　[B]情绪稳定性[/B]

　　稳定的情绪对技术性工作有预测力。冷静、稳定的情绪状态为工作提供了适度的激活水平。焦虑和抑郁会使人无端紧张、烦恼或无力，恐惧和急躁易使人忙中出乱。

　　[B]社会敏感性[/B]

　　对人际交往性质和发展趋势的洞察力和预见力，善于把握人际交往间的逻辑关系。行动之前要思考行为的结果，设身处地的想一想他人处境，乐于与人交往，能设身处地体察他人的感受。

　　[B]社会接纳性[/B]

　　在承认人人有差别和有不足的前提下接纳他人，社会接纳性是建立深厚的个人关系的基矗真诚对他人及他人的言语感兴趣，言语表达时认真倾听并注视对方。

　　[B]社会影响力[/B]

　　有以正直和公正为基础的说服力，有使他人发展和合作的精神，有一致性和耐力。善于沟通和交流。具有自信心、幽默等对情感的感染力，仔细、镇静、沉着等对行为的影响力，仪表、身姿等对视觉的影响力，忠诚和正直等对道德品德的感染力。
—–

[IMG]upload/2.jpg[/IMG]

[IMG]upload/3.jpg[/IMG]

[IMG]upload/4.jpg[/IMG]

[IMG]upload/1.jpg[/IMG]

[IMG]upload/5.jpg[/IMG]

—–

[B]开发环境[/B]
操作系统：Microsoft Windows 2003
程序语言：Java 2
开发包： Java(TM) 2 Standard Edition (build 1.4.2_04
Sun Micro. J2ME Wireless Tool Kit 2.2
IDE: Eclise 9.0

[B]程序的主要流程[/B]
[IMG]upload/tank.JPG[/IMG]

[B]程序的实现[/B]
Wireless Tool Kit 2.2+Nokia7210 Modo

[IMG]upload/tank1.gif[/IMG] [IMG]upload/tank2.gif[/IMG]
程序的开始界面 程序运行时界面

[FONT-COLOR=Green][B]目前发现的bug和未完善的功能列表如下：[/B][/FONT-COLOR]
1. 与敌人对子弹的时候有时候可能会出现当敌人死后，自己若仍在原地，子弹会发不出去。
2. 敌人的人工智能变化较少，不够理想。
3. 子弹和敌人经常会与画面的刷新的线程不同步，造成画面闪烁。
4. 由于每次子弹发射和每次坦克的移动的一个象素都会对所有坦克和所有子弹进行一次循环检查，并由于同时开的线程比较多，使得本来运行效率就不高的KVM运行异常缓慢。即使刷屏没有间隔也不会提高速度。
5. 最好有接宝物的设置，增强可玩性。
6. 当敌人和自己同时死亡时，仍会过关，但gameover字样会出现，下一关坦克不会出现，但可以隐身发炮。

[FONT-COLOR=Blue][B]已经解决的重要bug:[/B][/FONT-COLOR]
1. 当发出子弹到达边界并同时还在草丛中时会抛出数组边界异常。
2. 有时会莫名其妙的死机。
3. 当坦克在草丛中时，对方坦克发出的子弹不能将其击毁。

[b]让变动的事物与不变的事物彼此隔离，使面向对象设计(OOD)的首要考虑.考虑一下程序库的版本更新吧。[/b]

组件程序库(components library)的概念以及谁有资格去用其中组件等问题Java是通过关键字package等等来控制的。

《Java编程思想》(第二版)第5章：隐藏实现细节

[b]让变动的事物与不变的事物彼此隔离，使面向对象设计(OOD)的首要考虑.考虑一下程序库的版本更新吧。[/b]

组件程序库(components library)的概念以及谁有资格去用其中组件等问题Java是通过关键字package等等来控制的。

import关键字的用法，package关键字的用法，default package:同一个目录中的所有文件,如果没有明确的package声明,都会被视为该目录的default package.

当你编译数量较少的.java文件后，能够得到数量较多的.class文件。Java的jar压缩工具能将众多.class文件结合起来并予以压缩。

Java中没有类似C/C++的条件编译机制，原因是因为Java认为自己跨平台，而以前的条件编译正是为解决C/C++快平台问题而设计的。但是条件编译也有debug的功效，为了能更好的调试程序，你可以引入了原本在C中常用的断言机制（Assertion)，即建立Assertion类，并另外定义一个空的Assertion类放到不同的名字空间，当要把程序代码从调试版改为出货版的时候只要在原程序中导入空的Assertion类所在的package即可。这个技巧可用于任何类型的条件编译程序代码上。

Java访问权限修饰词(access specifiers): public,protected,private 应该置于class内的每个成员的定义前，无论此成员究竟是数据成员或函数。缺省的访问权限被解释成”friendly”。即同一个package内的其他所有classes都可以访问friendly成员，但对package以外的classes则形同private。public充当了访问接口的角色，而private则表示”不要碰我”。protecked表示继承类可以访问。

基于两个理由我们需要控制访问权限:1.给客户提供明确的接口，划定界限。2.将接口和实现分离。

Class的访问权限:Java的访问权限也可以用来决定”程序库中哪些classes可以被程序库使用者所用”，为classes设定的访问权限，可以控制客户端程序员或者说库使用者是否有权利产生某个class的对象。不过,这里还存在一些限制
1.每个编译单元(文件）都仅能有一个public class .
2.虽然通常不会这么做,但编译单元的确可以不含任何public class.这种情况下你可以任意给定文件名称.注意此时只要拿掉class定义前面的public 关键字即可,因为默认的是friendly,这表示同一个package内的其他classes能够乘胜该class的对象,而package之外则否.不过如果该class有某个static public 成员,那么客户端程序员即使无法生成该class的对象,仍然能够访问这个static成员.
3.class不能是private,protected的.(内隐类inner class除外).如果你不希望任何其他人取用某个class,请将其所有的构造函数申明为private,如此便可以阻止任何人产生其对象.惟有两个例外,class static成员中可以办到,继承类也可以办到.请看下面的例子:
//Demonstrates class access specifiers. Make a class effectively private with private constructors

class Soup{
private Soup(){}
public static Soup makeSoup(){
return new Soup();
}
}
public class Lunch{
void test(){
// Can’t do this ! Private constructor:
// Soup priv1=new Soup();
Soup priv2=Soup.makeSoup();
}
}
class soup示范如何将所有构造函数都声明为private以防止直接产生某个class对象。
如果你希望在执行Soup之前先尽享某些额外处理,或希望记录(或限制)究竟有多少个Soup对象被产生出来,这种做法十分有用.
——————————————————————————–
我的问题：
——————————————————————————–

当import java.until.*时 java.until.system.*会不会引入？

当class定义为public，而所有的构造函数定义为private，会有什么效果？

—–

在Java（和C++)中，构造函数是"函数名称必须能被重载"的另一个原因。每个重载函数必须拥有独一无二的引数列（argument list），而不可以以返回值（return value）作为重载的基准，因为有时候我们是以f（）来执行函数调用的，但是此时并没有返回值的任何信息，编译器会束手无策。

Default构造函数会不会被编译器主动提供则类似于C++：当您没有定义任何构造函数的时候编译器会自动提供，而当您提供了任何一个构造函数的时候，编译器是不会再给你提供default构造函数的。

“[b]每个函数的第一个字母以小写表示[/b]“这种编程风格不适用于构造函数身上，因为构造函数的名称必须完全吻合class名称

在Java（和C++)中，构造函数是”函数名称必须能被重载”的另一个原因。每个重载函数必须拥有独一无二的引数列（argument list），而不可以以返回值（return value）作为重载的基准，因为有时候我们是以f（）来执行函数调用的，但是此时并没有返回值的任何信息，编译器会束手无策。

Default构造函数会不会被编译器主动提供则类似于C++：当您没有定义任何构造函数的时候编译器会自动提供，而当您提供了任何一个构造函数的时候，编译器是不会再给你提供default构造函数的。

有时候为了方便我们需要在构造函数中调用构造函数。下面的例子告诉我们一些行为规则：

// Calling constructors with “this”

public class Flower{
int petalCount=0;
String s=new String(“null”);
Flower(int petals){
petalCount=petals;
}
Flower(String ss){
s=ss;
}
Flower(String s,int petals){
this(petals);
//! this(s); //Can’t call twice!
this.s=s;
}
Flower(){
this(“hi”,47);
}
void print(){
//! this (11); //Not inside non-constructor!
}
public static void main(String[] args){
Flower x=new Flower();
x.print();
}
}

此段程序告诉我们几点：
1.虽然你能够藉由this调用一个构造函数，却不能以相同手法调用两个。
2.对另一构造函数的调用动作必须置于最其实除，否则编译器会发出错误消息。
3.在print（）函数中你可以看出，编译器不允许你在构造函数以外的任何函数内调用构造函数,即构造函数只用于new关键字由系统自动调用。

finalize()第一种用法可以在垃圾回收之前给你做一些特殊的处理，因为垃圾回收只回收内存的，如果你有一些别的资源应该释放或者在对象销毁之前作一些动作比如说擦除以前绘制的图像等等，就应该会用到它。第二种用法：当采用原生函数(native methods)时，可以在finalize中调用free（）来释放先前malloc（）函数分配的内存。

Garbage collector的运作依赖于Java的两个关键技术：单根继承技术（继承自Object),对象完全从堆（heap）中分配内存（而非类成员的基本类型变量则放在stack中分配，为了效率的考虑）

在Java中 定义和初始化是一体的，两者不可能彼此脱离而独立存在。

成员初始化：Java保证，变量绝对会在被使用之前被适当初始化。当变量被定义与函数之内时，Java会运用编译期错误消息来贯彻它的保证。如果某个class的数据成员隶属基本类型，情况则稍有不同。因为所有函数都可以初始化或使用该数据值，所以强迫使用者一定得在使用之前给定适当初始值是不切实际的。不过，放任它持有毫无意义的处置也很危险，所以每个”隶属基本类别”的class数据成员都保证一定有初始值，即编译器设定默认初始值了。当然我们也可以方便的直接在class的变量定义出指定其值。构造函数可用来执行初始化操作，此时class中的初始化次序取决于变量在class中的定义次序。对于static的初始化动作之在必要时（一次且只有一次）可才会发生(比如被访问。或者所属的class第一个对象被建立此时，此时该static变量先于所有non-static变量初始化），自此之后，static对象便不会再被初始化。

Array的初始化：任何数组对象都隐含了length成员。在对数据元素存取的时候要做Java会对执行边界检查，而且你无法关闭此功能，牺牲程序的执行效率但是更安全，消除了C/C++数组的弊端，还完全灭杀了buffer overflow 攻击者的生存空间。

Good Luck ;)

下面是一个小小的例子，它可以取得WIndows2000、WindowsXP系统中当前登录用户的用户名和主文件夹，一下代码Copy过去就可以运行。

Good Luck

import java.util.*;
import java.io.*;

public class CurrentUser {
public CurrentUser() {
Process p = null;
Properties envVars = new Properties();
Runtime r = Runtime.getRuntime();
try
{
p = r.exec( “cmd.exe /c set user” );
BufferedReader br = new BufferedReader ( new InputStreamReader( p.getInputStream() ) );
String line;
//第一行是机器名;第二行是当前登陆的用户名，第三个是当前登陆用户的主文件夹
while( (line = br.readLine()) != null ) {
int idx = line.indexOf(‘=’);
String key = line.substring(0, idx);
String value = line.substring(idx + 1);
envVars.setProperty(key, value);
System.out.println(key + ” = ” + value);
}
}
catch(Exception e)
{
e.printStackTrace();
}
}
public static void main(String[] args) {
CurrentUser currentUser1 = new CurrentUser();
}
}

—–

一．    基本异常

第10章 通过异常处理错误

一． 基本异常

1. 抛出异常的原理
1) 像产生一个Java对象那样在heap上以new产生一个异常对象。
2) 停止目前的执行路线，将上述那个异常对象的reference自目前的context丢出。
3) 异常处理机制接手工作，寻找得以继续执行的适当地点。
2. 产生一个异常对象
异常类有两个构造函数：一个default构造函数；一个带String型参数的构造函数，参数的信息可以通过异常类中的各种方法取出。
3. 异常类的结构

[img]http://www.javaresearch.org/members/nepalon/exceptionClass.gif[/img]

1) Error是一些编译期错误或系统错误，一般无需在程序中捕捉到Error异常。
2) Exception是我们能捕捉到的异常，其中Exception异常又分为RuntimeException和non-RuntimeException两大类异常。

二． 异常的捕捉和处理

1. 异常的捕捉
1.1 通过try…catch就可捕捉异常
import java.lang.RuntimeException;
import java.lang.NullPointerException;
import java.sql.SQLException;
import java.io.IOException;
class TestException{
public void testSQLException() throws SQLException {
throw new SQLException();
}
public void testIOException() throws IOException {}
}
public class Test{
public static void main(String[] args){
TestException te = new TestException();
try{
te.testSQLException();
te.testIOException();
}
catch(SQLException ex){
System.out.println(“catch SQLException in main”);
}
catch(IOException ex){
System.out.println(“catch IOException in main”);
}
catch(Exception ex){ //（1）
System.out.println(“catch Exception in main”);
}
}
}

运行结果为：catch SQLException in main
只有参数类型与异常类型相同或相近的catch会被执行。
1.2 捕捉所有异常
如果想捕捉所有异常，只要捕捉Exception异常就行，如上面代码的（1）处
2. 异常规格（exception　specification）
1) 在函数定义时可以声明异常规格。如果一个函数在异常规格中声明了non-RuntimeException异常，那么当调用这个函数时，就一定要捕捉异常规格中的non-RuntimeException异常。
import java.lang.RuntimeException;
import java.lang.NullPointerException;
import java.sql.SQLException;
class TestException{
//（1）异常规格中声明将抛出RuntimeException异常
public void testRuntime() throws RuntimeException {}
//（2）异常规格中声明将抛出NullPointerException异常
public void testNullPointer() throws NullPointerException {}
//（3）异常规格中声明将抛出non-RuntimeException异常
public void testNonRuntime() throws SQLException {}
}
public class Test{
public static void main(String[] args){
TestException te = new TestException();
te.testRuntime();　//（4）
te.testNullPointer();　//（5）
//te.testNonRuntime();　（6）
try{
te.testNonRuntime();
}
catch(SQLException ex){}
}
}

在上述代码中，（1）处在异常规格中声明将抛出RuntimeException；（2）在异常规格中声明将抛出NullPointerException，而NullPointerException是RuntimeException的子类，所以在调用这两个函数时，可不捕捉异常，如（4）（5）处的代码一样直接调用。但（3）处在异常规格中声明将抛出SQLException，而SQLException不是RuntimeException的子类，所以必须捕捉SQLException异常。
2) 如果要在一个函数中抛出non-RuntimeException异常，则必须要在异常规格中声明该异常。
import java.sql.SQLException;
import java.io.IOException;
class Test1{
public void f() throws SQLException{　//（2）
throw new IOException(“IOException”); 　//（1）
}
}
public class ExplicitStatic{
public static void main(String[] args){
Test1 te = new Test1();
try{
te.f();
}
catch(Exception ex){
System.out.println(“catch Exception in main”);
}
}
}

在（1）处抛出了一个没有在异常规格中被声明的non-RuntimeException异常，在编译时会出错。
3. 取得异常中的信息的几个函数
1) String getMessage()、getLocalizedMessage 、toString
取得异常对象中的信息
import java.lang.RuntimeException;
import java.lang.NullPointerException;
Import java.sql.SQLException;
import java.io.IOException;
class TestException{
public void tSql() throws SQLException {
System.out.println(“Originating the exception in tSql()”);
throw new SQLException(“throw in tSql”);
}
}
public class Test{
public static void main(String[] args){
TestException te = new TestException();
try{
te.tSql();
}
catch(SQLException ex){
System.out.println(“catch SQLException in main”);
System.out.println(“ex.getMessage()：” + ex.getMessage());
System.out.println(“ex.getLocalizedMessage()：” +
ex.getLocalizedMessage());
System.out.println(“ex.toString()：” + ex.toString());
}
catch(Exception ex){
System.out.println(“catch Exception in main”);
}
}
}

运行结果：
Originating the exception in tSql()
catch SQLException in main
ex.getMessage()：throw in tSql
ex.getLocalizedMessage()：throw in tSql
ex.toString()：java.sql.SQLException: throw in tSql
2) void printStackTrace()、Throwable fillStackTrace()
printStackTrace打印出Throwable和其call　stack　trace。
FillStackTrace则在调用点设立新的stack　trace信息
import java.sql.SQLException;
class TestException{
public static void tSql() throws SQLException {
System.out.println(“Originating the exception in tSql()”);
throw new SQLException(“throw in tSql”);
}
public void f() throws SQLException{
try{
tSql();
}
catch(SQLException ex){
System.out.println(“In f(), e.printStackTrace()”);
ex.printStackTrace();
throw ex;　//（1）
//throw (SQLException)ex.fillInStackTrace();　（2）
}
}
}
public class Test{
public static void main(String[] args){
TestException te = new TestException();
try{
te.f();
}
catch(SQLException ex){
System.out.println(“catch in main, e.printStackTrace()”);
ex.printStackTrace();
}
catch(Exception ex){
System.out.println(“catch Exception in main”);
}
}
}

结果为：
Originating the exception in tSql()
In f(), e.printStackTrace()
catch in main, e.printStackTrace()
java.sql.SQLException: throw in tSql
void TestException.tSql()
Test.java:5
void TestException.f()
Test.java:9
void Test.main(java.lang.String[])
Test.java:22
java.sql.SQLException: throw in tSql
void TestException.tSql()
Test.java:5
void TestException.f()
Test.java:9
void Test.main(java.lang.String[])
Test.java:22
如果把（1）处代码注释掉，并去年（2）处代码的注释，结果将变成：
Originating the exception in tSql()
In f(), e.printStackTrace()
catch in main, e.printStackTrace()
java.sql.SQLException: throw in tSql
void TestException.tSql() //（3）
Test.java:6
void TestException.f()
Test.java:10
void Test.main(java.lang.String[])
Test.java:24
java.sql.SQLException: throw in tSql
void TestException.f()　//（4）
Test.java:16
void Test.main(java.lang.String[])
Test.java:24
由于在代码（2）处设立新的stack　trace信息，所以异常会被认为是在f()中发出的，所以在main()中得到的异常原始抛出点为f()（见（3）），而在f()中为tSql()（见（6））。
3) 如果重新抛出一个不同类型的异常，也能产生fillStackTrace()函数的效果。如果把上面代码的f()函数修改成下面的样子：
public void f() throws SQLException,IOException{
try{
tSql();
}
catch(SQLException ex){
System.out.println(“In f(), e.printStackTrace()”);
ex.printStackTrace();
throw new IOException(); //（1）
}
}

则结果为：
Originating the exception in tSql()
In f(), e.printStackTrace()
catch Exception in main
java.sql.SQLException: throw in tSql
void TestException.tSql()
Test.java:6
void TestException.f()
Test.java:10
void Test.main(java.lang.String[])
Test.java:25
java.io.IOException
void TestException.f()
Test.java:17
void Test.main(java.lang.String[])
Test.java:25
由于在（1）处抛出了一个新的类型的异常，那么在main()中捕捉到的是新的异常，所以在main()中捕捉到的异常的原始抛出点为f()。
4. RuntimeException异常
RuntimeException及其子类所代表的异常我们在程序中不用进行捕捉，如果发生此类异常，Java会自动抛出相应的异常对象，如：
class TestException{
public static void g(int x) {
System.out.println(“10/” + x + ” = ” + 10/x);
}
}
public class Test{
public static void main(String[] args){
TestException.g(2);
TestException.g(0);　//（1）
}
}

上面代码在编译时不会发生错误，只有在运行时（1）处会发生错误。虽然除法可能会存在错误，但我们不用进行捕捉，当发生错误时，Java会自动抛出相应异常。

三． 以finally进行清理

1. 如果某段代码不管是否发生异常都要执行，那可把它改入finally块中。
import java.sql.SQLException;
class TestException{
public static void tSql() throws SQLException {
System.out.println(“Originating the exception in tSql()”);
throw new SQLException(“throw in tSql”);
}
public void f() throws SQLException{
try{
tSql();
}
catch(SQLException ex){
System.out.println(“catch SQLException in f()”);
throw ex;　//（1）
}
finally{
System.out.println(“finally in f()”);
}
}
}
public class Test{
public static void main(String[] args){
TestException te = new TestException();
try{
te.f();
}
catch(SQLException ex){
System.out.println(“catch te.f() SQLException in main”);
}
catch(Exception ex){
System.out.println(“catch te.f() Exception in main”);
}
}
}

运行结果为：
Originating the exception in tSql()
catch SQLException in f()
finally in f()
catch te.f() SQLException in main
虽然在代码（1）处重新抛出异常，但finally块中的代码仍然会被执行。
2. finally造成的异常遗失
如果在finally中执行的代码又产生异常，那么在上一层调用中所捕捉到的异常的起始抛出点会是finally所在的函数。
import java.sql.SQLException;
class TestException{
public static void tSql1() throws SQLException {
System.out.println(“Originating the exception in tSql()”);
throw new SQLException(“throw in tSql1″);
}
public static void tSql2() throws SQLException {
System.out.println(“Originating the exception in tSql()”);
throw new SQLException(“throw in tSql2″);
}
public void f() throws SQLException{
try{
tSql1();
}
catch(SQLException ex){
System.out.println(“catch SQLException in f()”);
throw ex;　//（2）
}
finally{
System.out.println(“finally in f()”);
//tSql2();　（1）
}
}
}
public class Test{
public static void main(String[] args){
TestException te = new TestException();
try{
te.f();
}
catch(SQLException ex){
System.out.println(“catch te.f() SQLException in main”);
System.out.println(“getMessage：” + ex.getMessage());
System.out.println(“printStackTrace：”);
ex.printStackTrace();
}
}
}

运行结果为：
Originating the exception in tSql()
catch SQLException in f()
finally in f()
catch te.f() SQLException in main
getMessage：throw in tSql1
printStackTrace：
java.sql.SQLException: throw in tSql1
void TestException.tSql1()
Test.java:5
void TestException.f()
Test.java:13
void Test.main(java.lang.String[])
Test.java:29
从结果可以看出，在main()中能正确打印出所捕捉到的异常的起始抛出点。但如果去掉代码（1）的注释，结果将变为：
Originating the exception in tSql()
catch SQLException in f()
finally in f()
Originating the exception in tSql()
catch te.f() SQLException in main
getMessage：throw in tSql2
printStackTrace：
java.sql.SQLException: throw in tSql2
void TestException.tSql2()
Test.java:9
void TestException.f()
Test.java:21
void Test.main(java.lang.String[])
Test.java:29
从结果可以看出，在main()中捕捉到的异常是finally中产生的异常，代码（2）中抛出的异常丢失了。

四． 继承中异常

1. 关于构造函数中的异常
1.1 构造函数中的异常规则
某个derived　class构造函数的“异常规格接口“可以比其所调用的父类的构造函数的异常规格接口宽，但决不能变窄。
1) derived　class的构造函数必须在自己的异常规格中声明所有base　class构造函数的异常规格中所声明的异常。
2) 在derived　class的构造函数的异常规格中还可以声明新的异常，即声明在base　class构造函数的异常规格中没有声明的异常。
1.2 原因
当在产生一个derived　class的对象时，会在derived　class的构造函数中调用base　class的构造函数（初始化过程请见第6章），所以在derived　class的构造函数中可能会抛出base　class构造函数的异常规格中声明的异常，因此要在derived　class的异常规格中声明base　class构造函数的异常规格中声明的异常。
＊＊：如果调用的函数的异常规格中声明了异常，那么在调用该函数的时候要捕捉它的异常规格中声明的异常。但在derived　class构造函数中却无法捕捉其base　class构造函数所掷出的异常。
2. 关于非构造函数的异常规则
2.1 某个函数的“异常规格接口“在继承和重载中可以变窄，但决不能变宽
要覆写base　class的函数时，如果被覆写函数（base　class中的函数）的异常规格中声明了异常，那么覆写函数（derived　class中覆写了base　class中的函数的那个函数）的异常规格中可以声明（1）与被覆写函数完全相同的异常；（2）被覆写函数异常规格中的部分异常或其子类异常；（3）不声明异常规格。
2.2 原因
这么做是为了满足“能处理被覆写函数的代码，不用做任何修改就能处理覆写函数的代码”的原则。
如果覆写函数的异常规格中声明了在被覆写函数的异常规格中不存在的异常，那么能处理被覆写函数的代码就不能处理覆写函数，因为没有捕捉覆写函数中不存在于被覆写函数中的异常声明。
import java.sql.SQLException;
class BaseClass{
public void f(){}
}
class DerivedClass1 extends BaseClass{
//public void f() throws SQLException {}　（1）
public void f() {}　//（2）
}
public class Test{
public static void f(BaseClass bc) { bc.f(); }
/*　（3）
public static void f(BaseClass bc) {
try{
bc.f();
}
catch(SQLException ex){}
}
*/
public static void main(String[] args){
BaseClass bc = new BaseClass();
f(bc);
DerivedClass1 dc = new DerivedClass1();
f(bc);
}
}

如果允许“异常接口“变宽，我们看看上面代码会出现什么结果。首先，我们可以将代码（1）的注释去掉，并注释掉代码（2）。由于BaseClass　class中的被覆写f()函数没有声明异常规格，而代码（1）中覆写f()函数声明了，那么Test　class中的f(BaseClass bc)虽然能处理被覆写f()函数的调用，但不能处理覆写f()函数的调用，因为代码覆写f()函数声明了异常规格，而f(BaseClass bc)没有进行捕捉。那么为了处理覆写f()函数，我们还要编写代码（3）那样的处理函数。
2.3 产生对象的异常规则
在产生一个对象时，捕捉的是产生对象时所调用的构造函数中所声明的异常。
2.4 函数调用时的异常规则
1) 当把一个对象向上转型为它的base　class时，并通过转型后的reference进行函数调用时，我们要捕捉的是其base　class的异常声明。
2) 当用对象的原始类型来调用函数时，只需捕捉所调用的覆写函数的异常
2.5 继承中的异常规则的一个实例
import java.lang.Exception;
class BaseException extends Exception {}
class Derived1Exception extends BaseException {}
class Derived2Exception extends BaseException {}
class Derived11Exception extends Derived1Exception {}
class BaseClass{
BaseClass() throws Derived1Exception {}
BaseClass(int i) throws BaseException {}
BaseClass(int i, int j) {}
//在覆写f()时不能声明异常规格
public void f() {}
//在覆写g()时可以不声明异常或声明BaseException异常或声明
//BaseException异常的子类
public void g() throws BaseException {}
//在覆写u()时可以不声明异常
public void u() throws Derived1Exception, Derived2Exception {}
}
class DerivedClass1 extends BaseClass{
//base　class构造函数中声明了异常的处理方法
//声明与base　class构造函数中的异常完全相同的异常
DerivedClass1(int i) throws Derived1Exception {}
//声明base　class构造函数中的异常的父类异常
DerivedClass1() throws BaseException {}
//声明base　class构造函数中的异常和新的异常
DerivedClass1(String s) throws Derived1Exception, Derived2Exception{}
//声明base　class构造函数中的异常父类异常和新的异常
DerivedClass1(String s, int i) throws BaseException, Derived2Exception{}
DerivedClass1(int i, int j) { super(i, j); }
//注意下面这两句
DerivedClass1(int i, String s) throws BaseException { super(i); }
//！DerivedClass1(int i, String s) throws Derived1Exception { super(i);}
public void f() {}
//下面覆写g()的几种方式
//不声明
//public void g() {}
//public void g() throws BaseException {} 声明完全相同
//声明子类异常
public void g() throws Derived1Exception {}
//声明子类异常
//public void g() throws Derived1Exception, Derived11Exception {}　
//下面覆写u()的几种方式
//public void u() {}　不声明
//public void u() throws Derived11Exception {}　声明部分异常的异常
//public void u() throws Derived1Exception {}　声明部分异常
//声明完全相同
//public void u() throws Derived1Exception, Derived2Exception {}　
//声明子类异常
//public void u() throws Derived1Exception, Derived11Exception {}　
}
public class Test{
public static void main(String[] args){
//捕捉的是相应的构造函数的异常
try{
BaseClass bc1 = new DerivedClass1();
}
catch(BaseException be) {}
try{
BaseClass bc2 = new DerivedClass1(“bc2″);
}
catch(Derived1Exception be1) {}
catch(Derived2Exception be2) {}
//通过向上转型来调用函数
BaseClass bc3 = new DerivedClass1(1, 1);
/*捕捉的是父类中被覆写的函数的异常，而这里捕捉的是子类中
* 被覆写的函数的异常，所以编译错误
try{
bc3.g();
}
catch(Derived1Exception be) {}
*/
//捕捉了被覆写函数的异常，是正确的
try{
bc3.g();
}
catch(BaseException be) {}
//用对象的原始类型来调用函数
DerivedClass1 dc1 = new DerivedClass1(1, 1);
//只需捕捉所调用的覆写函数的异常
try{
dc1.g();
}
catch(Derived1Exception be) {}
}
}

—–

4．    自己实现一个简单的HashMap及其原理

（第9章-2HashMap的工作原理及其实现）

4． 自己实现一个简单的HashMap及其原理

4.1 在put()方法中：
1) 首先通过key得出要插入的key-value　pair的hash　code，并这个hash　code作为索引在数组bucket中找出key所对应的元素。
2) 把要插入的key-value　pair封装成实现了Map.Entry接口的类的一个对象。
3) 在操作1）所找出的数组元素（也是一个LinkedList）中查看是否有与要插入的key-value　pair的key相同的元素，如果有，则对之进行更新；如果无，则把要插入的key-value　pair数组元素中。
4.2 在get()方法中
1) 首先通过key得出要查找的key-value　pair的hash　code，并这个hash　code作为索引在数组bucket中找出key所对应的元素。
2) 把要查找的key-value　pair的key封装成实现了Map.Entry接口的类的一个对象。
3) 在操作1）所找出的数组元素（也是一个LinkedList）中查看是否有与要插入的key-value　pair的key相同的元素，如果有，则返回key所对应的value；如果无，则返回一个null。
4.3 一个实例
import java.util.*;
/**
* MPair类实现了Map.Entry
*/
class MPair
implements Map.Entry, Comparable{
Object key, value;
MPair(Object k, Object v){
key = k;
value = v;
}
public Object getKey() { return key; }
public Object getValue() { return value; }
public Object setValue(Object v){
Object result = value;
value = v;
return result;
}
/**
* 当比较两个MPair对象时，比较的是它们的key值
*/
public boolean equals(Object o){
return key.equals(((MPair)o).key);
}
public int compareTo(Object rv){
return (((Comparable)key).compareTo(((MPair)rv).key));
}
}
class SimpleHashMap extends AbstractMap{
private final static int SZ = 997;
private LinkedList[] bucket = new LinkedList[SZ];
/**
* 把key和value封装成Map.Entry的实现类后插入到array中
*/
public Object put(Object key, Object value){
Object result = null;
//通过key得到要插入的key-value　pair的hash　code
int index = key.hashCode() % SZ;
if(index 0.5;
public String toString(){
if(shadow)
return “Six more weeks of Winter!”;
else
return “Early Spring!”;
}
}
public class Test{
public static void main(String[] args){
HashMap hm = new HashMap();
for(int i = 1; i 0.5;
public String toString(){
if(shadow)
return “Six more weeks of Winter!”;
else
return “Early Spring!”;
}
}
public class Test{
public static void main(String[] args){
HashMap hm = new HashMap();
for(int i = 1; i

（第9章-1容器的使用及其工作原理）
第9章 持有你的对象

一. 容器简介

1. 容器的分类
1.1. Collection：一组各自独立的元素，即其内的每个位置仅持有一个元素。
1) List：以元素安插的次序来放置元素，不会重新排列。
2) Set：不接爱重复元素，它会使用自己内部的一个排列机制
1.2. Map：一群成对的key-value对象，即所持有的是key-value pairs。
Map中不能有重复的key，它拥有自己的内部排列机制。
2. 容器中的元素类型都为Object。从容器取得元素时，必须把它转换成原来的类型。

二. 容器的详细介绍

1． Collection
Collection不提供get()方法。如果要遍历Collectin中的元素，就必须用Iterator。
1.1. List
1.1.1 List（interface）：List为Collectin加入了一些函数，使它可以在List内进行安插和移除动作。List会产生ListIterator，通过它可以从两个方向来对List进行走访，也可以在List之内进行元素的安插和移除。
1.1.2 ArrayList：可以快速随机访问；但当元素的安插或移除发生在List中央位置时，效率很差。不宜用ArrayList来进行安插和移除操作。
1.1.3 LinkedList：与ArrayList相反，适合用来进行安插和移除，但随机访问的速度较慢。此外，可以通过LinkedList来实现stack、queue、deque。
1) LinkedList中的addFirst()、addLast()、getFirst()、getLast()、removeFirst()、removeLast()函数未定义于任何一个interface或base　class中，所以只能用于LinkedList中。
1.2. Set
1.2.1 Set（interface）：Set具有和Collection一模一样的interface（区别：List加入了自己的函数），所以Set就是一个Collection，只不过其行为不同罢了。加至Set内的每个元素都必须独一无二，不与其他元素重复；Set不允许持有重复元素，每个元素都必须定义equals()以判断所谓的独一性。
1.2.2 HashSet：一种把查找时间看得很重要的Sets。所有元素都必须定义hashCode()。
1.2.3 TreeSet：底层结构为tree的一种有序的Set。
2． Map
2.1. Map：维护key-value的关联性，使你可以使用key来查找value。
1) KeySet()函数和values()函数
import java.util.*;

public class ExplicitStatic{
public static void printKeys(Map m){
System.out.print(“Size = ” + m.size());
System.out.println(” , Keys: ” + m.keySet());
}
public static void printValues(Map m){
System.out.println(“Values: ” + m.values());
}
public static void test(Map m){
for( int i=1; i

一.    接口

[b]第8章 接口与内隐类[/b]

一. 接口

1． 如果实现接口的class未实现接口中的所有函数，则这个class必须被声明为abstract　class，而接口中未被实现的函数在这个class中为abstract　class。
interface Interface{
public void f();
public void g();
}
abstract class First implements Interface{
public void f(){}
}
class Second extends First{
public void g(){}
}
public class ExplicitStatic{
public static void main(String[] args){
Interface f = new Second();
f.f();
f.g();
}
}

2． 接口中的所有函数自动具有public访问权限，所以实现某个接口时，必须将承袭自该接口的所有函数都定义为public
interface MyInterface {
public void f();
void g();
}
class First implements MyInterface {
public void f(){}
//！void g(){}出错，应定义为public
}

3． 接口中的数据成员自动成为static和final
interface MyInterface{
int i = 5;
void f();
void g();
}
class First implements MyInterface {
public void f(){}
public void g(){}
}
public class ExplicitStatic{
public static void main(String[] args){
MyInterface x = new First();
// MyInterface的数据成员I为static，可直接调用
System.out.println(“MyInterface.i = ” + MyInterface.i + ” , x.i = ” + x.i);
// MyInterface的数据成员I为final，不能修改
//x.i++;
// MyInterface.i++;
}
}

4． 多重继承
1) devriced　class可以同时继承多个interface和一个abstract或concrete　base　class。如果同时继承了base　class和interface，那么要先写下具象类的名称，然后才是interfaces的名称。
2) 如果derived　class所继承的具象类具有与interfaces相同的函数，则可在derived　class不实现那个函数。
interface CanFight{
void fight();
}
interface CanSwim{
void swim();
}
class ActionCharacter{
public void fight(){}
}
class Hero extends ActionCharacter
implements CanFight, CanSwim{
public void swim(){};
}
public class ExplicitStatic{
static void f(CanFight x) { x.fight(); }
static void s(CanSwim x) { x.swim(); }
static void a(ActionCharacter x) { x.fight(); }
static void h(Hero x){
x.fight(); x.swim();
}
public static void main(String[] args){
Hero h = new Hero();
f(h); s(h); a(h); h(h);
}
}

因为在ActionCharacter　class中有与接口CanFight完全相同的函数fight()，所以在Hero　class可以不实现fight()方法。当要调用x.fight()时，会调用ActionCharacter　class中的fight()函数。
3) 接口的合并时的名称冲突问题
interface I1 { void f(); }
interface I2 { int f(int i); }
interface I3 { int f(); }
class C { public int f() { return 1; } }

class C2 implements I1, I2{
public void f() {}
public int f(int i) { return 1; }
}
class C3 extends C implements I2{
public int f(int i) { return 1; }
}
class C4 extends C implements I3{
public int f() { return 1; }
}
//class C5 extends C implements I1{}　（a）
//class C6 extends C implements I1{ public void f(){} }　（b）
interface I4 extends I1, I3{}　//（c）
class C7 implements I4{
public void f() {}
public int f() { return 1; }
}

（a）处代码会产生以下错误： method f() in class C cannot implement method f() in interface I1 with different return type, was void。
（b）处代码也是错误的： method f() in class C6 cannot override method f() in class C with different return type, was int。由（b）处代码也可看出，虽然你试图实现接口I1中的函数，但由于extends C在前，所以编译器会把C6中的函数看成是覆写class　C中的函数，而不是象你想象中的作为实现接口中的函数的函数。
（c）处代码在原书中（P253）说会出错，但我在测试时并没发生错误。但当你试图通过C7来实现接口I4时，是无论如何也不可能编译通过的。
4) Java中唯一可以使用多重继承的地方
Java是不允许通过关键字extends来实现多重继承的，但除了通过多重继承来扩充接口除外。
interface I1{
void f1();
}
interface I2{
void f2();
}
interface Ie1 extends I2{
void fe1();
}
class Ce1 implements Ie1{
public void f2() {}
public void fe1() {}
}
interface Ie2 extends Ie1, I1{
void fe2();
}
class Ce2 implements Ie2{
public void fe2() {}
public void f2() {}
public void fe1() {}
public void f1() {}
}

接口Ie2继承了两个接口。
5． 嵌套的interfaces
嵌套的interfaces可以在定义该内部接口的外部类（接口）之外被使用（但内隐类不行）。
1) 当接口嵌套于class中
a) 不论接口为public、friendly或private，都可被实现为public、friendly、private三种嵌套类。
b) 被声明为private的接口不能在class外被使用。
class A{
private interface B{
void f();
}
public class BImp implements B{
public void f() {}
}
private class BImp2 implements B{
public void f() {}
}
public B getB() { return new BImp(); }
private B dRef;
public void recivedD(B d){
dRef = d;
dRef.f();;
}
}
public class ExplicitStatic{
public static void main(String[] args){
A a = new A(); //（a）
//A.B ab = a.getB();　（b）
//A.BImp = a.getB();　（c）
a.recivedD(a.getB());
}
}

虽然A　class含有接口，但它仍可被实例化，如（a）。
由于接口B为private，所以在（b）处调用接口B时会出错。但当把接口B声明为public时，（b）将通过编译。但（c）处依然会出错，因为内隐类的作用域为定义该内隐类的外部类内（见内隐类）。
2) 当接口嵌套于接口中
1) 嵌套于接口中的接口自动为public，且只能为public。
2) 当实现某个接口时，无需实现其中嵌套的接口。
3) Private接口无法在其所定义的class之外被实现。

二. Inner classes（内隐类）

1． 内隐类的基本用法
1) 如果要在外围class的non-static函数之外产生一个inner class对象，得以OuterClassName.InnerClassName的形式指定该对象的型别。而在non-static函数内则不用。
public class ExplicitStatic{
class Contents{
private int i = 11;
public int value() { return i; }
}
class Destination{
private String label;
Destination(String whereTo){
label = whereTo;
}
String readLabel() { return label; }
}
public Destination to(String s){
//在outer class的non-static函数中可直接产生inner class对象
return new Destination(s); //（1）
}
public Contents cont(){
return new Contents(); //（1）
}
public void ship(String dest){
//在outer class的non-static函数中可直接通过InnerClassName
//来指定对象型别
Contents c = cont();
Destination d = to(dest);
System.out.println(d.readLabel());
}
public static void main(String[] args){
ExplicitStatic p = new ExplicitStatic();
p.ship(“Tanzania”);
ExplicitStatic q = new ExplicitStatic();
//在outer class的非non-static函数内产生inner class对象
ExplicitStatic.Contents c = q.cont();
ExplicitStatic.Destination d = q.to(“Borneo”);
//不能在static函数直接生成inner class对象
// new Contents();
}
}

2) 对于non-static　inner　class，在外围class的non-static函数可以通过new产生一个inner class对象，如上面的（1）处。但要在非non-static函数产生一个inner class对象，则一定要关联到其enclosing　class的某个对象。
3) inner class的向上转型
当把一个inner class对象向上转型成为interface时，我们得到的只是一个reference。
interface Destination{
String readLabel();
}
interface Contents{
int value();
}
class Parcel3{
private class PContents implements Contents{
private int i = 11;
public int value() { return i; }
}
protected class PDestination implements Destination{
private String label;
PDestination(String whereTo){
label = whereTo;
}
public String readLabel() { return label; }
}
public Destination to(String s){
return new PDestination(s);
}
public Contents cont(){
return new PContents();
}
}
public class ExplicitStatic{
public static void main(String[] args){
Parcel3 p = new Parcel3();
//把inner class对象向上转型
Contents c = p.cont();
Destination d = p.to(“Borneo”);
}
}

虽然我们不能在ExplicitStatic class无法调用Pcontents class，但我们把一个Pcontents　class对象向上转型为Contents，就可对之进行调用。
4) inner　class的作用域为定义该inner　class的scope内。但inner　class可在它的作用域之外被继承（见4）。
interface Contents{
int value();
}
class Parcel3{
//PContents1　class的作用域为Parcel3　class内
private class PContents1 implements Contents{
private int i = 11;
public int value() { return i; }
}
public Contents cont1(){
return new PContents1();
}
public Contents cont2(){
//PContents2　class的作用域为函数cont2内
class PContents2 implements Contents{
private int i = 11;
public int value() { return i; }
}
return new PContents2();
}
//不能在函数cont2外使用PContents2　class
/*
public Contents cont22(){
return new PContents2();
}
*/
public Contents cont3(boolean b){
if(b){
//PContents3　class的作用域为当前if内
class PContents3 implements Contents{
private int i = 11;
public int value() { return i; }
}
return new PContents3();
}
//不能在if外使用PContents3　class
//return new PContents3();
return null;
}
}
public class ExplicitStatic{
public static void main(String[] args){
Parcel3 p = new Parcel3();
Contents c1 = p.cont1();
Contents c2 = p.cont2();
Contents c3 = p.cont3(true);
}
}

2． 内隐类与外围enclosing class的连接关系
2.1　non-static　inner　class
1) inner　class可以访问enclosing　class的所有成员（包括private成员），就像inner　class自己拥有这些成员一样。即inner　class天生具有对enclosing　class的所有成员的访问权力。
2) Inner　class对象被产生时，一定要关联到其enclosing　class的某个对象（这个enclosing　class对象就是Inner　class对象的制造者）。建构inner　class对象的同时，得有其enclosing　class对象的reference才行。
原因：因为inner　class可以访问enclosing　class的所有成员，那么当产生一个inner　class时，编译器会自动为inner　class对象添加一个指向enclosing　class对象的reference（这个reference是隐藏的）。所以Inner　class被产生时，一定要关联到其enclosing　class的某个对象。
3) 同一个enclosing　class对象产生出来的inner　class对象访问的是同一个enclosing　class对象中的成员。
interface Destination{
String readLabel();
}
interface Contents{
int value();
}
class Parcel3{
int i1 = 10;
private String s1 = “Parcel3_”;
Parcel3(String s){
s1 += s;
}
private class PContents implements Contents{
//可调用enclosing　class的成员　（1）
private int i2 = i1;
private String s2 = s1;
PContents(int num){
System.out.println(“” + num + “： i2 = ” + i2 + “，s2 = ” + s2);
}
public int value() { return 1; }
}
public Contents cont(int i){
return new PContents(i);
}
}
public class ExplicitStatic{
public static void main(String[] args){
Parcel3 p1 = new Parcel3(“1″);
Contents c1 = p1.cont(1);
Contents c2 = p1.cont(2);
Parcel3 p2 = new Parcel3(“2″);
c2 = p2.cont(3);
c2 = p1.cont(4);
}
}

结果为：
1： i2 = 10，s2 = Parcel3_1
2： i2 = 10，s2 = Parcel3_1
3： i2 = 10，s2 = Parcel3_2
4： i2 = 10，s2 = Parcel3_1
在（1）在inner　class调用了enclosing　class的成员。结果表明，同一个enclosing　class对象p1产生的inner　class对象调用的是同一个enclosing　class对象中的成员，如结果中的1、2、4。
2.2　 Static inner classes（静态内隐类）
1) 产生Static inner classes对象时，不需要同时存在一个enclosing　class对象
2) 只能在Static inner classes对象中访问enclosing　class中的静态成员。
interface Contents{
int value();
}
class Parcel1{
private static String s1 = “Parcel3_”;
private String s11 = “Parcel3_”;
Parcel1(String s){
s1 += s;
}
protected static class PContents implements Contents{
//只能访问enclosing class中的s1
String s2 = s1;
//s11不是static成员，不能访问
//String 22 = s11;
PContents(int num){
System.out.println(“” + num + “：s2 = ” + s2);
}
public int value() { return 1; }
}
public static Contents cont(int i){
return new PContents(i);
}
}
public class ExplicitStatic{
public static void main(String[] args){
Parcel1 p1 = new Parcel1(“1″);
Contents c1 = p1.cont(1);
c1 = Parcel1.cont(2); 　//（1）
Parcel1 p2 = new Parcel1(“2″);
c1 = p2.cont(3);
c1 = Parcel1.cont(4);　//（1）
}
}

因为内隐类Pcontents　class是静态的，所以在（1）处不通过enclosing　class对象而是通过静态函数来直接产生其对象。
2.3 无论inner　class被嵌套置放的层次有多深，且所有outer　class的成员都可
被它访问。
class MNA{
private void f() {}
class A{
private void g() {}
class B{
void h(){
g();
f();
}
}
}
}

3． 如何产生inner　class对象的总结
3.1　non-static内隐类
1) 在enclosing　class的non-static函数中可以直接通过new来产生
2) 在enclosing　class的static函数或其它的class中，必须同时存在一个enclosing　class对象（原因在上面2.1已说明）。
interface Contents{
int value();
}
class Parcel1{
protected class PContents implements Contents{
public int value() { return 1; }
}
public Contents cont(){
//在non-static函数中直接通过new来产生PContents class对象
return new PContents();
}
public static void test(String[] args){
Parcel1 p1 = new Parcel1();
//在static函数中通过外部类Parcel1对象来产生
Contents c1 = p1.cont(); //调用函数
c1 = p1.new PContents();　//通过new
}
}
public class ExplicitStatic{
public static void main(String[] args){
//通过外部类Parcel1对象来产生
Parcel1 p1 = new Parcel1();
Contents c1 = p1.cont(); //调用函数
c1 = p1.new PContents(); //通过new
}
}

3.2　static内隐类
1) 除了可用产生non-static内隐类对象的方法来产生之外，也可以不通过已存在一个enclosing　class对象来产生。
interface Contents{
int value();
}
class Parcel1{
protected static class PContents implements Contents{
public int value() { return 1; }
}
public Contents cont(){
//在non-static函数中直接通过new来产生PContents class对象
return new PContents();
}
public static Contents cont1(){
//在static函数中直接通过new来产生PContents class对象
return new PContents(); //（1）
}
public static void test(String[] args){
Parcel1 p1 = new Parcel1();
//在static函数中通过外部类Parcel1对象来产生
Contents c1 = p1.cont(); //调用函数
c1 = p1.new PContents(); //通过new
//在static函数中直接通过new来产生PContents class对象
c1 = new PContents(); //（1）
}
}
public class ExplicitStatic{
public static void main(String[] args){
//通过外部类Parcel1对象来产生
Parcel1 p1 = new Parcel1();
Contents c1 = p1.cont(); //调用函数
c1 = p1.new PContents(); //通过new
//直接产生
c1 = Parcel1.cont1(); //（2）
}
}

上面的（1）和9（2）中的代码只有在Pcontents　class为static时才能通过。（1）不能通过的原因见2.1。
4． inner　class的继承
1) inner　class可被继承。inner　class的drived　class的drfault构造函数必须传入一个reference指向outer　object，并在构造函数中调用outer　class的构造函数。
class WithInner{
class Inner{}
}
class InheritInner extends WithInner.Inner
{
//InheritInner(){} 编译错误
InheritInner(WithInner wi) { wi.super(); }
}
public class ExplicitStatic{
public static void main(String[] args){
WithInner wi = new WithInner();
InheritInner ii = new InheritInner(wi);
}
}

2) 覆写inner　class不具备多态特性。
class Egg{
class Yolk{
public Yolk(){
System.out.println(“Egg.Yolk()”);
}
}
private Yolk y;
public Egg(){
System.out.println(“New Egg()”);
y = new Yolk(); //（1）
}
}
class BigEgg extends Egg{
//（2）尝试覆写inner　class
class Yolk{
public Yolk(){
System.out.println(“BigEgg.Yolk()”);
}
}
}
public class ExplicitStatic{
public static void main(String[] args){
new BigEgg(); //（3）
}
}

结果为：
New Egg()
Egg.Yolk()
在（2）中我们尝试覆写inner　class。当通过（3）产生一个BigEgg时，会调用Egg的构造函数。在Egg的构造函数的（1）处产生的是Egg.Yolk　class对象，而不是子类BigEgg.Yolk　class对象。
＊＊：如上所示，上述两个inner　class是完全独立的个体，各有其专属的命名空间。
—–

一．所有对象都必须由你建立

第2章 万事万物皆对象

一．所有对象都必须由你建立
1． 存储在哪里
1. 寄存器：我们在程序中无法控制
2. stack：存放基本类型的数据和对象的reference，但对象本身不存放在stack中，而是存放在Heap中
3. Heap：存放用new产生的数据
4. Static storage：存放在对象中用static定义的静态成员
5. Constant storage：存放常量
6. NON-RAM：硬盘等永久存储空间
2． 特例：基本型别
基本类型数据存放在Stack中，存放的是数据。而产生对象时，只把对象的reference存放在stack中，用于指向某个对象，对象本身存放在Heap中。
3． Java中的数组
当你产生某个存储对象的数组时，真正产生的其实是存储reference的数组。引数组建立后，其中的每一个reference都会被自动设为null，表示“不指向任何对象”。
二．建立新的数据型别：Class
1． 数据成员和函数
1.1 基本成员的缺省值
1） 当class的某个成员属于基本型别时，即使你没有为它提供初值，Java仍保证它有一个缺省值。
2） 只有当变量身份是“class内的成员时，Java才保证为该变量提供初值。
三．函数（Mehtods），引数（arguments），返回值（return values）
1． 引数列
当引数传递的是对象时，传递的是对象的reference。
四．注解用内嵌式文档
Java提供两种注解风格：/*XXXX*/、//XXXX

第3章 控制程序流程

一．使用Java运算符
1.关系运算符
1.） 当对两个对象运用关系运算符进行比较时，比较的是object reference，如：
Integer n1 = new Integer(3);
Integer n2 = new Integer(3);
System.out.println(n1==n2);

结果为false，因为两个object reference（n1和n2）值是不同的
2） quals()的缺省行为也是拿referenct来比较。不过Java中的class覆写了equals方法，如：
Integer n1 = new Integer(3);
Integer n2 = new Integer(3);
System.out.println(n1.quals(n2));//值为true

2． 逻辑运算符
1） 只能将and、or、not施用于boolean值身上。如果逻辑运算符两边的值存在non-boolean值，将会出错，如：
int test1 = 1;
System.out.println((test && 1

    这是我的读书笔记，希望能够对大家学习java有所帮助。

构造函数的继承问题(静水流深第一版）

这是我的读书笔记，希望能够对大家学习java有所帮助。
所有代码都经过测试，测试环境：
java version “1.4.0-rc”
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.0-rc-b91)
Java HotSpot(TM) Client VM (build 1.4.0-rc-b91, mixed mode)
如大家发现任何错误，或有任何意见请不吝赐教。

缺省构造函数的问题：base类是父类，derived类是子类，首先要
说明的是由于先有父类后有子类，所以生成子类之前要首先有父类。
class是由class的构造函数constructor产生的，每一个class都有
构造函数，如果你在编写自己的class时没有编写任何构造函数，那么
编译器为你自动产生一个缺省default构造函数。这个default构造函数
实质是空的，其中不包含任何代码。但是一牵扯到继承，它的问题就出现
了。

如果父类base class只有缺省构造函数，也就是编译器自动为你产生的。
而子类中也只有缺省构造函数，那么不会产生任何问题，因为当你试图产生
一个子类的实例时，首先要执行子类的构造函数，但是由于子类继承父类，
所以子类的缺省构造函数自动调用父类的缺省构造函数。先产生父类的实例，
然后再产生子类的实例。如下：

class base{
}
class derived extends base{
public static void main(String[] args){
derived d=new derived();
}
}

下面我自己显式地加上了缺省构造函数：
class base{
base(){
System.out.println(“base constructor”);
}
}
class derived extends base{
derived(){
System.out.println(“derived constructor”);
}
public static void main(String[] args){
derived d=new derived();
}
}

执行结果如下：说明了先产生base class然后是derived class。
base constructor
derived constructor

我要说明的问题出在如果base class有多个constructor
而derived class也有多个constructor,这时子类中的构造函数缺省
调用那个父类的构造函数呢？答案是调用父类的缺省构造函数。
但是不是编译器自动为你生成的那个缺省构造函数而是你自己显式地
写出来的缺省构造函数。

class base{
base(){
System.out.println(“base constructor”);
}
base(int i){
System.out.println(“base constructor int i”);
}
}
class derived extends base{
derived(){
System.out.println(“derived constructor”);
}
derived(int i){
System.out.println(“derived constructor int i”);
}
public static void main(String[] args){
derived d=new derived();
derived t=new derived(9);
}
}

D:\java\thinking\think6>java derived
base constructor
derived constructor
base constructor
derived constructor int i

如果将base 类的构造函数注释掉，则出错。

class base{
// base(){
// System.out.println(“base constructor”);
// }
base(int i){
System.out.println(“base constructor int i”);
}
}
class derived extends base{
derived(){
System.out.println(“derived constructor”);
}
derived(int i){
System.out.println(“derived constructor int i”);
}
public static void main(String[] args){
derived d=new derived();
derived t=new derived(9);
}
}

D:\java\thinking\think6>javac derived.java
derived.java:10: cannot resolve symbol
symbol : constructor base ()
location: class base
derived(){
^
derived.java:13: cannot resolve symbol
symbol : constructor base ()
location: class base
derived(int i){
^
2 errors

说明子类中的构造函数找不到显式写出的父类中的缺省
构造函数，所以出错。

那么如果你不想子类的构造函数调用你显式写出的父类中的缺省
构造函数怎么办呢？
如下例：

class base{
// base(){
// System.out.println(“base constructor”);
// }
base(int i){
System.out.println(“base constructor int i”);
}
}
class derived extends base{
derived(){
super(8);
System.out.println(“derived constructor”);
}
derived(int i){
super(i);
System.out.println(“derived constructor int i”);
}
public static void main(String[] args){
derived d=new derived();
derived t=new derived(9);
}
}

D:\java\thinking\think6>java derived
base constructor int i
derived constructor
base constructor int i
derived constructor int i

super(i)表示父类的构造函数base(i)请大家注意
一个是super(i)一个是super(8)。
大家想想是为什么？？

结论：子类如果有多个构造函数的时候，父类要么没有构造函数，
让编译器自动产生，那么在执行子类构造函数之前先执行编
译器自动产生的父类的缺省构造函数；要么至少要有一个显
式的缺省构造函数可以让子类的构造函数调用。
—–

　　“又一次”指的是什么？“革命”指的又是什么？光看结论的话肯定是一头雾水。其实，笔者要讲的并不是变化这样一个事实，而是“促进变化的原动力”。是什么让Java技术发生变化？让我们从这一角度出发，先看一下Java的变化历程。  

Java正处于转变期  

【日经BP社报道】 Java技术自问世时光已经过去了9个年头。作为一名一直关注其成长的记者，曾经一段时间有过这样的想法：“Java技术已经成熟，是不是发展速度该放慢一些了呢”。然而，这种想法错了。近来Java技术的进化相当显著。Java技术正在迎来“又一次革命”的风暴。这就是本文的结论。

　　“又一次”指的是什么？“革命”指的又是什么？光看结论的话肯定是一头雾水。其实，笔者要讲的并不是变化这样一个事实，而是“促进变化的原动力”。是什么让Java技术发生变化？让我们从这一角度出发，先看一下Java的变化历程。

Java正处于转变期

　　回顾Java技术的发展历程，人们一定会感慨：2004年到2005年发生的变化如此之大，可以说“现在”正是Java技术的转换期。Java技术由编程语言（Java语言）、运行环境（JVM：Java虚拟机）、框架（Java API群）组成，目前在每一个层面上都发生着巨大的变化。

（1）编程语言的变化

　　Java语言标准出现明显变化。在2004年9月发布的正式版本J2SE5.0（J2SE:Java2 Standard, Standard Edition，Java技术的核心运行环境）中，对Java语言标准中的Generics与元数据进行了大幅扩展。出现了被认为是“自Java问世以来的最大一次语言标准变化”（美国Sun Microsystems）。这次语言标准的变化给许多Java API带来了影响。许多企业API的新版本都引入了基于元数据的注解（程序中记录的附加信息），以较短的编码记述更多的信息。

（2）Java运行环境的变化

　　在J2SE5.0中，大幅度强化了JVM的管理功能与实用性，换句话说就是具备了Java执行OS（操作系统）的特征。例如，原来在J2EE（Java2 Platform, Enterprise Edition，构筑企业系统的Java技术）领域，标准配备有作为管理功能的应用软件管理框架JMX。不仅如此，还配备有JVM自身监控功能（（JSR 174: Monitoring and Management Specification for the Java Virtual Machine）。在标准功能架构中可以实时监视JVM运行时的状态，也就是内存使用量、线程状态等。

　　J2SE5.0中新追加的功能中包括并行处理实用程序（JSR 166），其基础是纽约州立大学Doug Lea提供的程序库。也就是说，标准规格中采用了来自民间的程序库。

（3）框架的变化

　　服务器端的Java框架也发生了巨大变化。企业级Java技术–J2EE的“使用方法”说明文件“J2EE Blueprint”中，提出了将应用软件分为Web层、EJB层（Enterprise JavaBeans，将包括事务处理在内的业务进程模块化的框架）来构筑的思路。这两种层次都迎来了架构更替时期。Web层的新框架为JSF（JavaServer Faces，将模块组合起来构筑Web应用程序的框架），EJB层为标准方案中刚刚公布的下一代EJB规格“EJB3.0”。

　　值得注意的是，促成框架发生变化的正是来自民间的源码开放软件。

　　对JSF产生影响的是作为源码开放的Web层框架得到普及的Apache Struts。JSF是对Struts的思路进行改进的产物，JSF的Spec Lead（规格制定领袖）之一Craig R. McClanahan就是Struts的作者。

　　对EJB3.0造成影响的也是民间源码开放软件。EJB3.0引入了DI（Dependency Injection，依赖注入）容器类（Container）与POJO（Plain Old Java Object）持久类这些新功能，大大减轻了编程的复杂性。这些概念因PicoContainer、Spring等源码开放软件的导入而引人注目。

　　其背景在于用户对“目前的EJB过于复杂”的批评。原本由EJB反对派提出的设计思想与源码开放软件，却变成了EJB3.0的中心概念，显出了巨大的影响力。

（4）脚本语言

　　在Java技术标准中新增加了编程语言Groovy（JSR 241）。这是一种可与Java语言无缝连接的脚本语言，有望以极短的程序完成相关处理。“在Java技术中添加Java以外的语言”，这听起来也许有些别扭，其实以前就有这样的呼声，希望将可以充分利用Java技术资源的脚本作为语言使用。Groovy本来是源码开放软件，最终得到认可，被采纳为标准规格。

　　由上述可以看出，Java技术的构成要素正在发生巨大变化。就在不久以前，一提起服务器Java，“Servlet、JSP、EJB是重要的API”这样的说明还占主流，但现在基于JSF和EJB3.0的应用程序已经变成了“面目全非”的程序。而在运行短程序或测试时，甚至还出现了不仅是Java语言，连脚本语言都开始调用Java框架的情况。

　　这些变化从大的方面来看的话，可以说是进一步发挥了Java面向对象的优势。当然，也包括提高开发效率、提高运行稳定性、简化运行管理等业务上的优势。

开发者团体是真正的“变革推动者”

　　那么，这些变化的原动力来自哪里呢？为什么说“目前”正面临着“又一次变革”呢？理由如下：

　　在Java技术的发展过程中，1999年到2000年是一个大的转折点。J2EE概念于1999年出现。日本国内的J2EE也在随后2～3年内得到正式普及，但这一技术体系早在5年前就已经确立。在我们眼前，新一代Java技术的轮廓正逐渐显现出来。

　　JCP（Java Community Process）2.0于2000年问世。以会员制的组织形式推进Java技术的规格制订、总体发展方向则以委员会的方式决定。从而形成了不依赖特定企业的规格制订流程。这一组织形式历经近5年的时间，逐渐发展成“变革的推动者”。

　　J2EE此前一直饱受批评，认为“Web层与EJB层的差距太大”、“EJB过于复杂”，但这也是因为这是一项实际使用的技术。JCP同样也遇到很多批评，称其“没有完全公开”、“制定的技术标准却不可思议地让Sun拥有知识产权”，但JCP却作为一个团体不断发展壮大。

　　直接推动Java技术变化的当事者为5年前形成的基于团体的标准制订流程–JCP，但真正将讨论与技术纳入JCP的却是包括Java技术批评者在内的众多Java开发者团体。他们也是早期开展Java技术变革的先行者。由此诞生的下一代技术将会在2～3年后逐渐波及主流企业用户。

　　Java技术的“变革推动者”为开发者团体。不受制于特定企业，通过众多需要Java的开发者的建议，Java技术正在不断发展进步。（记者：星 晓雄）

—–

　　其实这章介绍的是oop的思想，知道什么是抽象、接口、继承等等，其实这些我觉得没有必要专门提出来写一章，这个我就不介绍了
　　在以后的学习中，这些知识是会在里面融会贯通的。

第一章 对象导论

　　其实这章介绍的是oop的思想，知道什么是抽象、接口、继承等等，其实这些我觉得没有必要专门提出来写一章，这个我就不介绍了
　　在以后的学习中，这些知识是会在里面融会贯通的。

　　第二章 万事万物皆对象

　　在java程序中，万事万物皆对象，即使是java程序本身，也是一个对象

　　一、Reference是操纵对象之钥匙

　　c语言中是使用指针来操纵对象的，但是java呢？用的是reference来操纵对象，我习惯把他叫做句柄，句柄和对象的关系就想是电视遥控器和电视机的关系一样，既然是这样，那么遥控器和电视机都是可以独立出现的

　　例如：String name;

　　这个java语句只会产生句饼（遥控器），并不产生实际的对象（电视机），就想你老婆还没生孩子之前你们就把名字给取好了一样，句柄并没有连接到实际的对象上。这个样子写代码是不推荐的，一个没有指向对象的句柄在调用的时候编译器会抱错，应当使用String name=”baby”;，或者使用String name =new String(“baby”);这里new的意思是产生一个string类型的对象，并且这个string叫做baby。这2个方法都可以实现对象的建立。

　　二、所有的对象都需要你来建立

　　1、储存在那里

　　a、寄存器 这里是核心的存储空间，我们是没办法操纵的

　　b、栈 （stack ）这里的存取速度快，效率高，因为这里要求被存储的数据有具体大小和存活时间限制，使用弹性小，这里一般存储的是我们的对象句柄，而对象是不存在这里的

　　c、堆 （heap） 这里是通用的存储空间，他比stack好在编译器不需要知道实际在heap中存储数据的大小，也不知道这个空间需要分配多长时间，弹性好，所以用来存储对象，但是速度要比stack慢很多

　　d、静态存储空间（static storage）这里是存放被声明为static的特定成员，java对象本身是不会分配在这里的

　　e、常量储存空间 这里存放的是程序中的常量，常量值不会改变，最安全

　　f、non-ram 流或者是持久话对象

　　2、基本数据类型

　　boolean char byte short int long float double void 基本数据类型的数据是不用new 来创建的，直接int i=0，不使用heap空间，他是被放在stack中的，速度快！但是假如你要是想用heap来存储基本数据类型的话，就要使用该类型的外覆类来实现了 例如Integer i= new Integer(“0″);

　　注意！String不是基本数据类型，她是对象！从他的定义方法就可以知道了！

　　3、数组（array）

　　java中的数组使用和定义上要比c中的数组更安全，当你在定义数组的时候其实产生的是一个储存对象句柄的数组，而每一个句柄所指向的值回被设定为null，也就是不指向任何对象
三、你不需要摧毁对象

　　1、基本类型生存范围

　　java中基本类型的生存范围是由一对大括号决定的，在生存空间内定义的变量，只能用于生存空间结束之前

　　{
　　int i=1;
　　{
　　int i=100;//错误！这样的定义在java总是不允许的！编译器会认为i已经被定义过了
　　}
　　}

　　2、对象的生存范围

　　对象拥有的寿命和基本类型是不一样的，当你使用new来产生一个对象的时候，即使离开了大括号，该对象还是存在的

　　{
　　String name =new Sting(“baby”);
　　}

　　句柄name会在大括号的生存空间之外消失的，但是他所指向的string对象却还在继续占用着内存，但是大家会认为大量的无用对象会占用大量的内存，java中是怎么解决的呢？他使用的是垃圾回收机制，垃圾回收器会在特定的时间检查使用new创建的对象，假如这些对象已经没有句柄指向他们，那么他就回把无用的对象清理掉。

　　四、建立新的数据类型 class

　　java中既然一切全是对象，那么是什么来限制对象的属性呢？通过使用类。java中使用class关键字来自己定义一个类

　　例如：class women{ //class body}这样你就定义一个women 类，当然这个类没有任何属性

　　1、数据成员和方法

　　一个类中，存在2中成员，一个是数据成员，一个是方法。数据成员可以是基本数据类型，也可以是对象，而基本数据类型在声明的时候系统会自动的给他赋予一个初始值

　　五、方法、参数、返回值

　　一个合法的方法包括名称、参数、返回类型、方法体 例如

　　void name(int i)
　　{
　　return;

　　}其中 名称name() 参数int i 返回类型 void 方法体 {}，对于一个class而言，名称+参数的组合必须是唯一的，参数也可以是空的，有一个叫test的对象允许你调用一个返回值为string的方法getTest(),则 String name = test.getTest(); name的类型一定要和返回值的类型相同。

　　在向一个方法传递一个对象的时候，其实传递的是该对象的句柄（基本数据类型除外），而传递的对象类型一定要和方法中接受参数的参数类型相同。当你不需要方法给你返回什么东西的时候，你可以把该方法的返回类型设置为void，而此时方法中的return就是用来离开方法的，不需要等到他执行完毕，如果方法的返回类型不为void的时候，你可以使用return 返回一个和返回类型一样的值