Nangungunang 50 Java Core na Mga Tanong at Sagot sa Panayam. Bahagi 1

Kumusta sa lahat, mga binibini at mga ginoo na Mga Software Engineer! 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 mahusay na dahilan upang ulitin o pag-aralan ang mga puntong ito mula sa simula. Mayroon akong medyo malawak na koleksyon ng mga madalas itanong tungkol sa OOP, Java Syntax, mga pagbubukod sa Java, mga koleksyon at multithreading, na para sa kaginhawahan ay hahatiin ko sa ilang bahagi. Mahalaga:pag-uusapan lang natin ang mga bersyon ng Java hanggang 8. Ang lahat ng mga inobasyon mula 9, 10, 11, 12, 13 ay hindi isasaalang-alang dito. Anumang mga ideya/komento sa kung paano pagbutihin ang mga sagot ay malugod na tinatanggap . Maligayang pagbabasa, tara na!

Panayam sa Java: Mga tanong sa OOP

1. Anong mga tampok ang mayroon ang 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. Ang tanging bagay na kailangan mo ay isang naka-install na JVM (java virtual machine).

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

4. Multithreading: Isang thread ng execution na kilala bilang Thread. Ang JVM ay lumilikha ng isang thread na tinatawag na main thread. Ang isang programmer ay maaaring lumikha ng maraming mga thread sa pamamagitan ng pagmamana mula sa klase ng Thread o sa pamamagitan ng pagpapatupad ng isang interface Runnable.

2. Ano ang mana?

Ang ibig sabihin ng inheritance ay ang isang klase ay maaaring magmana (" extends ") ng isa pang klase. Sa ganitong paraan maaari mong muling gamitin ang code mula sa klase kung saan ka nagmana. Ang umiiral na klase ay kilala bilang superclass, at ang nilikha ay kilala bilang subclass. Sabi din nila parentat child.

public class Animal {
   private int age;
}

public class Dog extends Animal {

}

nasaan Animalsi parent, at Dog- child.

3. Ano ang encapsulation?

Ang tanong na ito ay madalas na lumalabas sa panahon ng mga panayam ng developer ng Java. Itinatago ng encapsulation ang pagpapatupad gamit ang mga modifier ng access, gamit ang mga getter at setter. Ginagawa ito upang isara ang pag-access para sa panlabas na paggamit sa mga lugar kung saan itinuturing ng mga developer na kinakailangan. Ang isang naa-access na halimbawa mula sa buhay ay isang kotse. Wala kaming direktang access sa pagpapatakbo ng makina. Para sa amin, ang trabaho ay ilagay ang susi sa ignition at i-on ang makina. At kung anong mga proseso ang magaganap sa ilalim ng hood ay wala sa aming negosyo. Bukod dito, ang aming pakikialam sa aktibidad na ito ay maaaring humantong sa isang hindi mahuhulaan na sitwasyon, dahil sa kung saan maaari naming masira ang kotse at makapinsala sa ating sarili. Eksakto ang parehong bagay na nangyayari sa programming. Mahusay na inilarawan sa Wikipedia . Mayroon ding artikulo tungkol sa encapsulation sa JavaRush .

4. Ano ang polymorphism?

Ang polymorphism ay ang kakayahan ng isang programa na magkaparehong gumamit ng mga bagay na may parehong interface nang walang impormasyon tungkol sa partikular na uri ng bagay na iyon. Tulad ng sinasabi nila, isang interface - maraming mga pagpapatupad. Sa polymorphism, maaari mong pagsamahin at gamitin ang iba't ibang uri ng mga bagay batay sa kanilang karaniwang pag-uugali. Halimbawa, mayroon kaming klaseng Hayop, na may dalawang inapo - Aso at Pusa. Ang generic na klase ng Animal ay may karaniwang pag-uugali para sa lahat - gumawa ng tunog. Sa kaso kung kailan kailangan nating pagsamahin ang lahat ng mga inapo ng klase ng Hayop at isagawa ang pamamaraang "gumawa ng tunog", ginagamit namin ang mga posibilidad ng polymorphism. Ito ang magiging hitsura nito:

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

