import java.io.FileInputStream;

import sun.audio.AudioPlayer;
import sun.audio.AudioStream;

public class Sound {
 public   static   void   main(String   args[])  
    {  
  try   {  
          FileInputStream   fileau=new   FileInputStream("hint.wav");  
          AudioStream   as=new   AudioStream(fileau);  
          AudioPlayer.player.start(as);  
            }  
        catch   (Exception   e)   {}  
      }  
}

三种配置环境变量的方法

1. 修改/etc/profile文件
如果你的计算机仅仅作为开发使用时推荐使用这种方法，因为所有用户的shell都有权使用这些环境变量，可能会给系统带来安全性问题。
·用文本编辑器打开/etc/profile
·在profile文件末尾加入：
export JAVA_HOME=/usr/share/jdk1.6.0_14
export PATH=$JAVA_HOME/bin:$PATH
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

·重新登录
·注解
a. 你要将 /usr/share/jdk1.6.0_14改为你的jdk安装目录
b. linux下用冒号“:”来分隔路径
c. $PATH / $CLASSPATH / $JAVA_HOME 是用来引用原来的环境变量的值
在设置环境变量时特别要注意不能把原来的值给覆盖掉了，这是一种
常见的错误。
d. CLASSPATH中当前目录“.”不能丢,把当前目录丢掉也是常见的错误。
e. export是把这三个变量导出为全局变量。
f. 大小写必须严格区分。

2. 修改.bash_profile文件

这种方法更为安全，它可以把使用这些环境变量的权限控制到用户级别，如果你需要给某个用户权限使用这些环境变量，你只需要修改其个人用户主目录下的.bash_profile文件就可以了。
·用文本编辑器打开用户目录下的.bash_profile文件
·在.bash_profile文件末尾加入：

export JAVA_HOME=/usr/share/jdk1.6.0_14
export PATH=$JAVA_HOME/bin:$PATH
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

·重新登录

3. 直接在shell下设置变量
不赞成使用这种方法，因为换个shell，你的设置就无效了，因此这种方法仅仅是临时使用，以后要使用的时候又要重新设置，比较麻烦。
只需在shell终端执行下列命令：
export JAVA_HOME=/usr/share/jdk1.6.0_14
export PATH=$JAVA_HOME/bin:$PATH
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

package serializable;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

public class ObjectToIO

{

    /**

     *

     * 对象转Byte数组

     *

     * @param obj

     *

     * @return

     *

     * @throws Exception

     *

     */

    public static byte[] objectToBytes(Object obj) throws Exception

    {

        // logger.debug("objectToString called ");

        ByteArrayOutputStream out = new ByteArrayOutputStream();

        ObjectOutputStream sOut = new ObjectOutputStream(out);

        sOut.writeObject(obj);

        sOut.flush();

        byte[] bytes = out.toByteArray();

        // logger.debug(bytes.toString());

        return bytes;

    }

    /**

     *

     * 字节数组转对象

     * @param content

     *

     * @return

     *

     * @throws Exception

     *

     */

    public static Object bytesToObject(byte[] bytes) throws Exception

    {

        // logger.debug("bytesToObject called ");

        // byte转object

        ByteArrayInputStream in = new ByteArrayInputStream(bytes);

        ObjectInputStream sIn = new ObjectInputStream(in);

        return sIn.readObject();

    }

}

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.IOException;
import java.util.Properties;
import javax.servlet.ServletContext;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * This class deals with maintaining options, including the e-mail account.
 *
 * @author <a href="mailto:fzammetti@omnytex.com">Frank W. Zammetti</a>.
 */
public class OptionsManager {

  /**
   * Log instance.
   */
  private static Log log = LogFactory.getLog(OptionsManager.class);

  /**
   * File name of the options file.
   */
  private static final String optionsFilename = "options.properties";

