Java code

String encoding = "gb2312";
char c[] = {'u4f60'};
CharToByteConverter converter = CharToByteConverter.getConverter(encoding);
byte b[] = converter.convertAll(c);
for (int i = 0; i < b.length; i++) {
System.out.println(Integer.toHexString(b[i]));
}

Java code

String encoding = "gb2312";
char c[] = {'u4f60'};
CharToByteConverter converter = CharToByteConverter.getDefault();
byte b[] = converter.convertAll(c);
for (int i = 0; i < b.length; i++) {
System.out.println(Integer.toHexString(b[i]));
}

Java code

String encoding = "gb2312";
InputStreamReader reader = new InputStreamReader(new FileInputStream(
"text.txt"), encoding);
char c[] = new char[10];
int length = reader.read(c);
for (int i = 0; i < length; i++) {
System.out.println(c[i]);
}

XML code

<web-app>
<filter>
<filter-name>RequestFilter</filter-name>
<filter-class>net.golden.uirs.util.RequestFilter</filter-class>
<init-param>
<param-name>charset</param-name>
<param-value>gb2312</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>RequestFilter</filter-name>
<url-pattern>*.jsp</url-pattern>
</filter-mapping>
</web-app>

Java code

public void doFilter(ServletRequest req, ServletResponse res,
FilterChain fChain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
HttpSession session = request.getSession();
String userId = (String) session.getAttribute("userid");
req.setCharacterEncoding(this.filterConfig.getInitParameter("charset")); // 设置字符集？实际上是设置了byte ??〉char的encoding
    try {
if (userId == null || userId.equals("")) {
if (!request.getRequestURL().toString().matches(
".*/uirs/logon/logon(Controller){0,1}x2Ejsp$")) {
session.invalidate();
response.sendRedirect(request.getContextPath() +
"/uirs/logon/logon.jsp");
}
}
else { // 看看是否具有信息上报系统的权限
        if (!net.golden.uirs.util.UirsChecker.check(userId, "信息上报系统",
net.golden.uirs.util.UirsChecker.ACTION_DO)) {
if (!request.getRequestURL().toString().matches(
".*/uirs/logon/logon(Controller){0,1}x2Ejsp$")) {
response.sendRedirect(request.getContextPath() +
"/uirs/logon/logonController.jsp");
}
}
}
}
catch (Exception ex) {
response.sendRedirect(request.getContextPath() +
"/uirs/logon/logon.jsp");
}
fChain.doFilter(req, res);
}

目前网络上关于对象序列化的文章不少，但是我发现详细叙述用法和原理的文章太少。本人把自己经过经验总结和实际运用中的体会写成的学习笔记贡献给大家。希望能为整个java社区的繁荣做一点事情。

      序列化的过程就是对象写入字节流和从字节流中读取对象。将对象状态转换成字节流之后，可以用java.io包中的各种字节流类将其保存到文件中，管道到另 一线程中或通过网络连接将对象数据发送到另一主机。对象序列化功能非常简单、强大，在RMI、Socket、JMS、EJB都有应用。对象序列化问题在网 络编程中并不是最激动人心的课题，但却相当重要，具有许多实用意义。

一：对象序列化可以实现分布式对象。
      主要应用例如：RMI要利用对象序列化运行远程主机上的服务，就像在本地机上运行对象时一样。

二： java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。可以将整个对象层次写入字节流中，可以保存在文件中或在网络连接上传 递。利用对象序列化可以进行对象的“深复制”，即复制对象本身及引用的对象本身。序列化一个对象可能得到整个对象序列。

   从上面的叙述中，我们知道了对象序列化是java编程中的必备武器，那么让我们从基础开始，好好学习一下它的机制和用法。

     java 序列化比较简单，通常不需要编写保存和恢复对象状态的定制代码。实现java.io.Serializable接口的类对象可以转换成字节流或从字节流恢 复，不需要在类中增加任何代码。只有极少数情况下才需要定制代码保存或恢复对象状态。这里要注意：不是每个类都可序列化，有些类是不能序列化的，例如涉及 线程的类与特定JVM有非常复杂的关系。
序列化机制：

     序列化分为两大部分：序列化和反序列化。 序列化是这个过程的第一部分，将数据分解成字节流，以便存储在文件中或在网络上传输。反序列化就是打开字节流并重构对象。对象序列化不仅要将基本数据类型 转换成字节表示，有时还要恢复数据。恢复数据要求有恢复数据的对象实例。ObjectOutputStream中的序列化过程与字节流连接，包括对象类型 和版本信息。反序列化时，JVM用头信息生成对象实例，然后将对象字节流中的数据复制到对象数据成员中。下面我们分两大部分来阐述：

处理对象流：
（序列化过程和反序列化过程）

   java.io包有两个序列化对象的类。ObjectOutputStream负责将对象写入字节流，ObjectInputStream从字节流重构对象。
     我们先了解ObjectOutputStream类吧。ObjectOutputStream类扩展DataOutput接口。
writeObject ()方法是最重要的方法，用于对象序列化。如果对象包含其他对象的引用，则writeObject()方法递归序列化这些对象。每个 ObjectOutputStream维护序列化的对象引用表，防止发送同一对象的多个拷贝。（这点很重要）由于writeObject()可以序列化整 组交叉引用的对象，因此同一ObjectOutputStream实例可能不小心被请求序列化同一对象。这时，进行反引用序列化，而不是再次写入对象字节 流。

下面，让我们从例子中来了解ObjectOutputStream这个类吧。
1. // 序列化 today's date 到一个文件中.
2.      FileOutputStream f = new FileOutputStream("tmp");
3.      ObjectOutputStream s = new ObjectOutputStream(f);
4.      s.writeObject("Today");
5.      s.writeObject(new Date());
6.      s.flush();

    现在，让我们来了解ObjectInputStream这个类。它与 ObjectOutputStream相似。它扩展DataInput接口。ObjectInputStream中的方法镜像 DataInputStream中读取Java基本数据类型的公开方法。readObject()方法从字节流中反序列化对象。每次调用 readObject()方法都返回流中下一个Object。对象字节流并不传输类的字节码，而是包括类名及其签名。readObject()收到对象 时，JVM装入头中指定的类。如果找不到这个类，则readObject()抛出ClassNotFoundException,如果需要传输对象数据和 字节码，则可以用RMI框架。ObjectInputStream的其余方法用于定制反序列化过程。

