[Version Python] Pourquoi ne pouvez-vous pas faire de développement orienté objet avec Java?

Aperçu

J'ai acheté "Pourquoi ne pouvez-vous pas faire de développement orienté objet avec Java" pour un réapprentissage orienté objet, mais uniquement avec Java / Ruby [exemple officiel](http://gihyo.jp/book/2005/4- 7741-2222-X / support) n'était pas là, donc je l'ai créé en Python. (Veuillez l'utiliser comme référence uniquement. Je suis également un débutant.)

Jusqu'à la leçon 5 (programme Janken)

Progression globale du traitement

object_janken.py

from judge import *
from player import *
from tactics import *

#Génération d'instance d'arbitre (M. Saito)
saito = Judge()

#Génération du joueur 1 (M. Murata)
murata_tactics = RandomTactics()
murata = Player("M. Murata",murata_tactics)

#Génération du joueur 2 (M. Yamada)
yamada_tactics = StoneOnlyTactics()
yamada = Player("M. Yamada",yamada_tactics)
# yamada = Player_STONE("M. Yamada")

#Commencez Janken avec M. Murata et M. Yamada comme joueurs
saito.start_janken(murata, yamada)

Classe de joueur

player.py

class Player:

    #Constante représentant la main de Janken
    STONE = 0  #Goo
    SCISSORS = 1  #Choki
    PAPER = 2  #Par

    def __init__(self, name, tactics):
        self.name = name
        self.win_count = 0
        self.tactics = tactics

    #Éteignez la main de Janken.
    def show_hand(self):
        hand = self.tactics.read_tactics()
        return hand

    #Écoutez la victoire ou la défaite de l'arbitre. S'il gagne, le résultat de l'argument est vrai
    def notify_result(self,result):
        if (result):
            self.win_count += 1

    #Répondez au nombre de fois que vous avez gagné.
    def get_win_count(self):
        return self.win_count

    #Répondez à votre nom.
    def get_name(self):
        return self.name

#Hériter de la création de classe enfant
class Player_STONE(Player):
    def show_hand(self):
        return self.STONE

Classe de juge

judge.py

class Judge:

    #Démarrez Janken.
    def start_janken(self, player1, player2):
        #Déclarer le début de Janken
        print("[Démarrage de Janken]\n")

        #Jouez à Janken 3 fois
        for cnt in range(3):
            #Montre combien de tours
            print("【", (cnt + 1), "Rond]")

            #Regardez la main du joueur pour déterminer laquelle gagne.
            winner = self.judge_janken(player1, player2)

            if (winner != None):
                #Gagnant du spectacle
                print("\n", winner.get_name(), "A gagné!\n")
                #Communiquez les résultats aux joueurs gagnants
                winner.notify_result(True)
            else:
                #En cas d'égalité
                print("\n C'est un tirage au sort!\n")

        #Déclarez la fin de Janken
        print("[Fin de Janken]\n")

        #Déterminez le vainqueur final
        final_winner = self.judge_final_winner(player1, player2)
        print(player1.get_win_count(), "contre", player2.get_win_count(), "alors")
        if (final_winner != None):
            print(final_winner.get_name(), "Est le gagnant!\n")
        else:
            print("C'est un tirage au sort!\n")

    #Regardez la main du joueur pour déterminer laquelle gagne.
    def judge_janken(self,player1, player2):
        winner = None

        hand_dict = {0: "STONE",
                     1: "SCISSORS",
                     2: "PAPER"}

        #Sortez la main du joueur
        player1hand = player1.show_hand()
        player2hand = player2.show_hand()
        player1hand_name = hand_dict[player1hand]
        player2hand_name = hand_dict[player2hand]

        #Montrez chaque main
        print(f"{player1hand_name} vs. {player2hand_name} \n")

        #Quand le joueur 1 gagne
        if (player1hand_name == "STONE" and player2hand_name == "SCISSORS") or \
            (player1hand_name == "SCISSORS" and player2hand_name == "PAPER") or \
            (player1hand_name == "PAPER" and player2hand_name == "STONE") :
            winner = player1

        #Quand le joueur 2 gagne
        if (player1hand_name == "STONE" and player2hand_name == "PAPER") or \
            (player1hand_name == "SCISSORS" and player2hand_name == "STONE") or \
            (player1hand_name == "PAPER" and player2hand_name == "SCISSORS") :
            winner = player2

        #Dessiner si ni l'un ni l'autre(Renvoie nul)
        return winner

    #Déterminez le vainqueur final.
    def judge_final_winner(self,player1, player2):
        final_winner = None

        #Écoutez le nombre de victoires
        player1_win_count = player1.get_win_count()
        player2_win_count = player2.get_win_count()

        #Déterminez le gagnant
        if (player1_win_count > player2_win_count):
            final_winner = player1
        elif(player1_win_count < player2_win_count):
            final_winner = player2
        else:
            final_winner = None

        return final_winner

