Nangungunang 50 tanong at sagot sa panayam sa trabaho para sa Java Core. Bahagi 1

Kumusta sa lahat, mga kababaihan at mga ginoo, mga inhinyero ng software! Pag-usapan natin ang mga tanong sa panayam. Tungkol sa kung ano ang kailangan mong paghandaan at kung ano ang kailangan mong malaman. Ito ay isang magandang panahon upang suriin o pag-aralan ang mga puntong ito sa unang pagkakataon. Nagtapos ako ng medyo malawak na koleksyon ng mga madalas itanong tungkol sa OOP, Java syntax, Java exceptions, collections, at multithreading, na hahatiin ko sa ilang bahagi para sa kaginhawahan. Mahirap sagutan ang lahat nang sabay-sabay, ngunit umaasa akong ang materyal na ito ay magbibigay ng magandang pundasyon para sa mga naghahanda na makahanap ng kanilang unang trabaho bilang isang programmer. Para sa pinakamahusay na pag-unawa at pagpapanatili, ipinapayo ko na magsuklay din sa iba pang mga mapagkukunan. Maaari kang makakuha ng mas malalim na pagkaunawa sa isang konsepto sa pamamagitan ng paglapit dito mula sa iba't ibang anggulo. Mahalaga:Pag-uusapan lang natin ang Java bago ang bersyon 8. Ang lahat ng inobasyon na dumating sa bersyon 9, 10, 11, 12, at 13 ay hindi isasaalang-alang dito. Anumang mga ideya/komento sa kung paano pagbutihin ang mga sagot ay malugod na tinatanggap . Masiyahan sa iyong pagbabasa. Tara na!

Panayam sa Java: mga tanong tungkol sa OOP

1. Ano ang mga katangian ng Java?

Sagot:

1. Mga konsepto ng OOP:

   1. oryentasyon ng bagay
   2. mana
   3. encapsulation
   4. polymorphism
   5. abstraction

2. Cross-platform: Ang isang Java program ay maaaring patakbuhin sa anumang platform nang walang anumang mga pagbabago. Siyempre, nangangailangan ito ng naka-install na JVM (Java virtual machine).

3. Mataas na pagganap: Ginagawang posible ng Just-In-Time (JIT) compiler ang mataas na pagganap. Kino-convert ng JIT compiler ang bytecode sa machine code at pagkatapos ay magsisimula ang JVM sa pagpapatupad.

4. Multithreading: Ang JVM ay lumilikha ng isang thread ng pagpapatupad na tinatawag na main thread. Ang isang programmer ay maaaring lumikha ng maraming mga thread sa pamamagitan ng pagkuha mula sa klase ng Thread o pagpapatupad ng Runnableinterface.

2. Ano ang mana?

Ang inheritance ay nangangahulugan na ang isang klase ay maaaring magmana ng isa pang klase (gamit ang extends na keyword). Nangangahulugan ito na maaari mong gamitin muli ang code mula sa klase na iyong minana. Ang kasalukuyang klase ay kilala bilang ang superclassat ang bagong likhang klase ay ang subclass. Sinasabi rin ng mga tao na gamitin ang mga terminong magulang at child.

public class Animal {
   private int age;
}

public class Dog extends Animal {

}

nasaan Animalang parentat Dogang child.

3. Ano ang encapsulation?

Ang tanong na ito ay madalas itanong sa mga panayam para sa mga posisyon ng developer ng Java. Itinatago ng Encapsulation ang pagpapatupad sa pamamagitan ng paggamit ng mga modifier ng access, getter, at setter. Ginagawa ito upang maiwasan ang panlabas na pag-access saanman sa tingin ng mga developer na ito ay kinakailangan. Ang isang simpleng halimbawa mula sa totoong buhay ay ang kotse. Wala kaming direktang access sa pagpapatakbo ng makina. Ang kailangan lang nating gawin ay ilagay ang susi sa ignition at i-on ang makina. Ang mga prosesong nagaganap sa ilalim ng hood ay wala sa aming negosyo. Bukod pa rito, kung tayo ay makikialam sa aktibidad ng makina, maaari itong humantong sa isang hindi inaasahang sitwasyon, na posibleng makapinsala sa kotse at magresulta sa pinsala sa katawan. Eksakto ang parehong bagay na nangyayari sa programming. Ito ay inilarawan nang maayos sa Wikipedia. Mayroon ding artikulo tungkol sa encapsulation sa CodeGym .