例子如下：
1. //从文件中反序列化 string 对象和 date 对象
2.      FileInputStream in = new FileInputStream("tmp");
3.      ObjectInputStream s = new ObjectInputStream(in);
4.      String today = (String)s.readObject();
5.      Date date = (Date)s.readObject();

定制序列化过程:

       序列化通常可以自动完成，但有时可能要对这个过程进行控制。java可以将类声明为serializable，但仍可手工控制声明为static或transient的数据成员。
例子：一个非常简单的序列化类。
1. public class simpleSerializableClass implements Serializable{
2.      String sToday="Today:";
3.      transient Date dtToday=new Date();
4. }

       序列化时，类的所有数据成员应可序列化除了声明为transient或static的成员。将变量声明为 transient告诉JVM我们会负责将变元序列化。将数据成员声明为transient后，序列化过程就无法将其加进对象字节流中，没有从 transient数据成员发送的数据。后面数据反序列化时，要重建数据成员（因为它是类定义的一部分），但不包含任何数据，因为这个数据成员不向流中写 入任何数据。记住，对象流不序列化static或transient。我们的类要用writeObject()与readObject()方法以处理这些 数据成员。使用writeObject()与readObject()方法时，还要注意按写入的顺序读取这些数据成员。

关于如何使用定制序列化的部分代码如下：

1. //重写writeObject()方法以便处理transient的成员。
2. public void writeObject(ObjectOutputStream outputStream) throws IOException{
3.      outputStream.defaultWriteObject();//使定制的writeObject()方法可以
4.                          利用自动序列化中内置的逻辑。
5.      outputStream.writeObject(oSocket.getInetAddress());
6.      outputStream.writeInt(oSocket.getPort());
7. }
8. //重写readObject()方法以便接收transient的成员。
9. private void readObject(ObjectInputStream inputStream) throws IOException,ClassNotFoundException{
10.      inputStream.defaultReadObject();//defaultReadObject()补充自动序列化
11.      InetAddress oAddress=(InetAddress)inputStream.readObject();
12.      int iPort =inputStream.readInt();
13.      oSocket = new Socket(oAddress,iPort);
14.      iID=getID();
15.      dtToday =new Date();
16. }

完全定制序列化过程:

       如果一个类要完全负责自己的序列化，则实现 Externalizable接口而不是Serializable接口。Externalizable接口定义包括两个方法writeExternal ()与readExternal()。利用这些方法可以控制对象数据成员如何写入字节流.类实现Externalizable时，头写入对象流中，然后类 完全负责序列化和恢复数据成员，除了头以外，根本没有自动序列化。这里要注意了。声明类实现Externalizable接口会有重大的安全风险。 writeExternal()与readExternal()方法声明为public，恶意类可以用这些方法读取和写入对象数据。如果对象包含敏感信 息，则要格外小心。这包括使用安全套接或加密整个字节流。到此为至，我们学习了序列化的基础部分知识.

}
用 serialPersistentFields 为某个类定义可序列化域后，即无需再将可序列化域限制在当前 Serializable 类的定义之内。利用第 1.7 节，"访问类的可序列化域" 中描述的接口，Serializable 类的 writeObject 和 readObject 方法可将该类的当前实现映射到其可序列化域。因此，后续版本中可以改变 Serializable 类的域，但前提是保持与版本兼容的 Serializable 域的映射。

1.6 对类的可序列化域和数据存档
对类的可序列化状态进行存档以使其与 Serializable 类的其它实现间可互操作，或者对类演变进行存档，这些都非常必要。对可序列化域进行存档可帮助用户最终确定该域是否应序列化。 序列化 javadoc 标记 @serial、@serialField 和 @serialData 可提供对源代码中 Serializable 类的序列化形式进行存档的方法。

对于缺省的可序列化域，@serial 标记应放在 javadoc 注释中。语法如下：@serial field-description 其中可选项 field-description 描述域及其容许值的含义。 field-description 可跨多行。当初始版本中增加一个域时，@since 标记指出所添域的版本。@serial 的 field-description 提供针对序列化的文档。在序列化形式文档内，field-description 将被添加到 javadoc 注释中。
@serialField 标记用于对 serialPersistentFields 数组的 ObjectStreamField 组件进行存档。每个 ObjectStreamField 组件都应使用其中的一个标记。语法如下：@serialField field-name field-type field-description
@serialData 标记描述写入或读取数据的次序和类型。该标记描述 writeObject 所写入的可选数据或 Externalizable.writeExternal 方法所写入的所有数据的次序或类型。语法如下：@serialData data-description
javadoc 应用程序识别序列化 javadoc 标记并为每个 Serializable 和 Externalizable 类生成说明文字。有关这些标记用法的示例，参见第 C.1 节 "java.io.File 可替代实现的示例。"

当某个类被声明为 Serializable 时，即通过可序列化域及可选数据（按名称和类型）定义了该对象的可序列化状态。可选数据只能用 Serializable 类中的 writeObject 方法显式写入，而其读取则可通过 Serializable 类和 readObject 方法进行。否则，序列化将跳过无法读取的可选数据。

当一个类被声明为 Externalizable 时，通过类自身写入流的数据即定义了该类的序列化状态。 该类必须指定顺序、类型及写入流的每个数据的含义。同时还必须处理其自身的演变，从而可读取以前版本所写入的数据，或写入以前版本所能读取的数据。在存储和恢复数据时，该类必须与父类相一致。必须指定流中父类数据的位置。

类的设计者必须确保为类存储的信息对于持久性是合适的，而且遵循为实现序列化的互操作性和演变而指定的序列化规则。第 5 章“可序列化对象的版本演变”对类的演变进行了更详细的说明。

1.10 Serializable 接口
Serialization 对象生成流，其中提供有关所存对象的 JavaTM 类的信息。对于可序列化对象，即使存在该类的不同（但兼容）版本的实现，也要保持足够的信息以恢复这些对象。定义 Serializable 接口可以标识实现可序列化协议的类：

package java.io;

public interface Serializable {};

Serializable 类必须具备如下功能：