  /**
   * This method retrieves the options and returns them.  If no
   * optionsFilename file is found, a 'blank' DTO is returned.
   *
   * @param  sc ServletContext associates with the request.
   * @return    An OptionsDTO containing all the stored options.
   */
  public OptionsDTO retrieveOptions(ServletContext sc) {

    // Instantiate an OptionsDTO, and by default assume it will be configured.
    // This means the application has already been configured for use.  This
    // affects what the user can do when the app is accessed initially.
    OptionsDTO options = new OptionsDTO();
    options.setConfigured(true);

    // Read in the options.
    InputStream isFeedFile =
      sc.getResourceAsStream("/WEB-INF/" + optionsFilename);
    Properties props = new Properties();
    try {
      if (isFeedFile == null) {
        throw new IOException(optionsFilename + " not found");
      }
      props.load(isFeedFile);
      isFeedFile.close();
    } catch (IOException e) {
      log.info("No " + optionsFilename + " file, a blank DTO will " +
        "be returned.");
      // Make sure the OptionsDTO is set as unconfigured so that when the
      // index.jsp page is loaded, all the user will be allowed to do is go to
      // the Options views.
      options.setConfigured(false);
      props.setProperty("pop3Server", "");
      props.setProperty("pop3ServerRequiresLogin", "false");
      props.setProperty("pop3Username", "");
      props.setProperty("pop3Password", "");
      props.setProperty("smtpServer", "");
      props.setProperty("smtpServerRequiresLogin", "false");
      props.setProperty("smtpUsername", "");
      props.setProperty("smtpPassword", "");
      props.setProperty("fromAddress", "");
    }

    // Populate OptionsDTO from options Properties.
    options.setPop3Server(props.getProperty("pop3Server"));
    options.setPop3ServerRequiresLogin(
      props.getProperty("pop3ServerRequiresLogin"));
    options.setPop3Username(props.getProperty("pop3Username"));
    options.setPop3Password(props.getProperty("pop3Password"));
    options.setSmtpServer(props.getProperty("smtpServer"));
    options.setSmtpServerRequiresLogin(
      props.getProperty("smtpServerRequiresLogin"));
    options.setSmtpUsername(props.getProperty("smtpUsername"));
    options.setSmtpPassword(props.getProperty("smtpPassword"));
    options.setFromAddress(props.getProperty("fromAddress"));

    return options;

  } // End retrieveOptions().

  /**
   * This method saves the options.
   *
   * @param  pop3Server              The POP3 server address.
   * @param  pop3ServerRequiresLogin Does the POP3 server require login?
   * @param  pop3Username            The POP3 username.
   * @param  pop3Password            The POP3 password.
   * @param  smtpServer              The SMTP server address.
   * @param  smtpServerRequiresLogin Does the SMTP server require login?
   * @param  smtpUsername            The SMTP username.
   * @param  smtpPassword            The SMTP password.
   * @param  fromAddress             From address for outgoing messages.
   * @param  sc                      ServletContext associated with the request.
   * @return                         A message saying the save was OK.
   */
  public String saveOptions(String pop3Server, String pop3ServerRequiresLogin,
    String pop3Username, String pop3Password, String smtpServer,
    String smtpServerRequiresLogin, String smtpUsername,
    String smtpPassword, String fromAddress, ServletContext sc) {

      // Log what we received.
      log.info("\nSaving options:\n" +
      "pop3Server = " + pop3Server + "\n" +
        "pop3ServerRequiresLogin = " + pop3ServerRequiresLogin + "\n" +
        "pop3Username = " + pop3Username + "\n" +
        "pop3Password = " + pop3Password + "\n" +
        "smtpServer = " + smtpServer + "\n" +
        "smtpServerRequiresLogin = " + smtpServerRequiresLogin + "\n" +
        "smtpUsername = " + smtpUsername + "\n" +
        "smtpPassword = " + smtpPassword + "\n" +
        "fromAddress = " + fromAddress + "\n");

      String result = "";

      // Populate Properties structure.
      Properties props = new Properties();
      props.setProperty("pop3Server", pop3Server);
      props.setProperty("pop3ServerRequiresLogin",
        pop3ServerRequiresLogin);
      props.setProperty("pop3Username", pop3Username);
      props.setProperty("pop3Password", pop3Password);
      props.setProperty("smtpServer", smtpServer);
      props.setProperty("smtpServerRequiresLogin",
        smtpServerRequiresLogin);
      props.setProperty("smtpUsername", smtpUsername);
      props.setProperty("smtpPassword", smtpPassword);
      props.setProperty("fromAddress",  fromAddress);

      // Lastly, delete any existing optionsFilename file in WEB-INF and
      // write out a new version from the Properties object we just populated.
      // Return a message saying the operation was complete, or if any problems
      // occur, a message saying what went wrong.
      FileOutputStream fos = null;
      try {
        new File(sc.getRealPath("WEB-INF") + "/" + optionsFilename).delete();
        fos = new FileOutputStream(sc.getRealPath("WEB-INF") +
          "/" + optionsFilename);
        props.store(fos, null);
        fos.flush();
        result = "Options have been saved.";
      } catch (IOException e) {
        log.error("Error saving contact:");
        e.printStackTrace();
        result = "Options could not be saved.  " +
          "Please review logs for details.";
      } finally {
        try {
          if (fos != null) {
            fos.close();
          }
        } catch (IOException e) {
          log.error("Error closing fos: " + e);
        }
      }

      return result;

  } // End saveOptions().

} // End class.

轉自：http://blog.csdn.net/huxin1/archive/2008/12/31/3669583.aspx

Java代码

1. public class UserManagerImpl implements UserManager {   
2.     private UserDao userDao;   
3.     public void setUserDao(UserDao userDao) {   
4.         this.userDao = userDao;   
5.     }   
6.     ...   
7. }  