Kaya tinutulungan tayo ng polymorphism. Bukod dito, nalalapat din ito sa mga polymorphic (overloaded) na pamamaraan. Pagsasanay sa paggamit ng polymorphism

Mga Tanong sa Panayam - Java Syntax

5. Ano ang isang constructor sa Java?

Ang mga sumusunod na katangian ay wasto:

1. Kapag ang isang bagong bagay ay nilikha, ang programa ay gumagamit ng naaangkop na constructor upang gawin ito.
2. Ang isang tagabuo ay tulad ng isang pamamaraan. Ang kakaiba nito ay walang bumabalik na elemento (kabilang ang void), at ang pangalan nito ay pareho sa pangalan ng klase.
3. Kung walang constructor na nakasulat nang tahasan, isang walang laman na constructor ang awtomatikong malilikha.
4. Maaaring ma-override ang constructor.
5. Kung ang isang constructor na may mga parameter ay nilikha, ngunit kinakailangan din nang walang mga parameter, dapat itong isulat nang hiwalay, dahil hindi ito awtomatikong nilikha.

6. Aling dalawang klase ang hindi nagmana mula sa Bagay?

Huwag magpalinlang sa mga provokasyon, walang ganoong klase: lahat ng klase nang direkta o sa pamamagitan ng mga ninuno ay minana mula sa klase ng Bagay!

7. Ano ang Lokal na Variable?

Isa pang tanyag na tanong sa isang panayam ng developer ng Java. Ang isang lokal na variable ay isang variable na tinukoy sa loob ng isang pamamaraan at umiiral hanggang sa sandaling ang pamamaraan ay naisakatuparan. Kapag natapos na ang pagpapatupad, ang lokal na variable ay titigil sa pag-iral. Narito ang isang programa na gumagamit ng helloMessage local variable sa main() na paraan:

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

8. Ano ang Instance Variable?

Ang Instance Variable ay isang variable na tinukoy sa loob ng isang klase, at umiiral ito hanggang sa sandaling umiral ang object. Ang isang halimbawa ay ang klase ng Bee, na mayroong dalawang variable na nectarCapacity at maxNectarCapacity:

public class Bee {

   /**
    * Current nectar capacity
    */
   private double nectarCapacity;

   /**
    * Maximal nectar that can take bee.
    */
   private double maxNectarCapacity = 20.0;

  ...
}

9. Ano ang mga access modifier?

Ang mga access modifier ay isang tool na nagbibigay-daan sa iyong i-customize ang access sa mga klase, pamamaraan, at variable. Mayroong mga sumusunod na modifier, na inayos sa pagkakasunud-sunod ng pagtaas ng access:

1. private- ginagamit para sa mga pamamaraan, field at constructor. Ang antas ng pag-access ay ang klase lamang kung saan ito idineklara.
2. package-private(default)- maaaring gamitin para sa mga klase. I-access lamang sa isang partikular na pakete kung saan ang isang klase, pamamaraan, variable, constructor ay ipinahayag.
3. protected— ang parehong pag-access tulad ng package-private+ para sa mga klase na nagmana mula sa isang klase na may modifier protected.
4. public- ginagamit din para sa mga klase. Buong pag-access sa buong application.

10. Ano ang mga overriding na pamamaraan?

Nangyayari ang overriding ng pamamaraan kapag gusto ng bata na baguhin ang pag-uugali ng klase ng magulang. Kung gusto mong maisakatuparan ang nasa parent method, maaari kang gumamit ng construction tulad ng super.methodName() sa bata, na gagawa ng gawain ng parent method, at pagkatapos ay magdagdag lamang ng logic. Mga kinakailangan upang matugunan:

• ang lagda ng pamamaraan ay dapat na pareho;
• dapat pareho ang return value.

11. Ano ang lagda ng pamamaraan?

