工厂模式：属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
主要解决接口选择的问题
一个工厂可以生产带有各种颜色的各种形状：
首先由颜色接口和形状接口：
//图像接口
public interface Shape {
enum Type {
Circle, Rectangle, Square
}
String Name();
void Draw();
}
//颜色接口
public interface Colour {
void Upper();
}
下面有实体类有圆形，三角形，正方形
//圆形
public class Circle implements Shape {
@Override
public String Name() {
return "Circle";
}
@Override
public void Draw() {
Log.e("Shape", "--------------" + Name() + "------------");
}
}
//正方形
public class Square implements Shape {
@Override
public void Draw() {
Log.e("Shape", "--------------" + Name() + "------------");
}
@Override
public String Name() {
return "Square";
}
}
//三角形
public class Rectangle implements Shape {
@Override
public String Name() {
return "Rectangle";
}
@Override
public void Draw() {
Log.e("Shape", "--------------" + Name() + "------------");
}
}
颜色实体类：
//灰色
public class Gray implements Colour {
@Override
public void Upper() {
Log.e("Colour","--------- Colour is Gray ---------");
}
}
//红色
public class Red implements Colour {
@Override
public void Upper() {
Log.e("Colour","--------- Colour is Red---------");
}
}
//绿色
public class Green implements Colour {
@Override
public void Upper() {
Log.e("Colour","--------- Colour is Green---------");
}
}
下面是我们的工厂，我们的形状工厂(标准工厂模式的实现)：
public class ShapeFactory {
public Shape getShape(Shape.Type type) {
if (type == Shape.Type.Circle) {
return new Circle();
} else if (type == Shape.Type.Rectangle) {
return new Rectangle();
} else {
return new Square();
}
}
}
我们还可以这样用（偏抽象工厂的实现）
public class Factory {
private Shape shape = null;
private Colour colour = null;
public Factory(Shape shape, Colour colour) {
this.shape = shape;
this.colour = colour;
}
public Shape getShape() {
return shape;
}
public Colour getColour() {
return colour;
}
public void showThis() {
getShape().Draw();
getColour().Upper();
}
}
如何使用：
Factory shapeFactory = new Factory();
Shape sq=shapeFactory.getShape(Shape.Type.Square);
Shape cc=shapeFactory.getShape(Shape.Type.Circle);
Shape rt=shapeFactory.getShape(Shape.Type.Rectangle);
或者
private Factory ff = new Factory(new Rectangle(),new Green());
ff.showThis();
抽象工厂模式Kotlin 实现：
接口
interface ktShape {
fun getName(): String
fun Draw()
}
enum class ShapeType {
Circle, Rectangle, Square
}
enum class ColorType {
Bule, Red, Wite
}
interface ktColor {
fun getName(): String
fun Upper()
}
interface ShapeFactory {
fun MakeShape(type: ShapeType): ktShape
}
interface ColorFactory {
fun MakeColor(type: ColorType): ktColor
}
颜色类，实现：
class RedC : ktColor {
override fun getName(): String {
return "Red Color"
}
override fun Upper() {
System.out.print(getName())
}
}
class BuleC : ktColor {
override fun getName(): String {
return "Bule Color"
}
override fun Upper() {
System.out.print(getName())
}
}
class WiteC : ktColor {
override fun getName(): String {
return "Wite Color"
}
override fun Upper() {
System.out.print(getName())
}
}
形状类
class Squarekt : ktShape {
override fun getName(): String {
return "Square Shape"
}
override fun Draw() {
System.out.print(getName())
}
}
class Circlekt : ktShape {
override fun getName(): String {
return "Circle Shape"
}
override fun Draw() {
System.out.print(getName())
}
}
class Rectanglekt : ktShape {
override fun getName(): String {
return "Rectangle Shape"
}
override fun Draw() {
System.out.print(getName())
}
}
工厂类：
class AbsFactory : ShapeFactory, ColorFactory {
var ktsp: ktShape? = null
var ktco: ktColor? = null
constructor ()
override fun MakeShape(type: ShapeType): ktShape {
when (type) {
ShapeType.Circle -> ktsp = Circlekt()
ShapeType.Rectangle -> ktsp = Rectanglekt()
ShapeType.Square -> ktsp = Squarekt()
}
return ktsp as ktShape
}
override fun MakeColor(type: ColorType): ktColor {
when (type) {
ColorType.Red -> ktco = RedC()
ColorType.Bule -> ktco = BuleC()
ColorType.Wite -> ktco = WiteC()
}
return ktco as ktColor
}
}
如何使用：
class main {
var absF: AbsFactory = AbsFactory()
fun Test() {
absF.MakeShape(ShapeType.Square)
absF.MakeColor(ColorType.Red)
}
}