实现 java.io.Serializable 接口
标识应序列化的域
(使用 serialPersistentFields 成员以显式声明其可序列化，或者使用瞬态关键字来指示非序列域。)
可访问其第一个非序列化父类的无参数构造函数。
该类可根据需要定义如下方法：

writeObject 方法，用于控制要保存哪些信息或将附加信息添加到流中
readObject 方法，用于读取由相应 writeObject 方法写入的信息，或在对象恢复后更新其状态
writeReplace 方法，用于允许类指定写入流的替换对象
readResolve 方法，用于允许类为刚从流中读取的对象指定替换对象
ObjectOutputStream 和 ObjectInputStream 支持所操作的可序列化类的演变（允许类发生改变以兼容早期版本的类）。有关实现兼容变化的机制的信息，参见第 5.5 节“兼容的 JavaTM 类型演变”。
--------------------------------------------------------------------------
class ObjectYouWannaSave implements Serializable{
   int x; int y;
   SubObject so = new SubObject();
   ..........
}

class SubObject implements Serializable{
   String s = "abc"; //String is OK, because String is java.io.Serializable
}

public class Save{ // in Save.java
   public void main(String[] args) {
      ObjectYouWannaSave original = new ObjectYouWannaSave();
      original.x = -1; original.y = 100; .....
     
      ObjectOutputStream out = null;
      try{
        out = new ObjectOutputStream(new FileOutputStream(new File("c:/save.dat")));
        out.writeObject(original);
      }catch(Exceptione){
      }finally{
        try{out.close();}catch(Exception e){}
      }
   }
}

public class Read{ // in Read.java
   public void main(String[] args) {
      ObjectInputStream in = null;
      try{
        out = new ObjectInStream(new FileInStream(new File("c:/save.dat")));
        ObjectYouWannaSave o = (ObjectYouWannaSave)in.readObject();
        System.out.println("x="+o.x);
        System.out.println("subobject.string=" + o.so.s);
        ........
      }catch(Exceptione){
      }finally{
        try{in.close();}catch(Exception e){}
      }
   }
}

这是个最简单的例子，先运行Save,以后什么时候运行Read都可以（只要c:\save.dat文件还存在就可以了）
--------------------------------------------------
对象的寿命通常随着生成该对象的程序终止而终止，有时候，可能需要将对象的状态保存下来，在需要的时候
再将对象恢复，我们把对象的这种记录自己状态的以便将来再生的能力，叫做对象的持续性（PERSISTENCE），
对象通过写出描述自己状态的数值来记录自己，这个过程叫对象的串行化Serializable。串行化的主要任务是写
出对象实例变量的值。如果变量是另一个对象的引用，则引用的对象也要串行化，这是个递归过程。
--------------------------------------------------------------------
java.io.Serializable interface是一个较为特殊的接口：
The serialization interface has no methods or fields and serves
only to identify the semantics of being serializable
即：它主要是一个用于通知JVM的标志

class X implements java.io.Serializable{...}

如果你要定制你自己的serializable行为，你应该在X中实现以下2个方法：
 private void writeObject(java.io.ObjectOutputStream out)
     throws IOException
 private void readObject(java.io.ObjectInputStream in)
     throws IOException, ClassNotFoundException;

否则将按缺省的策略进行。

由于上述2个方法是private的，所以在某些情况下，可以使用
java.io.Serializable的子接口java.io.Externalizable，
在这个interface中有2个public方法：

public void writeExternal(ObjectOutput out)
                   throws IOException

public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException

----------------------------------------------------------------------------
Serializable是一个串行化接口，它没有任何的属性和方法，一个类实现了串行化接口，就表明
该类具有持久性，通过WriteObjcet可将其持久保存在磁盘，在需要时，可用ReadObject从磁盘中读出，次时，对象的状态和存入似的相同。上面给出的列子比较简单，可通过串行化保存一个
链表对象，它的每个节点数据也会被保存。 当然，串行化接口还有其他用途，例如HTTP隧道等
。
-----------------------------------------------------------------------
对象序列化的持续性要和永久对象分别开。序列化只能达到有线持续性
在同一个jvm上可以重构对象的内容，达到持续性
---------------------------------------------------------------------
java序列化主要是用于两个方面：
一个是java的RMI（远程方法调用－Remote method invocation），你可以使用别人机器上的对象就像在你自己的机器上使用它一样（通过序列化），另外，在使用javabean时也需要使用序列化，序列化主要就是使用在这两方面。
-------------------------------------------------------------
所谓序列化就是把把对象以一个代码串的形式表示出来，
这样可以保存到磁盘或则通过网络传输，接受方可以在把代码串恢复成对象
具体的串形化方法可以自己写，接收放就可以根据您串形的规则把对象恢复出来
--------------------------------------------------------------------
序列化是把一个对象的状态写入一个字节流的过程，它执行RMI，RMI允许一台机器上的JAVA对象调用不同机器上的JAVA对象方法，对象可以作为参数提供给那个远程方法，发送机序列化该对象并传送它，接收机执行反序列化。
序列化和反序列化的关系图表可形成包含循环引用的顺序图表。这是整个序列化的总体思想。
而Serializable接口属于支持序列化的一个接口，只有一个实现它的对象可以被序列化工具存储和回复，Serializable接口没有定义任何成员，只用来表示一个累可以被序列化，若该类可以序列化，那么它的所有子类都可以。
下面是关于序列化的一个实例：
[b:a55efb5f91]程序名称：SerializationDemo.java
程序主题：实现对象的序列化和反序列化
程序说明：该程序由实例化一个MyClass类的对象开始，该对象有三个实例变量，类型分别为String、int、double，是希望存储和恢复的信息。[/b:a55efb5f91]

[code:1:a55efb5f91]

import java.io.*;

public class SerializationDemo{
        public static void main(String args[]){

//Object serialization
try{
MyClass object1=new MyClass("Hello",-7,2.7e10);
System.out.println("object1:"+object1);
FileOutputStream fos=new FileOutputStream("serial");
ObjectOutputStream oos=new ObjectOutputStream(fos);
oos.writeObject(object1);
oos.flush();
oos.close();
}
catch(Exception e){
System.out.println("Exception during serialization:"+e);
System.exit(0);
}

//Object deserialization
try{
MyClass object2;
FileInputStream fis=new FileInputStream("serial");
ObjectInputStream ois=new ObjectInputStream(fis);
object2=(MyClass)ois.readObject();
ois.close();
System.out.println("object2:"+object2);
}
catch(Exception e){
System.out.println("Exception during deserialization:"+e);
System.exit(0);
}
}
}

