Pagkakaiba sa pagitan nito at super keywords sa Java

thisat superdalawang espesyal na keyword sa Java na kumakatawan sa kasalukuyang instance ng isang klase at ang superclass nito, ayon sa pagkakabanggit. Ang mga programmer ng Java ay madalas na nalilito ang mga salitang ito at nagpapakita ng kaunting kaalaman sa kanilang mga espesyal na katangian, na kadalasang tinatanong tungkol sa mga panayam sa Java Core. Halimbawa, ang ilang tanong na agad na pumasok sa isip ay tungkol thissa at super, Posible bang magtalaga ng ibang kahulugan sa isang keyword thissa Java? at ano ang pagkakaiba sa pagitan ng mga keyword thisat supersa Java. Hindi alam? Well, hindi ko ibinibigay ang sagot dito - makikita ito sa dulo ng artikulo. Kaya, tulad ng sinabi ko sa simula, ang pangunahing pagkakaiba sa pagitan thisng at supersa Java ay thisang kasalukuyang instance ng isang klase ay kumakatawan, habang superang kasalukuyang instance ng parent class ay kumakatawan. Narito ang isang halimbawa ng paggamit ng mga variable thisat super- malamang na nakakita ka na ng mga halimbawa ng pagtawag sa mga constructor ng isa mula sa isa pa, ang tinatawag na. pagtawag sa mga constructor sa isang chain, ito ay posible sa pamamagitan ng paggamit ng mga keyword thisat super. Sa loob ng isang klase, para tawagan ang no-argument constructor nito, ay ginagamit this(), habang super()ginagamit ito para tawagan ang no-argument constructor, o kung tawagin din ito, ang default na constructor ng parent class. Sa pamamagitan ng paraan, sa ganitong paraan maaari kang tumawag hindi lamang isang constructor na walang mga argumento, kundi pati na rin ang anumang iba pang constructor sa pamamagitan ng pagpasa nito ng naaangkop na mga parameter. thisMakakakita tayo ng halimbawa ng paggamit na ito sa lalong madaling panahon super. Gayundin sa thisJava superginagamit ang mga ito upang ma-access ang mga variable ng isang halimbawa ng klase at ang magulang nito. Sa katunayan, maaari silang ma-access nang walang mga prefix superat this, ngunit kung sa kasalukuyang bloke ang mga naturang variable ay hindi magkakapatong sa iba pang mga variable, i.e. kung hindi ito naglalaman ng mga lokal na variable na may parehong mga pangalan, kung hindi, kakailanganin mong gumamit ng mga pangalan na may mga prefix, ngunit hindi ito mahalaga, dahil sa anyong ito ay mas nababasa pa sila. Ang isang klasikong halimbawa ng diskarteng ito ay ang paggamit nito thissa loob ng isang constructor na kumukuha ng parameter na may parehong pangalan bilang variable ng instance. Mamaya sa artikulo ay malalaman natin kung ano ang iba pang mga pagkakaiba sa pagitan ng superat this, at tingnan ang ilang mga halimbawa ng kanilang paggamit.

Paano ito at super magkatulad

Bago tingnan ang mga pagkakaiba sa pagitan ng mga keyword thisat super, tingnan natin ang ilan sa kanilang pagkakatulad:

1. Parehong this, at supermga non-static na variable, kaya hindi magagamit ang mga ito sa isang static na konteksto, na nangangahulugang hindi ito magagamit sa pangunahing paraan. Magreresulta ito sa isang error sa oras ng pag-compile "ang isang hindi static na variable thisay hindi maaaring i-reference mula sa isang static na konteksto". Ang parehong bagay ay mangyayari kung gagamitin mo ang keyword sa pangunahing paraan super.


2. Parehong this, at supermaaaring magamit sa loob ng mga konstruktor upang tawagan ang iba pang mga konstruktor sa isang kadena, halimbawa, this() at super() tumawag sa tagabuo nang walang mga argumento ng pagmamana at mga klase ng magulang, ayon sa pagkakabanggit.

Sa halimbawa sa ibaba, ipinasa muna namin ang isang tawag mula sa isang walang argumentong constructor ng class B sa isang constructor ng parehong klase B na kumukuha ng isang parameter ng type String, na siya namang super("")tinatawag na one-argument constructor mula sa superclass.

class A{

    A(){
        System.out.println("Конструктор без аргументов класса A");
    }

    A(String args){
        System.out.println("Конструктор с одним аргументом класса A");
    }
}

class B extends A{

   B(){
        this(""); // вызов конструктора с одним аргументом класса B
        System.out.println("Конструктор без аргументов класса B");
    }

   B(String args){
        super(""); // вызов конструктора с одним аргументом класса A
        System.out.println("Конструктор с одним аргументом класса B");
    }
}

// Тест-класс и вывод
public class Test {

    public static void main(String args[]) {
       B b = new B();
    }

}

Output: One-argument constructor ng class A One-argument constructor ng class B No-argument constructor ng class B

3. Sa loob ng constructor this, at superdapat na lumitaw sa itaas ng lahat ng iba pang mga expression, sa pinakadulo simula, kung hindi, ang compiler ay maglalabas ng mensahe ng error. Mula sa kung saan ito ay sumusunod na ang isang constructor ay hindi maaaring maglaman ng pareho this(), at super().

Mga pagkakaiba sa pagitan ng super at ito

Ngayon alam na namin kung paano gumamit ng mga keyword superat thisnauunawaan kung bakit kailangan ang mga ito. Ngunit may isa pang pagpipilian para sa paggamit ng mga keyword na ito na hindi ko binanggit - sa mga Inner class, kung saan sa kanilang tulong ito ay napaka-maginhawa upang sumangguni sa isang panlabas na klase gamit ang Outer notation form. thispara sa kasalukuyang halimbawa nito at Panlabas. super- para sa kanyang magulang. Huwag kalimutang palitan ang Outer ng pangalan ng outer class. Ngayon ay maikli nating ilista ang mga pangunahing pagkakaiba sa pagitan ng mga keyword thisatsuper

1. ang isang variable thisay tumutukoy sa kasalukuyang instance ng klase kung saan ito ginagamit, samantalang ito ay supertumutukoy sa kasalukuyang instance ng parent class.


2. Ang bawat constructor, sa kawalan ng mga tahasang tawag sa iba pang constructor, ay tahasang tumatawag super()sa no-argument constructor ng parent class nito, ngunit palagi kang may opsyon na tahasang tumawag sa alinmang constructor gamit ang alinman sa this(), o super().

Marahil ito lang ang masasabi tungkol sa mga pagkakaiba sa pagitan ng mga keyword thisat supersa Java at kung paano ginagamit ang mga ito sa mga programa. Tulad ng nakita natin, ang kanilang pangunahing layunin ay tumawag sa isang constructor mula sa isa pa at sumangguni sa mga variable na halimbawa na ipinahayag sa kasalukuyang klase at ang parent class nito. Huwag kalimutan na ang mga ito ay hindi eksaktong ordinaryong mga variable, at ngayon - ang sagot sa aking tanong, na tinanong ko sa unang talata. Hindi, ang isang variable thisay hindi maaaring magtalaga ng isang bagong halaga dahil ito ay ipinahayag na pinal. Maaari mong subukang gawin ito sa IDE - makakatanggap ka ng isang error sa compilation "hindi ka maaaring magtalaga ng isang bagong halaga sa isang variable this- ito ay ipinahayag na pinal." Orihinal na artikulo dito .