Classe de stratégie

tactics.py

class RandomTactics():

    def read_tactics(self):

        # 0.0 ou plus 3.Obtenez des nombres aléatoires sous forme de fractions inférieures à 0
        random_num = rm.random()* 3.0
        if (random_num < 1.0):
          hand = Player.STONE
        elif (random_num < 2.0):
          hand = Player.SCISSORS
        elif (random_num < 3.0):
          hand = Player.PAPER

        #Renvoie la main déterminée comme valeur de retour
        return hand


#==J'adore Goo! »Classe de stratégie.
class StoneOnlyTactics():

  def read_tactics(self):
    #Assurez-vous de sortir un goo
    return Player.STONE

Leçon 6 (programme de suppression de Bubba)

Classe de carte

card.py

class Card():

    #Une constante représentant un joker
    JOKER = 0
    #Constante représentant la bêche
    SUIT_SPADE = 1
    #Constante représentant un diamant
    SUIT_DIAMOND = 2
    #Constante représentant le club
    SUIT_CLUB = 3
    #Constante représentant le cœur
    SUIT_HEART = 4

    def __init__(self,suit,number):
        self.suit = suit
        self.number = number

    def getNumber(self):
        return self.number

    #Remplacer la fonction toString
    def toString(self):

        #Dans le cas de JOKER
        if self.suit == 0:
            card_code = "JK"

        #Cartes autres que JOKER
        else:
            suit_dict = {"SUIT_SPADE":"S", "SUIT_DIAMOND":"D",
                         "SUIT_CLUB":"C","SUIT_HEART":"H"}
            number_dict = {1:"A", 2:"2", 3:"3", 4:"4", 5:"5",
                           6:"6", 7:"7", 8:"8", 9:"9", 10:"T", 11:"J", 12:"Q", 13:"K"}
            card_code = suit_dict[self.suit] + number_dict[self.number]

        return card_code

Classe de main

hand.py

import random as rm

class Hand():

    #Conservez la classe de cartes sous forme de liste
    def __init__(self,list):
        self.hand = list

    #Ajouter une carte
    def add_card(self,card):
        self.hand.append(card)

    #Piochez une carte (en haut)
    def pick_card(self):
        picked_card = self.hand.pop(0)
        return picked_card

    #Rendre le nombre de biens
    def getNumberOfCard(self):
        return len(self.hand)

    #Mélangez votre main
    def shuffle(self):
        #Retirez les cartes au hasard et répétez le dernier ajout
        number = self.getNumberOfCard()
        for i in range(number):
            pos = int(rm.random() * number)
            picked_card = self.hand.pop(pos)
            self.hand.append(picked_card)

    #Trouvez le même nombre de cartes et remettez-les dans le tableau
    def find_same_number_card(self):

        same_cards = None

        #Obtenez le numéro de la dernière carte ajoutée
        last_added_card = self.hand[-1]
        last_added_card_num = last_added_card.number

        for index in range(len(self.hand)-1):

            card = self.hand[index]
            if card.number == last_added_card_num:

                #Si la même carte que la dernière carte ajoutée est trouvée
                #Stockez la combinaison trouvée dans sameCards et quittez la boucle
                same_cards = [self.hand.pop(-1),self.hand.pop(index)]
                break

        return same_cards

    #Exprimez les cartes de votre main sous forme de chaîne de caractères.
    def toString(self):
        hand_cards = ""
        for card in self.hand:
            hand_cards += card.toString() + " "
        return hand_cards

Classe de table

table.py

class Table():

    def __init__(self):
        self.disposed_cards = []

    #Jetez la carte.
    def dispose_card(self,dispose_list):
        for card in dispose_list:
            print(f"{card.toString()}Abandonné")
            self.disposed_cards.append(card)

    #Exprimez la carte abandonnée sous forme de chaîne de caractères.
    def toString(self):
        disposed_cards = ""
        for card in self.disposed_cards:
            disposed_cards += card.toString() + " "
        return disposed_cards

Classe de joueur

player.py

