Pagsusuri ng mga tanong at sagot mula sa mga panayam para sa developer ng Java. Bahagi 14

Paputok! Ang mundo ay patuloy na gumagalaw at tayo ay patuloy na gumagalaw. Noong nakaraan, upang maging isang developer ng Java, sapat na upang malaman ang kaunting Java syntax, at ang iba ay darating. Sa paglipas ng panahon, ang antas ng kaalaman na kinakailangan upang maging isang developer ng Java ay lumago nang malaki, pati na rin ang kumpetisyon, na patuloy na nagtutulak sa mas mababang antas ng kinakailangang kaalaman pataas. Kung talagang gusto mong maging isang developer, kailangan mong tanggapin ito nang walang kabuluhan at maghanda nang lubusan upang tumayo sa mga baguhan na tulad mo. Ang gagawin namin ngayon, ibig sabihin, patuloy naming susuriin ang 250+ na tanong . Sa mga nakaraang artikulo, sinuri namin ang lahat ng mga tanong sa junior level, at ngayon ay tatalakayin namin ang mga tanong sa gitnang antas. Bagama't napapansin kong hindi ito 100% middle-level na mga tanong, maaari mong matugunan ang karamihan sa mga ito sa isang junior-level interview, dahil sa mga ganoong panayam na nagaganap ang isang detalyadong pagsisiyasat ng iyong theoretical base, habang para sa isang middle student ang ang mga tanong ay mas nakatutok sa pagsisiyasat sa kanyang karanasan. Ngunit, nang walang karagdagang ado, magsimula tayo.

Gitna

Ay karaniwan

1. Ano ang mga pakinabang at disadvantages ng OOP kung ihahambing sa procedural/functional programming?

Nagkaroon ng tanong na ito sa pagsusuri ng mga tanong para kay Juinior, at naaayon ay nasagot ko na ito. Hanapin ang tanong na ito at ang sagot nito sa bahaging ito ng artikulo, mga tanong 16 at 17.

2. Paano naiiba ang pagsasama-sama sa komposisyon?

Sa OOP, mayroong ilang uri ng pakikipag-ugnayan sa pagitan ng mga bagay, na pinagsama sa ilalim ng pangkalahatang konsepto ng "May-Isang Relasyon". Ang kaugnayang ito ay nagpapahiwatig na ang isang bagay ay bahagi ng isa pang bagay. Kasabay nito, mayroong dalawang subtype ng relasyong ito: Komposisyon - ang isang bagay ay lumilikha ng isa pang bagay at ang buhay ng isa pang bagay ay nakasalalay sa buhay ng lumikha. Pagsasama-sama - ang isang bagay ay tumatanggap ng isang link (pointer) sa isa pang bagay sa panahon ng proseso ng pagtatayo (sa kasong ito, ang buhay ng ibang bagay ay hindi nakasalalay sa buhay ng lumikha). Para sa mas mahusay na pag-unawa, tingnan natin ang isang partikular na halimbawa. Mayroon kaming isang partikular na klase ng kotse - Kotse , na kung saan ay may mga panloob na field ng uri - Engine at isang listahan ng mga pasahero - List<Passenger> , mayroon din itong paraan para sa pagsisimula ng paggalaw - startMoving() :

public class Car {

 private Engine engine;
 private List<Passenger> passengers;

 public Car(final List<Passenger> passengers) {
   this.engine = new Engine();
   this.passengers = passengers;
 }

 public void addPassenger(Passenger passenger) {
   passengers.add(passenger);
 }

 public void removePassengerByIndex(Long index) {
   passengers.remove(index);
 }

 public void startMoving() {
   engine.start();
   System.out.println("Машина начала своё движение");
   for (Passenger passenger : passengers) {
     System.out.println("В машине есть пассажир - " + passenger.getName());
   }
 }
}

