Pausa para café #114. O construtor padrão em Java é um exemplo de construtor de classe. Maven vs Gradle: como escolher a ferramenta de construção certa

Construtor padrão em Java – exemplo de construtor de classe

Fonte: FreeCodeCamp Neste artigo falaremos sobre construtores, como criá-los e quais são os construtores padrão em Java.

O que é um construtor?

Como um termo de programação orientada a objetos baseado em classe, um construtor é um método exclusivo usado para inicializar um objeto (classe) recém-criado. Existem diversas regras que você deve seguir ao criar construtores. Essas regras incluem:

• O nome do construtor deve corresponder ao nome da classe.
• Um construtor não deve ter um tipo de retorno.

Antes de continuarmos, vamos ver como é uma classe em Java:

public class Student {
  String firstName;
  String lastName;
  int age;
}

O código acima mostra uma classe Student com três atributos – firstName , lastName e age . Assumiremos que a turma deve ser um modelo para matrícula de alunos. Lembre-se de que esses três atributos não possuem nenhum valor, portanto as informações neles contidas não são codificadas. Agora usaremos construtores para criar uma nova instância do nosso objeto Student :

public class Student {
  String firstName;
  String lastName;
  int age;

  //конструктор Student
  public Student(){
      firstName = "Ihechikara";
      lastName = "Abba";
      age = 100;
  }

  public static void main(String args[]) {
      Student myStudent = new Student();
      System.out.println(myStudent.age);
      // 100
  }
}

Criamos um construtor que usamos para inicializar os atributos definidos no objeto Student . O código acima é um exemplo de construtor sem argumentos . Vejamos agora um tipo diferente de exemplo:

public class Student {
  String firstName;
  String lastName;
  int age;

  //конструктор
  public Student(String firstName, String lastName, int age){
      this.firstName = firstName;
      this.lastName = lastName;
      this.age = age;
  }

  public static void main(String args[]) {
    Student myStudent = new Student("Ihechikara", "Abba", 100);
    System.out.println(myStudent.age);
  }

}

Agora criamos um construtor parametrizado. Um construtor parametrizado é um construtor criado com argumentos/parâmetros. Agora vamos mudar isso.

public Student(String firstName, String lastName, int age){

  }

Criamos um novo construtor que aceita três argumentos – duas strings e um número inteiro.

this.firstName = firstName;
this.lastName = lastName;
this.age = age;

Em seguida, associamos esses argumentos aos atributos que definimos ao criar nossa classe. Agora inicializamos o objeto Student usando o construtor.

public static void main(String args[]) {
    Student myStudent = new Student("Ihechikara", "Abba", 100);
    System.out.println(myStudent.age);
  }

Finalmente, criamos uma nova instância do objeto Student e passamos nossos argumentos para ela. Conseguimos fazer isso porque já os havíamos definido no construtor. Criei um construtor com três argumentos, mas você também pode criar construtores separados para inicializar cada atributo. Agora que você sabe o que é um construtor em Java e como usá-lo, vamos dar uma olhada nos construtores padrão.

Qual é o construtor padrão?

O construtor padrão é o construtor gerado pelo compilador se não definirmos nenhum construtor para a classe. Aqui está um exemplo:

public class Student {
  String firstName;
  String lastName;
  int age;

  public static void main(String args[]) {
      Student myStudent = new Student();

      myStudent.firstName = "Ihechikara";
      myStudent.lastName = "Abba";
      myStudent.age = 100;

      System.out.println(myStudent.age);
      //100

      System.out.println(myStudent.firstName);
      //Ihechikara
  }
}

Você consegue encontrar a diferença entre este e os dois exemplos anteriores? Observe que antes da criação, não definimos um construtor myStudent para inicializar os atributos criados na classe. Isso não gerará um erro em nosso caminho. Mais precisamente, o compilador criará um construtor vazio, mas você não verá esse construtor em nenhum lugar do código - isso acontece “nos bastidores”. Esta é a aparência do código acima quando o compilador começar a fazer seu trabalho:

