java靜態工廠
❶ java秘密是什麼意思
就是java隱藏的5個秘密。
1、注釋實現從JavaDevelopmentKit(JDK)5開始，注釋已成為許多Java應用程序和框架的組成部分。在絕大多數情況下，注釋將應用於語言構造，例如類，欄位，方法等，但是在另一種情況下，可以應用注釋：作為可實現的介面。
2、實例初始化，在Java中，與大多數面向對象的編程語言一樣，僅使用構造函數實例化對象(有一些關鍵的異常，例如Java對象反序列化)。即使我們創建靜態工廠方法來創建對象，我們也只是將對對象的構造函數的調用包裝起來以實例化它。
3、雙括弧初始化，許多編程語言都包含某種語法機制，可在不使用冗長的樣板代碼的情況下快速簡潔地創建列表或地圖(或字典)。例如，C++包含大括弧初始化，這使開發人員可以快速創建枚舉值列表，甚至在對象的構造函數支持此功能的情況下甚至初始化整個對象。不幸的是，在JDK9之前，還沒有包含這樣的功能(我們很快會涉及到此功能)。
4、可執行注釋注釋幾乎是每個程序的基本組成部分，注釋的主要好處是它們不被執行。
5、枚舉介面實現與Java中的類相比，枚舉(枚舉)的局限性之一是枚舉不能擴展另一個類或枚舉。
❷ java中的Array和Arrays兩個類什麼區別Collection和Collections什麼區別
這個啊
Array類主要提供了動態創建和訪問 Java 數組的方法。
Arrays包含用來操作數組（比如排序和搜索）的各種方法。此類還包含一個允許將數組作為列表來查看的靜態工廠。
Collections是個java.util下的類，它包含有各種有關集合操作的靜態方法。他提供一系列靜態方法實現對各種集合的搜索、排序、線程安全化等操作。
Collection是個java.util下的介面，它是各種集合結構的父介面 繼承與他的介面主要有Set 和List.
❸ JAVA構造方法
構造方法的方法名必須與類名一樣。
構造方法沒有返回類型，也不能定義為void，在方法名前面不聲明方法類型。
構造方法不能作用是完成對象的初始化工作，他能夠把定義對象時的參數傳遞給對象的域。
構造方法不能由編程人員調用，而要系統調用。
構造方法可以重載，以參數的個數，類型，或排序順序區分。
例子：
1；單個構造函數方法；』
❹ Java的幾個工廠方法解析
Java工廠模式可分為三種：
1.靜態工廠模式
2.工廠方法模式
3.抽象工廠模式
一、靜態工廠模式：用靜態的方法實現，其創建的對象具有一定的特性
舉例如下：
Vehicle類：
public abstract class Vehicle
{
private String name;
public Vehicle (){
super();
}
public Vehicle (String name){
super();
this.name=name;
}
public abstract void run();
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
}
Bus類：
public class Bus extends Vehicle
{
private String name;
public Bus(){}
public Bus(String name){
super(name);
}
@Override
public abstract void run(){
System.out.println("Bus is running");
}
}
Car類：
public class Car extends Vehicle
{
private String name;
public Car(){}
public Car(String name){
super(name);
}
@Override
public abstract void run(){
System.out.println("Car is running");
}
}
靜態工廠類：
（靜態工廠創建一個對象，
靜態工廠創建的對象一般都有一個共同的特性，
繼承自某一個類，
或者引用一個介面）
public class StaticFactory{
public static Object getInstance(String className){
Object instance=null;
try{
Class c=Class.forName(className);
instance=c.newInstance();
}catch(Exception e){}
return instance;
}
public static Object getInstance(String className,Object ...args){
Class c=null;
try{
c=Class.forName(className);
}catch(Exception e){}
Constructor[] cons=c.getConstructors();
Object instance=null;
for(Constructor con:cons){
Class<?>[] cs=con.getParmeterTypes();
if(cs.length>0){
boolean isConstructor=true;
for(int i=0;i<cs.length;i++){
Class t=cs[i];
if(!t.isInstance(args[i])){
isConstructor=false;
}
}
if(isConstructor){
try{
instance=con.newInstance(args);
break;
}catch(Exception e){}
}else{
continue;
}
}
}
return instance;
}
}
二、工廠方法模式：主要是對各類東西分類生產，但分類生產的對象仍然具有某一特性。
如果說靜態工廠是一個綜合的交通工具建造工廠，
那麼工廠方法模式就是具體分工，分成Bus與Car的工廠，
各自生產各自的產品，但是造出來的還是交通工具。
交通工具製造介面：
public interface VehicleMake{
/**製造交通工具**/
public Vehicle make();
}
Bus製造類：
public class BusMake implements VehicleMake{
@Override
public Vehicle make(){
Vehicle bus=new Bus();
System.out.println("Bus工廠製造了一輛Bus");
return bus;
}
}
Car製造類：
public class CarMake implements VehicleMake{
@Override
public Vehicle make(){
Vehicle car=new Car();
System.out.println("Car工廠製造了一輛Car");
return car;
}
}
三、抽象工廠模式：抽象工廠生產的對象可能是沒有共同特性的。比如，一個製造工廠BusMake不僅能製造Bus還能生產輪胎wheel等配件，Bus是交通工具，wheel是配件（代碼中有部分類沒具體寫出來只給了類名）
總工廠（抽象工廠總介面）：
public interface WheelVehicleMake extends VehicleMake{
/**製造輪胎**/
public Wheel makeWheel();
}
輪子BusMake：
public class WheelBusMake implements WheelVehicleMake{
@Override
public Vehicle make(){
Vehicle bus=new Bus();
System.out.println("WheelBusMake生產了一輛Bus");
return bus;
}
@Override
public Wheel makeWheel(){
Wheel busWheel=new BusWheel();
System.out.println("WheelBusMake生產了一個Bus輪子");
return busWheel;
}
}
輪子CarMake：
public class WheelCarMake implements WheelVehicleMake{
@Override
public Vehicle make(){
Vehicle car=new Car();
System.out.println("WheelCarMake生產了一輛Car");
return car;
}
@Override
public Wheel makeWheel(){
Wheel carWheel=new CarWheel();
System.out.println("WheelCarMake生產了一個Car輪子");
return carWheel;
}
}
❺ Java問題，為什麼下面工廠類中要使用靜態方法
工廠類一般用靜態方法，其實是因為， 通過靜態方法這個工廠本身 不需要其它來創建， 不 然誰來創建這個工廠呢， 另外一個工廠？
❻ java 如何把方法結果保存在內存中，避免重復調用這個方法
應該使用單例模式，下面是我收集的比較全的JAVA單例模式的幾種實現方法
1.餓漢式單例類
package pattern.singleton;
//餓漢式單例類.在類初始化時，已經自行實例化
public class Singleton1 {
//私有的默認構造子
private Singleton1() {}
//已經自行實例化
private static final Singleton1 single = new Singleton1();
//靜態工廠方法
public static Singleton1 getInstance() {
return single;
}
}
2.懶漢式單例類
package pattern.singleton;
//懶漢式單例類.在第一次調用的時候實例化
public class Singleton2 {
//私有的默認構造子
private Singleton2() {}
//注意，這里沒有final
private static Singleton2 single;
//只實例化一次
static{
single = new Singleton2();
}
//靜態工廠方法
public synchronized static Singleton2 getInstance() {
if (single == null) {
single = new Singleton2();
}
return single;
}
}
在上面給出懶漢式單例類實現里對靜態工廠方法使用了同步化，以處理多線程環境。有些設計師在這里建議使用所謂的"雙重檢查成例".必須指出的是，"雙重檢查成例"不可以在Java 語言中使用。不十分熟悉的讀者，可以看看後面給出的小節。 同樣，由於構造子是私有的，因此，此類不能被繼承。餓漢式單例類在自己被載入時就將自己實例化。即便載入器是靜態的，在餓漢式單例類被載入時仍會將自己實例化。單從資源利用效率角度來講，這個比懶漢式單例類稍差些。從速度和反應時間角度來講，則比懶漢式單例類稍好些。然而，懶漢式單例類在實例化時，必須處
理好在多個線程同時首次引用此類時的訪問限制問題，特別是當單例類作為資源控制器，在實例化時必然涉及資源初始化，而資源初始化很有可能耗費時間。這意味著出現多線程同時首次引用此類的機率變得較大。
餓漢式單例類可以在Java 語言內實現， 但不易在C++ 內實現，因為靜態初始化在C++ 里沒有固定的順序，因而靜態的m_instance 變數的初始化與類的載入順序沒有保證，可能會出問題。這就是為什麼GoF 在提出單例類的概念時，舉的例子是懶漢式的。他們的書影響之大，以致Java 語言中單例類的例子也大多是懶漢式的。實際上，本書認為餓漢式單例類更符合Java 語言本身的特點。
3.登記式單例類.
package pattern.singleton;
import java.util.HashMap;
import java.util.Map;
//登記式單例類.
//類似Spring裡面的方法，將類名注冊，下次從裡面直接獲取。
public class Singleton3 {
private static Map<String,Singleton3> map = new HashMap<String,Singleton3>();
static{
Singleton3 single = new Singleton3();
map.put(single.getClass().getName(), single);
}
//保護的默認構造子
protected Singleton3(){}
//靜態工廠方法,返還此類惟一的實例
public static Singleton3 getInstance(String name) {
if(name == null) {
name = Singleton3.class.getName();
System.out.println("name == null"+"--->name="+name);
}
if(map.get(name) == null) {
try {
map.put(name, (Singleton3) Class.forName(name).newInstance());
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
return map.get(name);
}
//一個示意性的商業方法
public String about() {
return "Hello, I am RegSingleton.";
}
public static void main(String[] args) {
Singleton3 single3 = Singleton3.getInstance(null);
System.out.println(single3.about());
}
}
引自http://..com/question/317105811.html 問號等於不明白的回答
❼ 在JAVA中，通常在什麼情況下用到工廠模式
工廠模式負責將大量有共同介面的類實例化。工廠模式可以決定將哪一個類實例化，不必事先知道每次要實例化哪一個類。
工廠模式的幾種形態：
l 簡單工廠模式。又稱靜態工廠模式。
l 工廠方法模式。Factory Method，又稱多態工廠或虛擬構造子模式（Virtual Constructor）。
l 抽象工廠模式。Abstract Factory，又稱工具箱（Kit或ToolKit）模式。
工廠模式的逐步遞演反映了抽象的步步加深、解決問題
❽ java中單列模式,我要詳細點的,麻煩各位給我介紹一下
單例模式分三種：懶漢式單例、餓漢式單例、登記式單例三種。
單例模式有一下特點：
1、單例類只能有一個實例。
2、單例類必須自己自己創建自己的唯一實例。
3、單例類必須給所有其他對象提供這一實例。
一、懶漢式單例
在類被載入的時候，唯一實例已經被創建。這個設計模式在Java中容易實現，在別的語言中難以實現。
/**
* Created by IntelliJ IDEA.
* User: leimin
* Date: 2007-9-11
* Time: 14:57:08
* <<Java與模式>> 單例模式-懶漢式單例
*/
public class LazySingleton {
/**
* 私有靜態對象,載入時候不做初始化
*/
private static LazySingleton m_intance=null;
/**
* 私有構造方法,避免外部創建實例
*/
private LazySingleton(){
}
/**
* 靜態工廠方法,返回此類的唯一實例.
* 當發現實例沒有初始化的時候,才初始化.
* @return LazySingleton
*/
synchronized public static LazySingleton getInstance(){
if(m_intance==null){
m_intance=new LazySingleton();
}
return m_intance;
}
}
二、餓漢式單例
在類載入的時候不創建單例實例。只有在第一次請求實例的時候的時候創建，並且只在第一次創建後，以後不再創建該類的實例。
/**
* Created by IntelliJ IDEA.
* User: leimin
* Date: 2007-9-11
* Time: 14:45:25
* <<Java與模式>> 單例模式-餓漢式單例
*/
public class EagerSingleton {
/**
* 私有的(private)唯一(static final)實例成員,在類載入的時候就創建好了單例對象
*/
private static final EagerSingleton m_instance = new EagerSingleton();
/**
* 私有構造方法,避免外部創建實例
*/
private EagerSingleton() {
}
/**
* 靜態工廠方法,返回此類的唯一實例.
* @return EagerSingleton
*/
public static EagerSingleton getInstance() {
return m_instance;
}
}
三、登記式單例
這個單例實際上維護的是一組單例類的實例，將這些實例存放在一個Map（登記薄）中，對於已經登記過的實例，則從工廠直接返回，對於沒有登記的，則先登記，而後返回。
/**
* Created by IntelliJ IDEA.
* User: leimin
* Date: 2005-9-11
* Time: 15:20:16
* <<Java與模式>> 單例模式- 登記式單例
*/
public class RegSingleton {
/**
* 登記薄,用來存放所有登記的實例
*/
private static Map<String, RegSingleton> m_registry = new HashMap();
//在類載入的時候添加一個實例到登記薄
static {
RegSingleton x = new RegSingleton();
m_registry.put(x.getClass().getName(), x);
}
/**
* 受保護的默認構造方法
*/
protected RegSingleton() {
}
/**
* 靜態工廠方法,返回指定登記對象的唯一實例;
* 對於已登記的直接取出返回,對於還未登記的,先登記,然後取出返回
* @param name
* @return RegSingleton
*/
public static RegSingleton getInstance(String name) {
if (name == null) {
name = "RegSingleton";
}
if (m_registry.get(name) == null) {
try {
m_registry.put(name, (RegSingleton) Class.forName(name).newInstance());
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
return m_registry.get(name);
}
/**
* 一個示意性的商業方法
* @return String
*/
public String about() {
return "Hello,I am RegSingleton!";
}
}
單列的列子
第一種形式:
public class Singleton {
private Singleton(){}
private static Singleton instance = new Singleton();
public static Singleton getInstance() {
return instance;
}
}
第二種形式:
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
if (instance==null)
instance＝new Singleton();
return instance;
}
}