Coffee break #114. Ang default na constructor sa Java ay isang halimbawa ng isang class constructor. Maven vs Gradle: Paano Pumili ng Tamang Tool sa Pagbuo

Default na Constructor sa Java - Halimbawa ng isang Class Constructor

Pinagmulan: FreeCodeCamp Sa artikulong ito ay pag-uusapan natin ang tungkol sa mga konstruktor, kung paano lumikha ng mga ito at kung ano ang mga default na konstruktor sa Java.

Ano ang isang constructor?

Bilang isang term na nakabatay sa klase na object-oriented programming, ang isang constructor ay isang natatanging paraan na ginagamit upang simulan ang isang bagong nilikha na bagay (klase). Mayroong ilang mga patakaran na dapat mong sundin kapag gumagawa ng mga konstruktor. Kasama sa mga panuntunang ito ang:

• Dapat tumugma ang pangalan ng constructor sa pangalan ng klase.
• Ang isang constructor ay hindi dapat magkaroon ng isang uri ng pagbabalik.

Bago tayo magpatuloy, tingnan natin kung ano ang hitsura ng isang klase sa Java:

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

Ang code sa itaas ay nagpapakita ng klase ng Mag-aaral na may tatlong katangian - firstName , lastName at edad . Ipagpalagay namin na ang klase ay dapat na isang modelo para sa pagpaparehistro ng mag-aaral. Alalahanin na ang tatlong katangiang ito ay walang anumang mga halaga, kaya ang impormasyon sa mga ito ay hindi hard-coded. Ngayon ay gagamit kami ng mga constructor upang lumikha ng bagong instance ng aming Student object :

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

Gumawa kami ng isang constructor na ginamit namin upang simulan ang mga katangian na tinukoy sa object ng Student . Ang code sa itaas ay isang halimbawa ng isang no-argument constructor . Tingnan natin ngayon ang ibang uri ng halimbawa:

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

}

Ngayon nakagawa kami ng isang parameterized constructor. Ang isang parameterized constructor ay isang constructor na nilikha gamit ang mga argumento/parameter. Ngayon ay baguhin natin ito.

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

  }

Gumawa kami ng bagong constructor na tumatagal ng tatlong argumento - dalawang string at isang integer.

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

Pagkatapos ay iniugnay namin ang mga argumentong ito sa mga katangiang tinukoy namin noong lumilikha ng aming klase. Ngayon nasimulan na namin ang object ng Student gamit ang constructor.

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

Sa wakas, gumawa kami ng bagong instance ng Student object at ipinasa ang aming mga argumento dito. Nagawa namin ito dahil natukoy na namin ang mga ito sa constructor. Gumawa ako ng isang constructor na may tatlong argumento, ngunit maaari ka ring lumikha ng hiwalay na mga constructor upang masimulan ang bawat katangian. Ngayong alam mo na kung ano ang isang constructor sa Java at kung paano ito gamitin, tingnan natin ang mga default na constructor.

Ano ang default na tagabuo?

Ang default na constructor ay ang constructor na nabuo ng compiler kung hindi namin tinukoy ang anumang mga constructor para sa klase. Narito ang isang halimbawa:

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

Mahahanap mo ba ang pagkakaiba nito sa dalawang naunang halimbawa? Tandaan na bago ang paglikha, hindi namin tinukoy ang isang myStudent constructor upang simulan ang mga katangiang ginawa sa klase. Hindi ito magtapon ng pagkakamali sa ating landas. Mas tiyak, ang compiler ay lilikha ng isang walang laman na tagabuo, ngunit hindi mo makikita ang tagabuo na ito kahit saan sa code - ito ay nangyayari "sa ilalim ng talukbong". Ito ang magiging hitsura ng code sa itaas kapag nagsimulang gawin ng compiler ang trabaho nito:

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

Maraming tao ang nalilito sa default na constructor sa no-argument constructor, ngunit sa Java hindi sila pareho. Anumang constructor na nilikha ng programmer ay hindi itinuturing na isang default na constructor sa Java.

Konklusyon

Sa artikulong ito, natutunan namin kung ano ang mga constructor at kung paano namin magagawa at gamitin ang mga ito upang simulan ang aming mga bagay. Napag-usapan din namin ang tungkol sa mga default na konstruktor at kung paano sila naiiba sa mga konstruktor na walang argumento. Maligayang coding!

Maven vs Gradle: Paano Pumili ng Tamang Tool sa Pagbuo