Sa kasong ito, ang Komposisyon ay ang koneksyon sa pagitan ng Kotse at Engine , dahil direktang nakasalalay ang pagganap ng kotse sa presensya ng object ng engine, dahil kung engine = null , makakatanggap kami ng NullPointerException . Sa turn, ang isang makina ay hindi maaaring umiral nang walang makina (bakit kailangan natin ng isang makina na walang makina?) at hindi maaaring kabilang sa ilang mga makina sa isang pagkakataon. Nangangahulugan ito na kung tatanggalin natin ang object ng Kotse , wala nang mga reference sa Engine object , at malapit na itong tanggalin ng Garbage Collector . Tulad ng nakikita mo, ang relasyon na ito ay napakahigpit (malakas). Ang pagsasama-sama ay ang koneksyon sa pagitan ng Sasakyan at Pasahero , dahil ang pagganap ng Sasakyan sa anumang paraan ay hindi nakasalalay sa mga bagay na may uri ng Pasahero at ang kanilang numero. Maaari silang umalis sa kotse - alisin angPassengerByIndex(Long index) o magpasok ng mga bago - addPassenger(Pasahero ng pasahero) , sa kabila nito, ang kotse ay patuloy na gagana nang maayos. Sa turn, maaaring umiral ang mga Passenger object nang walang Car object . Tulad ng naiintindihan mo, ito ay isang mas mahina na koneksyon kaysa sa nakikita natin sa komposisyon. Ngunit hindi lang iyon, ang isang bagay na konektado sa pamamagitan ng pagsasama-sama sa isa pa ay maaari ding magkaroon ng ibinigay na koneksyon sa iba pang mga bagay sa parehong punto ng oras. Halimbawa, ikaw, bilang isang mag-aaral ng Java, ay naka-enroll sa mga kursong English, OOP at logarithms sa parehong oras, ngunit sa parehong oras ay hindi ka isang kritikal na kinakailangang bahagi ng mga ito, kung wala ang normal na paggana ay imposible (tulad ng isang guro).

3. Anong mga pattern ng GoF ang ginamit mo sa pagsasanay? Magbigay ng halimbawa.

Nasagot ko na ang tanong na ito dati, kaya mag-iiwan na lang ako ng link sa pagsusuri , tingnan ang unang tanong. Nakakita rin ako ng magandang artikulo ng cheat sheet sa mga pattern ng disenyo, na lubos kong inirerekumenda na panatilihin sa kamay.

4. Ano ang proxy object? Magbigay ng halimbawa

Ang proxy ay isang structural design pattern na nagbibigay-daan sa iyong palitan ang mga espesyal na substitute object, o sa madaling salita, proxy object, sa halip na mga tunay na bagay. Ang mga proxy object na ito ay humarang sa mga tawag sa orihinal na bagay, na nagbibigay-daan sa ilang logic na maipasok bago o pagkatapos maipasa ang tawag sa orihinal. Mga halimbawa ng paggamit ng proxy object:

• Bilang isang malayuang proxy - ginagamit kapag kailangan namin ng isang malayuang bagay (isang bagay sa ibang espasyo ng address) na kailangang irepresenta nang lokal. Sa kasong ito, hahawakan ng proxy ang paglikha ng koneksyon, pag-encode, pag-decode, atbp., habang gagamitin ito ng kliyente na parang ito ang orihinal na bagay na matatagpuan sa lokal na espasyo.

• Bilang isang virtual proxy - ginagamit kapag kailangan ang isang bagay na masinsinang mapagkukunan. Sa kasong ito, ang proxy object ay nagsisilbing isang bagay tulad ng isang imahe ng isang tunay na bagay na talagang hindi pa umiiral. Kapag ang isang tunay na kahilingan (pamamaraan ng tawag) ay ipinadala sa bagay na ito, pagkatapos lamang ang orihinal na bagay ay naglo-load at ang pamamaraan ay isinasagawa. Ang pamamaraang ito ay tinatawag ding tamad na pagsisimula; maaari itong maging napaka-maginhawa, dahil sa ilang mga sitwasyon ang orihinal na bagay ay maaaring hindi kapaki-pakinabang, at pagkatapos ay walang gastos upang lumikha nito.

