<?xml version="1.0" encoding="utf-8"?><rss version="2.0">
<channel>
<title><![CDATA[Java学习]]></title>
<link>http://blog.pfan.cn/javaxx</link>
<description>编程爱好者博客</description>
<language>zh-cn</language>
			<item>
		<title><![CDATA[使用&nbsp;java.util.zip包压缩和解压缩数据]]></title>
		<link>http://blog.pfan.cn/javaxx/54417.html</link>
		<description><![CDATA[许多资料来源中都含有多余数据或对存储信息无用的数据。这常常造成客户机 和服务器应用程序间或电脑间浩如烟海的数据传输。很明显，数据存储和信息传 输问题解决办法是，安装辅助存储装置并扩展现有的通信设备。然而，要做到这 一点，就需要增加组织的运行费用。减轻部分数据存储和信息传输的方法之一是， 以更有效的代码表示数据。本文简要介绍数据压缩和解压缩，以及如何有效地、方便地从JavaTM应用程序内部使用 java.util.zip包压缩和解压缩数据。


 虽然 WinZip、gzip和Java ARchive(或 jar)等工具可以用来压缩和解压缩数据，这些工具仍被用作独立 的应用程序。从 Java 应用程序中可以调用这些工具，但并非是简捷有效的解决 方法。在希望迅速地(如在传输到远程机器之前)压缩和解压缩数据的情况下， 尤其如此。本文将:


 简要综述数据压缩


 描述java.util.zip包


 介绍如何使用这些包压缩和解压缩数据


 介绍如何压缩和解压缩已序列化的对象以节省磁盘空间


 介绍如何迅速压缩和解压缩数据，以提高客户/服务器应用程序的性能


 概述数据压缩


 文件冗余最单一的类型是字符的重复。例如，下列字符串：


 BBBBHHDDXXXXKKKKWWZZZZ


 可以更简洁地对本字符串进行编码，方法是以重复字符和代表其重复次数的数 字代替每个重复字符串。因此，上述字符串可以编码为：


 4B2H2D4X4K2W4Z


 这里的" 4B "表示4个B，而2H表示2个H,等等。以这种方法压缩字符串的编码 方式叫做运行长度编码。


 另一个例子，是矩形图像存储。因为是单色位图图像，所以按图表1所示存储。


 图表1∶带运行长度编码信息的位图


 第二种方法是将图像存为图解元文件∶


 矩形11、3、20、5


 它表示，该矩形起始坐标是(11, 3)，宽度是 20 像素，长度是 5 像素。


 矩形图像可以通过计算相等字节的方式，以运行长度编码进行压缩，如下：


 0, 40


 0, 40


 0,10 1,20 0,10


 0,10 1,1 0,18 1,1 0,10]]></description>
		<author><![CDATA[java学习]]></author>
		<pubDate>2014-03-27 10:21:00</pubDate>
		</item>
				<item>
		<title><![CDATA[简单说说JavaBean的使用]]></title>
		<link>http://blog.pfan.cn/javaxx/54416.html</link>
		<description><![CDATA[一：JavaBean定义


 JavaBean是一种可重复使用、跨平台的软件组件。JavaBean可分为两种：一种是有用户界面(UI，User Interface)的JavaBean，例如NetBean中的那些可视化图形界面 ，


 ;还有一种是没有用户界面，主要负责处理事务(如数据运算，操纵数据库)的JavaBean。JSP通常访问的是最后一种JavaBean。


 二：Jsp与JavaBean搭配使用的特点


 1.使得Html与Java程序分离，这样便于维护代码。如果把所有的程序代码都写成jsp到网页中，会使得代码繁杂，难以维护。


 2.可以降低开发jsp网页人员对Java编程能力的要求。


 3.jsp侧重生成动态网页，事务处理由JavaBean来完成，这样可以充分利用JavaBean组件的可重用性特点，提高开发网站的效率。


 三：一个标准的JavaBean有以下几个特性：


 -JavaBean是一个公共的(public)类。


 -JavaBean有一个不带参数的构造方法。


 -JavaBean通过setXXX方法设置属性，通过getXXX方法获得属性。


 四：声明JavaBean对象



	 标签用来声明JavaBean对象，的具体讲解请查看之前的博客jsp：useBean的用法。


	



	&nbsp; （转自 www.gztarena.com）]]></description>
		<author><![CDATA[java学习]]></author>
		<pubDate>2014-03-27 10:19:00</pubDate>
		</item>
				<item>
		<title><![CDATA[JAVA并发编程学习笔记之CAS操作&nbsp;分享]]></title>
		<link>http://blog.pfan.cn/javaxx/54415.html</link>
		<description><![CDATA[CAS是单词compare and set的缩写，意思是指在set之前先比较该值有没有变化，只有在没变的情况下才对其赋值。


 我们常常做这样的操作


 if（a==b） {


 a++;


 }


 试想一下如果在做a++之前a的值被改变了怎么办？a++还执行吗？出现该问题的原因是在多线程环境下，a的值处于一种不定的状态。采用锁可以解决此类问题，但CAS也可以解决，而且可以不加锁。


 int expect = a;


 if（a.compareAndSet（expect,a+1）） {


 doSomeThing1（）；


 } else {


 doSomeThing2（）；


 }


 这样如果a的值被改变了a++就不会被执行。


 按照上面的写法，a!=expect之后，a++就不会被执行，如果我们还是想执行a++操作怎么办，没关系，可以采用while循环


 while（true） {


 int expect = a;


 if （a.compareAndSet（expect, a + 1）） {


 doSomeThing1（）；


 return;


 } else {


 doSomeThing2（）；


 }


 }


 采用上面的写法，在没有锁的情况下实现了a++操作，这实际上是一种非阻塞算法。


 应用


 java.util.concurrent.atomic包中几乎大部分类都采用了CAS操作，以AtomicInteger为例，看看它几个主要方法的实现：


 public final int getAndSet（int newValue） {


 for （；；） {


 int current = get（）；


 if （compareAndSet（current, newValue））


 return current;


 }


 }


 getAndSet方法JDK文档中的解释是：以原子方式设置为给定值，并返回旧值。原子方式体现在何处，就体现在compareAndSe]]></description>
		<author><![CDATA[java学习]]></author>
		<pubDate>2014-03-27 10:18:00</pubDate>
		</item>
				<item>
		<title><![CDATA[Javascript删除列表项中的下拉项]]></title>
		<link>http://blog.pfan.cn/javaxx/54412.html</link>
		<description><![CDATA[Javascript如何删除列表项中的下拉项呢？要从列表框同时删除多个项目，我们不能从上到下的删除，因为上面的项目每删除一个，下面的项目的索引号就会变化，所以只能从下向上删除，这样才不会出现索引号乱变的问题了。


 如下面的例子：


 HTML代码：


 &lt;table&gt;


 &lt;tr&gt;


 &lt;td align="center"&gt;


 &lt;select id="lsbox" name="lsbox" size="10" multiple&gt;


 &lt;option value="1"&gt;India&lt;/option&gt;


 &lt;option value="2"&gt;United States&lt;/option&gt;


 &lt;option value="3"&gt;China&lt;/option&gt;


 &lt;option value="4"&gt;Italy&lt;/option&gt;


 &lt;option value="5"&gt;Germany&lt;/option&gt;


 &lt;option value="6"&gt;Canada&lt;/option&gt;


 &lt;option value="7"&gt;France&lt;/option&gt;


 &lt;option value="8"&gt;United Kingdom&lt;/option&gt;


 &lt;/select&gt;


 &lt;/td&gt;


 &lt;/tr&gt;


 &lt;tr&gt;


 &lt;td align="center"&gt;


 &lt;button onclick="listbox_remove('lsbox');"&gt;Delete&lt;/button&gt;


 &lt;button onclick="window.location.reload();"&gt;Reset&lt;/button&gt;


 &lt;/td&gt;


 &lt;/tr&gt;]]></description>
		<author><![CDATA[java学习]]></author>
		<pubDate>2014-03-24 11:10:00</pubDate>
		</item>
				<item>
		<title><![CDATA[JAVA面试指南：overload和override的区别]]></title>
		<link>http://blog.pfan.cn/javaxx/54411.html</link>
		<description><![CDATA[java软件工程师在应聘时面试官经常会问多个专业问题来考察你的java能力，其中override和overload的区别就是一个非常常见的面试问题，下面就来教教大家这两者到底有什么区别。 java软件工程师在应聘时面试官经常会问多个专业问题来考察你的java能力，其中override和overload的区别就是一个非常常见的面试问题，下面就来教教大家这两者到底有什么区别。


 Overload是重载的意思，Override是覆盖的意思，也就是重写。我们说面向对象有四大特征：抽象，继承，封装，多态。其中多态这种特征的表现形式就包括方法的重写与重载。


 重载Overload 表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同(即参数个数或类型不同)。那么如果两个方法的参数列表完全一样，是否可以让它们的返回值不同来实现重载?结果是不行的。，我们可以用反证法来说明这个问题，因为我们有时候调用一个方法时也可以不定义返回结果变量，即不要关心其返回结果，例如，我们调用map.remove(key)方法时，虽然remove 方法有返回值，但是我们通常都不会定义接收返回结果的变量，这时候假设该类中有两个名称和参数列表完全相同的方法，仅仅是返回类型不同，java 就无法确定编程者倒底是想调用哪个方法了，因为它无法通过返回结果类型来判断。


 重写Override 表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。子类覆盖父类的方法时，只能比父类抛出更少的异常，或者是抛出父类抛出的异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。子类方法的访问权限只能比父类的更大，不能更小。如果父类的方法是private 类型，那么，子类则不存在覆盖的限制，相当于子类中增加了一个全新的方法。
(转自 www.jvtarena.com)]]></description>
		<author><![CDATA[java学习]]></author>
		<pubDate>2014-03-24 11:09:00</pubDate>
		</item>
				<item>
		<title><![CDATA[JAVA中可以有两个方法处理大数计算]]></title>
		<link>http://blog.pfan.cn/javaxx/54260.html</link>
		<description><![CDATA[首页，感谢你的阅读，本人观点：学习编程是个漫长的过程并不是一时就会很厉害的，关键是坚持，快乐地学习，在这里分享我的一些笔记给你；
广州JAVA培训中可以在java中有两个方法处理这个问题

第一种方法就是BigInteger类，用这个类可以很方便的求出非常大的数.以求100！为例

import java.io.*;

import java.math.BigInteger;

public class calc {

public static void main(String[] args) throws IOException{

BigInteger s = BigInteger.valueOf(1);

for(int i=1;i&lt;=100;i++){

s = s.multiply(BigInteger.valueOf(i));

System.out.println(s);

}

}

}

第二种方法是，把求的值放在足够大的数组中

import java.util.*;

public class calc2{

public static void main(String[] args) throws Exception{

int[] data = new int[1000];

int num = 1;

data[1] = 1;

System.out.println("用数组解决java大数计算问题");

System.out.println("求一个整数的阶乘，请输入一个整数:");

Scanner input = new Scanner(System.in);

int n = input.nextInt();

for(int i=1;i&lt;=n;i++){

for(int j=1;j&lt;=num;j++){

data[j] = data[j] * i;

}

for(int j=1;j&lt;num;j++){

if(data[j] &gt;= 10){

data[j+1]+=data[j]/10;

data[j]=data[j]%10;

}

}

while]]></description>
		<author><![CDATA[java学习]]></author>
		<pubDate>2013-06-19 14:49:00</pubDate>
		</item>
				<item>
		<title><![CDATA[分享关于Java静态内部类]]></title>
		<link>http://blog.pfan.cn/javaxx/54245.html</link>
		<description><![CDATA[在学习编程的过程中，我觉得不止要获得课本的知识，更多的是解决问题的方法，面对新问题该怎么解决，这样我们才能走在最前方，我是达内java培训的学员，感谢你对本博客的支持；
今天在网上看到一篇关于Java静态内部类的介绍，文章还是写不错。于是加以装载，记录下来供更多读者学习和参考。

如果你不需要内部类对象与其外围类对象之间有联系，那你可以将内部类声明为static。这通常称为嵌套类（nested class）。Static Nested Class是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。想要理解static应用于内部类时的含义，你就必须记住，普通的内部类对象隐含地保存了一个引用，指向创建它的外围类对象。然而，当内部类是static的时，就不是这样了。

嵌套类意味着：

1. 嵌套类的对象，并不需要其外围类的对象。

2. 不能从嵌套类的对象中访问非静态的外围类对象。

public class StaticTest{

private static String name = "woobo";

private String num = "X001";

static class Person{ // 静态内部类可以用public,protected,private修饰

// 静态内部类中可以定义静态或者非静态的成员

private String address = "China";

private Static String x=“as”;

public String mail = "kongbowoo@yahoo.com.cn";//内部类公有成员

public void display(){

//System.out.println(num);//不能直接访问外部类的非静态成员

// 静态内部类不能访问外部类的非静态成员(包括非静态变量和非静态方法)

System.out.println(name);//只能直接访问外部类的静态成员

//静态内部类只能访问外部类的静态成员(包括静态变量和静态方法)

System.out.println("Inner " + address);//访问本内部]]></description>
		<author><![CDATA[java学习]]></author>
		<pubDate>2013-06-06 16:15:00</pubDate>
		</item>
				<item>
		<title><![CDATA[浅谈支持Java平台三种事务模型]]></title>
		<link>http://blog.pfan.cn/javaxx/54243.html</link>
		<description><![CDATA[在学习编程的过程中，我觉得不止要获得课本的知识，更多的是解决问题的方法，面对新问题该怎么解决，这样我们才能走在最前方，我是达内的学员，感谢你对本博客的支持；
在客户端发出了多个基于服务器或基于模型的调用来完成一个单独的工作单元时需要使用客户端编排(Client Orchestration)事务策略

事务对于确保数据的完整性与一致性是至关重要的。要想完全理解事务，必须得熟悉一些基本概念、模型还有策略。Mark Richards说到“混淆事务模型与事务策略是个常见错误”。这篇文章谈到了“Java"平台所支持的三种事务模型并对基于这些模型的四种主要事务策略展开了讨论。通过使用Spring Framework及Enterprise JavaBeans(EJB)3.0的一些示例，Mark介绍了事务模型的工作方式及他们缘何能作为从基本的事务处理到高速事务处理系统的基石” 。

Java平台支持三种事务模型：

* 本地事务模型——事务由DB资源而不是应用容器或框架管理。开发者管理连接而不是事务。

* 编程式事务模型——开发者从事务管理器中获取事务，之后需要自己编写事务启动、提交、异常及回滚代码。

* 声明式事务模型——最常见的模型，又叫做容器管理事务。在这种模型下，容器管理着事务，开发者定义(声明)事务的行为和参数。

但这种支持仅能描述事务基本信息和期望行为以及使用的语法和规则。事务策略能够解决如下问题：何时需要使用REQUIRED或MANDATORY属性、特定的指令、使用哪种模型及如何对特定的情况进行优化。

Mark在之前的一篇文章中讨论了事务模型的优势与陷阱。

这篇文章介绍了使用特定模型的策略及如何以恰当的方式使用模型。下面列出了这四个策略：

* 在客户端发出了多个基于服务器或基于模型的调用来完成一个单独的工作单元时需要使用客户端编排(Client Orchestration)事务策略。

* 在对后端调用的主要入口方法是粗粒度(如果你愿意可以称其为服务)的情况下需要使用API层事务策略。

* 高并发事务策略是上面策略的一个变种，在应用无法支持长事务的情况下需要使用该策略(通常基于性能和可伸缩性考虑)。

* 高速处理事务策略也许是最极端的一种事务策略了。如果应用需要最快的处理时间(以及吞吐量)，同时还要在处]]></description>
		<author><![CDATA[java学习]]></author>
		<pubDate>2013-06-03 14:19:00</pubDate>
		</item>
				<item>
		<title><![CDATA[提供对于java程序在职业道路的出路]]></title>
		<link>http://blog.pfan.cn/javaxx/54229.html</link>
		<description><![CDATA[在学习编程的过程中，我觉得不止要获得课本的知识，更多的是解决问题的方法，面对新问题该怎么解决，这样我们才能走在最前方，我是达内的学员，感谢你对本博客的支持；
&nbsp;从我做小程序员开始，就从未间断的在论坛看到有人在问java程序员的出路在哪里，其实我很能理解这些人的想法，在行业做了几年，有些感想跟大家随便聊聊。

俗话说，365行，行行出状元，此话也适用于IT行业，尤其是程序员。

当你迷茫找不到出路，又想快速成长和提高的时候，达内java培训有两种方案可以供你参考：

1、努力成为你工作环境中最优秀的人（技术最好的人）；

2、跳槽，去另外一家公司做比你能力要高的工作。

针对工作环境的不同，分为大环境和小环境（人多和人少）：

1、小环境，寻找技术最好的人，努力不断向他接近，当你通过努力觉得超过他的时候，我相信你就不会再来问“出路在哪里”的问题了。

2、大环境，人多优秀的人也多，想短时间超越所有人是有相当难度的，能与每个优秀人都交流的概率低，所以你可以选择跳槽。

跳槽，在我看来是程序员成功的必经之路。跳槽是有技巧的，同时也需要一定的运气，如果想跳槽就要果断。当你觉得不如意时，当你觉得没有出路时，当你觉得待遇不满意时，当你觉得成长不够快时。。。都可以考虑跳槽。

跳槽有利有弊，对企业来说，跳槽是不好的；对于打工者来说，跳槽是很完美的。企业培养一个程序员不容易，辛苦的带起来一个人，熟悉了业务，掌握了技术，这时候走人，损失最大的当然是企业，花时间培养人和熟悉业务也是需要成本的。对程序员来说，跳槽几乎是利大于弊，首先待遇上肯定立竿见影的体现，如果没体现出来那就是跳的失败，除非有其他想法和目标。

不要误会我的意图，跳槽对于技术人员来说并不是坏事：

1、一般的IT公司都有自己的常用的模式，该模式经过一个项目之后，就可以基本掌握，相关覆盖的知识、架构等大概也可以了解，此时可以换个环境寻找更高的发展；

2、跳槽相当于变向的升职，这个可以从你的简历中体现出来。

假如你是一个初级程序员。当你做完一个项目的时候，你会了解这个项目的整个流程，此时可以在简历中填写中级程序员的角色，把很多中级程序员做的事情写到你的履历里（前提是你要了解这些），跳槽的时候，你的目标自然就是中级程序员，而招聘公司看到你的情况也会觉得合适。]]></description>
		<author><![CDATA[java学习]]></author>
		<pubDate>2013-05-28 14:15:00</pubDate>
		</item>
				<item>
		<title><![CDATA[监控Java应用程序性能和跟踪Java中的代码]]></title>
		<link>http://blog.pfan.cn/javaxx/54228.html</link>
		<description><![CDATA[在学习编程的过程中，我觉得不止要获得课本的知识，更多的是解决问题的方法，面对新问题该怎么解决，这样我们才能走在最前方，我是达内的学员，感谢你对本博客的支持；
很多开发者觉得自己懂Java编程，事实是大多数开发人员都只领会到了Java平台的皮毛，所学也只够应付工作。作者将深度挖掘Java平台的核心功能，揭示一些鲜为人知的事实，帮助您解决最棘手的编程困难。

当应用程序性能受到损害时，大多数开发人员都惊慌失措，这在情理之中。跟踪Java应用程序瓶颈来源一直以来都是很麻烦的，因为Java虚拟机有黑盒效应，而且Java平台分析工具一贯就有缺陷。

然而，随着Java5中JConsole的引入，一切都发生了改变。JConsole是一个内置Java性能分析器，可以从命令行或在GUIshell中运行。它不是完美的，但是当尖头老板来问你关于性能的问题时，用它来应对还是绰绰有余的——这比查询PapaGoogle要好得多。

我们将向您展示5个方法，使您可以轻松地使用JConsole(或者，它更高端的“近亲”VisualVM)来监控Java应用程序性能和跟踪Java中的代码。

1.远程连接进程

因为Web应用程序分析工具假设通过一个套接字进行连通性分析，您只需要进行少许配置来设置JConsole(或者是基于JVMTI的分析器，就这点而言)，监控/分析远程运行的应用程序。

如果Tomcat运行在一个名为“webserve”的机器上，且JVM已经启动了JMX并监听端口9004，从JConsole(或者任何JMX客户端)连接它需要一个JMX URL“service:jmx:rmi:///jndi/rmi://webserver:9004/jmxrmi”。

基本上，要分析一个运行在远程数据中心的应用程序服务器，您所需要的仅仅是一个JMX URL。

2.JDK附带分析器

许多开发人员没有意识到从Java 5开始JDK中包含了一个分析器。JConsole(或者Java平台最新版本，VisualVM)是一个内置分析器，它同Java编译器一样容易启动。如果是从命令行启动，使JDK在PATH上，运行jconsole即可。如果从GUIshell启动，找到JDK安装路径，打开bin文件夹，双击jconsole。

当分析工具弹出时(取决于正在运行的Jav]]></description>
		<author><![CDATA[java学习]]></author>
		<pubDate>2013-05-24 16:15:00</pubDate>
		</item>
				<item>
		<title><![CDATA[浅谈Java开发工具一路走来的历程]]></title>
		<link>http://blog.pfan.cn/javaxx/54205.html</link>
		<description><![CDATA[在学习编程的过程中，我觉得不止要获得课本的知识，更多的是解决问题的方法，面对新问题该怎么解决，这样我们才能走在最前方，我是达内的学员，感谢你对本博客的支持；
2008年的软件开发生命周期管理软件(software development lifecycle: SDLC)在2008年有了长足进展，JavaWorld的Java工具领域专家John Ferguson 为我们带来2008年Java领域自动构建框架，软件开发周期管理工具，测试工具，以及IDEs方面的总结。他指出java工具2008年的变化包括CI持续集成工具的改进，JVM脚本语言支持上升，以及对支持多核系统编程工具需求增加等。让我们开始吧!

Build automation

让我们从现代软件开发进程的核心部分开始：Build automation自动构建，整体来看，build automation包括持续集成(continuous integration :CI)工具，构建脚本build-scripting工具，代码质量控制工具，以及版本管理或者称为SCM存储管理工具。

build automation的第一个舞台是自动build脚本。传统工具类似于Apache Maven和Apache Ant，以及最新的Gant和Gradle，能够帮助创建build脚本。在2008年，我看到许多大型公司都开始使用Maven，被Maven能在内部软件组件中为多个团队之间提供标准化开发实践，和提供显著的连贯透明的架构所吸引。这个趋势明显将继续延续到2009年。

Maven：最新的和即将发布的功能

在2008年，Maven 2的最高版本2.0.9发布，Maven 2.0.9修正了bug和添加了一些新的功能，Maven拥有更好的稳定性，并提供很好的方式使用插件来驾驭依赖管理。比如，你能够使用Checkstyle 插件来更新Checkstyle的版本。

总而言之，Maven开发中最活跃的是专注于新的重要版本的发布：Maven 2.1，这个版本将于2009年初面世。新的版本将包含很多性能改进和最优化，包括为多模块项目提供更精细的build 规则，和能够平行下载不相关依赖包，而不是现在我们使用的串行方式。

Eclipse对Maven的支持更好，m2eclipse 插件为Maven开发提供了完整]]></description>
		<author><![CDATA[java学习]]></author>
		<pubDate>2013-05-08 11:06:00</pubDate>
		</item>
				<item>
		<title><![CDATA[C编译BCB中实现动态创建一个按钮对象]]></title>
		<link>http://blog.pfan.cn/javaxx/54204.html</link>
		<description><![CDATA[在学习编程的过程中，我觉得不止要获得课本的知识，更多的是解决问题的方法，面对新问题该怎么解决，这样我们才能走在最前方，我是达内的学员，感谢你对本博客的支持；
另外由于BCB对内存管理或与系统、硬件的冲突，你的动态创建程序也许一点错误都没有，但就是编译不了;有时也许第一次通过了，第二次一样的程序却通过不了，出现这样那样的提示，最简单的办法就是注销一下系统，再试一下，多数就能解决了

BCB中提供了大量的VCL组件，有时难免要在程序中动态创建组件，VCL是用Object Pascal写的，她与C++语言还是存在着一些不同点的，要掌握正确的方法，不防我们先来看一下栈(stack)与堆(heap)的关系。

栈(stack)是存放函数的所有动态局部变量及函数调用和返回的有关信息的一块内存。栈的内存管理严格遵循先进后出的顺序，这一点正是实现函数调用所需要的。从栈中分配内存效率特别高。数据对象使用栈中的内存(如动态局部变量)比使用堆中内存会使程序运行更快。

堆(heap)是供malloc()、calloc()、realloc()和new等函数获取内存空间的一块内存。从堆中获取内存比从栈中要慢得多，但堆的内存管理却比栈灵活得多，任何时候你都可以从堆中获取(或释放)内存，我们可以按任意顺序进行。用来存放递归数据结构的内存几乎都要从堆中获取。用来存放字符串的内存通常也从堆中获取，尤其是对那些在程序运行时可能出现的很长的字符串。

从堆中获取的内存要用free()、delete来释放，它本身不会自动释放。

C编译的程序能产生如此优质的代码、程序运行的快速与对栈的正确运用是有关的，但Object Pascal中所有的对象都只能建构于堆中，无法和C++一样，能够在栈(在函数内创建类的对象)、数据区段(在函数外创建类的对象)、堆(用new等函数来创建类的对象)三种地方建立对象，所以VCL类的对象我们只能在堆中创建。

如创建一个按钮对象，我们可以这样来创建：

TButton *BTnMy= new Tbutton(From1);

可以写成如下程式：类名 *对象名=new 类名(…);

注意：()里面可以是你已创建的该类对象的父类名字、工程的名字、NULL或this。但最好是对象的父类名。

例：动态生成按钮

我们先在窗体(Form1)]]></description>
		<author><![CDATA[java学习]]></author>
		<pubDate>2013-05-07 14:51:00</pubDate>
		</item>
				<item>
		<title><![CDATA[Java&nbsp;Swing新方法来处理键盘事件]]></title>
		<link>http://blog.pfan.cn/javaxx/54196.html</link>
		<description><![CDATA[在学习java编程的过程中，我觉得不止要获得课本的知识，更多的是解决问题的方法，面对新问题该怎么解决，这样我们才能走在最前方，我是达内的学员，感谢你对本博客的支持；
行为是一个实现了Action接口的类。在Action接口中定义了7个方法。其中最关键的是actionPerformed()方法。这个方法描述了这个行为的具体操作过程。

在jdk1.2中，分别针对Jcomponent和Text类的对象定制了不同的处理键盘事件的方法：在Jcomponent中，定义了registerKeyboardAction方法，使用这个方法来将需要处理的键盘事件以及处理事件的行为绑定在一起。Text类中具有keymap对象，同Jcomponent中的处理方法类似，这个对象保存着需要处理的键盘事件和对应的行为。

而在jdk1.3中，使用一种新的方法来处理键盘事件，它将jdk1.2的两种方法整合在一起。不需要区分被处理的是Jcomponent还是Text类型的组件。它定义了两个新的类：InputMap和ActionMap.他们均是简单的表或映射。一个InputMap将一个Keystroke对应到一个对象，ActionMap将一个对象对应到一个行为(Action)。通常InputMap中KeyStroke所对应的对象是一个字符串，通过这个字符串可以在ActionMap中查找到相应的行为。

InputMap和ActionMap中均有put方法。InputMap的put方法可以将Keystroke对应到一个对象，而ActionMap的put方法可以将一个对象对应到一个行为。

在每一个Jcomponent组件中，会有三个缺省的InputMap和一个缺省的ActionMap.他们可以通过调用getInputMap(int condition)和getActionMap()得到。三个InputMap分别是当组件本身拥有焦点时的InputMap(WHEN_FOCUSED)，当组件的祖先拥有焦点时的InputMap(WHEN_ANCESTOR_OF_FOCUSED_COMPONENT)和组件所在的窗体具有焦点时的InputMap(WHEN_IN_FOCUSED_WINDOW)(括号内表示为了得到这些InputMap,应该在getInputMap中设置的参数)。以下分别说明这三种In]]></description>
		<author><![CDATA[java学习]]></author>
		<pubDate>2013-04-27 10:02:00</pubDate>
		</item>
				<item>
		<title><![CDATA[详解C语言的”endl“函数实现]]></title>
		<link>http://blog.pfan.cn/javaxx/54193.html</link>
		<description><![CDATA[在学习编程的过程中，我觉得不止要获得课本的知识，更多的是解决问题的方法，面对新问题该怎么解决，这样我们才能走在最前方，我是达内的学员，感谢你对本博客的支持；
首先，endl是一个操作符（Manipulators），但我们必须知道endl是一个什么类型的变量。endl是跟在”&lt;&lt;“运算符后面，故endl应该是一个参数。其实endl是一个函数名，它是一个"&lt;&lt;"运算符重载函数中的参数，参数类型为函数指针。下面我们看下内部函数实现。

1 ostream&amp; ostream::operator &lt;&lt; ( ostream&amp; (*op) (ostream&amp;)) 2 { 3     // call the function passed as parameter with this stream   as the argument

4      return (*op) (*this); 5 }

1 std::ostream&amp; std::endl (std::ostream&amp; strm) 2 { 3     // write newline

4     strm.put('\n'); 5     // flush the output buffer

6     strm.flush(); 7     // return strm to allow chaining

8     return strm; 9 }

可以看出，运算符重载函数中的函数参数为一个函数指针，其指向一个输入输出均为ostream类引用的函数。而endl正是这样一个函数。所以我们在运行"cout&lt;&lt;endl;"语句时，endl是一个函数参数，类型为函数指针。然后会执行”return (*endl) (*this);“语句，即执行endl函数。endl函数输出一个换行符，并刷新输出缓冲区。

这样我们知道在标准库中endl是作为一个函数实现的，显然我们也可以直接调用这一函数。我们看下面的测试程序：

1 #include&lt;iostream&gt;

2 using namespace std; 3

4 int main() 5 { 6     cout&lt;&l]]></description>
		<author><![CDATA[java学习]]></author>
		<pubDate>2013-04-26 14:51:00</pubDate>
		</item>
				<item>
		<title><![CDATA[程序中的图像复制到非java应用程序实现]]></title>
		<link>http://blog.pfan.cn/javaxx/54190.html</link>
		<description><![CDATA[在学习编程的过程中，我觉得不止要获得课本的知识，更多的是解决问题的方法，面对新问题该怎么解决，这样我们才能走在最前方，我是达内的学员，感谢你对本博客的支持；
Java开发图形应用程序的朋友一定遇到过如何在程序中实现复制图像的功能。在jdk1.4以前，java本身就支持将程序中文字串复制给其它的非java应用程序使用，而将程序中的图像复制到非java应用程序简直难上加难。只到jdk1.4出来，这个问题才得以解决。

一般我们开发java application界面，主要用swing图形包。几乎所有的swing控件都是由JComponent继承而来的。如果我们要取得JComponent的图像，可以用以下方式：

Rectangle rect = comp.getBounds();

BufferedImage bufImage = new BufferedImage(rect.width,

rect.height,

BufferedImage.TYPE_INT_RGB);

Graphics g = bufImage.getGraphics();

g.translate(-rect.x, -rect.y);

comp.paint(g);

这样的话，图像就保存到BufferedImage对象当中了。

现在来看如何将这个BufferedImage复制到系统clipboard中。要做复制功能，一般是继承TransferHandler类，实现Transferable接口，　这样你的复制内容才能传到系统clipboard,为此我们来写一个ImageSelection类:

/**

*

Copyright: Copyright (c) 2002

* @author Turbo Chen

* @version 1.00

*/

import java.awt.*;

import java.awt.image.*;

import java.awt.datatransfer.*;

import javax.swing.*;

public class ImageSelection extends TransferHandler

implements Transferab]]></description>
		<author><![CDATA[java学习]]></author>
		<pubDate>2013-04-23 13:49:00</pubDate>
		</item>
				<item>
		<title><![CDATA[C++的真实趋势越倾向于精英化的两个关键缺陷]]></title>
		<link>http://blog.pfan.cn/javaxx/54187.html</link>
		<description><![CDATA[首先，感谢你的阅读，本人观点：学习编程是个漫长的过程并不是一时就会很厉害的，关键是坚持，快乐地学习，在这里分享我的一些笔记给你；
C++是一门引起无数争议的语言。

眼下最常听到的声音则是C++将趋于没落，会被某某语言取代。

我很怀疑这种论调的起点是商业宣传，C++的真实趋势应该是越来越倾向于精英化。

精英化是指在可用可不用C++的领域中，C++将逐渐退出，

而所有剩下必须用C++的领域通常都是附加值比较高，难度较高的领域，比如：操作系统，数据库，大型网站后端等。

这一过程造成的现象就是在TIOBE上，C++的份额逐步下降。

但就像经济上挤泡沫一样，这倒不是C++衰落了，而是原本人们对C++的期望过高了。

早在1995年，美国的调查机构就曾经预测：“终端用户”编程从从业人员比率上将占94%，而“基础结构”编程从业人员只占1.5%不到。

(参见《软件成本估算：COCOMOII模型方法》)

C++本来就不适合“终端用户”这种涉众很多的项目，比如物流程序，而适合对性能要求较高的基础结构项目，比如OS，大型数据库等。

(根据Google的测试，C++的performance远高于其他语言)

只是当年OO很火的时候，大家又没有什么别的选择，就一窝蜂的用，实际上很多程序确实不适合用一个没有垃圾收集的程序来写。

这里有一份统计列表，大家可以自己看看，当前C++的主战场是那里。

The Programming Languages Beacon(这个表告诉我们：IT行业的骨头是C/C++做的)

这导致的结果就是修炼C++的程序员必须往高端走，你要么找不到工作，要么就找到很好的工作。

而不像其他语言，大差不差还能混口饭吃。

这个趋势不好绝对化，但估计在未来会被强化。TIOBE上C++的份额跌得越多，这个趋势强化的越厉害。

短时间完全看不到C++退出历史舞台的可能性，只要硬件还是软件的基础：

例1：网站A和网站B类似，用C++可以让速度提升30%，你感觉这个网站会选择语言的易用性，还是会选择速度?

例2：公司A要开发一个新的软硬结合的产品，你感觉他会先开发一个虚拟机，再开发产品，还是会直接基于硬件上封装驱动后开发程序?

两个关键缺陷

这两个关键缺陷分别是语言的过度]]></description>
		<author><![CDATA[java学习]]></author>
		<pubDate>2013-04-18 16:15:00</pubDate>
		</item>
				<item>
		<title><![CDATA[整理C++调试常用到的四个窍门笔记]]></title>
		<link>http://blog.pfan.cn/javaxx/54176.html</link>
		<description><![CDATA[首先，感谢你的阅读，本人观点：学习编程是个漫长的过程并不是一时就会很厉害的，关键是坚持，快乐地学习，在这里分享我的一些笔记给你；
一、C++编程-调试标记

适用预处理#define定义一个或多个调试标记，在代码中把调试部分使用#ifdef和#endif进行管理。当程序最终调试完成后，只需要使用#undef标记，调试代码就会消失。常用的调试标记为DEBUG, 语句序列：

1. #define DEBUG

2. #ifdef DEBUG

3. 调试代码

4. #endif

二、C++编程-运行期间调试标记

在程序运行期间打开和关闭调试标记。通过设置一个调试bool标记可以实现。这对命令行运行的程序更为方便。例如下面代码：

1. #include

2. #include

3. using namespace std;

4. bool debug =false;

5. int main(int argc,char*argv[])

6. {

7. for(int i=0;i

三、C++编程-把变量和表达式转换成字符串

可是使用字符串运算符来实现转换输出定义

1. #define PR(x） cout&lt;&lt;#x”=”&lt;

四、C++编程-C语言的assert()

该宏在中，，当使用assert时候，给他个参数，即一个判读为真的表达式。预处理器产生测试该断言的代码，如果断言不为真，则发出一个错误信息告诉断言是什么以及它失败一会，程序会终止。

1. #include&lt; assert&gt;

2. using namsapce std;

3. int main()

4. {

5. int i=100;

6. assert(i!=100);

7. //Fails

8. }

9. 当调试完毕后在#include前

10. 加入#define NDEBUG即可消除红产生的代码

11. }
从基础的学习到后面应用提高都非常的系统，无论你是本专业的还是跨专业的，都能有所收获，参加4个月的达内时光转眼已逝，伴随着喜悦，达内给你一个新的平台，一个崭新的开始。
（本文由广州达内为你分享；）]]></description>
		<author><![CDATA[java学习]]></author>
		<pubDate>2013-04-15 10:02:00</pubDate>
		</item>
				<item>
		<title><![CDATA[谈谈IOS开发测试软件兼容性]]></title>
		<link>http://blog.pfan.cn/javaxx/54171.html</link>
		<description><![CDATA[首先，感谢你的阅读，本人观点：学习编程是个漫长的过程并不是一时就会很厉害的，关键是坚持，快乐地学习，在这里分享我的一些笔记给你；
知道你之前有没有想象过，iOS 开发者在创造或者更新应用程序的时候，是怎样测试这个程序对于不同 iOS 版本的兼容性的，除了 iOS 系统，许多 iOS 开发者还会将程序推广到其他平台例如 WP7 或者 Android，那么需要测试的就更多了。下图就是开发者 David Smith 的测试设备，没错，一堆设备：四个 iPad，四个 iPod touch，四个 iPhone，用来测试不同种类 iOS 系统的兼容性，此外还有 Windows Phone 和 Kindle 等等。

这样 David 就可以从 iOS 3.1 一直测试到 iOS 5 了。其中 iOS 3.X 系统在测试的时候是相当有帮助的，因为 iOS 3.X 本质上是不可能复制出问题的。

很显然 David 是一个非常谨慎的开发者，而并不是所有开发者都像 David 一样。老设备和老系统慢慢会被淘汰掉，支持的程序越来越少这些都无可避免，相信许多使用老设备的朋友都深有体会。

这里要补充一点的是，苹果对 Mac 开发者有特别的待遇，开发者可以通过预约，在美国加州总部测试 Mac 与软件的兼容性，如果开发者离加州比较远，那么这个选择可不是什么明智之举。
从基础的学习到后面应用提高都非常的系统，无论你是本专业的还是跨专业的，都能有所收获，参加4个月的达内时光转眼已逝，伴随着喜悦，广州达内给你一个新的平台，一个崭新的开始。
（本文由广州达内为你分享；）]]></description>
		<author><![CDATA[java学习]]></author>
		<pubDate>2013-04-12 10:28:00</pubDate>
		</item>
				<item>
		<title><![CDATA[列举JAVA开发中需要注意的事项，你都知道吗？]]></title>
		<link>http://blog.pfan.cn/javaxx/54170.html</link>
		<description><![CDATA[首先，感谢你的阅读，本人观点：学习编程是个漫长的过程并不是一时就会很厉害的，关键是坚持，快乐地学习，在这里分享我的一些笔记给你；

java的类型自动提升规则

1、所有byte，short，char型的值将被提升到int型;

2、如果一个操作数为long型，计算结果就是long型;

3、如果一个操作数是float型，计算结果就是float型;

4、如果一个操作数是double型，计算结果就是double型。

我们不能把任何方法体内的变量声明为静态，例如下面这样是不行的

fun{

static int i = 0;

}

1、在静态的方法里只能直接调用同类中其他静态成员(包括变量和方法)，而不能直接访问类中的非静态成员，这是因为，对于非静态成员，先要创建类的实例对象后才可使用，而静态成员在使用前是不需要实例化的;

2、静态方法不能以任何形式引用this或super关键字;

3、main()方法是静态的，因此jvm在执行main方法时，不创建main方法所在的类的实例对象，因此在main方法中，不能直接访问该类中的非静态成员。

1.final标记的类不能被继承;

2.其标记的方法不能被子类重写;

3.其标记的变量即变成常量，只能赋值一次，但这个常量也只能在这个类内部使用，不能在类的外部使用，且赋值只能在声明的时候显式赋值或在构造方法中赋值，构造方法里不含返回值的概念是不同于“void”的，对于"public void example()"这样的写法就不再是构造方法了，而变成了普通方法，很多人都会犯这种错，在定义构造方法时加了void，结果这个方法就不再自动调用了。

1.java只支持单继承，不允许单继承，但一个类可以被多个类继承;

2.可以有多重继承，即一个类可以继承某个类的的子类，如B继承了A，C又可以继承B，那么C也间接继承了A;

3.子类继承父类所有的成员变量和成员方法，但不继承父类的的构造方法，在子类的构造方法中，可以使用语句super调用父类的构造方法;

4.如果子类的构造方法中没有显式地调用父类构造方法，也没有使用this关键字调用重 载的其他构造方法，则在产生子类的实例对象时，系统默认调用父类无参数的构造方法，如果父类没有无参数的构造方法，则编译出]]></description>
		<author><![CDATA[java学习]]></author>
		<pubDate>2013-04-12 10:16:00</pubDate>
		</item>
				<item>
		<title><![CDATA[在阐述Java程序员应当学习BlazeDS的几条理由]]></title>
		<link>http://blog.pfan.cn/javaxx/54169.html</link>
		<description><![CDATA[首先，感谢你的阅读，本人观点：学习编程是个漫长的过程并不是一时就会很厉害的，关键是坚持，快乐地学习，在这里分享我的一些笔记给你；
在阐述Java程序员应当学习BlazeDS的几条理由时，我以一个假想的苏打分派系统来展示如何让已有的Java程序转变为RIA应用。通过这个例子，我同时还会讲解到BlazeDS在已有Java应用或新建Java应用中的多种不同用法。

开源

Flex软件开发工具箱(SDK)的核心是个开源框架，专门用来开发、维护那些在不同浏览器、不同操作系统下界面都相同的RIA应用。Flex发布采用的是Mozilla公共许可证(MozillaPublicLicense)。编译后的Flex应用在AdobeFlash平台下运行。

BlazeDS是连接Flex和Java的索桥，是项针对远程调用和消息传递的开源技术。在Java应用服务器上，它以servlet的形式存在，因此可以在任何标准Java网络应用中运用它。BlazeDS以LGPL(LesserGNUPublicLicense)公共许可证书发布。在发布BlazeDS的同时，Adobe还公布了AMF(ActionScriptMessageFormat)规格说明，BlazeDS、Java和Flex客户端间以这种简洁的二进制格式实现通信。

完善的社区支持

Flex社区非常活跃，社区贡献了大量项目。Flex.org，这个配以社区新闻的Adobe站点几乎每天都有新的社区贡献;Yahoo!上的Flex用户组的成员也已经超过了11000。

再比如GoogleCode上的Flexlib项目，已经提交了大量的开源UI组件。Swiz和Mate项目贡献了优化事件处理的框架;还有GorillaLogic贡献了自动化UI测试的FlexMonkeym项目。

带来广阔的就业前景

据Adobe的Flex“传道士”——JamesWard看来，Flex高级开发员的市场需求非常大，学习Flex能让你拥有极具市场竞争力的开发技能。

更高的业务效益回报

总体上，开发企业web应用不是个轻松的活，这基本上是众所周知的事实。Flex和BlazeDS提供的不仅仅是功能强大的开发工具，而且开发技术本身相对也非常简单。开发效率可以得到大幅度的提升，产品因此可以很快推向市场。Flex和Flash带来的用户体]]></description>
		<author><![CDATA[java学习]]></author>
		<pubDate>2013-04-11 13:57:00</pubDate>
		</item>
		</channel>
</rss>