public class Student {
  String firstName;
  String lastName;
  int age;


  /* пустой конструктор, созданный компилятором. Этот конструктор не будет отображаться в вашем codeе*/
  Student() {

  }

  public static void main(String args[]) {
      Student myStudent = new Student();

      myStudent.firstName = "Ihechikara";
      myStudent.lastName = "Abba";
      myStudent.age = 100;

      System.out.println(myStudent.age);
      //100

      System.out.println(myStudent.firstName);
      //Ihechikara
  }
}

Muitas pessoas confundem o construtor padrão com o construtor sem argumento, mas em Java eles não são a mesma coisa. Qualquer construtor criado pelo programador não é considerado um construtor padrão em Java.

Conclusão

Neste artigo, aprendemos o que são construtores e como podemos criá-los e usá-los para inicializar nossos objetos. Também falamos sobre construtores padrão e como eles diferem dos construtores sem argumentos. Boa codificação!

Maven vs Gradle: como escolher a ferramenta de construção certa

Fonte: Hackernoon A automação de construção é um aspecto importante do desenvolvimento de software. Neste artigo, compararemos duas das ferramentas de construção mais populares para desenvolvimento Java: Maven e Gradle .

Faça e Apache Ant

Anteriormente, os desenvolvedores usavam a ferramenta Make para criar projetos Java, e o processo de construção não era muito diferente da criação de aplicativos em qualquer outra linguagem. Mas em 2000, o sistema de construção Ant (Another Neat Tool) foi lançado. Ant, assim como Make, usa um estilo imperativo e seus scripts de construção possuem sintaxe XML. Ant foi projetado como um sistema de automação de construção para projetos Java. Portanto, os desenvolvedores Java podem estender facilmente sua funcionalidade.

Maven

Em 2004, o novo sistema de construção Maven foi lançado e mudou o processo de construção de aplicações Java. Anteriormente, os próprios desenvolvedores organizavam uma estrutura de pastas para armazenar código-fonte, recursos, diretórios de classpath e diretórios de saída. Por causa disso, os scripts de construção Ant para dois aplicativos diferentes podem ser muito diferentes: compilação, montagem, cópia de arquivos para o diretório de saída, etc., foram escritos separadamente. No Maven, um projeto Java sempre possui uma estrutura clara. Por exemplo, as fontes devem estar em src/main/java, os recursos para testes devem estar em src/test/resources. Maven permite criar a estrutura de arquivos de um projeto típico com um único comando. Maven também introduz o conceito de “ciclo de vida de construção” com fases sequenciais: validar ➞ compilar ➞ testar ➞ empacotar ➞ verificar ➞ instalar ➞ implantar) Agora, graças às pastas de estrutura fixa e um conjunto de alvos, não há necessidade de escrever e mantêm um script de construção grande - eles se tornaram declarativos. Tornou-se mais conveniente para os desenvolvedores trabalhar não apenas com seu próprio código, mas também com projetos de terceiros, pois fica claro como funciona o código-fonte e como montá-lo. Existem algumas bibliotecas no mundo Java e grandes aplicativos usam centenas delas. Se você usa Ant, lembre-se de que você mesmo terá que adicionar os arquivos jar necessários ao projeto. Você também precisa cuidar das dependências transitivas necessárias. O Maven fornece funcionalidade de gerenciador de dependências por meio do Maven Central Repository. Agora, ao especificar uma nova dependência no script de construção, o Maven encontrará automaticamente o jar necessário da versão correspondente e todas as suas dependências transitivas, fará o download delas e garantirá que elas acabem no classpath do projeto. Você também pode manter seu próprio repositório privado, onde pode armazenar suas próprias bibliotecas ou bibliotecas corrigidas, ou bibliotecas padrão criadas manualmente. Deve-se notar que o Ant pode ser usado em conjunto com o Projeto Apache Ivy , que também permite gerenciar dependências e trabalhar com repositórios Maven. Apesar de todas as vantagens do Maven, a sua abordagem declarativa pode ser uma desvantagem em algumas situações. Por exemplo, quando você precisa alterar o ciclo de vida do build e adicionar novas metas ao processo de build. A funcionalidade do Maven pode ser estendida usando plug-ins. Existem muitos plug-ins Maven prontos que resolvem diferentes problemas, todos também disponíveis no Repositório Central Maven. Mas se por algum motivo você precisar alterar um pouco o ciclo de vida padrão e não houver um plugin adequado, o desenvolvedor terá que criá-lo sozinho.