Ang lagda ng pamamaraan ay isang hanay ng pangalan ng pamamaraan at ang mga argumento na tinatanggap ng pamamaraan. Ang lagda ng pamamaraan ay isang natatanging identifier para sa isang paraan kapag nag-overload ng mga pamamaraan.

12. Ano ang paraan ng overloading?

Ang overloading ng pamamaraan ay isang pag-aari ng polymorphism kung saan sa pamamagitan ng pagbabago ng lagda ng pamamaraan, maaari kang lumikha ng iba't ibang mga pamamaraan para sa parehong mga aksyon:

• parehong pangalan ng pamamaraan;
• iba't ibang mga argumento;
• maaaring may ibang uri ng pagbabalik.

Halimbawa, ang parehong add()ng ArrayListay maaaring ma-overload tulad ng sumusunod at gagawa ng karagdagan sa ibang paraan, depende sa mga papasok na argumento:

• add(Object o)- nagdadagdag lamang ng isang bagay;
• add(int index, Object o)— nagdaragdag ng isang bagay sa isang tiyak na index;
• add(Collection<Object> c)- nagdaragdag ng isang listahan ng mga bagay;
• add(int index, Collection<Object> c)— nagdaragdag ng listahan ng mga bagay, simula sa isang tiyak na index.

13. Ano ang Interface?

Hindi ipinapatupad sa Java ang maramihang pamana, kaya't upang malampasan ang problemang ito, idinagdag ang mga interface na alam natin sa kanila ;) Sa mahabang panahon, ang mga interface ay mayroon lamang mga pamamaraan nang hindi ipinapatupad ang mga ito. Bilang bahagi ng sagot na ito, pag-uusapan natin sila. Halimbawa:

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

Ang ilang mga nuances ay sumusunod mula dito:

• lahat ng mga pamamaraan sa interface ay pampubliko at abstract;
• lahat ng mga variable ay pampublikong static na pangwakas;
• Ang mga klase ay hindi namamana sa kanila (nagpapalawak), ngunit nagpapatupad ng mga ito (nagpapatupad). Bukod dito, maaari kang magpatupad ng maraming mga interface hangga't gusto mo.
• ang mga klase na nagpapatupad ng isang interface ay dapat magbigay ng mga pagpapatupad ng lahat ng mga pamamaraan na mayroon ang interface.

Ganito:

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

   public void eat() {
       // implementation
   }

   public void sleep() {
       // implementation
   }
}

14. Ano ang default na paraan sa Interface?

Ngayon pag-usapan natin ang tungkol sa mga default na pamamaraan. Para saan, para kanino? Ang mga pamamaraang ito ay idinagdag upang gawin ang lahat ng bagay na "kapwa sa iyo at sa amin." Ano bang pinagsasabi ko? Oo, sa isang banda, kinakailangan na magdagdag ng bagong pag-andar: lambdas, Stream API, sa kabilang banda, kinakailangan na iwanan kung ano ang sikat sa Java - pabalik na pagkakatugma. Upang gawin ito, kinakailangan upang ipakilala ang mga handa na solusyon sa mga interface. Ito ay kung paano dumating sa amin ang mga default na pamamaraan. Ibig sabihin, ang default na paraan ay isang ipinatupad na paraan sa interface na mayroong keyword default. Halimbawa, ang kilalang pamamaraan stream()sa Collection. Tingnan ito, ang interface na ito ay hindi kasing simple ng tila ;). O isa ring pantay na kilalang pamamaraan forEach()mula sa Iterable. Hindi rin ito umiiral hanggang sa naidagdag ang mga default na pamamaraan. Sa pamamagitan ng paraan, maaari mo ring basahin ang tungkol dito sa JavaRush .

15. Paano pagkatapos magmana ng dalawang magkaparehong default na pamamaraan?

Batay sa nakaraang sagot tungkol sa kung ano ang default na paraan, maaari kang magtanong 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, at kung paano gawin ito? Mayroong dalawang magkaibang interface na may parehong pamamaraan:

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

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