public class UserManagerImpl implements UserManager {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
...
}

<bean id="userManagerImpl" class="com.kedacom.spring.annotation.service.UserManagerImpl">
<property name="userDao" ref="userDao" />
</bean>
<bean id="userDao" class="com.kedacom.spring.annotation.persistence.UserDaoImpl">
<property name="sessionFactory" ref="mySessionFactory" />
</bean>

Java代码

1. public class UserManagerImpl implements UserManager {   
2.     @Autowired  
3.     private UserDao userDao;   
4.     ...   
5. }  

public class UserManagerImpl implements UserManager {
@Autowired
private UserDao userDao;
...
}

Java代码

1. public class UserManagerImpl implements UserManager {   
2.     private UserDao userDao;   
3.     @Autowired  
4.     public void setUserDao(UserDao userDao) {   
5.         this.userDao = userDao;   
6.     }   
7.     ...   
8. }  

public class UserManagerImpl implements UserManager {
private UserDao userDao;
@Autowired
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
...
}

Java代码

1. <bean id="userManagerImpl" class="com.kedacom.spring.annotation.service.UserManagerImpl" />   
2. <bean id="userDao" class="com.kedacom.spring.annotation.persistence.UserDaoImpl">   
3.     <property name="sessionFactory" ref="mySessionFactory" />   
4. </bean>  

<bean id="userManagerImpl" class="com.kedacom.spring.annotation.service.UserManagerImpl" />
<bean id="userDao" class="com.kedacom.spring.annotation.persistence.UserDaoImpl">
<property name="sessionFactory" ref="mySessionFactory" />
</bean>

Java代码

1. <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />  

<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />

Java代码

1. @Autowired  
2. public void setUserDao(@Qualifier("userDao") UserDao userDao) {   
3.     this.userDao = userDao;   
4. }  

	@Autowired
public void setUserDao(@Qualifier("userDao") UserDao userDao) {
this.userDao = userDao;
}

Java代码

1. @Autowired(required = false)   
2. public void setUserDao(UserDao userDao) {   
3.     this.userDao = userDao;   
4. }  

	@Autowired(required = false)
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}

1. 如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常
2. 如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常
3. 如果指定了type，则从上下文中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常
4. 如果既没有指定name，又没有指定type，则自动按照byName方式进行装配（见2）；如果没有匹配，则回退为一个原始类型（UserDao）进行匹配，如果匹配则自动装配；

Java代码

1. public class UserDaoImpl extends HibernateDaoSupport implements UserDao {   
2.     private SessionFactory mySessionFacotry;   
3.     @Resource  
4.     public void setMySessionFacotry(SessionFactory sessionFacotry) {   
5.         this.mySessionFacotry = sessionFacotry;   
6.     }   
7.     @PostConstruct  
8.     public void injectSessionFactory() {   
9.         super.setSessionFactory(mySessionFacotry);   
10.     }   
11.     ...   
12. }  

public class UserDaoImpl extends HibernateDaoSupport implements UserDao {
private SessionFactory mySessionFacotry;
@Resource
public void setMySessionFacotry(SessionFactory sessionFacotry) {
this.mySessionFacotry = sessionFacotry;
}
@PostConstruct
public void injectSessionFactory() {
super.setSessionFactory(mySessionFacotry);
}
...
}

Java代码

1. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
2.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
3.     http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
4.     http://www.springframework.org/schema/context   
5.     http://www.springframework.org/schema/context/spring-context-2.5.xsd">   
6.     <context:annotation-config />   
7. </beans>  

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:annotation-config />
</beans>

Java代码

1. @Component  
2. public class UserDaoImpl extends HibernateDaoSupport implements UserDao {   
3.     ...   
4. }  

@Component
public class UserDaoImpl extends HibernateDaoSupport implements UserDao {
...
}

Java代码

1. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
2.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
3.     http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
4.     http://www.springframework.org/schema/context   
5.     http://www.springframework.org/schema/context/spring-context-2.5.xsd">   
6.     <context:component-scan base-package="com.kedacom.ksoa" />   
7. </beans>  

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:component-scan base-package="com.kedacom.ksoa" />
</beans>

• 过滤器类型 表达式范例 说明
• 注解 org.example.SomeAnnotation 将所有使用SomeAnnotation注解的类过滤出来
• 类名指定 org.example.SomeClass 过滤指定的类
• 正则表达式 com\.kedacom\.spring\.annotation\.web\..* 通过正则表达式过滤一些类
• AspectJ表达式 org.example..*Service+ 通过AspectJ表达式过滤一些类

Java代码

1. <context:component-scan base-package="com.casheen.spring.annotation">   
2.     <context:exclude-filter type="regex" expression="com\.casheen\.spring\.annotation\.web\..*" />   
3. </context:component-scan>  

	<context:component-scan base-package="com.casheen.spring.annotation">