4. Ano ang polymorphism?

Ang polymorphism ay ang kakayahan ng isang programa na tratuhin ang mga bagay na may parehong interface sa parehong paraan, nang walang impormasyon tungkol sa partikular na uri ng bagay. Gaya nga ng kasabihan, "isang interface — maraming pagpapatupad". Sa polymorphism, maaari mong pagsamahin at gamitin ang iba't ibang uri ng mga bagay batay sa mga nakabahaging gawi. Halimbawa, mayroon kaming klase ng Animal na may dalawang inapo: Aso at Pusa. Ang generic na klase ng Animal ay may gawi na ibinabahagi ng lahat, ang kakayahang gumawa ng tunog. Gumagamit kami ng mga polymorphic na kakayahan kapag kailangan naming ipunin ang lahat na nagmamana ng klase ng Animal at isagawa ang "make sound" na paraan. Narito ang hitsura nito:

List<Animal> animals = Arrays.asList(new Cat(), new Dog(), new Cat());
animals.forEach(animal -> animal.makeSound());

Sa madaling salita, nakakatulong ang polymorphism. At nalalapat din ito sa mga polymorphic (overloaded) na pamamaraan. Paano gamitin ang polymorphism

Mga tanong sa panayam tungkol sa Java syntax

5. Ano ang isang constructor sa Java?

Ang mga konstruktor ay may mga sumusunod na katangian:

1. Kapag ang isang bagong bagay ay nilikha, ang programa ay gumagamit ng naaangkop na tagapagbuo upang lumikha nito.
2. Ang isang tagabuo ay tulad ng isang pamamaraan. Ang mga natatanging tampok nito ay nakasalalay sa katotohanang walang return value (kabilang ang void) at ang pangalan nito ay pareho sa pangalan ng klase.
3. Kung walang constructor na ginawang tahasan, ang isang walang laman na constructor ay awtomatikong nalilikha.
4. Maaaring ma-override ang isang constructor.
5. Kung idedeklara mo ang isang constructor na may mga parameter ngunit kailangan mo rin ng isa na walang mga parameter, dapat mo itong likhain nang hiwalay, dahil hindi ito awtomatikong gagawin.

6. Aling dalawang klase ang hindi nagmamana ng Bagay?

Huwag palinlang sa mga tanong na panlilinlang — walang ganoong klase. Lahat ng klase ay namamana ng Object class nang direkta o sa pamamagitan ng mga ninuno!

7. Ano ang lokal na variable?

Ito ay isa pang tanyag na tanong sa panayam para sa mga developer ng Java. Ang isang lokal na variable ay isang variable na tinukoy sa loob ng isang pamamaraan at umiiral hangga't ang pamamaraan ay isinasagawa. Sa sandaling matapos ang pagpapatupad, ang lokal na variable ay hindi na umiral. Narito ang isang programa na gumagamit ng lokal na variable na pinangalanang helloMessage sa pangunahing() na pamamaraan:

public static void main(String[] args) {
   String helloMessage;
   helloMessage = "Hello, World!";
   System.out.println(helloMessage);
}

8. Ano ang variable ng instance?

Ang isang variable na halimbawa ay isang variable na idineklara sa loob ng isang klase. Ito ay umiiral hangga't mayroong isang bagay. Halimbawa, mayroon kaming klase ng Bee, na may dalawang instance variable — nectarLoad at maxNectarLoad:

public class Bee {

   /**
    * Current nectar load
    */
   private double nectarLoad;

   /**
    * Maximum nectar that can the bee can collect.
    */
   private double maxNectarLoad = 20.0;
 
  ...
}

9. Ano ang mga access modifier?