At mayroong isang klase na nagpapatupad ng dalawang interface na ito. Upang maiwasan ang kawalan ng katiyakan at upang i-compile ang code, kailangan nating i-override ang pamamaraan foo()sa klase C, at maaari nating tawagan ang isang paraan foo()ng alinman sa mga interface dito - Ao B. Ngunit kung paano pumili ng isang tiyak na paraan ng interface Аo В? Mayroong isang istraktura na tulad nito para dito A.super.foo():

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

o:

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

Kaya, ang isang paraan ng foo()klase Cay gagamit ng alinman sa default na paraan foo()mula sa interface Ao isang paraan foo()mula sa interface B.

16. Ano ang mga abstract na pamamaraan at klase?

Ang Java ay may nakalaan na salita abstractna ginagamit upang tukuyin ang mga abstract na klase at pamamaraan. Una, ilang mga kahulugan. Ang abstract na pamamaraan ay isang paraan na nilikha nang walang pagpapatupad na may isang keyword abstractsa isang abstract na klase. Iyon ay, ito ay isang paraan tulad ng sa interface, lamang sa pagdaragdag ng isang keyword, halimbawa:

public abstract void foo();

Ang abstract na klase ay isang klase na mayroon ding abstractsalita:

public abstract class A {

}

Ang isang abstract na klase ay may ilang mga tampok:

• ang isang bagay ay hindi maaaring malikha sa batayan nito;
• maaari itong magkaroon ng mga abstract na pamamaraan;
• maaaring wala itong mga abstract na pamamaraan.

Ang mga abstract na klase ay kinakailangan upang gawing pangkalahatan ang ilang uri ng abstraction (paumanhin para sa tautolohiya), na hindi umiiral sa totoong buhay, ngunit naglalaman ito ng maraming karaniwang pag-uugali at estado (iyon ay, mga pamamaraan at mga variable). Mayroong higit sa sapat na mga halimbawa mula sa buhay. Lahat ay nasa paligid natin. Maaaring ito ay "hayop", "kotse", "geometric figure" at iba pa.

17. Ano ang pagkakaiba sa pagitan ng String, String Builder at String Buffer?

Ang mga halaga Stringay naka-imbak sa isang pare-parehong string pool. Kapag nalikha na ang isang row, lalabas ito sa pool na ito. At hindi ito magiging posible na tanggalin ito. Halimbawa:

String name = "book";

...ang variable ay tumutukoy sa string pool Constant string pool Kung itatakda mo ang variable na pangalan sa ibang value, makukuha mo ang sumusunod:

name = "pen";

Constant string pool Kaya ang dalawang halagang ito ay mananatili doon. String Buffer:

• ang mga halaga Stringay nakaimbak sa stack. Kung binago ang halaga, ang bagong halaga ay papalitan ng luma;
• String Buffernaka-synchronize at samakatuwid ay ligtas ang thread;
• Dahil sa kaligtasan ng thread, ang bilis ng operasyon ay nag-iiwan ng maraming nais.

Halimbawa:

StringBuffer name = "book";

Sa sandaling magbago ang halaga ng pangalan, magbabago ang halaga sa stack: StringBuilder Eksaktong kapareho ng StringBuffer, hindi lamang ito ligtas sa thread. Samakatuwid, ang bilis nito ay malinaw na mas mataas kaysa sa StringBuffer.

