Neno kuu la super la Java lilielezwa: Viumba, Mbinu, na Sehemu (Kwa Mifano)

1. Uhusiano Kati ya Urithi na super

Ili kuelewa neno kuu la Java super, unapaswa kwanza kuelewa urithi.
super si kitu ambacho unakumbuka peke yake—maana yake inakuwa wazi mara tu unapona jinsi darasa la mtoto na darasa la mzazi vinavyofanya kazi pamoja.

Katika sehemu hii, utajifunza urithi ni nini na kwa nini super ipo kwa msingi, ukitumia maelezo rahisi kwa wanaoanza na mifano ya msimbo rahisi.

1.1 Urithi ni Nini katika Java? (Misingi ya extends)

Katika Java, urithi hukuruhusu kuunda darasa jipya kulingana na darasa lililopo.

• Darasa la mzazi (superclass) : darasa la msingi
• Darasa la mtoto (subclass) : darasa linalorithi kutoka kwa darasa la mzazi

Wakati darasa la mtoto linaongeza (extends) darasa la mzazi, linaweza kutumia tena sehemu na mbinu za mzazi bila kuziandika upya.

Sarufi ya msingi ya urithi (extends)

class Parent {
    void hello() {
        System.out.println("Hello from Parent");
    }
}

class Child extends Parent {
}

Hapa, Child inarithi mbinu ya hello() kutoka kwa Parent.

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.hello(); // calling a method inherited from Parent
    }
}

Matokeo:

Hello from Parent

Hivyo ingawa Child haijafafanua hello(), bado inaweza kuitia kwa sababu imeirithi.

1.2 Kwa Nini Tunahitaji super?

Katika hatua hii, unaweza kufikiri:

“Kama mtoto tayari anirithi kila kitu kutoka kwa mzazi, kwa nini tunahitaji super kabisa?”

Katika hali nyingi, huna haja ya kuandika super wazi.
Hata hivyo, super inakuwa muhimu unapohitaji kufikia toleo la mzazi la kitu kwa uwazi.

Hali za kawaida ni pamoja na:

• Darasa la mtoto linabadilisha (overrides) mbinu, lakini bado unataka kuita toleo la mzazi
• Darasa la mtoto na darasa la mzazi wana sehemu zenye jina sawa
• Unahitaji kuita kijenga cha mzazi maalum kwa kutumia hoja

Kwa kifupi:

super hutumika unapohitaji kurejelea wazi upande wa darasa la mzazi.

1.3 Kubadilisha (Overriding) na super (Kuhifadhi Tabia ya Mzazi)

Moja ya sababu za kawaida za kutumia super ni kubadilisha mbinu.

Kubadilisha (overriding) maana yake darasa la mtoto linatoa toleo lake la mbinu ambayo tayari ipo katika darasa la mzazi.

Mfano: kubadilisha mbinu

class Parent {
    void greet() {
        System.out.println("Parent: Hello!");
    }
}

class Child extends Parent {
    @Override
    void greet() {
        System.out.println("Child: Hi!");
    }
}

Sasa ikiwa utaita greet() kwenye kipengele cha Child:

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.greet();
    }
}

Matokeo:

Child: Hi!

Toleo la mtoto linafanya kazi, kwa sababu kubadilisha kunampa darasa la mtoto kipaumbele.

Kuita toleo la mzazi kwa super.greet()

Wakati mwingine hutaki kubadilisha kabisa tabia ya mzazi—unataka tu kuongeza mantiki ya ziada.

Hapo ndipo super.method() inafaa:

class Parent {
    void greet() {
        System.out.println("Parent: Hello!");
    }
}

class Child extends Parent {
    @Override
    void greet() {
        super.greet(); // call parent version
        System.out.println("Child: Hi!");
    }
}

Matokeo:

Parent: Hello!
Child: Hi!

Huu ni muundo wa kiutendaji sana:

• Darasa la mzazi hushughulikia tabia ya kawaida
• Darasa la mtoto linaongeza tabia maalum

1.4 Wakati Mzazi na Mtoto Wana Jina Moja la Sehemu

Hali nyingine ambapo super ina umuhimu ni wakati darasa la mzazi na darasa la mtoto wana sehemu zenye jina sawa.

Mfano:

class Parent {
    int value = 100;
}

class Child extends Parent {
    int value = 200;

    void printValue() {
        System.out.println(value);
    }
}

