Մասնավոր դասը որպես վերադարձի տեսակ հանրային մեթոդից

Ես պարզապես մի քիչ ուսումնասիրել եմ այս մասին և չեմ կարողացել վերջնական պատասխան գտնել: Ամենայն հավանականությամբ, դա պարզապես անտեսում է Java լեզվի դիզայներների կողմից, և քանի որ այն իրականում որևէ վնաս չի պատճառում, այն մնացել է: Այն իրականում չի տարբերվում public մեթոդը private դասի մեջ դնելուց: Ոչինչ չի խանգարում ձեզ դա անել, թեև այդ public մեթոդն իրականում մուտք գործելու հնարավորություն չկա:

Իհարկե, NetBeans-ը ձեզ նախազգուշացնում է «Ոչ հրապարակային տիպի արտահանում հանրային API-ի միջոցով», երբ փորձում եք դա անել: Ես ակնկալում եմ, որ այլ միջավայրերի մեծ մասը նման նախազգուշացում կտա:

Վերադարձված օբյեկտը բոլորովին անիմաստ է բոլորի համար, ովքեր փորձում են օգտագործել այն (եթե նրանք օգտագործում են արտացոլումը), գրեթե այն ամենը, ինչ նրանք կարող են անել, այն պահելն է Object-ում (կամ ցանկացած այլ սուպեր դասի, որին նրանք հասանելի են) և այնուհետև փոխանցել այդ Objectը: շուրջը։

Դուք կարող եք պոտենցիալ ցանկանալ դա անել, եթե անցած Objectն օգտագործվի որպես «բռնակ», որը փոխանցվում է, բայց երբեք չի վիրահատվում: Այդ դեպքում, թեև շատ ավելի խելամիտ կլիներ ունենալ public դասը, բայց դրա մեջ եղած բոլոր մեթոդները դարձնել private՝ կանխելու դրանց վրա գործելու ձեր դասից դուրս (կամ սահմանեք public ինտերֆեյս, որպեսզի վերադառնա, և private դասը դա իրականացնի):

Այսպիսով, պատասխանը կարծես թե հետևյալն է.

Հավանաբար, այն չպետք է վավեր լինի, բայց քանի որ դա ոչ մի վնաս չի պատճառում, այն երբեք չի արգելափակվել:

Նմանատիպ թեմայի վերաբերյալ այստեղ լավ պատասխան կա.

Ոչ հրապարակային տիպի արտահանում հանրային API-ի միջոցով

Ինչու է սա վավեր:

Քանի որ հաճախորդի կոդը զանգի վայրում կարող է ակնկալել Object (կամ ընդհանրապես ոչինչ չակնկալել), այս մեթոդը որևէ տեղից զանգահարելու խնդիր չկա.

Object o = new Foo().getBar();

Այն վավեր է, քանի որ Bar-ը տեսանելի է Foo դասին: Այսպիսով այն կազմում է.

Իհարկե, մեկ այլ դաս չի կարող տեսնել Bar-ը և, հետևաբար, չի կարող օգտագործել վերադարձի արժեքը:

Բայց մեկ այլ դաս դեռ կարող է պարզապես կանչել մեթոդը՝ առանց վերադարձի արժեքի օգտագործման:

public class FooBar {

   public void invokeBar() {
        Foo foo = new Foo();
        foo.getBar();
   }
}

Մասնավոր դաս վերադարձնող հանրային մեթոդը կարող է օգտակար լինել, քանի որ դուք պետք է կարողանաք մեթոդը կանչել ցանկացած շրջանակից (օրինակ՝ մուտացիայի ենթարկել Foo-ի ներքին վիճակը) և ներքին օգտագործման համար, եթե ձեզ անհրաժեշտ է որևէ արդյունք, ի լրումն պարզապես զանգելու: մեթոդը։

public class Foo {

    private String myString;

    public String getMyString() {
        return myString;
    }

}

Սա նույնպես վավեր է։ Ինչու՞ պետք է ներքին դասերը այլ կերպ վարվեն:

Bar private դարձնելը միայն այն դարձնում է անտեսանելի արտաքին աշխարհի համար, ինչպես դաշտերը private պատրաստելը:

Կարևոր նախազգուշացումներից մեկն այն է, որ նույնիսկ եթե դուք կարողանաք զանգահարել getBar() Foo օբյեկտի վրա, դուք չեք կարող զանգահարել այդ հղումի մեթոդները (տեսանելիության պատճառով):

Այսպիսով, գլխավորն այն է, որ դուք կարող եք դա անել, բայց չպետք է դա անել:

Միակ իրավիճակը, որը ես կարող եմ պատկերացնել, այն է, երբ Foo-ը նույնպես ներքին դաս է, իսկ Foo-ի արտաքին դասը ցանկանում է օգտագործել Bar-ը:

Ներքին դասարան

Ներքին դասերը ներկայացնում են հարաբերությունների հատուկ տեսակ, որն այն է, որ այն կարող է մուտք գործել արտաքին դասի բոլոր անդամներին (տվյալների անդամներ և մեթոդներ), ներառյալ մասնավորը: Ներդրված դասերը կարող են հանգեցնել ավելի ընթեռնելի և պահպանվող կոդի, քանի որ այն տրամաբանորեն խմբավորում է դասերը միայն մեկ տեղում:

Բնադրված տեսակների ձևերից է։ Այս տեսակի դասի հռչակագիրը հայտնի է որպես ներքին դաս: Եթե ​​դուք հայտարարում եք ներքին դասը որպես ստատիկ, ապա այն հայտնի կդառնա որպես վերին մակարդակի nested class: Java-ում առկա ներդիր տիպերի այլ ձևեր են տեղական դասը; դասը հայտարարված և սահմանված է բլոկի ներսում, այսինքն՝ մեթոդի կամ կոնստրուկտորի կամ սկզբնավորիչի բլոկի մեջ: Բնադրված տիպի չորրորդ ձևը անանուն դասն է; դաս առանց որևէ անվան, որի օբյեկտն օգտագործվում է այնտեղ, որտեղ սահմանված է դասը:

Ինչ վերաբերում է ձեր գործին, այսինքն՝ ներքին դասին, դասի բոլոր դասերը կարող են հայտարարվել հանրային, մասնավոր և պաշտպանված մուտքի ցուցիչներով: Բոլոր դասերը, որոնց հետ կցվում է դասը, ինչպես նաև ինքնին կցվող դասը կիսում են վստահության հարաբերությունները: Դա նշանակում է, որ ներքին դասի բոլոր մասնավոր անդամները, ինչպես նաև կից դասի մասնավոր անդամները կիսվում են միմյանց միջև: Այնուամենայնիվ, դուք չեք կարող մուտք գործել ներքին դասի օբյեկտ առանց պարփակող դասի օբյեկտի:

Երբ դուք կփորձեք ստեղծել ներքին դասի օբյեկտ, կոմպիլյատորը կզեկուցի կոմպիլյացիայի ժամանակի սխալ: Այնուամենայնիվ, հետևյալ օրինակը մուտք գործեք միմյանց դասի մասնավոր անդամներին, այսինքն՝ փակելով ներքին դասի մասնավոր անդամներին և ներքաշող դասի մասնավոր անդամներին.

class Bar {
    private static int x;

    public void getFoo() {
        System.out.println(new Foo().y);
    }

    private class Foo {
        private int y;
        public void getBar() {
            System.out.println(Bar.x);
        }
    }
}

public class Test{
    public static void main(String[] a) {
        Bar b = new Bar();
        //Bar.Foo f = new Bar.Foo(); This is completely illegal syntax.     
    }
}

Լավագույն օրինակը, որը դուք կարող եք ունենալ ներքին դասի համար, Accounts դասի հարաբերությունն է, որը կցում է դասը և Transaction դասը, որը ներքին դաս է: Մեկ Accounts դասը կարող է ունենալ մեկից ավելի Transaction օբյեկտ, սակայն Transaction օբյեկտը չի կարող գոյություն ունենալ առանց Accounts օբյեկտի:

Թեև մասնավոր ներքին դասի օբյեկտը վերադարձնելն անօգուտ է, քանի որ այն դառնում է անտեսանելի իր դասից դուրս: Ինչպես բացատրում է Accounts և Transaction դասի վերը նշված օրինակը: Transaction-ը չի կարող գոյություն ունենալ առանց Accounts օբյեկտի:

Ես դրա համար ունեմ միանգամայն վավեր օգտագործման դեպք, և ես ուրախ եմ, որ դա թույլատրված է:

Եկեք մնանք, դուք ունեք դաս, որը ստեղծում է UI-ի կտորներ: Այն ընդունում է ինչ-որ տիրույթի օբյեկտ և ստեղծում է UI-ի մի հատված.

public Node createPersonUI(Person person) {
    BasePanel panel = new BasePanel();
    // ... setup panel with values ...
    return panel;
}

BasePanel-ը Node-ի ենթադաս է և որոշ ներքին դաս է, որի հետ զանգահարողը գործ չունի, քանի որ այս դասը որոշում է, թե ինչ տեսք կունենան իրերը:

Այժմ, ես գտա, որ պետք է նորից օգտագործեմ այս դասի մի մասը, երբ պետք է աջակցեի նոր օբյեկտ, PersonalProfile, որը պարունակում է շատ ավելի շատ տեղեկատվություն, բայց նաև պարունակում է հիմնական Person տվյալները.

public Node createPersonalProfileUI(PersonalProfile profile) {
    BasePanel panel = new BasePanel();
    // ... setup panel with values ...
    return panel;
}

Այնուամենայնիվ, այդ կոդը մասամբ կրկնօրինակված էր, ուստի ես արեցի.

public Node createPersonalProfileUI(PersonalProfile profile) {
    BasePanel panel = (BasePanel)createPerson(profile.getPerson());
    // ... only setup missing values ...
    return panel;
}

Դերասանական կազմը, սակայն, մի փոքր ծիծաղելի է. այն փոխելով BasePanel վերադարձնելու համար ոչ միայն աշխատում է, այլև չի բացահայտում իմ մասնավոր դասի որևէ գործառույթ: Փոխարենը, այն բացահայտում է միայն այն մեթոդները հանրային դասերից, որոնք նա ժառանգել է... փայլուն:

Ամբողջական կոդը.

public BasePanel createPersonUI(Person person) {
    BasePanel panel = new BasePanel();
    // ... setup panel with values ...
    return panel;
}

public BasePanel createPersonalProfileUI(PersonalProfile profile) {
    BasePanel panel = createPerson(profile.getPerson());
    // ... only setup missing values ...
    return panel;
}

private class BasePanel extends Node {
}