Ang mga access modifier ay isang mekanismo para sa pag-customize ng access sa mga klase, pamamaraan, at variable. Ang mga sumusunod na modifier ay umiiral, na nakalista sa pagkakasunud-sunod ng pagtaas ng access:

1. private— Ang access modifier na ito ay ginagamit sa mga pamamaraan, field at constructor. Ang pag-access ay limitado sa klase kung saan sila idineklara.
2. package-private (default)— Ito ang default na antas ng pag-access para sa mga klase. Limitado ang access sa partikular na package kung saan idineklara ang isang klase, pamamaraan, variable, o constructor.
3. protected— Ang access modifier na ito ay nag-aalok ng parehong antas ng pag-access tulad package-privateng pagdaragdag ng access para sa mga klase na nagmamana ng klase na may protectedmodifier.
4. public— Ang antas ng access na ito ay ginagamit din para sa mga klase. Ang antas ng access na ito ay nangangahulugan na mayroong ganap na access sa buong application.

10. Ano ang paraan ng overriding?

Ino-override namin ang mga pamamaraan kapag gusto ng isang child class na baguhin ang gawi ng parent class nito. Kung kailangan din nating gawin kung ano ang nasa paraan ng magulang, maaari nating gamitin ang super.methodName() sa bata, na magpapatupad ng paraan ng magulang. Maaari naming idagdag ang aming karagdagang lohika pagkatapos nito. Mga kinakailangan na dapat sundin:

• dapat pareho ang lagda ng pamamaraan
• dapat pareho ang return value

11. Ano ang mga lagda ng pamamaraan?

Ang lagda ng pamamaraan ay ang kumbinasyon ng pangalan ng pamamaraan at ang mga argumentong kinukuha ng pamamaraan. Ang lagda ng pamamaraan ay ang natatanging identifier ng isang pamamaraan kapag nag-overload ng mga pamamaraan.

12. Ano ang paraan ng overloading?

Ang overloading ng pamamaraan ay isang tampok ng polymorphism kung saan binabago namin ang lagda ng pamamaraan upang lumikha ng maraming pamamaraan na gumaganap ng parehong aksyon:

• ang parehong pangalan
• iba't ibang argumento
• maaaring may iba't ibang uri ng pagbabalik

Halimbawa, ang pamamaraan ArrayListng klase add()ay maaaring ma-overload, na nagpapahintulot sa amin na magdagdag sa ibang paraan depende sa mga argumento ng input:

• add(Object o)— Ang pamamaraang ito ay nagdaragdag lamang ng isang bagay
• add(int index, Object o)— Ang pamamaraang ito ay nagdaragdag ng isang bagay sa isang partikular na index
• add(Collection<Object> c)— Ang pamamaraang ito ay nagdaragdag ng isang listahan ng mga bagay
• add(int index, Collection<Object> c)— Ang pamamaraang ito ay nagdaragdag ng isang listahan ng mga bagay na nagsisimula sa isang partikular na index.

13. Ano ang isang interface?

Hindi sinusuportahan ng Java ang maramihang pamana. Upang malampasan ang limitasyong ito, idinagdag ang mga interface sa anyo na alam natin at minamahal ;) Sa mahabang panahon, ang mga interface ay mayroon lamang mga pamamaraan nang walang anumang pagpapatupad. Sa konteksto ng sagot na ito, pag-usapan natin sila. Halimbawa:

public interface Animal {
   void makeSound();
   void eat();
   void sleep();
}

Ang ilang mga detalye ay sumusunod mula dito:

• Ang lahat ng mga pamamaraan sa isang interface ay pampubliko at abstract
• Ang lahat ng mga variable ay pampublikong static na pangwakas
• Ang mga klase ay hindi nagmamana ng mga interface (ibig sabihin, hindi namin ginagamit ang extends na keyword). Sa halip, ipinapatupad ng mga klase ang mga ito (ibig sabihin, ginagamit namin ang keyword na ipinapatupad). Bukod dito, maaari mong ipatupad ang maraming mga interface hangga't gusto mo.
• Ang mga klase na nagpapatupad ng isang interface ay dapat magbigay ng isang pagpapatupad ng lahat ng mga pamamaraan na nasa interface.

