Pause café #114. Le constructeur par défaut en Java est un exemple de constructeur de classe. Maven vs Gradle : comment choisir le bon outil de construction

Constructeur par défaut en Java - Exemple de constructeur de classe

Source : FreeCodeCamp Dans cet article, nous parlerons des constructeurs, comment les créer et quels sont les constructeurs par défaut en Java.

Qu'est-ce qu'un constructeur ?

En tant que terme de programmation orientée objet basé sur les classes, un constructeur est une méthode unique utilisée pour initialiser un objet (classe) nouvellement créé. Il existe plusieurs règles que vous devez suivre lors de la création de constructeurs. Ces règles comprennent :

• Le nom du constructeur doit correspondre au nom de la classe.
• Un constructeur ne doit pas avoir de type de retour.

Avant de continuer, voyons à quoi ressemble une classe en Java :

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

Le code ci-dessus montre une classe Student avec trois attributs : firstName , lastName et age . Nous supposerons que la classe doit être un modèle pour l'inscription des étudiants. Rappelez-vous que ces trois attributs n’ont aucune valeur, donc les informations qu’ils contiennent ne sont pas codées en dur. Nous allons maintenant utiliser des constructeurs pour créer une nouvelle instance de notre objet 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
  }
}

Nous avons créé un constructeur que nous avons utilisé pour initialiser les attributs définis dans l' objet Student . Le code ci-dessus est un exemple de constructeur sans argument . Regardons maintenant un autre type d'exemple :

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);
  }

}

Nous avons maintenant créé un constructeur paramétré. Un constructeur paramétré est un constructeur créé avec des arguments/paramètres. Maintenant, changeons-le.

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

  }

Nous avons créé un nouveau constructeur qui prend trois arguments : deux chaînes et un entier.

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

Nous avons ensuite associé ces arguments aux attributs que nous avons définis lors de la création de notre classe. Nous avons maintenant initialisé l' objet Student à l'aide du constructeur.

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

Enfin, nous avons créé une nouvelle instance de l' objet Student et lui avons transmis nos arguments. Nous avons pu le faire car nous les avions déjà définis dans le constructeur. J'ai créé un constructeur avec trois arguments, mais vous pouvez également créer des constructeurs distincts pour initialiser chaque attribut. Maintenant que vous savez ce qu'est un constructeur en Java et comment l'utiliser, examinons les constructeurs par défaut.

Quel est le constructeur par défaut ?

Le constructeur par défaut est le constructeur généré par le compilateur si nous ne définissons aucun constructeur pour la classe. Voici un exemple :

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
  }
}

Pouvez-vous trouver la différence entre cet exemple et les deux exemples précédents ? Notez qu'avant la création, nous n'avons pas défini de constructeur myStudent pour initialiser les attributs créés dans la classe. Cela ne créera pas d’erreur sur notre chemin. Plus précisément, le compilateur créera un constructeur vide, mais vous ne verrez ce constructeur nulle part dans le code - cela se passe « sous le capot ». Voici à quoi ressemblera le code ci-dessus lorsque le compilateur commencera à faire son travail :

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
  }
}

Beaucoup de gens confondent le constructeur par défaut avec le constructeur sans argument, mais en Java, ce n'est pas la même chose. Tout constructeur créé par le programmeur n'est pas considéré comme un constructeur par défaut en Java.

Conclusion

Dans cet article, nous avons appris ce que sont les constructeurs et comment les créer et les utiliser pour initialiser nos objets. Nous avons également parlé des constructeurs par défaut et de la manière dont ils diffèrent des constructeurs sans argument. Bon codage !

Maven vs Gradle : comment choisir le bon outil de construction

Source : Hackernoon Build L'automatisation est un aspect important du développement logiciel. Dans cet article, nous comparerons deux des outils de build les plus populaires pour le développement Java : Maven et Gradle .

Faire et Apache Ant

Auparavant, les développeurs utilisaient l'outil Make pour créer des projets Java, et le processus de création n'était pas très différent de la création d'applications dans n'importe quel autre langage. Mais en 2000, le système de construction Ant (Another Neat Tool) a été publié. Ant, comme Make, utilise un style impératif et ses scripts de construction ont une syntaxe XML. Ant est conçu comme un système d'automatisation de construction pour les projets Java. Par conséquent, les développeurs Java peuvent facilement étendre ses fonctionnalités.

Maven