Hapa, value inarejelea sehemu ya darasa la mtoto, hivyo matokeo yatakuwa:

200

Ikiwa unataka kufikia uga wa mzazi, tumia super.value:

class Child extends Parent {
    int value = 200;

    void printValue() {
        System.out.println(value);       // child value
        System.out.println(super.value); // parent value
    }
}

Matokeo:

200
100

Mambo muhimu:

• value → uga wa darasa la mtoto
• super.value → uga wa darasa la mzazi

1.5 super Inamaanisha Nini Kwa Hakika (Ufafanuzi Rahisi)

Sasa unaweza kufupisha super kama ifuatavyo:

super ni neno muhimu linalokuruhusu kufikia wazi toleo la darasa la mzazi la uga, mbinu, na vijenzi.

Ukumbuka mstari mmoja tu, kumbuka haya:

super inamaanisha “tumia toleo la darasa la mzazi.”

Katika sehemu ijayo, utajifunza njia 3 muhimu zaidi za kutumia super, pamoja na mifano wazi kwa kila moja.

2. Jinsi ya Kutumia super (Mifumo 3 ya Msingi)

Sasa unapofahamu super inamaanisha nini, hebu tuelekeze jinsi inavyotumika katika Java.

Katika msimbo wa ulimwengu halisi, super inaonekana katika mifumo mitatu kuu:

1. Kuita kijenga cha mzazi ( super() / super(args...) )
2. Kuita mbinu ya mzazi ( super.method() )
3. Kufikia ugha wa mzazi ( super.field )

Mara tu unapojifunza hizi tatu, super inakuwa rahisi sana kutambua na kuitumia kwa usahihi.

2.1 Kuita Kijenga cha Mzazi (super() / super(args...))

2.1.1 Kumbukumbu ya Haraka: Kijenga ni Nini?

Kijenga ni mbinu maalum inayotekelezwa unapounda kipengele.

class Person {
    Person() {
        System.out.println("Person constructor");
    }
}

Vijenzi hutumika kwa uanzishaji, kama vile kuweka uga.

2.1.2 Katika urithi, kijenga cha mzazi hufanyika kwanza

Katika urithi wa Java, kuunda kipengele cha mtoto daima huanza kwa kuanzisha sehemu ya mzazi kwanza.

Hiyo inamaanisha:

Kijenga cha mzazi → Kijenga cha mtoto

Mfano:

class Parent {
    Parent() {
        System.out.println("Parent constructor");
    }
}

class Child extends Parent {
    Child() {
        System.out.println("Child constructor");
    }
}

public class Main {
    public static void main(String[] args) {
        new Child();
    }
}

Matokeo:

Parent constructor
Child constructor

Ingawa hatukuandika super(), kijenga cha mzazi bado kilitekelezwa.

2.1.3 super() inaingizwa kiotomatiki (ikiwezekana)

Kama darasa la mzazi lina kijenga kisicho na hoja, Java inaingiza kiotomatiki mstari huu juu ya kijenga cha mtoto:

super();

Hivyo vijenzi hivi viwili ni sawa kimsingi:

Child() {
    System.out.println("Child constructor");
}

Child() {
    super(); // implicitly inserted by the compiler
    System.out.println("Child constructor");
}

2.1.4 Wakati mzazi ana kijenga kilicho na vigezo pekee

Hii ni mojawapo ya makosa ya kawaida ya wanaoanza.

Kama darasa la mzazi halina kijenga kisicho na hoja, Java haiwezi kuingiza super() kiotomatiki.

Mfano (hii itasababisha kosa la kukusanya):

class Parent {
    Parent(int x) {
        System.out.println("Parent: " + x);
    }
}

class Child extends Parent {
    Child() {
        System.out.println("Child created");
    }
}

Kwa nini inashindwa:

• Kajamii anajaribu kuingiza super();
• Lakini Parent() haipo

✅ Suluhisho: itiiita kijenga sahihi cha mzazi waziwazi

class Child extends Parent {
    Child() {
        super(10);
        System.out.println("Child created");
    }
}

Matokeo:

Parent: 10
Child created

2.1.5 super(...) lazima iwe mstari wa kwanza katika kijenga

Java inahitaji super(...) iwe tamko la kwanza katika kijenga.

❌ Sio sahihi:

Child() {
    System.out.println("Something first");
    super(10); // compile error
}