class MyClass implements Serializable{
String s;
int i;
double d;
public MyClass(String s,int i,double d){
this.s=s;
this.i=i;
this.d=d;
}
public String toString(){
return "s="+s+";i="+i+";d="+d;
}
}
[/code:1:a55efb5f91]

程序运行结果：object1和object2的实例变量是一样的，输出如下：[code:1:a55efb5f91]object1:s=Hello;i=-7;d=2.7E10
object2:s=Hello;i=-7;d=2.7E10[/code:1:a55efb5f91]
--------------------------------------------------------------------------------
Object serialization的定义：
Object serialization 允许你将实现了Serializable接口的对象转换为字节序列，这些字节序列可以被完全存储以备以后重新生成原来的对象。 

serialization不但可以在本机做，而且可以经由网络操作（就是猫小说的RMI）。这个好处是很大的----因为它自动屏蔽了操作系统的差异，字节顺序（用Unix下的c开发过网络编程的人应该知道这个概念，我就容易在这上面犯错）等。比如，在Window平台生成一个对象并序列化之，然后通过网络传到一台Unix机器上，然后可以在这台Unix机器上正确地重构这个对象。

Object serialization主要用来支持2种主要的特性：
1。Java的RMI(remote method invocation).RMI允许象在本机上一样操作远程机器上的对象。当发送消息给远程对象时，就需要用到serializaiton机制来发送参数和接收返回直。

2。Java的JavaBeans.   Bean的状态信息通常是在设计时配置的。Bean的状态信息必须被存起来，以便当程序运行时能恢复这些状态信息。这也需要serializaiton机制。

二。持久化
持久化应该是英文里的persistence.但是Java语言里现在只支持lightweight persistence,就是轻量级持久化，这是通过serialization机制来实现的。

persistence是指一个对象的生命周期不由程序是否执行来决定，即使是在程序终止时这个对象也存在。它把一个serializable的对象写到磁盘（本机或其他机器上的非RAM存储器），并在程序重新调用时再读取对象到通常的RAM存储器。

为什么说Java的serialization机制实现的是lightweight persistence?因为你必须显式的序列化和反序列化程序里的对象；而不是直接由一个关键词来定义一个对象是序列化的然后由系统做相应的处理。  如果以后的Java版本出现一个新的关键字来实现这种机制，比如就是persistence,如果我用

persistence  (String s="chinaunix")

然后系统自动做上面程序里的那些处理，那么Java就实现了persistence.

构造方法必须满足以下条件：

l. 方法名必须与类名称完全相匹配；

2. 不要声明返回类型；

3. 不能被static、final、synchronized、abstract、native修饰。

下列代码中的构造方法都是合法的。

public class Xyz {

public Xyz() { // No-arg constructor

// set up the object.

}

public Xyz(int x) { //int-arg constructor

// set up the object using the parameter x.

}

}

5.2.2 重载构造方法

如果有一个类带有几个构造方法，那么也许会想复制其中一个构造方法的某些操作到另一个构造方法中。可以通过使用关键字this作为一个方法调用来达到这个目的。不能通过方法名直接调用构造方法。

public class Employee {

private String name;

private int salary;

public Employee(String n, int s) {

name = n;

salary = s;

}

public Employee(String n) {

this(n, 0);

}

public Employee() {

this( " Unknown " );

}

}

在第二个构造方法中，有一个字符串参数，调用this(n,0)将控制权传递到构造方法的另一个版本，即采用了一个String参数和一个int参数的构造方法。

在第三个构造方法中，它没有参数，调用this("Unknownn")将控制权传递到构造方法的另一个版本，即采用了一个String参数的构造方法。

对于this的任何调用，如果出现在任何构造方法中，必须作为第一个语句。

5.2.3 缺省构造方法

缺省构造方法是没有参数的构造方法，你可以显式定义类的缺省构造方法。

为了保证每个类至少有一个构造方法，如果定义的类中一个构造方法也没有写，Java将自动提供一个缺省构造方法。该构造方法没有参数，用public 修饰，而且方法体为空。格式如下：

public ClassName(){}

只要类中显式定义了一个或多个构造方法，而且所有显式定义的构造方法都带参数，那么将失去缺省构造方法。

举例如下：

public class Sample1{}

public class Sample2

{

public Sample2(int a){System.out.println("My Constructor");}

}

public class Sample3

{

public Sample3(){System.out.println("My Default Constructor");}

}

可以调用Sample1的缺省构造方法来创建Sample1对象。

Sample1 s=new Sample1();

Sample2类的缺省构造方法失效，因此以下的创建Sample2对象的方法编译会出错。

Sample2 s=new Sample2();

正确的创建方法是：

Sample2 s=new Sample2(0);

Sample3类定义了自己的缺省构造方法，因此以下语句是合法的。

Sample3 s=new Sample3();

5.2.4 子类调用父类的构造方法

父类的构造方法不能被子类继承。子类不能直接通过方法名调用父类的一个构造方法，而是要通过super关键字调用父类的一个构造方法，super语句必须位于子类构造方法的第一行。

例如：

/**

* Son.java

*/

class GrandPa

{

protected GrandPa()

{

System.out.println("default GrandPa");

}

public GrandPa(String name)

{

System.out.println(name);

}

}

class Father extends GrandPa

{

protected Father()

{

System.out.println("default Father");

}

public Father(String grandPaName,String fatherName)

{

super(grandPaName);

System.out.println(fatherName);

}

}

public class Son extends Father

{

public Son()

{

System.out.println("default Son");

}

public Son(String grandPaName,String fatherName,String sonName)

{

super(grandPaName,fatherName);

System.out.println(sonName);

}

public static void main(String args[])

{

Son s1=new Son();

Son s2= new Son("My GrandPa", "My Father", "My Son");

}

}

执行语句：

Son s2=new Son("My GrandPa", "My Father", "My Son");

将会输出如下结果：

My GrandPa

My Father

My Son

当子类的某个构造方法没有调用父类的一个构造方法，通过这个构造方法创建子类对象时，会自动先调用父类的缺省构造方法。对于多级继承，执行缺省构造方法的顺序是从最上层的类开始。

