Հիմնական տարբերություն – սա ընդդեմ սուպերի Java-ում
«սա» և «սուպեր» հիմնաբառերն օգտագործվում են Java ծրագրավորման մեջ: Այս հիմնաբառերը չեն կարող օգտագործվել որպես փոփոխականներ կամ որևէ այլ նույնացուցիչ անուն: Java-ն աջակցում է Object Oriented Programming (OOP): Ծրագիրը կամ ծրագրաշարը կարելի է մոդելավորել օբյեկտների միջոցով: Օբյեկտները անհագ են՝ օգտագործելով դասերը: OOP-ի մեկ սյունը ժառանգությունն է: Այն ապահովում է կոդի կրկնակի օգտագործման հնարավորություն: Արդեն գոյություն ունեցող դասերը գերդասեր են, իսկ ստացված դասերը ենթադասեր են։ Սուպեր հիմնաբառը կարող է օգտագործվել գերդասարանի օբյեկտին հղում տալու համար: Համակարգում կան բազմաթիվ օբյեկտներ: «Այս» հիմնաբառը օգտագործվում է ընթացիկ օբյեկտը վերաբերելու համար:Այս և սուպերի միջև հիմնական տարբերությունն այն է, որ «սա» հղման փոփոխականն է, որն օգտագործվում է ընթացիկ օբյեկտը վերաբերելու համար, մինչդեռ «սուպերը» հղման փոփոխական է, որն օգտագործվում է անմիջական սուպերդասի օբյեկտին հղում կատարելու համար:
Ի՞նչ է սա Java-ում:
«սա» հիմնաբառը օգտագործվում է ընթացիկ օբյեկտը հիշատակելու համար: Հղում տրված Java ծրագրին։
Նկար 01. Java ծրագիր՝ օգտագործելով այս հիմնաբառը
Java-ում կան երեք տեսակի փոփոխականներ. Դրանք օրինակի փոփոխականներ են, տեղական փոփոխականներ և դասի փոփոխականներ: Համաձայն վերոնշյալ ծրագրի, դասի Employee-ն ունի երկու օրինակելի փոփոխական։ Նրանք id և անուն են: Տեղական փոփոխականները այն փոփոխականներն են, որոնք պատկանում են մեթոդներին: Դասի փոփոխականները համօգտագործվում են բոլոր օբյեկտների կողմից: ID-ն և անունը փոխանցվում են Employee կոնստրուկտորին: Եթե ծրագրավորողը գրում է id=id; այն չի նախաստորագրի օրինակի փոփոխականները, քանի որ Կոնստրուկտորն արդեն ունի ID և անուն:Չկան արժեքներ, օրինակ, փոփոխականներ: Այսպիսով, դրանք տպելը կցուցադրվի null: Սա օգտագործելիս այն վերաբերում է ընթացիկ օբյեկտին: Հետևաբար, կոնստրուկտորին id և անուն տալը կարող է սահմանել օրինակի փոփոխականները:
«սա» հիմնաբառը կարող է օգտագործվել ընթացիկ դասի մեթոդը կանչելու համար: Տե՛ս տվյալ java ծրագրին։
public class ThisDemo{
public static void main (String args){
Myclass myClass=նոր Myclass();
myClass. B();
}
}
դաս Myclass{
public void A(){
System.out.println(«A»);
}
public void B(){
System.out.prinltn(«B»);
this. A();
}
}
Myclass դասը պարունակում է երկու մեթոդ: Դրանք A և B մեթոդներն են: Myclass-ի օբյեկտ ստեղծելիս և B մեթոդը կանչելիս B, A-ն կտպվի որպես արդյունք: B մեթոդում B տպելուց հետո կա հետևյալ արտահայտությունը. A(): Օգտագործելով սա՝ գործարկվել է ընթացիկ դասի մեթոդը։
Հնարավոր է նաև օգտագործել այս հիմնաբառը ընթացիկ դասի կոնստրուկտորը կանչելու համար: Հղում տրված ծրագրին։
public class ThisDemo{
public static void main (String args){
A obj=նոր A(5);
}
}
դաս A{
public A(){
System.out.println(«Կառուցիչ A»);
}
public A(int x){
this();
System.out.println(«Parameterized Constructor A»);
}
}
Ըստ վերը նշված ծրագրի՝ A դասը ունի լռելյայն կոնստրուկտոր և պարամետրացված կոնստրուկտոր։ A-ի օբյեկտ ստեղծելիս կանչվում է պարամետրացված կոնստրուկտորը։ Պարամետրացված կոնստրուկտորում կա այսպիսի հայտարարություն (); Այն կկանչի ընթացիկ դասի կոնստրուկտորը, որը A(). է
Ի՞նչ է սուպեր Java-ում:
«Սուպեր» հիմնաբառը կապված է ժառանգության հետ: Ժառանգությունը օբյեկտ կողմնորոշված ծրագրավորման հիմնական հասկացությունն է: Այն թույլ է տալիս օգտագործել արդեն գոյություն ունեցող դասի հատկությունները և մեթոդները նոր դասում: Արդեն գոյություն ունեցող դասը հայտնի է որպես մայր դաս կամ գերդաս: Նոր դասը հայտնի է որպես երեխայի դաս կամ ենթադաս:
«Սուպեր»-ը հղման փոփոխական է, որն օգտագործվում է անմիջական ծնող դասի օբյեկտին հղում տալու համար: Սուպեր հիմնաբառը կարող է վերաբերել անմիջական ծնող դասի օրինակի փոփոխականին կամ կանչել անմիջական ծնող դասի մեթոդը: Super()-ն օգտագործվում է անմիջական ծնող դասի կառուցողին կանչելու համար:
Ենթադրենք, որ կա երկու դաս՝ որպես A և B: A դասը գերդաս է, իսկ B դասը՝ ենթադաս: A, B դասերը երկուսն էլ ունեն ցուցադրման մեթոդ:
հանրային դաս A{
public void display(){
System.out.println(«A»);
}
}
հանրային B դասը տարածվում է A{
public void display(){
System.out.println(«B»);
}
}
B տիպի օբյեկտ ստեղծելիս և մեթոդի ցուցադրումը կանչելիս այն կտա ելք B: A դասը ունի ցուցադրման մեթոդ, բայց այն վերագրվում է B ենթադաս ցուցադրման մեթոդով: Եթե ծրագրավորողը ցանկանում է անվանել ցուցադրման մեթոդը A դասում, ապա նա կարող է օգտագործել սուպեր հիմնաբառը։ Հղում տրված Java ծրագրին։
Նկար 02. Java ծրագիր՝ օգտագործելով սուպեր հիմնաբառ
Ըստ վերոհիշյալ ծրագրի՝ A դասը ունի 10 արժեք ունեցող փոփոխական անունով համար: B դասը տարածում է A և ունի 20 արժեք ունեցող փոփոխական անունով համար: Ընդհանրապես, B տիպի օբյեկտ ստեղծելիս և ցուցադրման մեթոդը կանչելիս: պետք է տա ենթադասի համարը, քանի որ սուպերդասի արժեքը վերացվել է նոր դասի կողմից:Օգտագործելով super.num-ը, տպագրվում է գերդասարանի համարի արժեքը:
Սուպեր()-ը կարող է օգտագործվել գերդասերի կոնստրուկտորը կանչելու համար: Տե՛ս ստորև ներկայացված ծրագիրը։
public class Հիմնական {
public static void main (String args){
B obj=նոր B();
}
}
դաս A{
A(){
System.out.println(«A»);
}
}
դաս B ընդլայնվում է A{
B(){
սուպեր();
System.out.println(«B»);
}
}
Ըստ վերը նշված ծրագրի՝ A դասը ունի A կոնստրուկտոր (): B դասն ունի B կոնստրուկտոր (): B դասը ընդլայնում է A դասը: B տիպի օբյեկտ ստեղծելիս այն կտպագրի A, B որպես արդյունք: B () կոնստրուկտորն ունի սուպեր (): Հետևաբար, նախ կանչվում է A կոնստրուկտորը, այնուհետև գնում է B:Թեև super ()-ը գրված չէ, լռելյայնորեն կոչվում է մայր կառուցող:
Մեթոդը օգտագործող սուպերը հետևյալն է.
Նկար 03. Java ծրագիր, որը կանչում է գերդասակարգի մեթոդը
Ըստ վերը նշված ծրագրի՝ A դասը ունի ցուցադրման մեթոդ։ B դասը ունի նաև ցուցադրման մեթոդ: B դասը ընդլայնում է A-ն: B տիպի օբյեկտ ստեղծելիս և ցուցադրման մեթոդը կանչելիս արդյունքը կտրվի որպես A և B: B դասի ցուցադրման մեթոդում A դասի ցուցադրման մեթոդը կոչվում է օգտագործելով super.display(): Այդ մեթոդը նախ տպում է «A»: Այնուհետև տպում է «B»:
Ո՞րն է նմանությունը սրա և սուպերի միջև:
Երկուսն էլ հիմնաբառեր են Java ծրագրավորման մեջ:
Ո՞րն է տարբերությունը սրա և սուպերի միջև:
Սա ընդդեմ Super |
|
| «սա»-ը հղման փոփոխական է, որն օգտագործվում է ընթացիկ օբյեկտին հղում կատարելու համար: | «Սուպեր»-ը հղման փոփոխական է, որն օգտագործվում է անմիջական սուպերդասի օբյեկտին վերաբերելու համար: |
| Օրինակի փոփոխական | |
| Ընթացիկ դասի օրինակի փոփոխականը կարելի է ուղղել այս միջոցով: | Սուպերդասի օրինակի փոփոխականը կարելի է ուղղել super-ի միջոցով: |
| Դասի մեթոդ | |
| Ընթացիկ դասի մեթոդը կարելի է կանչել այս միջոցով: | Superclass մեթոդը կարելի է կանչել՝ օգտագործելով super: |
| Կոնստրուկտոր | |
| Ընթացիկ դասի կոնստրուկտորը կարելի է կանչել այս(). | Սուպերդասի կոնստրուկտորը կարելի է կանչել՝ օգտագործելով super(). |
Ամփոփում – սա ընդդեմ սուպերի Java-ում
«սա» և «սուպեր» հիմնաբառերը օգտագործվում են Java-ում: Հիմնաբառերը չեն կարող օգտագործվել որպես փոփոխականներ կամ որևէ այլ նույնացուցիչ անուն: Նրանք կարծես նույնն են, բայց ունեն տարբերություն. Սրա և super-ի միջև տարբերությունն այն է, որ super-ը հղման փոփոխական է, որն օգտագործվում է անմիջական սուպերդասի օբյեկտը նշելու համար, մինչդեռ սա հղման փոփոխական է, որը վերաբերում է ընթացիկ օբյեկտին:
Ներբեռնեք այս vs super-ի PDF-ը Java-ով
Դուք կարող եք ներբեռնել այս հոդվածի PDF տարբերակը և օգտագործել այն անցանց նպատակներով՝ ըստ մեջբերումների: Խնդրում ենք ներբեռնել PDF տարբերակը այստեղ՝ այս և սուպերի միջև տարբերությունը Java-ում