Ganito:

public class Cat implements Animal {
   public void makeSound() {
       // Method implementation
   }

   public void eat() {
       // Implementation
   }

   public void sleep() {
       // Implementation
   }
}

14. Ano ang isang default na paraan sa isang interface?

Ngayon pag-usapan natin ang tungkol sa mga default na pamamaraan. Para saan sila? Para kanino sila? Ang mga pamamaraang ito ay idinagdag upang maglingkod sa "parehong mga kamay". Ano bang pinagsasabi ko? Well, sa isang banda, nagkaroon ng pangangailangan na magdagdag ng bagong functionality: lambdas at ang Stream API. Sa kabilang banda, kinakailangan na panatilihin kung ano ang sikat sa Java — pabalik na pagkakatugma. Upang gawin ito, ang mga interface ay nangangailangan ng ilang mga bagong handa na solusyon. Ito ay kung paano dumating sa amin ang mga default na pamamaraan. Ang default na paraan ay isang ipinatupad na paraan sa isang interface, na minarkahan ng defaultkeyword. Halimbawa, ang kilalang stream()paraan sa Collectioninterface. Maniwala ka sa akin, ang interface na ito ay hindi kasing simple ng tila. O din ang parehong sikat forEach()na paraan saIterableinterface. Hindi rin ito umiiral hanggang sa naidagdag ang mga default na pamamaraan. Sa pamamagitan ng paraan, maaari mo ring basahin ang tungkol dito sa CodeGym dito .

15. Paano tayo magmamana ng dalawang magkaparehong default na pamamaraan?

Ang nakaraang sagot tungkol sa kung ano ang isang default na pamamaraan ay humihingi ng isa pang tanong. Kung maaari mong ipatupad ang mga pamamaraan sa mga interface, pagkatapos ay theoretically maaari mong ipatupad ang dalawang mga interface na may parehong paraan. Paano natin gagawin iyon? Narito ang dalawang magkaibang interface na may parehong paraan:

interface A {
   default void foo() {
       System.out.println("Foo A");
   }
}

interface B {
   default void foo() {
       System.out.println("Foo B");
   }
}

At mayroon kaming klase na nagpapatupad ng dalawang interface na ito. Ngunit paano lamang tayo pipili ng isang tiyak na pamamaraan sa interface A o B? Pinapayagan ito ng sumusunod na espesyal na konstruksyon: A.super.foo():

public class C implements A, B {
   public void fooA() {
       A.super.foo();
   }

   public void fooB() {
       B.super.foo();
   }
}

Kaya, fooA()gagamitin ng pamamaraan ang default foo()na paraan ng Ainterface, habang fooB()gagamitin ng pamamaraan ang foo()paraan ng Binterface.

16. Ano ang mga abstract na pamamaraan at klase?

Sa Java, abstractay isang nakalaan na salita. Ginagamit ito upang tukuyin ang mga abstract na klase at pamamaraan. Una, kailangan natin ng mga kahulugan. Ang abstract na pamamaraan ay isang paraan na idineklara gamit ang abstractkeyword na walang pagpapatupad sa abstract na klase. Iyon ay, ito ay isang paraan tulad ng sa isang interface, ngunit may pagdaragdag ng isang keyword, halimbawa:

public abstract void foo();

Ang abstract na klase ay isang klase na minarkahan din ng abstractkeyword:

public abstract class A {

}

Ang isang abstract na klase ay may ilang mga tampok:

• hindi ka makakagawa ng object ng abstract class
• maaari itong magkaroon ng mga abstract na pamamaraan
• maaaring wala rin itong mga abstract na pamamaraan

Ang mga abstract na klase ay kailangan para sa abstraction (paumanhin para sa tautolohiya) na may isang hanay ng mga karaniwang pag-uugali at estado (iyon ay, mga pamamaraan at mga variable). Ang totoong buhay ay puno ng mga halimbawa. Lahat sa paligid natin. "Animal", "Car", "Geometric figure", at iba pa.