对于以上的代码执行语句Son s1=new Son();

将会输出如下结果：

default GrandPa

default Father

default Son

当子类的某个构造方法没有调用父类的一个构造方法，而父类又没有提供缺省构造方法时，将会出现编译错误。

例如：修改一下Son.java文件。去掉GrandPa类中显式定义的缺省构造方法：

protected GrandPa()

{

System.out.println("default GrandPa");

}

这样，GrandPa类中就失去了缺省构造方法，这时，在编译Father类的缺省构造方法时，因为找不到GrandPa类的缺省构造方法而出错。

子类的某个构造方法没有通过super语句调用父类的构造方法，而是通过this语句调用了另一个构造方法，而在另一个构造方法中通过super语句调用了父类的构造方法，这种情况下，父类的缺省构造方法不会被调用。

例如：

class A

{

A(int i){}

}

class B extends A

{

B(){this(0);}

B(int i){super(i);}

}

对于new B()语句将依次执行如下方法：

1：A(int) 2：B(int) 3：B()

5.2.5 构造方法的作用域

构造方法只能被所在类的其他构造方法或子类的构造方法调用，或在用new语句创建类的实例时被调用。引用类型的变量不能访问对象的构造方法。

对于以下代码，请读者自己分析某些语句编译出错的原因。

class Base

{

public Base(int i,int j){}

public Base(int i){

this(i,0); //CORRECT

Base(i,0); //ERROR

}

}

class Sub extends Base

{

public Sub(int i,int j)

{

super(i,0); //CORRECT

}

void method1(int i,int j)

{

this(i,j); //ERROR

Sub(i,j); //ERROR

}

void method2(int i,int j)

{

super(i,j); //ERROR

}

void method3(int i,int j)

{

Base s＝new Base(0,0); //CORRECT

s.Base(0,0); //ERROR

}

}

5.2.6 构造方法不能被继承

构造方法可以被子类的构造方法调用，但不能被子类继承。

例如：

class A

{

A(int i){};

A(){}

}

class B extends A{}

class C extends B

{

C(){

super.super(0); //COMPILE ERROR

A(0); //COMPILE ERROR

}

}

由于类B并没有继承类A的构造方法A(int i)，所以在构造方法C()中调用类A的构造方法是非法的。

5.2.7 考察要点

l 识别合法的构造方法；

2 构造方法可以被重载，一个构造方法可以通过this关键字调用另一个构造方法，this语句必须位于构造方法的第一行；

3 当一个类中没有定义任何构造方法，Java将自动提供一个缺省构造方法；

4 子类通过super关键字调用父类的一个构造方法；

5 当子类的某个构造方法没有通过super关键字调用父类的构造方法，通过这个构造方法创建子类对象时，会自动先调用父类的缺省构造方法

6 构造方法不能被static、final、synchronized、abstract、native修饰，但可以被public、private、protected修饰；

7 构造方法不是类的成员方法；

8 构造方法不能被继承。

5.2.8 试题解析

1．Which line contains a constructor in this class definition?

public class Counter { // (a)

int current, step;

public Counter(int startValue, int stepValue) { // (b)

set(startValue);

setStepValue(stepValue);

}

public int get() { return current; } // (c)

public void set(int value) { current = value; } // (d)

public void setStepValue(int stepValue) { step = stepValue; } // (e)

}

a) Code marked with (a) is a constructor

b) Code marked with (b) is a constructor

c) Code marked with (c) is a constructor

d) Code marked with (d) is a constructor

e) Code marked with (e) is a Constructor

答案：b

解析：类的构造方法必须遵循以下规则：方法名和类同名，无返回值。一个方法同时满足这两个条件，Java编译器就会将其当作类的构造方法。一个方法如果只满足其中的一个条件，将会编译出错，被认为是不合法的方法声明。

2．Which of the following can be applied to constructors:

a) final

b) static

c) synchronized

d) native

e) None of these.

答案：e

解析：构造方法不能被子类继承，所以用final修饰没有意义。构造方法用于创建一个新的对象，不能作为类的静态方法，所以用static修饰没有意义。此外，Java语言不支持native或synchronized的构造方法。

3．What will happen when you attempt to compile and run the following code .

public class Hope{

public static void main(String argv[]){

Hope h = new Hope();

}

protected Hope(){

for(int i =0; i <10; i ++){

System.out.println(i);

}

}

}

a) Compilation error: Constructors cannot be declared protected

b) Run time error: Constructors cannot be declared protected

c) Compilation and running with output 0 to 10

d) Compilation and running with output 0 to 9

答案：d

解析：构造方法可以被public、protected、private修饰。

4．What will happen if you try to compile and execute B´s main() method?

class A {

int i;

A(int i) {

this.i = i * 2;

}

}

class B extends A {

public static void main(String[] args) {

B b = new B(2);

}

B(int i) {

System.out.println(i);

}

}

Select the one right answer.

a) The instance variable i is set to 4

b) The instance variable i is set to 2

c) The instance variable i is set to 0

d) This code will not compile

答案：d

解析：由于类B的构造方法B(int i)中没有调用父类的构造方法，而父类中又没有缺省构造方法，导致编译错误。

5．What happens when you try to compile and run the following program?

class Mystery {

String s;

public static void main(String[] args) {

Mystery m = new Mystery();

m.go();

}

void Mystery() {

s = "constructor";

}

void go() {

System.out.println(s);

}

}

Select the one right answer.

a) this code will not compile

b) this code compiles but throws an exception at runtime

c) this code runs but nothing appears in the standard output

d) this code runs and "constructor" in the standard output

e) this code runs and writes "null" in the standard output

答案：e

解析：这道题中故意设置了一个陷阱，定义了一个貌似构造方法的Mystery()方法。由于它被声明了返回类型，所以其实不是构造方法。new Mystery()语句其实调用的是类Mystery的缺省构造方法。

6．Yes or No?

Statement1) If you create a non-default derived constructor and don´t call the base class constructor ，the compiler will call the default base class constructor automatically. (Assume that the default constructor is defined for the base class).

Statement2) What about if it is not defined?

Statement3) What about the case of a default derived constructor, does the compiler

call the default base class constructor

a) Yes ,No,Yes

b) Yes,No,No

答案：a