Gradle

A primeira versão do sistema de compilação Gradle foi lançada em 2008. 4 anos depois a versão 1.0 foi lançada. O objetivo do projeto Gradle é manter todos os benefícios do Maven, mas ao mesmo tempo aumentar a capacidade de customização do processo de construção. Os scripts de construção do Gradle são escritos em Groovy DSL. Gradle permite escrever scripts de construção declarativos e é mais compacto que o Maven porque o XML é bastante volumoso. Você pode adicionar facilmente lógica personalizada ao processo de construção do Gradle. Tudo o que você precisa fazer é escrever um script Groovy e não precisa desenvolver plug-ins. O desenvolvedor pode depurar facilmente a execução de scripts de construção, uma vez que são arquivos Groovy regulares. Assim, Gradle combina abordagens declarativas e imperativas. Gradle também oferece suporte a plug-ins, permitindo que os desenvolvedores alterem as configurações. Uma das vantagens significativas do Gradle são as compilações incrementais. Quando a compilação é reiniciada, o Gradle determina se os arquivos de entrada do destino foram alterados e, caso contrário, a execução do destino é ignorada porque seus artefatos de saída já foram compilados. Isso proporciona um aumento significativo na velocidade de construção em comparação com o Maven, especialmente em grandes projetos com vários módulos. Gradle também pode executar o daemon Gradle, um processo em segundo plano que evita o desperdício de recursos e tempo de inicialização cada vez que a compilação é executada. O Gradle possui um recurso útil de wrapper do Gradle - a capacidade de gerar scripts de comando shell e do Windows que baixam automaticamente a distribuição Gradle da versão especificada e a usam para construir o projeto. Isso significa que para construir um projeto Gradle você não precisa instalar o Gradle separadamente, basta instalar o Java. Se necessário, você pode facilmente mudar seu projeto para uma versão diferente do Gradle.

Escolhendo entre Maven e Gradle

Apesar dos benefícios do Gradle, alguns projetos usam o sistema de construção Maven. A escolha depende do tipo de projeto e equipe. O Maven está em uso desde 2004, então mais desenvolvedores estão familiarizados com ele. Além disso, o Maven é estável. A última versão principal 3 foi lançada em 2010. O Gradle já mudou significativamente várias vezes sem compatibilidade com versões anteriores, e os desenvolvedores tiveram que portar seus scripts de construção para novas versões. Como nem todo mundo está familiarizado com Groovy ou Kotlin, trabalhar com Gradle requer conhecimento adicional, enquanto Maven usa XML claro. Isso levanta a questão: se o projeto começou a ser desenvolvido antes do Gradle se tornar popular, faz sentido mover os scripts de construção para o Gradle? Por um lado, cada vez mais desenvolvedores estão escolhendo o Gradle. Por exemplo, Spring, Hibernate e LinkedIn usam Gradle. O sistema de compilação do Android também é Gradle e geralmente é popular entre os desenvolvedores de aplicativos Android. Por outro lado, todos os IDEs conhecidos têm integração com sistemas de construção e suportam preenchimento automático ao editar scripts de construção. Assim como o Maven, o Gradle possui um grande número de plug-ins que permitem adicionar funções usadas com frequência ao processo de construção do projeto.

Conclusão

Dos prós e contras de cada um dos sistemas de montagem descritos acima, pode-se tirar a seguinte conclusão. O Maven é mais adequado para projetos pequenos que não exigem customização do processo de construção e para os quais o tempo de construção do projeto não é tão crítico. Gradle é mais adequado para projetos de grande escala com grande número de módulos, bem como para aplicativos Android.