最簡單的java代碼肯定就是這個了，如下：
成都創(chuàng)新互聯(lián)是一家專注于成都做網(wǎng)站、網(wǎng)站建設(shè)與策劃設(shè)計,長島網(wǎng)站建設(shè)哪家好?成都創(chuàng)新互聯(lián)做網(wǎng)站,專注于網(wǎng)站建設(shè)10年,網(wǎng)設(shè)計領(lǐng)域的專業(yè)建站公司;建站業(yè)務(wù)涵蓋:長島等地區(qū)。長島做網(wǎng)站價格咨詢:18982081108
public class MyFirstApp
{
public static void main(String[] args)
{
System.out.print("Hello world");
}
}
“hello world”就是應(yīng)該是所有學(xué)java的新手看的第一個代碼了。如果是零基礎(chǔ)的新手朋友們可以來我們的java實驗班試聽，有免費的試聽課程幫助學(xué)習(xí)java必備基礎(chǔ)知識，有助教老師為零基礎(chǔ)的人提供個人學(xué)習(xí)方案，學(xué)習(xí)完成后有考評團進行專業(yè)測試，幫助測評學(xué)員是否適合繼續(xù)學(xué)習(xí)java，15天內(nèi)免費幫助來報名體驗實驗班的新手快速入門java，更好的學(xué)習(xí)java！
這個應(yīng)該比較簡單一點。
某系統(tǒng)日志記錄器要求支持多種日志記錄方式，如文件記錄、數(shù)據(jù)庫記錄等，且用戶可以根據(jù)要求動態(tài)選擇日志記錄方式?，F(xiàn)使用工廠方法模式設(shè)計該系統(tǒng),并寫出相應(yīng)Java代碼。
interface Log{
public void writeLog();
}
class FileLog implements Log{
public void writeLog(){
System.out.println("文件記錄");
}
}
class DatabaseLog implements Log{
public void writeLog(){
System.out.println("數(shù)據(jù)庫記錄");
}
}
interface LogFactory{
public Log createLog();
}
class FileLogFactory implements LogFactory{
public Log createLog(){
return new FileLog();
}
}
class DatabaseLogFactory implements LogFactory{
public Log createLog(){
return new DatabaseLog();
}
}
public class Client{
public static void main(String[] args) {
try{
Log log;
LogFactory factory;
//這里可以改成使用DOM和Java反射機制讀取XML文件，獲取工廠類名
factory=new DatabaseLogFactory ();
log=factory.createLog();
log.writeLog();
}
catch(Exception e){
System.out.println(e.getMessage());
}
}
}
我從我的博客里把我的文章粘貼過來吧，對于單例模式模式應(yīng)該有比較清楚的解釋：
單例模式在我們?nèi)粘５捻椖恐惺殖Ｒ?，?dāng)我們在項目中需要一個這樣的一個對象，這個對象在內(nèi)存中只能有一個實例，這時我們就需要用到單例。
一般說來，單例模式通常有以下幾種：
1.饑漢式單例
public class Singleton {
private Singleton(){};
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;
}
}
這是最簡單的單例，這種單例最常見，也很可靠！它有個唯一的缺點就是無法完成延遲加載——即當(dāng)系統(tǒng)還沒有用到此單例時，單例就會被加載到內(nèi)存中。
在這里我們可以做個這樣的測試：
將上述代碼修改為：
public class Singleton {
private Singleton(){
System.out.println("createSingleton");
};
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;
}
public static void testSingleton(){
System.out.println("CreateString");
}
}
而我們在另外一個測試類中對它進行測試（本例所有測試都通過Junit進行測試）
public class TestSingleton {
@Test
public void test(){
Singleton.testSingleton();
}
}
輸出結(jié)果：
createSingleton
CreateString
我們可以注意到，在這個單例中，即使我們沒有使用單例類，它還是被創(chuàng)建出來了，這當(dāng)然是我們所不愿意看到的，所以也就有了以下一種單例。
2.懶漢式單例
public class Singleton1 {
private Singleton1(){
System.out.println("createSingleton");
}
private static Singleton1 instance = null;
public static synchronized Singleton1 getInstance(){
return instance==null?new Singleton1():instance;
}
public static void testSingleton(){
System.out.println("CreateString");
}
}
上面的單例獲取實例時，是需要加上同步的，如果不加上同步，在多線程的環(huán)境中，當(dāng)線程1完成新建單例操作，而在完成賦值操作之前，線程2就可能判
斷instance為空，此時，線程2也將啟動新建單例的操作，那么多個就出現(xiàn)了多個實例被新建，也就違反了我們使用單例模式的初衷了。
我們在這里也通過一個測試類，對它進行測試，最后面輸出是
CreateString
可以看出，在未使用到單例類時，單例類并不會加載到內(nèi)存中，只有我們需要使用到他的時候，才會進行實例化。
這種單例解決了單例的延遲加載，但是由于引入了同步的關(guān)鍵字，因此在多線程的環(huán)境下，所需的消耗的時間要遠遠大于第一種單例。我們可以通過一段測試代碼來說明這個問題。
public class TestSingleton {
@Test
public void test(){
long beginTime1 = System.currentTimeMillis();
for(int i=0;i100000;i++){
Singleton.getInstance();
}
System.out.println("單例1花費時間："+(System.currentTimeMillis()-beginTime1));
long beginTime2 = System.currentTimeMillis();
for(int i=0;i100000;i++){
Singleton1.getInstance();
}
System.out.println("單例2花費時間："+(System.currentTimeMillis()-beginTime2));
}
}
最后輸出的是：
單例1花費時間：0
單例2花費時間：10
可以看到，使用第一種單例耗時0ms，第二種單例耗時10ms，性能上存在明顯的差異。為了使用延遲加載的功能，而導(dǎo)致單例的性能上存在明顯差異，
是不是會得不償失呢？是否可以找到一種更好的解決的辦法呢？既可以解決延遲加載，又不至于性能損耗過多，所以，也就有了第三種單例：
3.內(nèi)部類托管單例
public class Singleton2 {
private Singleton2(){}
private static class SingletonHolder{
private static Singleton2 instance=new Singleton2();
}
private static Singleton2 getInstance(){
return SingletonHolder.instance;
}
}
在這個單例中，我們通過靜態(tài)內(nèi)部類來托管單例，當(dāng)這個單例被加載時，不會初始化單例類，只有當(dāng)getInstance方法被調(diào)用的時候，才會去加載
SingletonHolder，從而才會去初始化instance。并且，單例的加載是在內(nèi)部類的加載的時候完成的，所以天生對線程友好，而且也不需要
synchnoized關(guān)鍵字，可以說是兼具了以上的兩個優(yōu)點。
4.總結(jié)
一般來說，上述的單例已經(jīng)基本可以保證在一個系統(tǒng)中只會存在一個實例了，但是，仍然可能會有其他的情況，導(dǎo)致系統(tǒng)生成多個單例，請看以下情況：
public class Singleton3 implements Serializable{
private Singleton3(){}
private static class SingletonHolder{
private static Singleton3 instance = new Singleton3();
}
public static Singleton3 getInstance(){
return SingletonHolder.instance;
}
}
通過一段代碼來測試：
@Test
public void test() throws Exception{
Singleton3 s1 = null;
Singleton3 s2 = Singleton3.getInstance();
//1.將實例串行話到文件
FileOutputStream fos = new FileOutputStream("singleton.txt");
ObjectOutputStream oos =new ObjectOutputStream(fos);
oos.writeObject(s2);
oos.flush();
oos.close();
//2.從文件中讀取出單例
FileInputStream fis = new FileInputStream("singleton.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
s1 = (Singleton3) ois.readObject();
if(s1==s2){
System.out.println("同一個實例");
}else{
System.out.println("不是同一個實例");
}
}
輸出：
不是同一個實例
可以看到當(dāng)我們把單例反序列化后，生成了多個不同的單例類，此時，我們必須在原來的代碼中加入readResolve()函數(shù)，來阻止它生成新的單例
public class Singleton3 implements Serializable{
private Singleton3(){}
private static class SingletonHolder{
private static Singleton3 instance = new Singleton3();
}
public static Singleton3 getInstance(){
return SingletonHolder.instance;
}
//阻止生成新的實例
public Object readResolve(){
return SingletonHolder.instance;
}
}
再次測試時，就可以發(fā)現(xiàn)他們生成的是同一個實例了。
重慶分公司
重慶分公司