解析：子类的构造方法中如果没有调用父类的构造方法，程序运行时会自动先调用父类的缺省构造方法（包括自动提供的缺省构造方法或显式定义的缺省构造方法）。如果父类没有缺省构造方法，将会编译出错。

7．Given the following code how could you invoke the Base constructor that will print out the string "base constructor";

class Base{

Base(int i){

System.out.println("base constructor");

}

Base(){

}

}

public class Sup extends Base{

public static void main(String argv[]){

Sup s= new Sup();

//One

}

Sup()

{

//Two

}

public void derived()

{

//Three

}

}

a) On the line After //One put Base(10);

b) On the line After //One put super(10);

c) On the line After //Two put super(10);

d) On the line After //Three put super(10);

答案：c

解析：构造方法只能被所在类的其他构造方法或子类的构造方法调用。所以在//one、//three处调用构造方法都是非法的。

8．True or False.

The Class class has no public constructor.

a) True

b) False

答案：a

解析：Class类没有公共构造方法，所以Class类的对象不能在程序中通过构造方法创建。当Java虚拟机装载某个类（假如类名是ClassSample）的时候，会自动调用JVM的类装载器的defineClass()方法，这个方法会创建和某个类ClassSample相关的Class类的对象。Object类有个方法getClass()，它返回一个Class类的对象。所以，所有的Java对象都可以通过方法getClass()获得它的Class类的对象。例如：

ClassSample s＝new ClassSample();

System.out.println(s.getClass().getName());

将会打印ClassSample。

9．Which statements concerning the following code are true?

class A {

public A() {}

public A(int i) { this(); }

}

class B extends A {

public boolean B(String msg) { return false; }

}

class C extends B {

private C() { super(); }

public C(String msg) { this(); }

public C(int i) {}

}

a) The code will fail to compile.

b) The constructor in A that takes an int as an argument will never be called as a result of constructing an object of class B or C.

c) Class C has three constructors.

d) Objects of class B cannot be constructed.

e) At most one of the constructors of each class is called as a result of constructing an object of class C.

答案：b，c

解析：在类B中定义的方法B()有返回值，所以它不是构造方法。类B只有一个缺省构造方法，所以创建类B或类C的对象时，会先调用类B的缺省构造方法，而类B的缺省构造方法会先调用类C的缺省构造方法，类A的构造方法A(int i)永远不会被调用。选项e是不正确的，new C("hello")语句将调用类C的两个构造方法C()和C(String msg)。

10．Which of the following code fragments are legal?

a) class MusicWork {

MusicWork(String s) {

System.out.println("The name of this work is" + s);

}

}

class ClassicalWork extends MusicWork {

ClassicalWork(String s, String composer) {

System.out.println("The composer is " + composer);

}

}

b) class MusicWork {

MusicWork(String s) {

System.out.println("The name of this work is" + s);

}

}

class ClassicalWork extends MusicWork {

ClassicalWork(String s, String composer) {

super(s);

System.out.println("The composer is " + composer);

}

}

c) class MusicWork {

MusicWork(String s) {

System.out.println("The name of this work is" + s);

}

}

class ClassicalWork extends MusicWork {

ClassicalWork(String s, String composer) {

System.out.println("This is a work of classical music");

System.out.println("The composer is " + composer);

super(s);

}

}

d) class MusicWork {

MusicWork() {

System.out.println("This is a work of music");

}

MusicWork(String name) {

this();

System.out.println("The name of this work is" + name);

}

}

e) class MusicWork {

MusicWork() {

System.out.println("This is a work of music");

}

MusicWork(String name) {

this();

System.out.println("The name of this work is" + name);

}

MusicWork(String composer) {

this();

System.out.println("The composer of this work is" + composer);

}

}

f) class MusicWork {

MusicWork() {

System.out.println("This is a work of music");

}

MusicWork(String name) {

System.out.println("The name of this work is" + name);

this();

}

}

答案：b，d

解析：选项a中必须为父类提供缺省构造方法。选项c中没有把super语句放在构造方法的第一行。选项e中有两个Music(String)构造方法，不合法。选项f中没有把this语句放在构造方法的第一行。

11．Given the following class definition which of the following can be legally placed after the comment line//Here ?

class Base{

public Base(int i){}

}

public class MyOver extends Base{

public static void main(String arg[]){

MyOver m = new MyOver(10);

}

MyOver(int i){

super(i);

}

MyOver(String s, int i){

this(i);

//Here

}

}

a) MyOver m = new MyOver();

b) super();

c) this("Hello",10);

d) Base b = new Base(10);

答案：d

解析：类MyOver没有缺省构造方法，所以选项a不正确。

从上一节可以看出，在多数情况下，初始化一个对象的最终步骤是去调用这个对象的构造方法。构造方法负责对象的初始化工作，为实例变量赋予合适的初始值。构造方法必须满足以下语法规则：
(1) 方法名必须与类名相同。
(2)不要声明返回类型。
(3)不能被static、final、synchronized、abstract和native修饰。构造方法不能被子类继承，所以用final和

abstract修饰没有意义。构造方法用于初始化一个新建的对象，所以用static修饰没有意义。多个线程不会同时创建内存地址相同的同一个对象，因此用synchronized修饰没有必要。此外，Java语言不支持native类型的构造方法。
在以下Sample类中，具有int返回类型的Sample(int x)方法只是个普通的实例方法，不能作为构造方法：
public class Sample {
private int x;
public Sample() { // 不带参数的构造方法
this(1);
}
public Sample(int x) { //带参数的构造方法
this.x=x;
}
public int Sample(int x) { //不是构造方法
return x++;
}
}

以上例子尽管能编译通过，但是把实例方法和构造方法同名，不是好的编程习惯，容易引起混淆。例如以下Mystery类的Mystery()方法有void返回类型，因此是普通的实例方法：

public class Mystery {
private String s;
public void Mystery() { //不是构造方法
s = "constructor";
}
void go() {
System.out.println(s);
}
public static void main(String[] args) {
Mystery m = new Mystery();
m.go();
}
}

以上程序的打印结果为null。因为用new语句创建Mystery实例时，调用的是Mystery类的默认构造方法，而不是以上有void返回类型的Mystery()方法。关于默认构造方法的概念，参见本章第11.2.2节（默认构造方法）。

11.2.1 重载构造方法