17. Ano ang pagkakaiba sa pagitan ng String, StringBuilder at StringBuffer?

Stringang mga halaga ay nakaimbak sa isang pare-parehong string pool. Sa sandaling magawa ang isang string, lalabas ito sa pool na ito. At hindi mo ito matatanggal. Halimbawa:

String name = "book";

Ang variable ay ituturo sa pare-parehong string pool Ang pagtatakda ng pangalan ng variable sa ibang halaga, mayroon kaming:

name = "pen";

Ang pare-parehong string pool ay ganito ang hitsura: Sa madaling salita, ang parehong mga halaga ay nananatili doon. String Buffer:

• Stringang mga halaga ay nakaimbak sa isang stack. Kung binago ang isang halaga, papalitan ng bagong halaga ang luma.
• String Bufferay naka-synchronize at samakatuwid ay ligtas sa thread.
• Dahil sa kaligtasan ng thread, mahina ang pagganap nito.

Halimbawa:

StringBuffer name = “book”;

Sa sandaling magbago ang halaga ng variable ng pangalan, nagbabago ang halaga sa stack: Ang StringBuilder ay eksaktong kapareho ng StringBuffer, ngunit hindi ito ligtas sa thread. Bilang resulta, ito ay kapansin-pansing mas mabilis kaysa sa StringBuffer.

18. Ano ang pagkakaiba sa pagitan ng abstract na klase at isang interface?

Abstract na klase:

• Ang mga abstract na klase ay may default na tagabuo. Ito ay tinatawag sa tuwing ang isang inapo ng abstract class ay nilikha.
• Maaari nilang isama ang mga abstract na pamamaraan at hindi abstract. Sa pangkalahatan, ang isang abstract na klase ay hindi kailangang magkaroon ng mga abstract na pamamaraan.
• Ang isang klase na nagmamana ng abstract ay dapat magpatupad lamang ng mga abstract na pamamaraan.
• Ang abstract na klase ay maaaring magkaroon ng mga instance variable (tingnan ang Tanong #5).

Interface:

• Ang isang interface ay walang constructor at hindi maaaring simulan.
• Mga abstract na pamamaraan lamang ang maaaring idagdag (maliban sa mga default na pamamaraan).
• Ang mga klase na nagpapatupad ng interface ay dapat magpatupad ng lahat ng pamamaraan (maliban sa mga default na pamamaraan).
• Ang mga interface ay maaari lamang magkaroon ng mga pare-pareho.

19. Bakit ang pag-access sa isang elemento sa isang array O(1)?

Ang tanong na ito ay literal na tinanong sa aking huling panayam. Gaya ng nalaman ko sa ibang pagkakataon, ang layunin ng tanong na ito ay makita kung paano nag-iisip ang isang tao. Maliwanag, may maliit na praktikal na halaga sa kaalamang ito. Ang alam lang ay sapat na. Una, kailangan nating linawin na ang O(1) ay notasyon para sa pagiging kumplikado ng oras ng isang algorithm na "pare-parehong oras". Sa madaling salita, ang pagtatalaga na ito ay nagpapahiwatig ng pinakamabilis na oras ng pagpapatupad. Upang masagot ang tanong na ito, kailangan nating isaalang-alang ang alam natin tungkol sa mga array. Upang lumikha ng isang intarray, dapat nating isulat ang sumusunod:

int[] intArray = new int[100];

Maraming mga konklusyon ang maaaring makuha mula sa syntax na ito:

1. Kapag ang isang array ay ipinahayag, ang uri nito ay kilala. Kung kilala ang uri, malalaman ang laki ng bawat cell sa array.
2. Ang laki ng buong array ay kilala.

Samakatuwid, upang maunawaan kung aling cell ang isusulat, kailangan lang nating kalkulahin kung aling bahagi ng memorya ang susulatan. Para sa isang computer, ito ay madaling peasy. Alam ng computer kung saan magsisimula ang inilalaan na memorya, ang bilang ng mga elemento, at ang laki ng bawat cell. Ang lahat ng ito ay nangangahulugan na ang lugar na isusulat ay magiging katumbas ng panimulang lugar ng array + ang laki ng bawat cell na pinarami ng index.

Kaya paano tayo makakarating sa O(1) kapag nag-a-access ng mga bagay sa isang ArrayList?

Kaagad na sinundan ng tanong na ito ang nauna. Ang katotohanan ay kapag nagtatrabaho sa isang array na nagtataglay ng mga primitive, alam natin nang maaga (sa oras ng paglikha) ang laki ng uri ng elemento. Ngunit ano ang gagawin namin kung mayroon kaming ganitong uri ng hierarchy ng mana at gusto naming lumikha ng isang koleksyon para sa mga elemento ng uri A at magdagdag ng iba't ibang mga pagpapatupad (B, C, at D):

List<A> list = new ArrayList();
list.add(new B());
list.add(new C());
list.add(new D());
list.add(new B());

Sa sitwasyong ito, paano natin makalkula ang laki ng bawat cell? Pagkatapos ng lahat, ang bawat bagay ay magkakaiba, posibleng may iba't ibang karagdagang mga patlang. Anong gagawin? Narito ang tanong ay ibinibigay sa paraang para malito ka. Alam namin na ang koleksyon ay hindi direktang nag-iimbak ng mga bagay. Nag-iimbak lamang ito ng mga sanggunian sa mga bagay. At lahat ng mga sanggunian ay may parehong laki, at ito ay kilala. Bilang resulta, kinakalkula namin ang mga address dito sa parehong paraan tulad ng sa nakaraang tanong.

21. Autoboxing at unboxing

Makasaysayang background: ang autoboxing at unboxing ay ilan sa mga pangunahing inobasyon sa JDK 5. Ang Autoboxing ay ang proseso ng awtomatikong conversion mula sa isang primitive na uri patungo sa isang kaukulang klase ng wrapper. Ang pag-unbox ay ang eksaktong kabaligtaran ng autoboxing. Ito ay ang proseso ng pag-convert ng isang klase ng wrapper sa isang primitive. Ngunit kung ang halaga ng isang wrapper ay null, ang isang NullPointerExceptionay itatapon sa panahon ng pag-unbox.

Primitives at ang kanilang kaukulang mga wrapper

// Nangyayari ang Autoboxing:

• kapag nagtatalaga ng primitive sa isang reference sa isang klase ng wrapper:

  BAGO ang Java 5:

  
  // Manual boxing (the way it was BEFORE Java 5).
  public void boxingBeforeJava5() {
     Boolean booleanBox = new Boolean(true);
     Integer intBox = new Integer(3);
     // And so on for other types
  }
  
  After Java 5:
  // Automatic boxing (the way it became in Java 5).
  public void boxingJava5() {
     Boolean booleanBox = true;
     Integer intBox = 3;
     // And so on for other types
  }
  

• kapag ang isang primitive ay ipinasa bilang isang argumento sa isang pamamaraan na umaasa ng isang wrapper:

  
  public void exampleOfAutoboxing() {
     long age = 3;
     setAge(age);
  }
  
  public void setAge(Long age) {
     this.age = age;
  }
  

// Unboxing ang mangyayari:

• kapag nagtalaga kami ng isang halimbawa ng isang klase ng wrapper sa isang primitive na variable:

  
  // BEFORE Java 5:
  int intValue = new Integer(4).intValue();
  double doubleValue = new Double(2.3).doubleValue();
  char c = new Character((char) 3).charValue();
  boolean b = Boolean.TRUE.booleanValue();
  
  // And after JDK 5:
  int intValue = new Integer(4);
  double doubleValue = new Double(2.3);
  char c = new Character((char) 3);
  boolean b = Boolean.TRUE;
  

• Sa panahon ng mga operasyon ng aritmetika. Ang mga operasyon ay nalalapat lamang sa mga primitive na uri, kaya ang pag-unbox sa mga primitive ay kinakailangan.

  
  // BEFORE Java 5:
  Integer integerBox1 = new Integer(1);
  Integer integerBox2 = new Integer(2);
  
  // A comparison used to require this:
  integerBox1.intValue() > integerBox2.intValue()
        
  // In Java 5
  integerBox1 > integerBox2
  

• kapag nagpapasa ng isang instance ng isang klase ng wrapper sa isang pamamaraan na kumukuha ng kaukulang primitive:

  
  public void exampleOfAutoboxing() {
     Long age = new Long(3);
     setAge(age);
  }
  
  public void setAge(long age) {
     this.age = age;
  }
  

22. Ano ang panghuling keyword at saan ito ginagamit?

finalMaaaring gamitin ang keyword sa mga variable, pamamaraan, at klase.

1. Ang halaga ng isang panghuling variable ay hindi mababago pagkatapos itong masimulan.
2. Ang panghuling klase ay sterile :) Hindi ito maaaring magkaanak.
3. Ang isang pangwakas na paraan ay hindi maaaring i-override ng isang inapo.