✅ Sahihi:

Child() {
    super(10);
    System.out.println("Child logic");
}

Sababu:

• Mzazi lazima aanzishwe kabla ya mtoto kuweza kutekeleza mantiki yake kwa usalama.

2.2 Kuita Njia ya Mzazi (super.method())

Matumizi mengine yanayofanyika sana ni kupigia simu njia ya mzazi baada ya kuibadilisha.

2.2.1 Mfano wa Msingi

class Parent {
    void show() {
        System.out.println("Parent show()");
    }
}

class Child extends Parent {
    @Override
    void show() {
        System.out.println("Child show()");
    }

    void test() {
        super.show(); // parent version
        show();       // child version
    }
}

public class Main {
    public static void main(String[] args) {
        new Child().test();
    }
}

Matokeo:

Parent show()
Child show()

2.2.2 Ni Lini Hii Inafaa?

super.method() inafaa wakati:

• Njia ya mzazi ina mantiki ya kawaida
• Njia ya mtoto inahitaji kuongeza tabia badala ya kuibadilisha
• Unataka kuepuka kunakili mantiki ya mzazi ndani ya mtoto

Mfano:

class Parent {
    void process() {
        System.out.println("Common processing");
    }
}

class Child extends Parent {
    @Override
    void process() {
        super.process();
        System.out.println("Child-specific processing");
    }
}

Muundo huu humweka msimbo wako safi na unaoweza kudumishwa.

2.3 Kupata Uwanja wa Mzazi (super.field)

Uwanja hufanya vivyo hivyo. Ikiwa mzazi na mtoto wote wana uwanja wenye jina sawa, uwanja wa mtoto hujificha uwanja wa mzazi.

Mfano:

class Parent {
    int value = 100;
}

class Child extends Parent {
    int value = 200;

    void print() {
        System.out.println(value);       // child field
        System.out.println(super.value); // parent field
    }
}

public class Main {
    public static void main(String[] args) {
        new Child().print();
    }
}

Matokeo:

200
100

2.3.1 Je, unapaswa kufanya hivi katika miradi halisi?

Kwa kawaida, kuwa na jina la uwanja sawa katika mzazi na mtoto si wazo zuri kwani linaweza kuchanganya wasomaji.

Hata hivyo, inaweza kutokea wakati:

• Unahifadhi msimbo wa urithi
• Unalazimika kulingana na muundo wa darasa la mzazi uliopo
• Unahitaji kutofautisha wazi thamani za mzazi na mtoto

Katika hali hizo, super.field ni chombo sahihi.

2.4 Muhtasari wa mifumo 3

Unaweza kukumbuka super kama ifuatavyo:

• super() / super(args...) → piga kijenga cha mzazi
• super.method() → piga njia ya mzazi
• super.field → pata uwanja wa mzazi

Katika sehemu ijayo, tutachunguza kwa undani kwa mifano ya msimbo ili uweze kuona wazi jinsi mifumo hii inavyofanya kazi wakati inatekelezwa.

3. Mifano ya Kivitendo Kujifunza super

Kwa hatua hii, tayari unajua njia tatu kuu za kutumia super.
Sasa hebu tufanye maarifa hayo yadumu kwa kupitia mifano ya vitendo.

Sehemu hii inazingatia:

• Utaratibu wa utekelezaji
• Nini kinapigwa na kwa nini
• Jinsi super inavyobadilisha tabia katika msimbo halisi

3.1 Mfano 1: Utaratibu wa kupiga kijenga (Mzazi → Mtoto)

Sheria muhimu zaidi ya kukumbuka:

Unapounda kipengele cha mtoto, Java daima huanzisha sehemu ya mzazi kwanza.

class Parent {
    Parent() {
        System.out.println("Parent constructor");
    }
}

class Child extends Parent {
    Child() {
        super(); // optional here, but allowed
        System.out.println("Child constructor");
    }
}

public class Main {
    public static void main(String[] args) {
        new Child();
    }
}

Matokeo:

Parent constructor
Child constructor

Jambo kuu:
Hata kama unaondoa super(), matokeo yanabaki sawa (mradi mzazi awe na kijenga kisicho na hoja).

3.2 Mfano 2: Mzazi ana kijenga kilichopaswa vigezo pekee

Kama darasa la mzazi halina kijenga kisicho na hoja, mtoto lazima ipige moja kwa moja kijenga sahihi.