当通过new语句创建一个对象时，在不同的条件下，对象可能会有不同的初始化行为。例如对于公司新进来的一个雇员，在一开始的时候，有可能他的姓名和年龄是未知的，也有可能仅仅他的姓名是已知的，也有可能姓名和年龄都是已知的。如果姓名是未知的，就暂且把姓名设为"无名氏"，如果年龄是未知的，就暂且把年龄设为-1。
可通过重载构造方法来表达对象的多种初始化行为。以下例程11-2的Employee类的构造方法有三种重载形式。在一个类的多个构造方法中，可能会出现一些重复操作。为了提高代码的可重用性，Java语言允许在一个构造方法中，用this语句来调用另一个构造方法。

例程11-2 Employee.java
public class Employee {
private String name;
private int age;

/** 当雇员的姓名和年龄都已知，就调用此构造方法 */
public Employee(String name, int age) {
this.name = name;
this.age=age;
}

/** 当雇员的姓名已知而年龄未知，就调用此构造方法 */
public Employee(String name) {
this(name, -1);
}

/** 当雇员的姓名和年龄都未知，就调用此构造方法 */
public Employee() {
this( "无名氏" );
}
public void setName(String name){this.name=name; }
public String getName(){return name; }
public void setAge(int age){this.age=age;}
public int getAge(){return age;}
}

以下程序分别通过三个构造方法创建了三个Employee对象：

Employee zhangsan=new Employee("张三",25);
Employee lisi=new Employee("李四");
Employee someone=new Employee();

在Employee(String name)构造方法中，this(name,-1)语句用于调用Employee(String name,int age)构造方法。在Employee()构造方法中，this("无名氏")语句用于调用Employee(String name)构造方法。
用this语句来调用其他构造方法时，必须遵守以下语法规则：

（1）假如在一个构造方法中使用了this语句，那么它必须作为构造方法的第一条语句（不考虑注释语句）。以下构造方法是非法的：
public Employee(){
String name="无名氏";
this(name); //编译错误，this语句必须作为第一条语句
}
（2）只能在一个构造方法中用this语句来调用类的其他构造方法，而不能在实例方法中用this语句来调用类的其他构造方法。
（3）只能用this语句来调用其他构造方法，而不能通过方法名来直接调用构造方法。以下对构造方法的调用方式是非法的：
public Employee() {
String name= "无名氏";
Employee(name); //编译错误，不能通过方法名来直接调用构造方法
}

11.2.2 默认构造方法

默认构造方法是没有参数的构造方法，可分为两种：（1）隐含的默认构造方法（2）程序显式定义的默认构造方法。
在Java语言中，每个类至少有一个构造方法。为了保证这一点，如果用户定义的类中没有提供任何构造方法，那么Java语言将自动提供一个隐含的默认构造方法。该构造方法没有参数，用public 修饰，而且方法体为空，格式如下：

public ClassName(){} //隐含的默认构造方法

在程序中也可以显式的定义默认构造方法，它可以是任意的访问级别。例如：

protected Employee() { //程序显式定义的默认构造方法
this("无名氏");
}

如果类中显式定义了一个或多个构造方法，并且所有的构造方法都带参数，那么这个类就失去了默认构造方法。在以下程序中，Sample1类有一个隐含的默认构造方法，Sample2类没有默认构造方法，Sample3类有一个显式定义的默认构造方法：

public class Sample1{}
public class Sample2{
public Sample2(int a){System.out.println("My Constructor");}
}

public class Sample3{
public Sample3(){System.out.println("My Default Constructor");}
}

可以调用Sample1类的默认构造方法来创建Sample1对象：

Sample1 s=new Sample1(); //合法
Sample2类没有默认构造方法，因此以下语句会导致编译错误：
Sample2 s=new Sample2(); //编译出错
Sample3类显式定义了默认构造方法，因此以下语句是合法的。
Sample3 s=new Sample3();

11.2.3 子类调用父类的构造方法

父类的构造方法不能被子类继承。以下MyException类继承了java.lang.Exception类：

public class MyException extends Exception{} // MyException类只有一个隐含的默认构造方法

尽管在Exception类中定义了如下形式的构造方法：

public Exception(String msg)

但MyException类不会继承以上Exception类的构造方法，因此以下代码是不合法的：

//编译出错，MyException类不存在这样的构造方法
Exception e=new MyException("Something is error");

在子类的构造方法中，可以通过super语句调用父类的构造方法。例如：
public class MyException extends Exception{
public MyException(){
//调用Exception父类的Exception(String msg)构造方法
super("Something is error");
}

public MyException(String msg){
//调用Exception父类的Exception(String msg)构造方法
super(msg);
}
}
用super语句来调用父类的构造方法时，必须遵守以下语法规则。
（1）在子类的构造方法中，不能直接通过父类方法名调用父类的构造方法，而是要使用super语句，以下代码是非法的：
public MyException(String msg){
Exception(msg); //编译错误
}
（2）假如在子类的构造方法中有super语句，它必须作为构造方法的第一条语句，以下代码是非法的：

public MyException(){
String msg= "Something wrong";
super(msg); //编译错误，super语句必须作为构造方法的第一条语句
}

在创建子类的对象时，Java虚拟机首先执行父类的构造方法，然后再执行子类的构造方法。在多级继承的情况下，将从继承树的最上层的父类开始，依次执行各个类的构造方法，这可以保证子类对象从所有直接或间接父类中继承的实例变量都被正确的初始化。例如以下Base父类和Sub子类分别有一个实例变量 a和b，当构造Sub实例时，这两个实例变量都会被初始化。

public class Base{
private int a;
public Base(int a){ this.a=a;}
public int getA(){return a;}
}
public class Sub extends Base{
private int b;
public Base(int a,int b){super(a); this.b=b;}
public int getB(){return b;}

public static void main(String args[]){
Sub sub=new Sub(1,2);
System.out.println("a="+sub.getA()+" b="+sub.getB()); //打印a=1 b=2
}
}
在以下例程11-3（Son.java）中，Son类继承Father类，Father类继承Grandpa类。这三个类都显式定义了默认的构造方法，此外还定义了一个带参数的构造方法。

例程11-3 Son.java
class Grandpa{
protected Grandpa(){
System.out.println("default Grandpa");
}
public Grandpa(String name){
System.out.println(name);
}
}