<context:exclude-filter type="regex" expression="com\.casheen\.spring\.annotation\.web\..*" />
</context:component-scan>

Java代码

1. @Scope("session")   
2. @Component()   
3. public class UserSessionBean implements Serializable {   
4.     ...   
5. }  

@Scope("session")
@Component()
public class UserSessionBean implements Serializable {
...
}

Class类的forName方法

public static Class<?> forName(String className)
throws ClassNotFoundException

返回与带有给定字符串名的类或接口相关联的 Class 对象。调用此方法等效于：

  Class.forName(className, true, currentLoader)

其中 currentLoader 表示此类的定义类加载器。

例如，以下代码片段返回 java.lang.Thread 类的运行时 Class 描述符。

   Class t = Class.forName("java.lang.Thread")

调用 forName("X") 将导致名为 X 的类被初始化。

 

参数：

className - 所需类的完全限定名。

返回：

具有指定名的类的 Class 对象。

抛出：

LinkageError - 如果链接失败

ExceptionInInitializerError - 如果此方法所激发的初始化失败

ClassNotFoundException - 如果找不到该类

Object类的clone()方法

protected Object clone()
throws CloneNotSupportedException

创建并返回此对象的一个副本。“副本”的准确含义可能依赖于对象的类。一般来说，对于任何对象 x，如果表达式：

x.clone() != x

是正确的，则表达式：

x.clone().getClass() == x.getClass()

将为 true，但这些不是绝对条件。一般情况下是：

x.clone().equals(x)

将为 true，但这不是绝对条件。

按照惯例，返回的对象应该通过调用 super.clone 获得。如果一个类及其所有的超类（Object 除外）都遵守此约定，则 x.clone().getClass() == x.getClass()。

按照惯例，此方法返回的对象应该独立于该对象（正被克隆的对象）。要获得此独立性，在 super.clone 返回对象之前，有必要对该对象的一个或多个字段进行修改。这通常意味着要复制包含正在被克隆对象的内部“深层结构”的所有可变对象，并使用对副本的引用替换对这些对象的引用。如果一个类只包含基本字段或对不变对象的引用，那么通常不需要修改 super.clone 返回的对象中的字段。

Object 类的 clone 方法执行特定的克隆操作。首先，如果此对象的类不能实现接口 Cloneable，则会抛出 CloneNotSupportedException。注意：所有的数组都被视为实现接口 Cloneable。否则，此方法会创建此对象的类的一个新实例，并像通过分配那样，严格使用此对象相应字段的内容初始化该对象的所有字段；这些字段的内容没有被自我克隆。所以，此方法执行的是该对象的“浅表复制”，而不“深层复制”操作。

Object 类本身不实现接口 Cloneable，所以在类为 Object 的对象上调用 clone 方法将会导致在运行时抛出异常。

 

返回：

此实例的一个克隆。

抛出：

CloneNotSupportedException - 如果对象的类不支持 Cloneable 接口，则重写 clone 方法的子类也会抛出此异常，以指示无法克隆某个实例。

另请参见：

Cloneable

  UML把类之间的关系分为以下5种.
  ● 关联：类A与类B的实例之间存在特定的对应关系
  ● 依赖：类A访问类B提供的服务
  ● 聚集：类A为整体类，类B为局部类，类A的对象由类B的对象组合而成
  ● 泛化：类A继承类B
  ● 实现：类A实现了B接口
  
关联（Association）
  关联指的是类之间的特定对应关系，在UML中用带实线的箭头表示。按照类之间的数量对比，关联
可以分为以下三种：
  ● 一对一关联
  ● 一对多关联
  ● 多对多关联
注意：关联还要以分为单向关联和双向关联

依赖（Dependency）
  依赖指的是类之间的调用关系，在UML中用带虚线的箭头表示。如果类A访问类B的属性或者方法，
或者类A负责实例化类B，那么可以说类A依赖类B。和关联关系不同，无须在类A中定义类B类型的属性。

聚集（Aggregation）
  聚集指的是整体与部分之间的关系，在UML中用带实线的菱形箭头表示。
聚集关系还可以分为两种类型：
  ● 被聚集的子系统允许被拆卸和替换，这是普通聚集关系。
  ● 被聚集的子系统不允许被拆卸和替换，这种聚集称为强聚集关系，或者组成关系。
   注：强聚集（组成）可用带实线的实心菱形箭头表示。
   
泛化（Generalization）
  泛化指的是类之间的继承关系，在UML中用带实线的三角形箭头表示。
  
实现（Realization）
  实现指的是类与接口之间的关系，在UML中用带虚线的三角形箭头表示。 

同    类

同    包

子    类

不同的包