18. Ano ang pagkakaiba sa pagitan ng isang 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 bata ng abstract class na ito ay nilikha;
• naglalaman ng parehong abstract at non-abstract na mga pamamaraan. Sa pangkalahatan, maaaring hindi ito naglalaman ng mga abstract na pamamaraan, ngunit isa pa ring abstract na klase;
• ang isang klase na nagmana mula sa isang abstract ay dapat magpatupad lamang ng mga abstract na pamamaraan;
• ang abstract na klase ay maaaring maglaman ng Instance Variable (tingnan ang tanong #5).

Interface:

• ay walang constructor at hindi maaaring masimulan;
• mga abstract na pamamaraan lamang ang dapat idagdag (hindi binibilang ang mga default na pamamaraan);
• ang mga klase na nagpapatupad ng isang interface ay dapat magpatupad ng lahat ng mga pamamaraan (hindi binibilang ang mga default na pamamaraan);
• ang mga interface ay maaari lamang maglaman ng mga constant.

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

Ang tanong na ito ay literal mula sa huling panayam. Tulad ng nalaman ko sa ibang pagkakataon, ang tanong na ito ay itinatanong upang makita kung paano nag-iisip ang isang tao. Malinaw na may maliit na praktikal na kahulugan sa kaalamang ito: sapat na ang pag-alam sa katotohanang ito. Una, kailangan nating linawin na ang O(1) ay isang pagtatalaga para sa pagiging kumplikado ng oras ng isang algorithm kapag nagaganap ang operasyon sa pare-parehong oras. Ibig sabihin, ang pagtatalagang ito ang pinakamabilis na pagpapatupad. Upang masagot ang tanong na ito, kailangan nating maunawaan kung ano ang alam natin tungkol sa mga array? Upang lumikha ng array int, dapat nating isulat ang sumusunod:

int[] intArray = new int[100];

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

1. Kapag gumagawa ng array, alam ang uri nito. Kung alam ang uri, malinaw kung anong laki ng bawat cell ng array.
2. Ito ay kilala kung ano ang laki ng array.

Ito ay sumusunod mula dito: upang maunawaan kung aling cell ang susulatan, kailangan mo lamang kalkulahin kung aling lugar ng memorya ang susulatan. Para sa isang kotse hindi ito maaaring maging mas madali. Ang makina ay may simula ng inilalaang memorya, isang bilang ng mga elemento, at isang solong laki ng cell. Mula dito ay malinaw na ang espasyo sa pag-record ay magiging katumbas ng panimulang lokasyon ng array + ang laki ng cell na pinarami ng laki nito.

Paano ka makakakuha ng O(1) sa pag-access ng mga bagay sa isang ArrayList?

Kaagad na sinundan ng tanong na ito ang nauna. Totoo na kapag nagtatrabaho kami sa isang array at mayroong mga primitive doon, alam namin nang maaga kung ano ang laki ng ganitong uri kapag ito ay nilikha. Ngunit paano kung mayroong isang pamamaraan tulad ng nasa larawan: at nais naming lumikha ng isang koleksyon na may mga elemento ng uri A, at magdagdag ng iba't ibang mga pagpapatupad - B, C, 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 mo mauunawaan kung anong laki ng bawat cell, dahil ang bawat bagay ay magkakaiba at maaaring may iba't ibang karagdagang mga patlang (o ganap na naiiba). Anong gagawin? Dito inilalahad ang tanong sa paraang nakakalito at nakakalito. Alam namin na sa katunayan, ang koleksyon ay hindi nag-iimbak ng mga bagay, ngunit nag-uugnay lamang sa mga bagay na ito. At lahat ng mga link ay may parehong laki, at ito ay kilala. Kaya ang pagbibilang ng espasyo dito ay gumagana sa parehong paraan tulad ng sa nakaraang tanong.

21. Autoboxing at unboxing

Makasaysayang background: ang autoboxing at autounboxing ay isa sa mga pangunahing inobasyon ng JDK 5. Ang Autoboxing ay ang proseso ng awtomatikong conversion mula sa isang primitive na uri patungo sa naaangkop na klase ng wrapper. Auto-unboxing - ginagawa ang eksaktong kabaligtaran ng auto-boxing - ginagawang primitive ang klase ng wrapper. Ngunit kung mayroong halaga ng pambalot null, kung gayon ang isang pagbubukod ay itatapon sa panahon ng pag-unpack NullPointerException.

Katugmang primitive - wrapper

Nangyayari ang autopacking:

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

  BAGO ang Java 5:

  //manual packaging or how it was BEFORE Java 5.
  public void boxingBeforeJava5() {
     Boolean booleanBox = new Boolean(true);
     Integer intBox = new Integer(3);
     // and so on to other types
  }
  
  после Java 5:
  //automatic packaging or how it became in Java 5.
  public void boxingJava5() {
     Boolean booleanBox = true;
     Integer intBox = 3;
     // and so on to other types
  }

• kapag nagpapasa ng primitive bilang argumento sa isang pamamaraan na umaasa sa isang wrapper:

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

Nangyayari ang awtomatikong pag-unpack:

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

  //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 mga kaso na may mga operasyon sa aritmetika. Nalalapat lamang ang mga ito sa mga primitive na uri; para dito kailangan mong gawin ang pag-unpack sa primitive.

  // Before Java 5
  Integer integerBox1 = new Integer(1);
  Integer integerBox2 = new Integer(2);
  
  // for comparison it was necessary to do this:
  integerBox1.intValue() > integerBox2.intValue()
  
  //в Java 5
  integerBox1 > integerBox2

• kapag ipinasa sa isang wrapper sa isang paraan na tumatanggap 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 gagamitin?

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

1. Ang isang panghuling variable ay hindi maaaring italaga muli sa isa pang bagay.
2. ang huling klase ay sterile)) hindi ito maaaring magkaroon ng mga tagapagmana.
3. ang huling paraan ay hindi maaaring i-override sa isang ninuno.

