# Python 3.9
# 工厂方法模式 Factory Method Pattern
from __future__ import annotations
from abc import ABC, abstractmethod
import pygame # pip install pygame -i https://pypi.tuna.tsinghua.edu.cn/simple
class Shape(object):
def __init__(self, x, y):
self.x = x
self.y = y
def draw(self):
raise NotImplementedError()
def move(self, direction):
if direction == 'up':
self.y -= 4
elif direction == 'down':
self.y += 4
elif direction == 'left':
self.x -= 4
elif direction == 'right':
self.x += 4
@staticmethod
def factory(shape_type, pos_x, pos_y):
if shape_type == 'Circle':
return Circle(pos_x, pos_y)
if shape_type == 'Square':
return Square(pos_x, pos_y)
assert 0, "Bad shape requested:" + type
class Square(Shape):
def __init__(self, x, y):
if x < 0:
x = 0
elif x > 780:
x = 780
if y < 0:
y = 0
elif y > 580:
y = 580
super(Square, self).__init__(x,y)
def draw(self):
pygame.draw.rect(
screen,
(255, 255, 0),
pygame.Rect(self.x, self.y, 20, 20)
)
def move(self, direction):
if direction == 'up' and self.y > 0:
super(Square, self).move('up')
elif direction == 'down' and self.y < 580:
super(Square, self).move('down')
elif direction == 'left' and self.x > 0:
super(Square, self).move('left')
elif direction == 'right' and self.x < 780:
super(Square, self).move('right')
class Circle(Shape):
def __init__(self, x, y):
if x < 10:
x = 10
elif x > 790:
x = 790
if y < 10:
y = 10
elif y > 590:
y = 590
super(Circle, self).__init__(x, y)
def draw(self):
pygame.draw.circle(
screen,
(0, 255, 255),
(self.x, self.y),
10
)
def move(self, direction):
if direction == 'up' and self.y > 10:
super(Circle, self).move('up')
elif direction == 'down' and self.y < 590:
super(Circle, self).move('down')
elif direction == 'left' and self.x > 10:
super(Circle, self).move('left')
elif direction == 'right' and self.x < 790:
super(Circle, self).move('right')
class Creator(ABC):
"""
The Creator class declares the factory method that is supposed to return an
object of a Product class. The Creator's subclasses usually provide the
implementation of this method.
"""
@abstractmethod
def factory_method(self):
"""
Note that the Creator may also provide some default implementation of
the factory method.
"""
pass
def some_operation(self) -> str:
"""
Also note that, despite its name, the Creator's primary responsibility
is not creating products. Usually, it contains some core business logic
that relies on Product objects, returned by the factory method.
Subclasses can indirectly change that business logic by overriding the
factory method and returning a different type of product from it.
"""
# Call the factory method to create a Product object.
product = self.factory_method()
# Now, use the product.
result = f"Creator: The same creator's code has just worked with {product.operation()}"
return result
"""
Concrete Creators override the factory method in order to change the resulting
product's type.
"""
class ConcreteCreator1(Creator):
"""
Note that the signature of the method still uses the abstract product type,
even though the concrete product is actually returned from the method. This
way the Creator can stay independent of concrete product classes.
"""
def factory_method(self) -> Product:
return ConcreteProduct1()
class ConcreteCreator2(Creator):
def factory_method(self) -> Product:
return ConcreteProduct2()
class Product(ABC):
"""
The Product interface declares the operations that all concrete products
must implement.
"""
@abstractmethod
def operation(self) -> str:
pass
"""
Concrete Products provide various implementations of the Product interface.
"""
class ConcreteProduct1(Product):
def operation(self) -> str:
return "{Result of the ConcreteProduct1}"
class ConcreteProduct2(Product):
def operation(self) -> str:
return "{Result of the ConcreteProduct2}"
def client_code(creator: Creator) -> None:
"""
The client code works with an instance of a concrete creator, albeit through
its base interface. As long as the client keeps working with the creator via
the base interface, you can pass it any creator's subclass.
"""
print(f"Client: I'm not aware of the creator's class, but it still works.\n"
f"{creator.some_operation()}", end="")
def print_hi(name):
# Use a breakpoint in the code line below to debug your script.
print(f'Hi, {name}') # Press Ctrl+F8 to toggle the breakpoint.
调用：
# 调用 工厂方法模式 Factory Method Pattern
# Press the green button in the gutter to run the script.
if __name__ == '__main__':
print_hi('geovindu')
window_dimensions = 800, 600
print("App: Launched with the ConcreteCreator1.")
client_code(ConcreteCreator1())
print("\n")
print("App: Launched with the ConcreteCreator2.")
client_code(ConcreteCreator2())
window_dimensions = 800, 600
screen = pygame.display.set_mode(window_dimensions)
obj = Shape.factory('Square', 100, 100)
player_quits = False
while not player_quits:
for event in pygame.event.get():
if event.type == pygame.QUIT:
player_quits = True
pressed = pygame.key.get_pressed()
if pressed[pygame.K_c]:
obj = Shape.factory('Circle', obj.x, obj.y)
if pressed[pygame.K_s]:
obj = Shape.factory('Square', obj.x, obj.y)
if pressed[pygame.K_UP]:
obj.move('up')
if pressed[pygame.K_DOWN]:
obj.move('down')
if pressed[pygame.K_LEFT]:
obj.move('left')
if pressed[pygame.K_RIGHT]:
obj.move('right')
screen.fill((0, 0, 0))
obj.draw()
pygame.display.flip()
输出：
Hi, geovindu
App: Launched with the ConcreteCreator1.
Client: I'm not aware of the creator's class, but it still works.
Creator: The same creator's code has just worked with {Result of the ConcreteProduct1}
App: Launched with the ConcreteCreator2.
Client: I'm not aware of the creator's class, but it still works.
Creator: The same creator's code has just worked with {Result of the ConcreteProduct2}
Process finished with exit code 0
标签：__,direction,Python,Pattern,self,move,Factory,pygame,def From： https://www.cnblogs.com/geovindu/p/16757473.html