這個應(yīng)該比較簡單一點。
在高昌等地區(qū)，都構(gòu)建了全面的區(qū)域性戰(zhàn)略布局，加強發(fā)展的系統(tǒng)性、市場前瞻性、產(chǎn)品創(chuàng)新能力，以專注、極致的服務(wù)理念，為客戶提供網(wǎng)站制作、做網(wǎng)站 網(wǎng)站設(shè)計制作按需策劃設(shè)計,公司網(wǎng)站建設(shè),企業(yè)網(wǎng)站建設(shè),成都品牌網(wǎng)站建設(shè),網(wǎng)絡(luò)營銷推廣,成都外貿(mào)網(wǎng)站制作,高昌網(wǎng)站建設(shè)費用合理。
某系統(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());
}
}
}
interface Fruit { // 定義一個水果接口
public void eat(); // 吃水果
}
class Apple implements Fruit {
public void eat() {
System.out.println("** 吃蘋果。");
}
};
class Orange implements Fruit {
public void eat() {
System.out.println("** 吃橘子。");
}
};
class Factory { // 定義工廠類
private static Factory factory;
private Factory(){}
public static Factory getInstance() {
if(factory==null){
factory=new Factory();
}
return factory;
}
public Apple newApplet(){
return new Apple();
}
public Orange newOrange(){
return new Orange();
}
};
class FactoryModel {
public static void main(String args[]) {
Fruit f = Factory.getInstance().newApplet();
if (f != null) { // 判斷是否取得實例
f.eat();
}
f = Factory.getInstance().newOrange();
if (f != null) { // 判斷是否取得實例
f.eat();
}
}
};
簡單工廠模式的：簡單工廠模式是類的創(chuàng)建模式，又叫做靜態(tài)工廠方法（Static Factory Method）模式。簡單工廠模式是由一個工廠對象決定創(chuàng)建出哪一種產(chǎn)品類的實例。
那么簡單工廠模式是在什么場景下使用呢，下面就以本人的理解舉例說明:
就拿登錄功能來說，假如應(yīng)用系統(tǒng)需要支持多種登錄方式如：口令認(rèn)證、域認(rèn)證（口令認(rèn)證通常是去數(shù)據(jù)庫中驗證用戶，而域認(rèn)證則是需要到微軟的域中驗證用戶）。那么自然的做法就是建立一個各種登錄方式都適用的接口，如下圖所示：
public interface Login {
//登錄驗證
public boolean verify(String name , String password);
}
public class DomainLogin implements Login {
@Override
public boolean verify(String name, String password) {
// TODO Auto-generated method stub
/**
* 業(yè)務(wù)邏輯
*/
return true;
}
}
public class PasswordLogin implements Login {
@Override
public boolean verify(String name, String password) {
// TODO Auto-generated method stub
/**
* 業(yè)務(wù)邏輯
*/
return true;
}
}
我們還需要一個工廠類LoginManager，根據(jù)調(diào)用者不同的要求，創(chuàng)建出不同的登錄對象并返回。而如果碰到不合法的要求，會返回一個Runtime異常。
public class LoginManager {
public static Login factory(String type){
if(type.equals("password")){
return new PasswordLogin();
}else if(type.equals("passcode")){
return new DomainLogin();
}else{
/**
* 這里拋出一個自定義異常會更恰當(dāng)
*/
throw new RuntimeException("沒有找到登錄類型");
}
}
}
測試類：
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
String loginType = "password";
String name = "name";
String password = "password";
Login login = LoginManager.factory(loginType);
boolean bool = login.verify(name, password);
if (bool) {
/**
* 業(yè)務(wù)邏輯
*/
} else {
/**
* 業(yè)務(wù)邏輯
*/
}
}
}
簡單工廠模式的結(jié)構(gòu)如下圖：
我們可以設(shè)想一下真實的場景，如果把上面的Test當(dāng)做一個servlet的話，當(dāng)客戶端發(fā)起登錄請求——請求交給服務(wù)端的Servlet——Servlet根據(jù)客戶端傳遞的loginType調(diào)用工廠類LoginManager的factory()方法——factory()方法根據(jù)參數(shù)loginType創(chuàng)建相應(yīng)的登錄驗證類(DomainLogin或PasswordLogin)并返回——登錄驗證類調(diào)用方法verify()驗證用戶名密碼是否正確
假如不使用簡單工廠模式則驗證登錄Servlet代碼如下（假設(shè)Test為一個Servlet，變量loginType、name、password表示從客戶端傳遞過來的參數(shù)）：
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
String loginType = "password";
String name = "name";
String password = "password";
//處理口令認(rèn)證
if(loginType.equals("password")){
PasswordLogin passwordLogin = new PasswordLogin();
boolean bool = passwordLogin.verify(name, password);
if (bool) {
/**
* 業(yè)務(wù)邏輯
*/
} else {
/**
* 業(yè)務(wù)邏輯
*/
}
}
//處理域認(rèn)證
else if(loginType.equals("passcode")){
DomainLogin domainLogin = new DomainLogin();
boolean bool = domainLogin.verify(name, password);
if (bool) {
/**
* 業(yè)務(wù)邏輯
*/
} else {
/**
* 業(yè)務(wù)邏輯
*/
}
}else{
/**
* 業(yè)務(wù)邏輯
*/
}
}
}
上面的代碼會不會很蛋疼啊。。。呵呵
《JAVA與模式》一書中使用java.text.DataFormat類作為簡單工廠模式的典型例子敘述。
簡單工廠模式的優(yōu)點
模式的核心是工廠類。這個類含有必要的邏輯判斷，可以決定在什么時候創(chuàng)建哪一個登錄驗證類的實例，而調(diào)用者則可以免除直接創(chuàng)建對象的責(zé)任。簡單工廠模式通過這種做法實現(xiàn)了對責(zé)任的分割，當(dāng)系統(tǒng)引入新的登錄方式的時候無需修改調(diào)用者。
簡單工廠模式的缺點
這個工廠類集中了所以的創(chuàng)建邏輯，當(dāng)有復(fù)雜的多層次等級結(jié)構(gòu)時，所有的業(yè)務(wù)邏輯都在這個工廠類中實現(xiàn)。什么時候它不能工作了，整個系統(tǒng)都會受到影響。
單體模式 很簡單，就是將構(gòu)造函數(shù)變?yōu)樗接?，那么就不能通過new 來創(chuàng)建對象。 同時創(chuàng)建一個 共有的靜態(tài)的方法來獲得實例，代碼如下：
class Test{
private static Test instance = null;
private Test(){}
public static Test getInstance(){
if( instance == null ){
instance = new Test();
}
return instance ;
}
}
工廠模式有三個參與者，抽象產(chǎn)品(Product)、工廠(Creator)和具體產(chǎn)品(ConcreteProduct)?？蛻糁粫吹焦S和抽象產(chǎn)品。
public interface Product{
public String getName();
}
public class ConcreteProduct implements Product{
public String getName(){
return "產(chǎn)品1";
}
}
public class Creator{
public static Product create1(){
return new ConcreteProduct();
}
}
工廠模式的作用在于將創(chuàng)建具體產(chǎn)品的方法由工廠類控制，客戶只需要知道產(chǎn)品的抽象類型
Java工廠模式可分為三種：
1.靜態(tài)工廠模式
2.工廠方法模式
3.抽象工廠模式
一、靜態(tài)工廠模式：用靜態(tài)的方法實現(xiàn)，其創(chuàng)建的對象具有一定的特性
舉例如下：
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");
}
}
靜態(tài)工廠類：
（靜態(tài)工廠創(chuàng)建一個對象，
靜態(tài)工廠創(chuàng)建的對象一般都有一個共同的特性，
繼承自某一個類，
或者引用一個接口）
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.length0){
boolean isConstructor=true;
for(int i=0;ics.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;
}
}
二、工廠方法模式：主要是對各類東西分類生產(chǎn)，但分類生產(chǎn)的對象仍然具有某一特性。
如果說靜態(tài)工廠是一個綜合的交通工具建造工廠，
那么工廠方法模式就是具體分工，分成Bus與Car的工廠，
各自生產(chǎn)各自的產(chǎn)品，但是造出來的還是交通工具。
交通工具制造接口：
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;
}
}
三、抽象工廠模式：抽象工廠生產(chǎn)的對象可能是沒有共同特性的。比如，一個制造工廠BusMake不僅能制造Bus還能生產(chǎn)輪胎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生產(chǎn)了一輛Bus");
return bus;
}
@Override
public Wheel makeWheel(){
Wheel busWheel=new BusWheel();
System.out.println("WheelBusMake生產(chǎn)了一個Bus輪子");
return busWheel;
}
}
輪子CarMake：
public class WheelCarMake implements WheelVehicleMake{
@Override
public Vehicle make(){
Vehicle car=new Car();
System.out.println("WheelCarMake生產(chǎn)了一輛Car");
return car;
}
@Override
public Wheel makeWheel(){
Wheel carWheel=new CarWheel();
System.out.println("WheelCarMake生產(chǎn)了一個Car輪子");
return carWheel;
}
}
工廠模式j(luò)ava實例如下：
public interface Work {
void doWork();
}
ConcreteProduct
public class StudentWork implements Work {
public void doWork() {
? ?System.out.println("學(xué)生做作業(yè)!");
}
}
public class TeacherWork implements Work {
public void doWork() {
? ?System.out.println("老師審批作業(yè)!");
}
}
生產(chǎn)者
public interface IWorkFactory {
Work getWork();
}
ConcreteCreator
public class StudentWorkFactory implements IWorkFactory {
public Work getWork() {
? ?return new StudentWork();
}
}
public class TeacherWorkFactory implements IWorkFactory {
public Work getWork() {
? ?return new TeacherWork();
}
}
Test
public class Test {
public static void main(String[] args) {
? ?IWorkFactory studentWorkFactory = new StudentWorkFactory();
? ?studentWorkFactory.getWork().doWork();
? ?
? ?IWorkFactory teacherWorkFactory = new TeacherWorkFactory();
? ?teacherWorkFactory.getWork().doWork();
}
}
字符串反轉(zhuǎn)如下：
public String getReverseStr(String str)
{
String reverseStr = "";
if (null != str !str.equals(""))
{
? for (int i = 1 ; i =str.length(); i++){
? ? ? ??reverseStr += str.charAt(str.length() - i);
? ? ? ? // 依次按與原字符串相反的順序拼裝字符串，內(nèi)部會自動進行類型轉(zhuǎn)換
? ? ? ? //str.length() - i剛好是str的下標(biāo)，因為i是從1開始
? }
}
return reverseStr;
}
冒泡排序算法，從小到大
public int[] sortArr(int[] targetArr){
? ? ?//小到大的排序
? ? ? ?int temp = 0;
? ? ? ?for(int i = 0;itargetArr.length;i++){
? ? ? ? ? ?for(int j = i;jtargetArr.length;j++){
? ? ? ? ? ? ? ?if(targetArr[i]targetArr[j]){
? ? ? ? ? ? ? ? ? ?temp = targetArr[i];
? ? ? ? ? ? ? ? ? ?targetArr[i] = targetArr[j];
? ? ? ? ? ? ? ? ? ?targetArr[j] = temp;
? ? ? ? ? ? ? ? ? }
? ? ? ? ? ? }
? ? ? ?}
? ? return?targetArr;
}
重慶分公司
重慶分公司