Tinakpan na natin ang itaas, ngayon ay talakayin natin ito nang mas detalyado.

panghuling variable

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

1. Maaari kang magdeklara ng isang variable at simulan ito sa ibang pagkakataon.
2. Maaari mong ideklara ang isang variable at italaga ito kaagad.

Halimbawa gamit ang panghuling variable para sa mga kasong ito:

public class FinalExample {

   //final static variable, which is immediately initialized:
   final static String FINAL_EXAMPLE_NAME = "I'm likely final one";

   //final is a variable that is not initialized, but will only work if
   //initialize this 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);

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

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

Maaari bang ituring na pare-pareho ang Pangwakas na variable?

Dahil hindi kami makakapagtalaga ng bagong value sa isang panghuling variable, lumalabas na ang mga ito ay pare-pareho ang mga variable. Ngunit ito ay sa unang tingin lamang. Kung ang uri ng data na tinutukoy ng variable ay immutable, oo, ito ay pare-pareho. Ngunit kung ang uri ng data mutableay nababago, gamit ang mga pamamaraan at mga variable posible na baguhin ang halaga ng bagay na finaltinutukoy ng variable, at sa kasong ito ay hindi ito matatawag na pare-pareho. Kaya, ipinapakita ng halimbawa na ang ilan sa mga huling variable ay talagang mga pare-pareho, ngunit ang ilan ay hindi, at maaari silang baguhin.

public class FinalExample {

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

   // mutable filter variables
   final List<String> addresses = new ArrayList();
   final StringBuilder finalStringBuilder = new StringBuilder("constant?");
}

Mga lokal na huling variable

Kapag finalang isang variable ay nilikha sa loob ng isang pamamaraan, ito ay tinatawag na local finalisang variable:

public class FinalExample {

   public static void main(String[] args) {
       // This is how you can
       final int minAgeForDriveCar = 18;

       // or you can do it this way, in the foreach loop:
       for (final String arg : args) {
           System.out.println(arg);
       }
   }

}

Maaari naming gamitin ang keyword finalsa pinahabang loop fordahil pagkatapos makumpleto ang isang pag-ulit ng loop, forisang bagong variable ang nilikha sa bawat oras. Ngunit hindi ito nalalapat sa isang normal na for loop, kaya ang code sa ibaba ay maglalagay ng error sa compile-time.

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

Panghuling klase

Hindi mo maaaring palawigin ang isang klase na idineklara bilang final. Sa madaling salita, walang klase ang maaaring magmana sa isang ito. Ang isang magandang halimbawa finalng isang klase sa JDK ay String. Ang unang hakbang sa paglikha ng isang hindi nababagong klase ay markahan ito bilang final, upang hindi ito mapalawak:

public final class FinalExample {
}

// Compilation error here
class WantsToInheritFinalClass extends FinalExample {
}

Panghuling pamamaraan

Kapag ang isang pamamaraan ay minarkahan na pangwakas, ito ay tinatawag na isang pangwakas na pamamaraan (lohikal, tama?). Ang Pangwakas na paraan ay hindi maaaring ma-override sa isang descendant na klase. Sa pamamagitan ng paraan, ang mga pamamaraan sa klase ng Object - wait() at notify() - ay pinal, kaya wala kaming pagkakataon na i-override ang mga ito.

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

class ChildOfFinalExample extends FinalExample {

