Koda smarža 286 — vecāku un bērnu metodes pārklājas

Kad vecāku un bērnu metodes saduras!

TL;DR: neizmantojiet privātās metodes vecāku klasēs ar nosaukumiem, kurus var izmantot pakārtotās klases.

Problēmas

• Mazākais pārsteiguma principa pārkāpums
• Negaidīta uzvedība un defekti
• Slēptās atkarības
• Ierobežota paplašināmība
• Koda neskaidrība
• Atvērtā/slēgtā principa pārkāpums
• Maldinošs dizains

Risinājumi

1. Izvairieties no hierarhijām
2. Pārdēvējiet privātās metodes
3. Saglabājiet skaidru nosaukumu
4. Izvairieties no nosaukumiem, kas pārklājas
5. Izvairieties no aizsargātām metodēm
6. Apakšklasifikējiet būtiskām attiecībām , nevis lai atkārtoti izmantotu kodu

Konteksts

Ja izmantojat vienu un to pašu metodes nosaukumu vecāku un bērnu klasēs, rodas neskaidrības.

Privāto metodi vecākklasē nevar ignorēt pat tad, ja pakārtotajā klasē pastāv publiska metode ar tādu pašu nosaukumu.

Tā ir problēma vairumam statisko valodu dizainā. Šī atvienošana izraisa kļūdas un apgrūtina koda uzturēšanu.

Koda paraugs

Nepareizi

 <? class ParentClass { private function greet() { // This method is private return "Hello from ParentClass"; } public function callGreet() { return $this->greet(); } } class ChildClass extends ParentClass { public function greet() { // Overriding a concrete method is a code smell // Compilers SHOULD warn you return "Hello from ChildClass"; } } $child = new ChildClass(); echo $child->callGreet(); // When callGreet() is invoked on the $child object, // it executes the following: // It calls $this->greet(), // which refers to the greet() method of ParentClass // because the original method is private // and cannot be overridden or accessed from ChildClass. // The unexpected output is 'Hello from ParentClass'

Pareizi

 <? class ParentClass { protected function greet() { // notice the 'protected qualifier' return "Hello from ParentClass"; } public function callGreet() { return $this->greet(); } } class ChildClass extends ParentClass { public function greet() { return "Hello from ChildClass"; } } $child = new ChildClass(); echo $child->callGreet(); // The output is "Hello from ChildClass" // This is the standard (and wrong) solution // Also fixed by most AIs

 <? abstract class ParentClass { // Declare greet() as an abstract method // Following the template-method design pattern abstract protected function greet(); public function callGreet() { return $this->greet(); } } class ChildClass extends ParentClass { protected function greet() { return "Hello from ChildClass"; } } class OtherChild extends ParentClass { protected function greet() { return "Hello from OtherChild"; } } $child = new ChildClass(); echo $child->callGreet(); // Output: Hello from ChildClass $otherChild = new OtherChild(); echo $otherChild->callGreet(); // Output: Hello from OtherChild

Atklāšana

• [x] Pusautomātiska

Šo smaku var noteikt, meklējot privātās metodes vecāku klasēs un pārbaudot, vai bērnu klasēs ir definētas metodes ar tādu pašu nosaukumu. Jums ir arī jāpārbauda vecāku metodes, izsaucot privātās metodes.

Tagi

• Hierarhija

Līmenis

• [x] Vidēja līmeņa

Kāpēc bijekcija ir svarīga

Skaidram un paredzamam kodam jāatspoguļo tā modeļu reālās pasaules hierarhija.

Izmantojot privātās metodes ar nosaukumiem, kas pārklājas, jūs izveidojat bijekcijas atstarpi starp modeli un ieviešanu.

Šī plaisa mulsina izstrādātājus, palielina defektu skaitu un pārkāpj tīra koda principus.

AI paaudze

AI ģeneratori bieži rada šo smaku, ģenerējot vecāku un bērnu attiecības.

Viņi var nepārbaudīt piekļuves līmeņus vai ņemt vērā mantojuma sekas.

AI noteikšana

AI rīki var novērst šo smaku, izmantojot skaidrus norādījumus.

Varat lūgt AI pārbaudīt, vai metožu nosaukumi un faktora hierarhijas nepārklājas.

Izmēģiniet tos!

Atcerieties: AI palīgi pieļauj daudz kļūdu

Secinājums

Veidojot vecāku un bērnu klases, jums vajadzētu izmantot metodes, kas skaidri nosaka mantošanu un pieejamību.

Izvairieties no privātām metodēm, kas pārklājas ar bērnu metodēm. Tādējādi jūsu kods ir lasāms, paplašināms un saskaņots ar tīra koda principiem.

Valodas, piemēram , Python, ļauj ignorēt vecāku metodes neatkarīgi no to nosaukumiem, savukārt Java stingri piemēro piekļuves līmeņus.

C# darbojas līdzīgi kā Java . Šīs atšķirības nozīmē, ka jums ir jāsaprot īpašie valodas noteikumi, ar kuriem strādājat, lai izvairītos no neparedzētas uzvedības.

Attiecības

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxviii

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xii

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-iii-t7h3zkv

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxv

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-viii-8mn3352

Mantojums ir labs, taču nekad nevajadzētu aizmirst, ka tas ievieš ciešu savienojumu.

Roberts C. Mārtins