Pinagmulan: Ang automation ng Hackernoon Build ay isang mahalagang aspeto ng software development. Sa artikulong ito, ihahambing namin ang dalawa sa pinakasikat na tool sa pagbuo para sa pagpapaunlad ng Java: Maven at Gradle .

Gumawa at Apache Ant

Noong nakaraan, ginamit ng mga developer ang Make tool upang lumikha ng mga proyekto ng Java, at ang proseso ng pagbuo ay hindi gaanong naiiba sa paglikha ng mga application sa anumang iba pang wika. Ngunit noong 2000, inilabas ang An t (Another Neat Tool) build system. Ang Ant, tulad ng Make, ay gumagamit ng isang imperative na istilo, at ang mga build script nito ay may XML syntax. Idinisenyo ang Ant bilang isang build automation system para sa mga proyekto ng Java. Samakatuwid, madaling mapalawak ng mga developer ng Java ang pagpapagana nito.

Maven

Noong 2004, lumabas ang bagong Maven build system at binago ang proseso ng pagbuo ng mga application ng Java. Dati, ang mga developer mismo ang nag-organisa ng istraktura ng folder upang mag-imbak ng source code, mga mapagkukunan, mga direktoryo ng classpath, at mga direktoryo ng output. Dahil dito, maaaring magkaiba ang Ant build script para sa dalawang magkaibang application: ang compilation, assembly, pagkopya ng mga file sa output directory, atbp. ay isinulat nang hiwalay. Sa Maven, ang isang proyekto ng Java ay palaging may malinaw na istraktura. Halimbawa, ang mga mapagkukunan ay dapat nasa src/main/java, ang mga mapagkukunan para sa mga pagsubok ay dapat nasa src/test/resources. Pinapayagan ka ng Maven na lumikha ng istraktura ng file ng isang tipikal na proyekto na may isang solong utos. Ipinakilala rin ni Maven ang konsepto ng "build lifecycle" na may mga sunud-sunod na yugto: validate ➞ compile ➞ test ➞ package ➞ verify ➞ install ➞ deploy) Ngayon, salamat sa mga fixed structure folder at set ng mga target, hindi na kailangang magsulat at mapanatili ang isang malaking build script - sila ay naging deklaratibo. Naging mas maginhawa para sa mga developer na gumana hindi lamang sa kanilang sariling code, kundi pati na rin sa mga proyekto ng third-party, dahil malinaw kung paano gumagana ang source code at kung paano ito tipunin. Mayroong ilang mga aklatan sa mundo ng Java, at ang malalaking application ay gumagamit ng daan-daang mga ito. Kung gagamit ka ng Ant, tandaan na kakailanganin mong idagdag ang mga kinakailangang jar file sa proyekto mismo. Kailangan mo ring pangalagaan ang mga kinakailangang transitive dependencies. Nagbibigay ang Maven ng functionality ng dependency manager sa pamamagitan ng Maven Central Repository. Ngayon, kapag tumutukoy ng bagong dependency sa build script, awtomatikong mahahanap ni Maven ang kinakailangang jar ng kaukulang bersyon at lahat ng mga transitive dependencies nito, i-download ang mga ito at tiyaking mapupunta sila sa classpath ng proyekto. Maaari mo ring panatilihin ang iyong sariling pribadong imbakan, kung saan maaari mong iimbak ang iyong sarili o naka-patch na mga aklatan, o karaniwang mga aklatan na ginawa gamit ang kamay. Dapat tandaan na ang Ant ay maaaring gamitin kasabay ng Apache Ivy Project , na nagpapahintulot din sa iyo na pamahalaan ang mga dependency at magtrabaho kasama ang mga repositoryo ng Maven. Sa kabila ng lahat ng mga pakinabang ng Maven, ang deklaratibong diskarte nito ay maaaring maging isang kawalan sa ilang mga sitwasyon. Halimbawa, kapag kailangan mong baguhin ang build lifecycle at magdagdag ng mga bagong layunin sa proseso ng build. Ang pag-andar ng Maven ay maaaring mapalawak gamit ang mga plugin. Mayroong maraming mga handa na Maven plugin na lumulutas ng iba't ibang mga problema, ang lahat ay magagamit din mula sa Maven Central Repository. Ngunit kung sa ilang kadahilanan kailangan mong bahagyang baguhin ang karaniwang ikot ng buhay, at walang angkop na plugin, ang developer ay kailangang lumikha nito mismo.

Gradle