   // compile error here
   @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 panghuling variable para sa mga bagay kapag ayaw mong baguhin ang mga ito. Halimbawa, mga katangiang partikular sa bagay na magagamit namin para sa mga layunin ng pag-log;
• kung ayaw mong ma-extend ang klase, markahan ito bilang final;
• kung kailangan mong lumikha ng hindi nababagong< class, kailangan mong gawin itong pangwakas;
• kung nais mong ang pagpapatupad ng isang pamamaraan ay hindi magbago sa mga inapo nito, italaga ang pamamaraan bilang final. Napakahalaga nito upang matiyak na hindi magbabago ang pagpapatupad.

23. Ano ang nababagong hindi nababago?

Nababago

Ang nababago ay mga bagay na ang mga estado at variable ay maaaring baguhin pagkatapos ng paglikha. Halimbawa, ang mga klase tulad ng StringBuilder, 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());

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

hindi nababago

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

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

   //remove the setter

   public static void main(String[] args) {

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

       // Therefore, do not change this field in any way, so this is an immutable object
       // obj.setName("new address");
       // System.out.println(obj.getName());

   }
}

24. Paano magsulat ng isang hindi nababagong klase?

Matapos mong malaman kung ano ang nababago at hindi nababagong mga bagay, natural ang susunod na tanong - paano ito isulat? Upang magsulat ng isang hindi nababagong hindi nababagong klase, kailangan mong sundin ang mga simpleng hakbang:

• gawing pangwakas ang klase.
• gawing pribado ang lahat ng field at gumawa lang ng mga getter para sa kanila. Ang mga setter, siyempre, ay hindi kailangan.
• Gawing pinal ang lahat ng nababagong field para isang beses lang maitakda ang value.
• simulan ang lahat ng mga patlang sa pamamagitan ng tagabuo, nagsasagawa ng malalim na kopya (iyon ay, pagkopya sa mismong bagay, mga variable nito, mga variable ng mga variable, at iba pa)
• I-clone ang mga nababagong variable na bagay sa mga getter upang magbalik lamang ng mga kopya ng mga halaga, hindi mga sanggunian sa mga aktwal na bagay.

Halimbawa:

/**
* An example of creating an immutable object.
*/
public final class FinalClassExample {

   private final int age;

   private final String name;

   private final HashMap<String, String> addresses;

   public int getAge() {
       return age;
   }


   public String getName() {
       return name;
   }

   /**
    * Clone the object before returning it.
    */
   public HashMap<String, String> getAddresses() {
       return (HashMap<String, String>) addresses.clone();
   }

   /**
    * In the constructor, deep copy the mutable objects.
    */
   public FinalClassExample(int age, String name, HashMap<String, String> addresses) {
       System.out.println("Performing a deep copy in the constructor");
       this.age = age;
       this.name = name;
       HashMap<String, String> temporaryMap = new HashMap<>();
       String key;
       Iterator<String> iterator = addresses.keySet().iterator();
       while (iterator.hasNext()) {
           key = iterator.next();
           temporaryMap.put(key, addresses.get(key));
       }
       this.addresses = temporaryMap;
   }
}

• Aking GitHub profile
• Nangungunang 50 Java Core na Mga Tanong at Sagot sa Panayam. Bahagi 2