class Father extends Grandpa{
protected Father(){
System.out.println("default Father");
}

public Father(String grandpaName,String fatherName){
super(grandpaName);
System.out.println(fatherName);
}
}

public class Son extends Father{
public Son(){
System.out.println("default Son");
}

public Son(String grandpaName,String fatherName,String sonName){
super(grandpaName,fatherName);
System.out.println(sonName);
}

public static void main(String args[]){
Son s1= new Son("My Grandpa", "My Father", "My Son"); //①
Son s2=new Son(); //②
}
}
执行以上main()方法的第①条语句，打印结果如下：
My Grandpa
My Father
My Son

此时构造方法的执行顺序如图11-1所示。

图11-1 调用Son类的带参数的构造方法时所有构造方法的执行顺序

当子类的构造方法没有用super语句显式调用父类的构造方法，那么通过这个构造方法创建子类对象时，Java虚拟机会自动先调用父类的默认构造方法。执行以上Son类的main()方法的第②条语句，打印结果如下：
default Grandpa
default Father
default Son

此时构造方法的执行顺序如图11-2所示。

图11-2 调用Son类的默认构造方法时所有构造方法的执行顺序

当子类的构造方法没有用super语句显式调用父类的构造方法，而父类又没有提供默认构造方法时，将会出现编译错误。例如把例程11-3做适当修改，删除Grandpa类中显式定义的默认构造方法：

// protected Grandpa(){
// System.out.println("default GrandPa");
// }

这样，Grandpa类就失去了默认构造方法，这时，在编译Father类的默认构造方法时，因为找不到Grandpa类的默认构造方法而编译出错。如果把Grandpa类的默认构造方法的protected访问级别改为private访问级别，也会导致编译错误，因为Father类的默认构造方法无法访问Grandpa类的私有默认构造方法。
在以下例子中，子类Sub的默认构造方法没有通过super语句调用父类的构造方法，而是通过this语句调用了自身的另一个构造方法Sub(int i)，而在Sub(int i)中通过super语句调用了父类Base的Base(int i)构造方法。这样，无论通过Sub类的哪个构造方法来创建Sub实例，都会先调用父类Base的Base(int i)构造方法。

class Base{
Base(int i){System.out.println("call Base(int i)");}
}
public class Sub extends Base{
Sub(){this(0); System.out.println("call Sub()");}

Sub(int i){super(i); System.out.println("call Sub(int i)");}
public static void main(String args[]){
Sub sub=new Sub();
}
}
执行以上Sub类的main()方法的new Sub()语句，打印结果如下：
call Base(int i)
call Sub(int i)
call Sub()
此时构造方法的执行顺序如图11-3所示。

图11-3 调用Sub类的默认构造方法时所有构造方法的执行顺序
在下面的例子中，Base类中没有定义任何构造方法，它实际上有一个隐含的默认构造方法：
Base(){}
Sub类的Sub(int i)构造方法没有用super语句显式调用父类的构造方法，因此当创建Sub实例时，会先调用Base父类的隐含默认构造方法。
class Base{} //具有隐含默认构造方法
public class Sub extends Base{
Sub(int i){System.out.println(i);}
public static void main(String args[]){
System.out.println(new Sub(1)); //打印1
}
}
11.2.4 构造方法的作用域
构造方法只能通过以下方式被调用：
(1) 当前类的其他构造方法通过this语句调用它。
(2) 当前类的子类的构造方法通过super语句调用它。
(3)在程序中通过new语句调用它。
对于例程11-4（Sub.java）的代码，请读者自己分析某些语句编译出错的原因。

例程11-4 Sub.java
class Base{
public Base(int i,int j){}
public Base(int i){
this(i,0); //合法
Base(i,0); //编译出错
}
}

class Sub extends Base{
public Sub(int i,int j){
super(i,0); //合法
}

void method1(int i,int j){
this(i,j); //编译出错
Sub(i,j); //编译出错
}
void method2(int i,int j){
super(i,j); //编译出错
}
void method3(int i,int j){
Base s=new Base(0,0); //合法
s.Base(0,0); //编译出错
}
}

11.2.5 构造方法的访问级别
构造方法可以处于public、protected、默认和private这四种访问级别之一。本节着重介绍构造方法处于private级别的意义。
当构造方法为private级别，意味着只能在当前类中访问它：在当前类的其他构造方法中可以通过this语句调用它，此外还可以在当前类的成员方法中通过new语句调用它。
在以下场合之一，可以把类的所有构造方法都声明为private类型。
（1）在这个类中仅仅包含了一些供其他程序调用的静态方法，没有任何实例方法。其他程序无需创建该类的实例，就能访问类的静态方法。例如 java.lang.Math类就符合这种情况，在Math类中提供了一系列用于数学运算的公共静态方法，为了禁止外部程序创建Math类的实例， Math类的惟一的构造方法是private类型的：

private Math(){}

在第7章的7.2节（abstract修饰符）提到过，abstract类型的类也不允许实例化。也许你会问，把Math类定义为如下abstract类型，不是也能禁止Math类被实例化吗？

public abstract class Math{…}

如果一个类是抽象类，意味着它是专门用于被继承的类，可以拥有子类，而且可以创建具体子类的实例。而JDK并不希望用户创建Math类的子类，在这种情况下，把类的构造方法定义为private类型更合适。

（2）禁止这个类被继承。当一个类的所有构造方法都是private类型，假如定义了它的子类，那么子类的构造方法无法调用父类的任何构造方法，因此会导致编译错误。在第7章的7.3.1节（final类）提到过，把一个类声明为final类型，也能禁止这个类被继承。这两者的区别是：
1)如果一个类允许其他程序用new语句构造它的实例，但不允许拥有子类，那就把类声明为final类型。
2)如果一个类既不允许其他程序用new语句构造它的实例，又不允许拥有子类，那就把类的所有构造方法声明为private类型。

由于大多数类都允许其他程序用new语句构造它的实例，因此用final修饰符来禁止类被继承的做法更常见。

（3）这个类需要把构造自身实例的细节封装起来，不允许其他程序通过new语句创建这个类的实例，这个类向其他程序提供了获得自身实例的静态方法，这种方法称为静态工厂方法，本章第11.3节（静态工厂方法）对此作了进一步的介绍。