Ang unang release ng Gradle build system ay inilabas noong 2008. Pagkalipas ng 4 na taon, inilabas ang bersyon 1.0. Ang layunin ng proyekto ng Gradle ay panatilihin ang lahat ng mga benepisyo ng Maven, ngunit sa parehong oras ay dagdagan ang kakayahang i-customize ang proseso ng pagbuo. Ang mga script ng Gradle build ay nakasulat sa Groovy DSL. Binibigyang-daan ka ng Gradle na magsulat ng mga declarative build script at mas compact kaysa sa Maven dahil ang XML ay napakalaki. Madali kang makakapagdagdag ng custom na logic sa iyong proseso ng pagbuo ng Gradle. Ang kailangan mo lang gawin ay magsulat ng Groovy script, at hindi mo kailangang bumuo ng mga plugin. Madaling ma-debug ng developer ang pagpapatupad ng mga build script dahil ang mga ito ay regular na Groovy file. Kaya, pinagsasama ng Gradle ang mga deklaratibo at imperative na diskarte. Sinusuportahan din ng Gradle ang mga plugin, na nagpapahintulot sa mga developer na baguhin ang mga setting. Ang isa sa mga makabuluhang bentahe ng Gradle ay incremental build. Kapag na-restart ang build, tinutukoy ng Gradle kung nagbago ang mga input file ng target, at kung hindi, nilaktawan ang execution ng target dahil naitayo na ang mga output artifact nito. Nagbibigay ito ng makabuluhang pagtaas sa bilis ng build kumpara sa Maven, lalo na sa malalaking multi-module na proyekto. Maaari ding patakbuhin ng Gradle ang Gradle daemon, isang proseso sa background na umiiwas sa pag-aaksaya ng mga mapagkukunan at oras ng pagsisimula sa tuwing tatakbo ang build. Ang Gradle ay may madaling gamiting tampok na Gradle wrapper - ang kakayahang bumuo ng shell at mga script ng command ng Windows na awtomatikong nagda-download ng pamamahagi ng Gradle ng tinukoy na bersyon at ginagamit ito upang buuin ang proyekto. Nangangahulugan ito na para makabuo ng proyekto ng Gradle hindi mo kailangang i-install nang hiwalay ang Gradle, i-install lang ang Java. Kung kinakailangan, madali mong mailipat ang iyong proyekto sa ibang bersyon ng Gradle.

Pagpili sa pagitan ng Maven at Gradle

Sa kabila ng mga benepisyo ng Gradle, kakaunti ang mga proyekto ang gumagamit ng Maven build system. Ang pagpili ay depende sa uri ng proyekto at koponan. Ginagamit na ang Maven mula noong 2004, kaya mas maraming developer ang pamilyar dito. Tsaka stable naman si Maven. Ang pinakabagong pangunahing bersyon 3 ay inilabas noong 2010. Ang Gradle ay nagbago nang malaki nang ilang beses nang walang backward compatibility, at kinailangan ng mga developer na i-port ang kanilang mga build script sa mga bagong bersyon. Dahil hindi lahat ay pamilyar sa Groovy o Kotlin, ang pagtatrabaho sa Gradle ay nangangailangan ng karagdagang kaalaman, samantalang si Maven ay gumagamit ng malinaw na XML. Itinataas nito ang tanong: kung nagsimula ang proyekto sa pag-develop bago naging sikat ang Gradle, makatuwiran bang ilipat ang mga script ng build sa Gradle? Sa isang banda, parami nang parami ang mga developer na pumipili ng Gradle. Halimbawa, ang Spring, Hibernate at LinkedIn ay gumagamit ng Gradle. Ang Android build system ay Gradle din, at ito ay karaniwang sikat sa mga developer ng Android application. Sa kabilang banda, lahat ng kilalang IDE ay may integration sa parehong build system at sumusuporta sa autocompletion kapag nag-e-edit ng mga build script. Tulad ng Maven, ang Gradle ay may malaking bilang ng mga plugin na nagbibigay-daan sa iyong magdagdag ng mga madalas na ginagamit na function sa proseso ng pagbuo ng proyekto.

Konklusyon

Mula sa mga kalamangan at kahinaan ng bawat isa sa mga sistema ng pagpupulong na inilarawan sa itaas, ang sumusunod na konklusyon ay maaaring iguguhit. Ang Maven ay mas angkop para sa maliliit na proyekto na hindi nangangailangan ng pagpapasadya ng proseso ng pagbuo, at kung saan ang oras ng pagbuo ng proyekto ay hindi masyadong kritikal. Mas angkop ang Gradle para sa mga malalaking proyekto na may malaking bilang ng mga module, pati na rin para sa mga Android application.