class Player():

    def __init__(self,name,hand,master,table):
        self.hand = hand
        self.name = name
        self.master = master
        self.table = table

    #Désignez votre tour (votre tour)
    def play(self,next_player):

        #Demandez au joueur suivant de retirer sa main
        next_hand = next_player.show_hand()

        #Piochez une carte de la main de votre adversaire
        picked_card = next_hand.pick_card()

        #Afficher le résultat de la soustraction
        print(self.name, "：", next_player.name, "De", picked_card.toString(),"J'ai tiré\n")

        #Ajoutez les cartes piochées à votre main et défaussez le même nombre de cartes
        self.deal_card(picked_card)

        #Découvrez si votre main est nulle
        if self.hand.getNumberOfCard() == 0:
            #Déclarez la montée au facilitateur
            self.master.declare_win(self)
        else:
            #Montrez votre main actuelle
            print(self.name, ": La main restante",self.hand.getNumberOfCard(), "est\n")

    #Mélangez votre main pour montrer
    def show_hand(self):
        if self.hand.getNumberOfCard() == 1:
            self.master.declare_win(self)
        self.hand.shuffle()
        return self.hand

    #Recevoir la carte
    def receive_card(self,card):
        self.deal_card(card)

    #Si vous avez la même carte, jetez-la
    def deal_card(self,card):

        #Ajoutez une carte à votre main
        self.hand.add_card(card)

        #Trouvez la même carte que vous venez d'ajouter
        same_cards = self.hand.find_same_number_card()

        #Si la même combinaison de cartes existe
        if (same_cards != None):
            #Jeter la carte sur la table
            self.table.dispose_card(same_cards)

    #Renvoie le nom du joueur
    def toString(self):
        return self.name

Cours de maître

master.py

class Master():

    def __init__(self,player_list):
        self.player_list = player_list

    def prepare_game(self,hand):
        print("[Distribuer les cartes]\n")

        #Mélanger les cartes à jouer
        hand.shuffle()

        #Obtenez le nombre de cartes à jouer
        number_of_cards = hand.getNumberOfCard()

        #Obtenez le nombre de joueurs
        number_of_players = len(self.player_list)

        for index in range(number_of_cards):

            #Tirez-en un sur la carte
            card = hand.pick_card()

            #Distribuez les cartes à chaque joueur à tour de rôle
            player = self.player_list[index % number_of_players]
            player.receive_card(card)


    #Commencer le jeu.
    def start_game(self):
        print("\n [Commencer à retirer le molleton]\n")

        #Obtenez le nombre de joueurs
        count = 0
        while len(self.player_list) > 1:
            player_index = count % len(self.player_list)
            next_player_index = (count + 1) % len(self.player_list)

            #Acquérir un joueur désigné
            player = self.player_list[player_index]
            #Obtenez le prochain joueur
            next_player = self.player_list[next_player_index]

            #Nommer un joueur
            print("\n", player.name, "C'est ton tour--- ({})".format(count), "\n")
            player.play(next_player)
            count += 1

        #Quittez la boucle lorsque le lecteur monte et qu'il n'en reste qu'un
        print("[Terminé la suppression]\n")


    #Déclarez la montée.
    def declare_win(self,winner):
        #Joueur qui est monté
        print(winner.name, "Je me suis levé!\n")

        #Retirer le joueur soulevé de la liste
        self.player_list.remove(winner)

        #Afficher le perdant lorsqu'il ne reste qu'un seul joueur
        if len(self.player_list) == 1:
            loser = self.player_list[0]
            print(loser.name, "Est vaincu!\n")


    #Enregistrez les joueurs qui participeront au jeu.
    def register_player(self,player):
        self.player_list.append(player)

Programme d'exécution

old_maid.py

from card import *
from hand import *
from master import *
from player import *
from table import *

#Un programme ridicule.


#Générez 53 cartes à jouer.
def create_trump():
    trump = Hand([])

    #Génère 13 cartes pour chaque suie
    for i in range(13):
        number = i + 1
        trump.add_card(Card("SUIT_CLUB", number))
        trump.add_card(Card("SUIT_DIAMOND", number))
        trump.add_card(Card("SUIT_HEART", number))
        trump.add_card(Card("SUIT_SPADE", number))

    #Créer un joker
    trump.add_card(Card(0, 0))

    return trump

#Générer des facilitateurs
master = Master([])

#Génération de champ
field = Table()

#Génération de joueurs
murata = Player("Murata", Hand([]), master, field)
yamada = Player("Yamada", Hand([]), master, field)
saito = Player("Saito", Hand([]),master, field)

#Enregistrer le joueur comme facilitateur
master.register_player(murata)
master.register_player(yamada)
master.register_player(saito)

#Générer des cartes à jouer
trump = create_trump()

#Préparez-vous pour le jeu
master.prepare_game(trump)

#Commencer le jeu
master.start_game()

Frameworkisation (7 lignes)

・ Comme il a été ignoré, il est omis. Il y a deux points à prendre en compte:

Classe abstraite

-Lors de la création d'une classe abstraite avec python, il est nécessaire d'importer ABC (Abstract Base Classes) et d'hériter de la classe abstraite. → Référence: ABC in Python-Abstract Classes and Duck Typing

Passer par valeur

· Doit être passé par valeur lorsque la classe de table renvoie des informations de table

table.py

class FantanTable(Table):

    #Table créée avec numpy
    matrix = np.full((4,13),"..")

    def getCard(self):
        return self.matrix.copy()