class Parent {
    Parent(String name) {
        System.out.println("Parent: " + name);
    }
}

class Child extends Parent {
    Child() {
        super("Taro");
        System.out.println("Mtoto umeundwa");
    }
}

public class Main {
    public static void main(String[] args) {
        new Child();
    }
}

Output:

Mzazi: Taro
Mtoto umeundwa

Key point:
If you forget super("Taro"), Java tries to insert super() automatically and fails.

3.3 Example 3: Calling a parent method after overriding (super.method())

This is one of the most useful patterns in real projects.

class Parent {
    void greet() {
        System.out.println("Habari kutoka Mzazi");
    }
}

class Child extends Parent {
    @Override
    void greet() {
        super.greet(); // ita tabia ya mzazi
        System.out.println("Habari kutoka Mtoto");
    }
}

public class Main {
    public static void main(String[] args) {
        new Child().greet();
    }
}

Output:

Habari kutoka Mzazi
Habari kutoka Mtoto

Key point:
You can extend parent behavior without rewriting it.

3.4 Example 4: Accessing a hidden parent field (super.field)

If parent and child both define a field with the same name, the child version hides the parent version.

class Parent {
    int value = 100;
}

class Child extends Parent {
    int value = 200;

    void printValues() {
        System.out.println("Thamani ya Mtoto: " + value);
        System.out.println("Thamani ya Mzazi: " + super.value);
    }
}

public class Main {
    public static void main(String[] args) {
        new Child().printValues();
    }
}

Output:

Thamani ya Mtoto: 200
Thamani ya Mzazi: 100

Key point:

• value refers to the child’s field
• super.value refers to the parent’s field

3.5 Example 5: Calling both parent and child versions clearly

This is a great example to remove confusion.

class Parent {
    void show() {
        System.out.println("Mzazi show()");
    }
}

class Child extends Parent {
    @Override
    void show() {
        System.out.println("Mtoto show()");
    }

    void test() {
        super.show(); // toleo la mzazi
        this.show();  // toleo la mtoto (sawa na kuita show() tu)
    }
}

public class Main {
    public static void main(String[] args) {
        new Child().test();
    }
}

Output:

Mzazi show()
Mtoto show()

Key point:

• super.show() = parent
• this.show() = child

3.6 A realistic example: shared logic in the parent class

In real applications, parent classes often contain common logic such as logging, validation, or setup steps.

class BaseService {
    void execute() {
        System.out.println("[LOG] Anza utekelezaji");
    }
}

class UserService extends BaseService {
    @Override
    void execute() {
        super.execute(); // tumia tena tabia iliyoshirikiwa
        System.out.println("Logic ya UserService inaendesha...");
    }
}

public class Main {
    public static void main(String[] args) {
        new UserService().execute();
    }
}

Output:

[LOG] Anza utekelezaji
Logic ya UserService inaendesha...

Why this is useful:

• You avoid duplicating common behavior
• The child focuses only on what’s unique
• Your code becomes easier to maintain

3.7 Section summary

From these examples, you should remember:

• Parent constructors run before child constructors
• super(args...) is required if the parent has no no-arg constructor
• super.method() is perfect for reusing and extending behavior
• super.field helps when parent and child fields share the same name

Next, we’ll clarify one of the most confusing topics for beginners:

What’s the difference between this and super?

4. Difference Between this and super

When learning Java’s super, you will almost always see this at the same time.
Both are reference keywords, so it’s easy for beginners to mix them up.

In this section, you’ll learn:

answer.* Nini maana ya this * Nini maana ya super * Jinsi ya kuvitumia kwa usahihi na sehemu, mbinu, na vijenzi

4.1 this inarejelea kipengele cha sasa (kifungu cha mtoto)

this maana yake:

“kitu cha sasa cha mfano”

Inatumika zaidi wakati jina la sehemu na jina la kipengele cha muundaji ni sawa.

class User {
    String name;

    User(String name) {
        this.name = name; // field = parameter
    }
}

Hapa:

• name (upande wa kulia) ni kipengele cha muundaji
• this.name (upande wa kushoto) ni sehemu ya mfano

Hivyo this hukusaidia kuepuka mkanganyiko.

4.2 super inarejelea upande wa darasa mzazi

super inarejelea sehemu ya darasa mzazi (superclass) ya kitu cha sasa.

Inamaanisha:

“tumia toleo la darasa mzazi”

Unaitumia hasa unapohitaji kufikia wanachama wa darasa mzazi ambao wamefichwa au kubadilishwa.

4.3 Njia rahisi ya kukumbuka tofauti

Njia rafiki kwa wanaoanza ya kukumbuka:

• this → upande wa darasa la mtoto
• super → upande wa darasa la mzazi

Hazi si vitu viwili tofauti.
Ni mtazamo miwili tofauti ya kitu kimoja.

4.4 Kutumia this na super na sehemu

Kama mzazi na mtoto wote wanatengeneza sehemu yenye jina sawa, unaweza kuchagua wazi ni ipi unayotaka.

class Parent {
    int value = 100;
}

class Child extends Parent {
    int value = 200;

    void print() {
        System.out.println(this.value);  // child field
        System.out.println(super.value); // parent field
    }
}

public class Main {
    public static void main(String[] args) {
        new Child().print();
    }
}

Matokeo:

200
100

Jambo kuu:

• this.value = sehemu ya mtoto
• super.value = sehemu ya mzazi

Pia, katika Java, this mara nyingi si lazima:

System.out.println(value);

ni sawa na:

System.out.println(this.value);

4.5 Kutumia this na super na mbinu

Mbinu ni eneo linalojulikana zaidi ambapo this dhidi ya super hufanya tofauti—hasa wakati wa kubatilisha.

class Parent {
    void show() {
        System.out.println("Parent show()");
    }
}

class Child extends Parent {
    @Override
    void show() {
        System.out.println("Child show()");
    }

    void test() {
        this.show();   // child method (same as show())
        super.show();  // parent method
    }
}

public class Main {
    public static void main(String[] args) {
        new Child().test();
    }
}

Matokeo:

Child show()
Parent show()

Jambo kuu:

• this.show() → toleo la mtoto
• super.show() → toleo la mzazi

4.6 Vijenzi: this() vs super()

Hii ni moja ya sehemu zinazochanganya zaidi kwa wanaoanza, lakini ni muhimu sana.

• this() inaita muundaji mwingine katika darasa hilo hilo
• super() inaita muundaji katika darasa la mzazi

4.6.1 Mfano wa this() (kufuatilia muundaji ndani ya darasa hilo hilo)

class User {
    String name;
    int age;

    User() {
        this("NoName", 0); // call another constructor
    }

    User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Hii ni muhimu kwa sababu inazuia kurudia mantiki ya uanzishaji.

4.6.2 Mfano wa super() (kuita muundaji wa mzazi)

class Parent {
    Parent() {
        System.out.println("Parent constructor");
    }
}

class Child extends Parent {
    Child() {
        super(); // initialize parent
        System.out.println("Child constructor");
    }
}

Matokeo:

Parent constructor
Child constructor

4.7 Huwezi kutumia this() na super() pamoja

Wanaoanza wengi hujaribu kitu kama hiki:

Child() {
    this(1);
    super(); // error
}

Hii hairuhusiwi.

Sababu:

• Zote this() na super() lazima ziwe mstari wa kwanza katika muundaji
• Moja tu ya hizo inaweza kuwa ya kwanza

Kwa hiyo lazima uchague moja.

4.8 Kumbusho muhimu: super haijenge kitu kipya

super haijengea kitu cha mzazi tofauti.

Badala yake:

• this = kipengele cha sasa kinachoonekana kama mtoto
• super = kipengele hicho hicho kinachoonekana kama mzazi

Hii ndiyo sababu super inafaa kufikiriwa kama neno kuu la rejea, si muundaji wa kitu.

4.9 Muhtasari wa Sehemu

• this inarejelea kipengele cha sasa (upande wa mtoto)
• super inarejelea upande wa darasa la mzazi
• this() inaita muundaji mwingine katika darasa lile lile
• super() inaita muundaji katika darasa la mzazi
• this() na super() haviwezi kutumika pamoja

Ifuatayo, tutashughulikia makosa ya kawaida na mifumo ya hitilafu ili uweze kuepuka vizingiti vya kawaida vya wanaoanza.

5. Makosa ya Kawaida na Vizingiti (Jinsi ya Kuepuka Hitilafu)

Neno kuu la super la Java lina nguvu, lakini pia ni rahisi kutumika vibaya—haswa unapojifunza urithi na muundaji.

Katika sehemu hii, utajifunza makosa ya kawaida yanayofanywa na wanaoanza na jinsi ya kuyarekebisha haraka.

5.1 Kuandika super(...) mahali pasipo sahihi (kanuni ya muundaji)

Moja ya kanuni muhimu zaidi:

super(...) lazima iwe tamko la kwanza ndani ya muundaji.

❌ Si sahihi (kosa la kukusanya):

class Parent {
    Parent(int x) {}
}

class Child extends Parent {
    Child() {
        System.out.println("Do something first");
        super(10); // ERROR: must be first line
    }
}

✅ Sahihi:

class Child extends Parent {
    Child() {
        super(10);
        System.out.println("Child logic");
    }
}

Kwa nini?
Kwa sababu sehemu ya mzazi ya kipengele lazima ianze kabla ya mantiki ya mtoto kutekelezwa.

5.2 Kusahau super(args...) wakati mzazi hana muundaji usio na hoja

Kama darasa la mzazi lina muundaji tu wenye vigezo, Java haiwezi kiingiza kiotomatiki super().

❌ Si sahihi:

class Parent {
    Parent(String name) {}
}

class Child extends Parent {
    Child() {
        // compiler tries to insert super() here -> ERROR
    }
}

✅ Sahihi:

class Child extends Parent {
    Child() {
        super("Taro");
    }
}

Huu ni kosa la kukusanya linalojitokeza sana kwa wanaoanza, kwa hivyo daima angalia muundaji wa mzazi.

5.3 Kujaribu kutumia this() na super() pamoja katika muundaji mmoja

Wanaoanza mara nyingi wanafikiri:

“Nataka kuita muundaji mwingine NA muundaji wa mzazi.”

Lakini Java hairuhusu hili.

❌ Si sahihi:

class Parent {
    Parent() {}
}

class Child extends Parent {
    Child() {
        this(1);
        super(); // ERROR
    }

