当前位置：首页 » 编程语言 » java静态工厂方法

java静态工厂方法

发布时间: 2021-03-07 11:08:15

Ⅰ java与模式，简单工厂模式的方法为什么是静态的

在不需要用对象成员的时候就用类成员，这个没什么好说的... 一定要说的话静态方法调用速度快

Ⅱ 为什么要在JAVA工厂模式中使用静态方法

工厂模式是一种封装对象创建的方法。
如果不使用工厂模式，你就需要直接使用构造方法来创建对象：Foo x = new Foo()
使用工厂模式，就可以取而代之的调用工厂方法：Foo x = Foo.create()
工厂类的构造方法被标记为private，所以构造方法除了在类的内部被调用以外就不能够被访问。
工厂类的其他方法被标记为static，这样就不需要在调用该方法之前必须首先拥有一个该类的对象。
使用工厂模式有一些好处。

Ⅲ 求教：Java中使用静态工厂方法的作用

这种方法多用在业务逻辑方面，向外面只暴露接口，隐藏具体算法细节。灵活度高，容易扩展。例如结算工资，每个部门，每个人的工资可能不一样(包括基本工资，加层，项目奖金，税等等一些列算法)。你只需要一个口接口，具体实现交给具体类去做，这样你就可以根据不同的类，得到不同的结果。

Ⅳ JAVA 静态工厂方法

//只管描述，其他
class DrinkNotFoundException extends Exception{
DrinkNotFoundException(){}
DrinkNotFoundException(String message){
super(message);
}
}
class Drink{ //工厂类
static Object getDrink(int drinkType) throws DrinkNotFoundException{ //工厂静态方法
switch(drinkType){
case 1: return new Coffee();
default:throw new DrinkNotFoundException("没有相对应的饮料类型");
}
}
}
class Coffee{
public void taste(){
System.out.println("咖啡能提神。");
}
}
public class Main{
public static void main(String args[]){
try {
Coffee coffee = (Coffee)Drink.getDrink(1);//正常，这就是静态工厂方法
coffee.taste();
Coffee c = (Coffee)Drink.getDrink(0);//抛出异常
} catch (DrinkNotFoundException e) {
e.printStackTrace();
}
}
}

Ⅳ effective java 中的静态工厂方法是什么意思。

它的意思是把一个常用公共操作统一分类定义到一些工厂类中，说是工厂类其实就是因为你在给类命名的时候使用了Factory。你也可以换成其名字，不过统一定义成这个命名在团队开发中易与相互理解，知道这是一个工具类而已，这样可以节省代码，使代码更健壮。

Ⅵ JAVA中静态工厂方法跟new语句的差别！

静态方法创建类的实例的时候, 有可能不是new一个(也有可能new一个)而是把一个已经有的对象返回回去了回. 其实没什么"根本"差别, 里面一般还是调用new, 只是一答些情况下没有在静态方法里面new而是直接拿一个以前已经new出来的对象返回回去了.

Ⅶ Java问题，为什么下面工厂类中要使用静态方法

工厂类需要被重复多次使用，static的好处是，能够出淤泥不染，把它当成一个工具，里面的东西被单次赋值之后，可以再次恢复。不影响二次重用。。。

Ⅷ java带有多线程同步机制的静态工厂模式怎么写

publicclassT{
	
	;
	
	privateT(){}
	
	publicstaticTgetInstance(){
		if(null==instance){
			synchronized(T.class){
				if(null==instance){
					instance=newT();
				}
			}
		}
		
		returninstance;
	}
	
}

Ⅸ 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;
}
}

Ⅹ 静态工厂方法代替构造函数中

Spring中大量使用单例模式和工厂模式，工厂模式可以将Java对象的调用者从被调用者的实现逻辑中版分离出来，调用者只需要关权心被调用者必须满足的规则（接口，或者高层抽象类），而不必关心实例实现的具体过程。这是面向对象接口编程的优势，能提高程序的解耦。工厂模式是设计模式里最常用，也是最基础的一种设计模式，因为最简单的道理，绝大部分的类被定义出来就是为了生成对象的，那么生成对象就必须进行new操作，工厂方法就是把new的实现分开来。

阅读全文

java静态工厂方法

与java静态工厂方法相关的阅读推荐