En 2004, le nouveau système de build Maven est sorti et a modifié le processus de création d'applications Java. Auparavant, les développeurs eux-mêmes organisaient une structure de dossiers pour stocker le code source, les ressources, les répertoires de chemin de classe et les répertoires de sortie. Pour cette raison, les scripts de construction Ant pour deux applications différentes peuvent être très différents : la compilation, l'assemblage, la copie de fichiers dans le répertoire de sortie, etc. ont été écrits séparément. Dans Maven, un projet Java a toujours une structure claire. Par exemple, les sources doivent être dans src/main/java, les ressources pour les tests doivent être dans src/test/resources. Maven vous permet de créer la structure de fichiers d'un projet typique avec une seule commande. Maven introduit également le concept de « cycle de vie de build » avec des phases séquentielles : valider ➞ compiler ➞ tester ➞ package ➞ vérifier ➞ installer ➞ déployer. Désormais, grâce à la structure fixe des dossiers et à un ensemble de cibles, il n'est plus nécessaire d'écrire et maintenir un gros script de construction - ils sont devenus déclaratifs. Il est devenu plus pratique pour les développeurs de travailler non seulement avec leur propre code, mais également avec des projets tiers, car il est clair comment fonctionne le code source et comment l'assembler. Il existe de nombreuses bibliothèques dans le monde Java et les grandes applications en utilisent des centaines. Si vous utilisez Ant, n'oubliez pas que vous devrez ajouter vous-même les fichiers jar nécessaires au projet. Vous devez également prendre en charge les dépendances transitives nécessaires. Maven fournit une fonctionnalité de gestion de dépendances via le référentiel central Maven. Désormais, lors de la spécification d'une nouvelle dépendance dans le script de construction, Maven trouvera automatiquement le fichier jar requis de la version correspondante et toutes ses dépendances transitives, les téléchargera et s'assurera qu'ils se retrouvent dans le chemin de classe du projet. Vous pouvez également gérer votre propre référentiel privé, dans lequel vous pouvez stocker vos propres bibliothèques ou des bibliothèques corrigées, ou des bibliothèques standard créées à la main. Il convient de noter qu'Ant peut être utilisé conjointement avec le projet Apache Ivy , qui permet également de gérer les dépendances et de travailler avec les référentiels Maven. Malgré tous les avantages de Maven, son approche déclarative peut s’avérer un inconvénient dans certaines situations. Par exemple, lorsque vous devez modifier le cycle de vie de la build et ajouter de nouveaux objectifs au processus de build. La fonctionnalité Maven peut être étendue à l'aide de plugins. Il existe de nombreux plugins Maven prêts à l'emploi qui résolvent différents problèmes, tous également disponibles dans le référentiel central Maven. Mais si, pour une raison quelconque, vous devez modifier légèrement le cycle de vie standard et qu'il n'existe pas de plugin approprié, le développeur devra le créer lui-même.

Graduation

La première version du système de build Gradle a été publiée en 2008. 4 ans plus tard, la version 1.0 est sortie. L'objectif du projet Gradle est de conserver tous les avantages de Maven, tout en augmentant la possibilité de personnaliser le processus de construction. Les scripts de construction Gradle sont écrits en Groovy DSL. Gradle vous permet d'écrire des scripts de construction déclaratifs et est plus compact que Maven car XML est assez volumineux. Vous pouvez facilement ajouter une logique personnalisée à votre processus de création Gradle. Tout ce que vous avez à faire est d'écrire un script Groovy et vous n'avez pas besoin de développer de plugins. Le développeur peut facilement déboguer l’exécution des scripts de construction puisqu’il s’agit de fichiers Groovy classiques. Ainsi, Gradle combine des approches déclaratives et impératives. Gradle prend également en charge les plugins, permettant aux développeurs de modifier les paramètres. L'un des avantages importants de Gradle réside dans les constructions incrémentielles. Lorsque la construction est redémarrée, Gradle détermine si les fichiers d'entrée de la cible ont changé, et sinon, l'exécution de la cible est ignorée car ses artefacts de sortie ont déjà été construits. Cela donne une augmentation significative de la vitesse de construction par rapport à Maven, en particulier dans les grands projets multi-modules. Gradle peut également exécuter le démon Gradle, un processus en arrière-plan qui évite de gaspiller des ressources et du temps d'initialisation à chaque exécution de la build. Gradle dispose d'une fonctionnalité pratique de wrapper Gradle - la possibilité de générer des scripts de commande Shell et Windows qui téléchargent automatiquement la distribution Gradle de la version spécifiée et l'utilisent pour créer le projet. Cela signifie que pour créer un projet Gradle, vous n'avez pas besoin d'installer Gradle séparément, installez simplement Java. Si nécessaire, vous pouvez facilement basculer votre projet vers une autre version de Gradle.

Choisir entre Maven et Gradle

Malgré les avantages de Gradle, de nombreux projets utilisent le système de build Maven. Le choix dépend du type de projet et de l'équipe. Maven est utilisé depuis 2004, donc davantage de développeurs le connaissent. De plus, Maven est stable. La dernière version majeure 3 est sortie en 2010. Gradle a déjà changé de manière significative à plusieurs reprises sans compatibilité ascendante, et les développeurs ont dû porter leurs scripts de build vers de nouvelles versions. Comme tout le monde n'est pas familier avec Groovy ou Kotlin, travailler avec Gradle nécessite des connaissances supplémentaires, alors que Maven utilise du XML clair. Cela soulève la question : si le développement du projet a commencé avant que Gradle ne devienne populaire, est-il judicieux de déplacer les scripts de construction vers Gradle ? D'une part, de plus en plus de développeurs choisissent Gradle. Par exemple, Spring, Hibernate et LinkedIn utilisent Gradle. Le système de construction Android est également Gradle et il est généralement populaire parmi les développeurs d'applications Android. D'un autre côté, tous les IDE bien connus sont intégrés aux deux systèmes de build et prennent en charge l'auto-complétion lors de l'édition des scripts de build. Comme Maven, Gradle dispose d'un grand nombre de plugins qui vous permettent d'ajouter des fonctions fréquemment utilisées au processus de construction de projet.

Conclusion

Des avantages et des inconvénients de chacun des systèmes d'assemblage décrits ci-dessus, la conclusion suivante peut être tirée. Maven est plus adapté aux petits projets qui ne nécessitent pas de personnalisation du processus de construction et pour lesquels le temps de construction du projet n'est pas si critique. Gradle est plus adapté aux projets à grande échelle comportant un grand nombre de modules, ainsi qu'aux applications Android.