Tinakpan namin ang mga bagay na may mataas na antas. Ngayon ay sumisid tayo nang mas malalim.

Mga huling variable

Binibigyan tayo ng Java ng dalawang paraan upang magdeklara ng isang variable at magtalaga ng isang halaga dito:

1. Maaari kang magdeklara ng isang variable at simulan ito sa ibang pagkakataon.
2. Maaari kang magdeklara ng isang variable at magtalaga ng isang halaga kaagad.

Narito ang isang halimbawa na nagpapakita ng mga paggamit na ito ng mga huling variable:

public class FinalExample {

   // A static final variable that is immediately initialized:
   final static String FINAL_EXAMPLE_NAME = "I'm likely the final one";

   // A final variable that is not initialized, but will only work if you
   // initialize it in the constructor:
   final long creationTime;

   public FinalExample() {
       this.creationTime = System.currentTimeMillis();
   }

   public static void main(String[] args) {
       FinalExample finalExample = new FinalExample();
       System.out.println(finalExample.creationTime);

       // The final FinalExample.FINAL_EXAMPLE_NAME field cannot be accessed
//    FinalExample.FINAL_EXAMPLE_NAME = "Not you're not!";

       // The final Config.creationTime field cannot be accessed
//    finalExample.creationTime = 1L;
   }
}

Maaari bang ituring na isang pare-pareho ang panghuling variable?

Dahil hindi kami makapagtalaga ng mga bagong halaga sa mga huling variable, tila ang mga ito ay pare-pareho ang mga variable. Ngunit sa unang tingin lamang: Kung ang uri ng data ng variable ay immutable, kung gayon, oo, ito ay pare-pareho. Ngunit kung ang uri ng data ay mutable, iyon ay, nababago, posible na gumamit ng mga pamamaraan at mga variable upang baguhin ang halaga ng bagay na isinangguni ng isang finalvariable. Dahil dito, hindi ito matatawag na pare-pareho. Ang sumusunod na halimbawa ay nagpapakita na ang ilang mga huling variable ay tunay na mga pare-pareho, habang ang iba ay hindi, dahil maaari silang baguhin.

public class FinalExample {

   // Immutable final variables
   final static String FINAL_EXAMPLE_NAME = "I'm likely the final one";
   final static Integer FINAL_EXAMPLE_COUNT  = 10;

   // Mutable final variables
   final List<String> addresses = new ArrayList();
   final StringBuilder finalStringBuilder = new StringBuilder("Constant?");
}

Mga lokal na huling variable

Kapag ang isang finalvariable ay nilikha sa loob ng isang pamamaraan, ito ay tinatawag na isang local finalvariable:

public class FinalExample {

   public static void main(String[] args) {
       // You can do this
       final int minAgeForDriveCar = 18;

       // Or you can do this, in a for-each loop:
       for (final String arg : args) {
           System.out.println(arg);
       }
   }

}

Maaari naming gamitin ang panghuling keyword sa isang pinahusay na para sa loop, dahil ang isang bagong variable ay nilikha pagkatapos ng bawat pag-ulit ng loop. Tandaan na hindi ito nalalapat sa isang normal na for loop, kaya makakakuha tayo ng error sa compile-time.