    Child(int x) {}
}

Sababu:

• this() na super() lazima zote ziwe mstari wa kwanza
• Moja tu inaweza kuwa ya kwanza

Hivyo lazima ubuni muundaji wako ili moja tu itumike moja kwa moja.

5.4 Kujaribu kutumia super ndani ya njia ya static

super imehusishwa na tukio la kipengele cha sasa, hivyo haifanyi kazi katika njia za static.

❌ Si sahihi (dhana):

class Parent {
    void hello() {}
}

class Child extends Parent {
    static void test() {
        super.hello(); // ERROR
    }
}

Jambo kuu:

• Njia za static ni za darasa, si za tukio
• super inarejelea sehemu ya mzazi ya tukio

Kwa hiyo Java inazuia hili.

5.5 Kuelewa vibaya super kama “kuunda kipengele cha mzazi”

Wanaoanza wengine wanadhani:

“Kutumia super kunaunda kipengele cha mzazi tofauti.”

Hilo si sahihi.

super hai iunde kitu kipya.
Inafikia tu upande wa darasa la mzazi wa kipengele kimoja.

Fikiria hivi:

• this = kipengele kimoja, mtazamo wa mtoto
• super = kipengele kimoja, mtazamo wa mzazi

5.6 Kutumia super.field sana (kuficha uga kawaida ni wazo mbaya)

Ndiyo, super.field ipo—lakini katika miradi mingi halisi, unapaswa kuepuka kuunda uga wa mzazi/mtoto wenye jina sawa.

Mfano (muundo unaokusanya):

class Parent {
    int value = 100;
}

class Child extends Parent {
    int value = 200; // hides parent field
}

Ingawa super.value inafanya kazi, muundo huu hufanya msimbo usomeke na kudumishwa kwa ugumu.

Mazoezi bora:

. Tumia majina tofauti ya uga
Weka uga kuwa ya faragha na uyafichue kwa njia za (getters)
* Epuka kuficha uga isipokuwa ni lazima sana

5.7 “Ukikuita super.method(), mantiki ya mzazi pekee ndiyo inayoendeshwa” (si kila wakati)

Hii ni kidogo ya juu zaidi, lakini ni muhimu kujua.

Unapokuita super.method(), bila shaka unaita njia ya mzazi.
Hata hivyo, ndani ya njia hiyo ya mzazi, ikiwa itaita njia nyingine ambayo mtoto amebadilisha, toleo la mtoto linaweza kutekelezwa.

Mfano:

class Parent {
    void a() {
        b(); // calls b()
    }

