Métodos construtores

Alguém poderia me explicar detalhadamente o que são métodos construtores... vo deixar um exemplo

public class Card 
{
   private String face;  
   private String suit;  

   // construtor de dois argumentos inicializa face e naipe da carta
   public Card( String cardFace, String cardSuit )
   {
      face = cardFace; // inicializa face da carta
      suit = cardSuit; // inicializa naipe da carta
   }  

   
   public String toString()               
   {                                      
      return face + " of " + suit;        
   }  
}

qual a função do método Card..?? ao meu ver ele atribui as variaveis de instancia os argumentos cardFace e cardSuit e isso mesmo???? qual a utilidade de usar métodos construtores..?? peguei um exemplo do livro mais não endenti vo colocar o código logo abaixo pra ficar mais fácil o entendimento classe Card:

public class Card 
{
   private String face; // face da carta ("Ace", "Deuce", ...)
   private String suit; // naipe da carta ("Hearts", "Diamonds", ...)

   // construtor de dois argumentos inicializa face e naipe da carta
   public Card( String cardFace, String cardSuit )
   {
      face = cardFace; // inicializa face da carta
      suit = cardSuit; // inicializa naipe da carta
   } // fim do construtor Card de dois argumentos

   // retorna representação String de Card
   public String toString()               
   {                                      
      return face + " of " + suit;        
   } // fim do método toString
} /

classe DeckOfCards:

import java.util.Random;

public class DeckOfCards
{
   private Card deck[]; // array de objetos Card
   private int currentCard; // índice do próximo Card a ser distribuído
   private final int NUMBER_OF_CARDS = 52; // número constante de Cards
   private Random randomNumbers; // gerador de número aleatório

   // construtor preenche baralho de cartas
   public DeckOfCards()
   {
      String faces[] = { "Ace", "Deuce", "Three", "Four", "Five", "Six",
         "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King" };    
      String suits[] = { "Hearts", "Diamonds", "Clubs", "Spades" };     

      deck = new Card[ NUMBER_OF_CARDS ]; // cria array de objetos Card
      currentCard = 0; // configura currentCard então o primeiro Card distribuído é deck[ 0 ]
      randomNumbers = new Random(); // cria gerador de número aleatório

      // preenche baralho com objetos Card
      for ( int count = 0; count < deck.length; count++ )        
         deck[ count ] =                                         
            new Card( faces[ count % 13 ], suits[ count / 13 ] );
   } // fim do construtor DeckOfCards

   // embaralha as cartas com um algoritmo de uma passagem
   public void shuffle()
   {
      // depois de embaralhar, a distribuição deve iniciar em deck[ 0 ] novamente
      currentCard = 0; // reinicializa currentCard

      // para cada Card, seleciona outro Card aleatório e os compara
      for ( int first = 0; first < deck.length; first++ )
      {
         // seleciona um número aleatório entre 0 e 51
         int second =  randomNumbers.nextInt( NUMBER_OF_CARDS );

         // compara Card atual com Card aleatoriamente selecionado
         Card temp = deck[ first ];     
         deck[ first ] = deck[ second ];
         deck[ second ] = temp;         
      } // for final
   } // fim do método shuffle

   // distribui um Card
   public Card dealCard()
   {
      // determina se ainda há Cards a serem distribuídos
      if (currentCard < deck.length)
         return deck[ currentCard++ ]; // retorna Card atual no array
      else        
         return null; // retorna nulo p/ indicar que todos os Cards foram distribuídos
   } // fim do método dealCard
} // fim da classe DeckOfCards

classe DeckOfCardsTest:

public class DeckOfCardsTest
{
   // executa o aplicativo
   public static void main( String args[] )
   {
      DeckOfCards myDeckOfCards = new DeckOfCards();
      myDeckOfCards.shuffle(); // coloca Cards em ordem aleatória
      
      // imprime todas as 52 cartas na ordem em que elas são distribuídas
      for ( int i = 0; i < 13; i++ )
      {
         // distribui e imprime 4 Cards
         System.out.printf( "%-20s%-20s%-20s%-20s\n",
            myDeckOfCards.dealCard(), myDeckOfCards.dealCard(), 
            myDeckOfCards.dealCard(), myDeckOfCards.dealCard() );
      } // for final
   } // fim de main
} /

esse tipo de procedimento vai ser útil quando estiver trabalhando com programação??
achei sem sentido por favor alguém me explique como essa estrutura funciona..

Dentro do método construtor tu pode fazer praticamente o que quiser!! pode chamar outros métodos que você criou, pode não fazer nada!! Se você não declarar um método construtor, o java automaticamente implicitamente coloca um construtor vazio pra voce!!

Ex: Não fiz nada!

public Construtor() {}

public Construtor() {
    // Chama teus métodos
    montaTela();
}

Você pode criar mais de um método construtor na mesma classe!! ( Sobrecarga de método! )

Assim:

public Construtor() {}

public Construtor( String texto ) {
     // Chama um método qualquer
     imprimiTexto( texto );
}

public Construtor( int um, int dois ) {
      soma( um, dois );
}

// Teus métodos
    public void imprimiTexto( String texto ) {
           // Imprimi teu texto
           System.out.println( texto );          
    }

    public int soma( int valorUm, int valorDois ) {
          int total = valoorUm + valorDois;
          return total;
   }

Sempre que você usa assim:

Classe classe = new Classe();

A parte de new Classe() é a chamada ao método construtor!! Se ele tiver paramentros, tu faz assim:

Classe classe = new Classe( "Texto" );

Se teu método construtor chamar algum método dentro dele, ao ser chamado, os métodos dentro dele também serão chamados!!! Então são n possibilidades!!!

3 Respostas

Topicos relacionados