// The final local j variable cannot be assigned
for (final int i = 0; i < args.length; i ++) {
   System.out.println(args[i]);
}

Panghuling klase

Isang klase na idineklara bilang finalhindi maaaring palawigin. Sa mas simple, walang ibang klase ang maaaring magmana nito. Ang isang mahusay na halimbawa ng isang finalklase sa JDK ay String. Ang unang hakbang sa paglikha ng hindi nababagong klase ay markahan ito bilang final, kaya pinipigilan itong ma-extend:

public final class FinalExample {
}

// Compilation error!
class WantsToInheritFinalClass extends FinalExample {
}

Panghuling pamamaraan

Kapag ang isang pamamaraan ay minarkahan na pangwakas, ito ay tinatawag na isang pangwakas na pamamaraan (makatuwiran, tama?). Ang isang panghuling paraan ay hindi maaaring i-override sa isang klase ng bata. Hindi sinasadya, ang mga pamamaraan ng wait() at notify() ng klase ng Object ay pinal, kaya wala kaming kakayahang i-override ang mga ito.

public class FinalExample {
   public final String generateAddress() {
       return "Some address";
   }
}

class ChildOfFinalExample extends FinalExample {

   // Compilation error!
   @Override
   public String generateAddress() {
       return "My OWN Address";
   }
}

Paano at saan gagamitin ang final sa Java

• Gamitin ang panghuling keyword upang tukuyin ang ilang mga pare-pareho sa antas ng klase;
• Lumikha ng mga huling variable para sa mga bagay na hindi mo gustong baguhin. Halimbawa, mga katangiang partikular sa bagay na magagamit namin para sa mga layunin ng pag-log.
• Kung ayaw mong ma-extend ang isang klase, markahan ito bilang pangwakas.
• Kung kailangan mong lumikha ng hindi nababagong klase, kailangan mong gawin itong pangwakas.
• Kung gusto mong ang pagpapatupad ng isang pamamaraan ay hindi magbago sa mga inapo nito, pagkatapos ay markahan ang pamamaraan bilang final. Napakahalaga nito upang matiyak na hindi magbabago ang pagpapatupad.

23. Ano ang mga nababago at hindi nababagong mga uri?

Nababago

Ang mga nababagong bagay ay mga bagay na ang estado at mga variable ay maaaring baguhin pagkatapos ng paglikha. Kasama sa mga halimbawa ng nababagong klase ang StringBuilder at StringBuffer. Halimbawa:

public class MutableExample {

   private String address;

   public MutableExample(String address) {
       this.address = address;
   }

   public String getAddress() {
       return address;
   }

   // This setter can change the name field
   public void setAddress(String address) {
       this.address = address;
   }

   public static void main(String[] args) {

       MutableExample obj = new MutableExample("First address");
       System.out.println(obj.getAddress());

       // We are updating the name field, so this is a mutable object
       obj.setAddress("Updated address");
       System.out.println(obj.getAddress());
   }
}

hindi nababago

Ang mga bagay na hindi nababago ay mga bagay na ang estado at mga variable ay hindi mababago pagkatapos gawin ang bagay. Isang mahusay na susi para sa isang HashMap, hindi ba? :) Halimbawa, String, Integer, Double, at iba pa. Halimbawa:

// We'll make this class final so no one can change it
public final class ImmutableExample {

   private String address;

   ImmutableExample(String address) {
       this.address = address;
   }

   public String getAddress() {
       return address;
   }

   // We remove the setter

   public static void main(String[] args) {

       ImmutableExample obj = new ImmutableExample("Old address");
       System.out.println(obj.getAddress());

       // There is no way to change this field, so it is an immutable object
       // obj.setName("new address");
       // System.out.println(obj.getName());

   }
}

Sa susunod na bahagi, isasaalang-alang namin ang mga tanong at sagot tungkol sa mga koleksyon. Ang aking profile sa GitHub Top 50 na tanong at sagot sa pakikipanayam sa trabaho para sa Java Core. Bahagi 2