    void b() {
        System.out.println("Parent b()");
    }
}

class Child extends Parent {
    @Override
    void b() {
        System.out.println("Child b()");
    }
}

public class Main {
    public static void main(String[] args) {
        Child c = new Child();
        c.a();
    }
}

Matokeo:

Child b()

Ingawa a() iko katika mzazi, inaita b(), na b() imebadilishwa katika mtoto.

Muhtasari kwa wanaoanza:
super.method() inaita toleo la mzazi la njia hiyo, lakini miito ya njia ndani yake inaweza bado kutumia sheria za ubadilishaji.

5.8 Orodha ya haraka (kuepuka makosa ya wanaoanza)

Kabla ya kutumia super, angalia haya:

• Je, super(...) ni mstari wa kwanza katika muundaji?
• Je, darasa la mzazi lina muundaji usio na hoja (no‑arg constructor)?
• Je, unajaribu kutumia this() na super() pamoja?
• Je, unatumia super ndani ya njia ya static?
• Je, unaficha uga kwa jina sawa bila sababu?

6. Hitimisho (Mambo Muhimu)

Katika makala hii, umejifunza neno kuu la Java super, ni kwa nini lipo, na jinsi ya kulitumia kwa usahihi katika msimbo halisi.

Hebu tumalize kila kitu kwa pointi muhimu ambazo unapaswa kukumbuka.

6.1 super ina maana gani katika Java?

super ni neno kuu linalokuruhusu kufikia sehemu ya darasa la mzazi (superclass) ya kitu.

Inatumika hasa katika urithi (extends) unapohitaji kurejelea toleo la mzazi la:

• viumbi (constructors)
• njia (methods)
• uga (fields)

Kwa maneno rahisi:

super inamaanisha “tumia toleo la darasa la mzazi.”

6.2 Njia 3 muhimu za kutumia super

Unaweza kukumbuka super katika mifumo mitatu hii:

1) Ita muundaji wa mzazi

• super()
• super(args…)

Hii inatumiwa unapohitaji kuanzisha darasa la mzazi ipasavyo, hasa ikiwa mzazi unahitaji hoja.

2) Ita njia ya mzazi

• super.method()

Hii ni muhimu unapobadilisha njia lakini bado unataka kutumia tabia ya mzazi.

3) Fikia uga wa mzazi

• super.field

Hii inatumika wakati mzazi na mtoto wana uga wenye jina sawa na unataka kurejelea ule wa mzazi.

6.3 this vs super (njia rahisi ya kuelewa)

Wanaoanza wengi huchanganya maneno haya mawili, lakini tofauti ni rahisi:

• this → kitu cha sasa (mtazamo wa mtoto)
• super → mtazamo wa mzazi wa kitu hicho

Hawawakilishi vitu viwili tofauti.

6.4 Makosa mengi yanatokea karibu na viumbi

Ukikataa makosa ya kawaida, kumbuka sheria hizi:

• super(...) lazima iwe mstari wa kwanza ndani ya muundaji
• Ikiwa mzazi hana muundaji usio na hoja, lazima uandike super(args…)
• Huwezi kutumia this() na super() pamoja katika muundaji mmoja
• super haina kazi katika njia za static

6.5 Muhtasari wa mwisho: super hukusaidia kutumia tena na kupanua mantiki ya mzazi kwa usalama

Nguvu halisi ya super ni kwamba inakuwezesha:

• kuweka mantiki ya pamoja katika darasa la mzazi
• kupanua tabia katika darasa la mtoto
• kuepuka kunakili na kubandika msimbo (copy‑pasting)
• kufanya urithi uwe safi na rahisi kudumisha

Ukikumbuka mstari mmoja kutoka makala hii yote, kumbuka huu:

super ni neno kuu unalotumia unapohitaji toleo la darasa la mzazi.

7. Maswali Yanayoulizwa Mara Kwa Mara (FAQ)

Hapa kuna maswali ya kawaida zaidi ambayo wanaoanza kuuliza wakati wa kujifunza neno la super la Java.
Kama bado unahisi kutokuwa na uhakika kuhusu sehemu fulani, sehemu hii inapaswa kufafanua mambo haraka.

7.1 Lini ninapaswa kutumia super katika Java?

Kawaida hutumia super katika hali hizi:

• Wakati unataka kuita konstruktari ya mzazi ( super() / super(args...) )
• Wakati unaandika tena njia lakini bado unataka kuita njia ya mzazi ( super.method() )
• Wakati mzazi na mtoto wana jina la uwanja sawa na unataka uwanja wa mzazi ( super.field )

Kwa wanaoanza, hali ya kawaida na muhimu zaidi ni:

kuandika tena njia na kuita mantiki ya mzazi kwa kutumia super.method().

7.2 Nini kinatokea kama sitaandika super()?

Kama darasa la mzazi lina konstruktari isiyo na hoja, Java inaingiza kiotomatiki:

super();

juu ya konstruktari ya mtoto.

Kwa hivyo katika hali nyingi, hutaji kuiandika kwa mkono.

Hata hivyo, kama darasa la mzazi halina konstruktari isiyo na hoja, msimbo utashindwa isipokuwa ukiita moja sahihi kwa hoja.

7.3 Ni tofauti gani kati ya super() na this()?

Zinaaita konstruktari tofauti:

• super() → inaita konstruktari katika darasa la mzazi
• this() → inaita konstruktari katika darasa sawa

Wazo la mfano:

• Tumia this() kupunguza msimbo wa konstruktari uliorudiwa
• Tumia super() kuanza vizuri sehemu ya mzazi ya kitu

7.4 Je, ninaweza kutumia zote mbili this() na super() katika konstruktari sawa?

Hapana, huwezi.

Sababu:

• Zote mbili this() na super() lazima ziwe taarifa ya kwanza katika konstruktari
• Taarifa moja tu inaweza kuwa ya kwanza

Kwa hivyo Java inakulazimisha kuchagua moja.

7.5 Je, ninaweza kutumia super ndani ya njia ya static?

Hapana (kwa ujumla).

super inahusiana na mfumo wa kitu wa sasa, lakini njia za static zina miliki ya darasa lenyewe na hazina marejeleo ya mfumo.

Ndiyo sababu kutumia super katika njia za static husababisha hitilafu ya kuandika.

7.6 Je, super inaunda kitu kipya cha mzazi?

Hapana.

super haiaundi kitu chochote kipya.

Inafikia tu mwonekano wa darasa la mzazi wa kitu sawa.

Njia ya kufikiria yenye msaada:

• this = kitu sawa kinachoonekana kama mtoto
• super = kitu sawa kinachoonekana kama mzazi

7.7 Kama nitaaita super.method(), je, daima inaendesha mantiki ya mzazi pekee?

super.method() daima inaita toleo la mzazi la njia hiyo.

Hata hivyo, kama njia ya mzazi inaita ndani njia nyingine ambayo mtoto unaandika tena, toleo la mtoto linaweza kuendesha kutokana na sheria za kuandika tena za Java.

Ujumbe wa kiwango cha mwanzo:

super.method() inaita toleo la mzazi, lakini maamrisho ya njia ndani yake yanaweza bado kuathiriwa na kuandika tena.

7.8 Je, ninapaswa kutumia super.field mara kwa mara?

Kawaida, hapana.

Kama unahitaji mara kwa mara super.field, inaweza kumaanisha kwamba muundo wako unafafanua kwa sababu mzazi na mtoto wanashiriki jina la uwanja sawa.

Katika miradi halisi, ni bora kuepuka kuficha uwanja isipokuwa una sababu thabiti (kama msimbo wa zamani au vikwazo vya nje).

7.9 Je, super inaweza kutumiwa na miingiliano?

Katika urithi wa kawaida (extends), super inarejelea darasa la mzazi.

Hata hivyo, Java pia inaruhusu sintaksia maalum kuita njia ya chaguo la miingiliano:

InterfaceName.super.method();

Hii ni ya kiwango cha juu zaidi, kwa hivyo kama uko mwanzo, zingatia kwanza:

• urithi wa darasa
• super() / super.method() / super.field

7.10 Ni njia ya haraka zaidi ya kufahamu super?

Njia rahisi ya kujifunza:

1. Andika darasa la mzazi/mtoto la msingi na uthibitishe mpangilio wa konstruktari
2. Andika tena njia na uita super.method()
3. Linganisha this dhidi ya super na uwanja na njia
4. Fanya mazoezi ya kurekebisha makosa yanayohusiana na konstruktari

Mazoezi bora ni kuandika mifano midogo na kuiendesha.