• Bilang proxy ng seguridad - ginagamit kapag kailangan mong kontrolin ang pag-access sa ilang bagay batay sa mga karapatan ng kliyente. Iyon ay, kung ang isang kliyente na may nawawalang mga karapatan sa pag-access ay sumusubok na i-access ang orihinal na bagay, haharangin ito ng proxy at hindi ito papayagan.

Tingnan natin ang isang halimbawa ng isang virtual proxy: Mayroon kaming ilang interface ng handler:

public interface Processor {
 void process();
}

Ang pagpapatupad ng kung saan ay gumagamit ng masyadong maraming mga mapagkukunan, ngunit sa parehong oras na ito ay maaaring hindi gamitin sa bawat oras na ang application ay inilunsad:

public class HiperDifficultProcessor implements Processor {
 @Override
 public void process() {
   // некоторый сверхсложная обработка данных
 }
}

Klase ng proxy:

public class HiperDifficultProcessorProxy implements Processor {
private HiperDifficultProcessor processor;

 @Override
 public void process() {
   if (processor == null) {
     processor = new HiperDifficultProcessor();
   }
   processor.process();
 }
}

Patakbuhin natin ito sa pangunahing :

Processor processor = new HiperDifficultProcessorProxy();
// тут тяжеловсеного оригинального an object, ещё не сущетсвует
// но при этом есть an object, который его представляет и у которого можно вызывать его методы
processor.process(); // лишь теперь, an object оригинал был создан

Tandaan ko na maraming mga frameworks ang gumagamit ng proxying, at para sa Spring ito ay isang pangunahing pattern (Spring ay stitched kasama nito sa loob at labas). Magbasa nang higit pa tungkol sa pattern na ito dito .

5. Anong mga inobasyon ang inihayag sa Java 8?

Ang mga inobasyon na dala ng Java 8 ay ang mga sumusunod:

• Naidagdag ang mga functional na interface, basahin ang tungkol sa kung anong uri ng hayop ito dito .

• Ang mga expression ng Lambda, na malapit na nauugnay sa mga functional na interface, magbasa nang higit pa tungkol sa kanilang paggamit dito .

• Idinagdag ang Stream API para sa maginhawang pagproseso ng mga koleksyon ng data, magbasa nang higit pa dito .

• Nagdagdag ng mga link sa mga pamamaraan .

• Ang paraang forEach() ay naidagdag sa Interable na interface .

• Nagdagdag ng bagong date and time API sa java.time package , detalyadong pagsusuri dito .

• Pinahusay na Kasabay na API .

• Pagdaragdag ng Opsyonal na klase ng wrapper , na ginagamit upang wastong pangasiwaan ang mga null value, makakahanap ka ng mahusay na artikulo sa paksang ito dito .

• Ang pagdaragdag ng kakayahan para sa mga interface na gumamit ng mga static at default na pamamaraan (na, sa esensya, ay nagdadala ng Java na mas malapit sa maramihang mana), higit pang mga detalye dito .

• Nagdagdag ng mga bagong pamamaraan sa Collection(removeIf(), spliterator()) class .

• Mga maliliit na pagpapabuti sa Java Core.

6. Ano ang High Cohesion at Low Coupling? Magbigay ng halimbawa.

Ang High Cohesion o High Cohesion ay ang konsepto kapag ang isang partikular na klase ay naglalaman ng mga elemento na malapit na magkakaugnay sa isa't isa at pinagsama para sa kanilang layunin. Halimbawa, ang lahat ng mga pamamaraan sa klase ng User ay dapat kumatawan sa gawi ng user. Ang isang klase ay may mababang pagkakaisa kung naglalaman ito ng mga hindi nauugnay na elemento. Halimbawa, ang klase ng User na naglalaman ng paraan ng pagpapatunay ng email address:

public class User {
private String name;
private String email;

 public String getName() {
   return this.name;
 }

 public void setName(final String name) {
   this.name = name;
 }

 public String getEmail() {
   return this.email;
 }

 public void setEmail(final String email) {
   this.email = email;
 }

 public boolean isValidEmail() {
   // некоторая логика валидации емейла
 }
}

Maaaring responsable ang klase ng user sa pag-imbak ng email address ng user, ngunit hindi para sa pagpapatunay nito o pagpapadala ng email. Samakatuwid, upang makamit ang mataas na pagkakaugnay, inililipat namin ang paraan ng pagpapatunay sa isang hiwalay na klase ng utility:

public class EmailUtil {
 public static boolean isValidEmail(String email) {
   // некоторая логика валидации емейла
 }
}

At ginagamit namin ito kung kinakailangan (halimbawa, bago i-save ang gumagamit). Ang Low Coupling o Low Coupling ay isang konsepto na naglalarawan ng mababang interdependence sa pagitan ng software modules. Sa esensya, ang pagtutulungan ay kung paano ang pagbabago ng isa ay nangangailangan ng pagbabago sa isa pa. Ang dalawang klase ay may matibay na pagkakabit (o mahigpit na pagkakabit) kung malapit silang magkaugnay. Halimbawa, dalawang kongkretong klase na nag-iimbak ng mga sanggunian sa isa't isa at tumatawag sa mga pamamaraan ng isa't isa. Ang maluwag na pinagsamang mga klase ay mas madaling bumuo at mapanatili. Dahil sila ay independyente sa isa't isa, maaari silang mabuo at masuri nang magkatulad. Bukod dito, maaari silang baguhin at i-update nang hindi naaapektuhan ang isa't isa. Tingnan natin ang isang halimbawa ng malakas na pinagsamang mga klase. Mayroon kaming ilang klase ng mag-aaral:

public class Student {
 private Long id;
 private String name;
 private List<Lesson> lesson;
}

Na naglalaman ng isang listahan ng mga aralin:

public class Lesson {
 private Long id;
 private String name;
 private List<Student> students;
}

Ang bawat aralin ay naglalaman ng isang link sa pagdalo sa mga mag-aaral. Napakalakas ng pagkakahawak, hindi ba? Paano mo ito mababawasan? Una, tiyakin natin na ang mga mag-aaral ay walang listahan ng mga paksa, ngunit isang listahan ng kanilang mga identifier:

public class Student {
 private Long id;
 private String name;
 private List<Long> lessonIds;
}

Pangalawa, hindi kailangang malaman ng klase ng aralin ang tungkol sa lahat ng mga mag-aaral, kaya tanggalin natin ang kanilang listahan nang buo:

public class Lesson {
 private Long id;
 private String name;
}

Kaya ito ay naging mas madali, at ang koneksyon ay naging mas mahina, sa palagay mo ba?

OOP

7. Paano mo maipapatupad ang maramihang pamana sa Java?

Ang multiple inheritance ay isang feature ng object-oriented na konsepto kung saan ang isang klase ay maaaring magmana ng mga property mula sa higit sa isang parent class. Ang problema ay lumitaw kapag may mga pamamaraan na may parehong lagda sa parehong super class at subclass. Kapag tumatawag ng isang pamamaraan, hindi matukoy ng compiler kung aling paraan ng klase ang dapat tawagan, at kahit na ang pagtawag sa pamamaraan ng klase na mauuna. Samakatuwid, hindi sinusuportahan ng Java ang maramihang pamana! Ngunit mayroong isang uri ng butas, na pag-uusapan natin sa susunod. Tulad ng nabanggit ko kanina, sa paglabas ng Java 8, ang kakayahang magkaroon ng mga default na pamamaraan ay idinagdag sa mga interface . Kung hindi na-override ng klase na nagpapatupad ng interface ang pamamaraang ito, gagamitin ang default na pagpapatupad na ito (hindi kinakailangang i-override ang default na paraan, tulad ng pagpapatupad ng abstract). Sa kasong ito, posible na ipatupad ang iba't ibang mga interface sa isang klase at gamitin ang kanilang mga default na pamamaraan. Tingnan natin ang isang halimbawa. Mayroon kaming ilang interface ng flyer, na may default na paraan ng fly() :

public interface Flyer {
 default void fly() {
   System.out.println("Я лечу!!!");
 }
}

Ang interface ng walker, na may default na walk() na pamamaraan :

public interface Walker {
 default void walk() {
   System.out.println("Я хожу!!!");
 }
}

Ang interface ng manlalangoy, na may pamamaraang swim() :

public interface Swimmer {
 default void swim() {
   System.out.println("Я плыву!!!");
 }
}

Well, ngayon ipatupad natin ang lahat ng ito sa isang klase ng pato:

public class Duck implements Flyer, Swimmer, Walker {
}

At patakbuhin natin ang lahat ng mga pamamaraan ng ating pato:

Duck donald = new Duck();
donald.walk();
donald.fly();
donald.swim();

Sa console makakatanggap kami ng: Nangangahulugan ito na nailarawan namin nang tama ang maramihang mana, kahit na hindi ito kung ano ito. Napansin ko rin na kung ang isang klase ay nagpapatupad ng mga interface na may mga default na pamamaraan na may parehong mga pangalan ng pamamaraan at parehong mga argumento sa mga pamamaraang ito, kung gayon ang compiler ay magsisimulang magreklamo tungkol sa hindi pagkakatugma, dahil hindi nito naiintindihan kung aling pamamaraan ang talagang kailangang gamitin. Mayroong ilang mga paraan palabas:

• Palitan ang pangalan ng mga pamamaraan sa mga interface upang magkaiba ang mga ito sa isa't isa.
• I-override ang mga kontrobersyal na pamamaraan sa klase ng pagpapatupad.
• Magmana mula sa isang klase na nagpapatupad ng mga kontrobersyal na pamamaraang ito (pagkatapos ay eksaktong gagamitin ng iyong klase ang pagpapatupad nito).

8. Ano ang pagkakaiba sa pagitan ng final, finally at finalize() na mga pamamaraan?

Ang final ay isang keyword na ginagamit upang maglagay ng constraint sa isang klase, pamamaraan, o variable, isang constraint na kahulugan:

• Para sa isang variable - pagkatapos ng paunang pagsisimula, hindi na muling tukuyin ang variable.
• Para sa isang pamamaraan, ang pamamaraan ay hindi maaaring i-override sa isang subclass (kapalit na klase).
• Para sa isang klase - hindi maaaring magmana ang klase.

panghuli ay isang keyword bago ang isang bloke ng code, na ginagamit kapag humahawak ng mga pagbubukod, kasabay ng isang try block , at magkasama (o maaaring palitan) ng catch block. Ang code sa block na ito ay isinasagawa sa anumang kaso, hindi alintana kung ang isang pagbubukod ay itinapon o hindi. Sa bahaging ito ng artikulo, sa tanong 104, tinatalakay ang mga pambihirang sitwasyon kung saan hindi isasagawa ang block na ito. finalize() ay isang paraan ng Object class , na tinatawag bago ang bawat object ay tanggalin ng garbage collector, ang pamamaraang ito ay tatawagin (huling), at ginagamit upang linisin ang mga nasasakupang mapagkukunan. Para sa karagdagang impormasyon tungkol sa mga pamamaraan ng klase ng Bagay na minana ng bawat bagay, tingnan ang tanong 11 sa bahaging ito ng artikulo. Well, diyan tayo magtatapos ngayon. See you sa susunod na bahagi!