streamalism.org

1. Overzicht

In dit korte artikel behandelen we de openbaar modifier in detail, en we zullen bespreken wanneer en hoe het te gebruiken met klassen en leden.

Bovendien zullen we de nadelen van het gebruik van openbare gegevensvelden illustreren.

Voor een algemeen overzicht van toegangsmodificatoren, bekijk zeker ons artikel over toegangsmodificatoren in Java.

2. Wanneer moet u de Public Access Modifier gebruiken?

Openbare klassen en interfaces, samen met openbare leden, definiëren een API. Het is dat deel van onze code dat anderen kunnen zien en gebruiken om het gedrag van onze objecten te controleren.

Overmatig gebruik van de public modifier is echter in strijd met het Object-Oriented Programming (OOP) inkapselingsprincipe en heeft een paar nadelen:

• Het vergroot de grootte van een API, waardoor het moeilijker wordt voor klanten om te gebruiken
• Het wordt moeilijker om onze code te wijzigen omdat klanten erop vertrouwen - toekomstige wijzigingen kunnen hun code breken

3. Openbare interfaces en klassen

3.1. Openbare interfaces

Een openbare interface definieert een specificatie die een of meer implementaties kan hebben. Deze implementaties kunnen door ons worden geleverd of door anderen worden geschreven.

De Java-API stelt bijvoorbeeld de Verbinding interface om databaseverbindingsbewerkingen te definiëren, waarbij de daadwerkelijke implementatie aan elke leverancier wordt overgelaten. Tijdens runtime krijgen we de gewenste verbinding op basis van de projectconfiguratie:

Verbindingsverbinding = DriverManager.getConnection (url);

De getConnection method retourneert een instantie van een technologiespecifieke implementatie.

3.2. Openbare lessen

We definiëren openbare klassen zodat klanten hun leden kunnen gebruiken door middel van instantiatie en statische verwijzingen:

assertEquals (0, nieuwe BigDecimal (0) .intValue ()); // instantie-lid assertEquals (2147483647, Integer.MAX_VALUE); // statisch lid 

Bovendien kunnen we openbare klassen ontwerpen voor overerving door het optionele abstract modificator. Wanneer we de abstract modifier, de klasse is als een skelet met velden en vooraf geïmplementeerde methoden die elke concrete implementatie kan gebruiken, naast het hebben van abstracte methoden die elke subklasse moet implementeren.

Het Java-verzamelingsframework biedt bijvoorbeeld het SamenvattingLijst klasse als basis voor het maken van aangepaste lijsten:

openbare klasse ListOfThree breidt AbstractList uit {@Override public E get (int index) {// aangepaste implementatie} @Override public int size () {// aangepaste implementatie}}

We hoeven dus alleen het krijgen() en grootte() methoden. Andere methoden zoals index van() en bevatAll () zijn al voor ons geïmplementeerd.

3.3. Geneste openbare klassen en interfaces

Net als bij openbare klassen en interfaces op het hoogste niveau, definiëren geneste openbare klassen en interfaces een API-datatype. Ze zijn echter bijzonder nuttig op twee manieren:

• Ze geven de API-eindgebruiker aan dat het omsluitende topniveau-type en de omsloten typen een logische relatie hebben en samen worden gebruikt
• Ze maken onze codebase compacter door het aantal broncodebestanden te verminderen dat we zouden hebben gebruikt als we ze hadden gedeclareerd als klassen en interfaces op het hoogste niveau

Een voorbeeld is de Kaart.Binnenkomst interface van de core Java API:

voor (Map.Entry entry: mapObject.entrySet ()) {}

Maken Kaart.Invoer een geneste interface relateert het sterk aan de java.util.Map interface en heeft ons gered van het maken van een ander bestand in de java.util pakket.

Lees het artikel over geneste klassen voor meer details.

4. Openbare methoden

Met openbare methoden kunnen gebruikers kant-en-klare bewerkingen uitvoeren. Een voorbeeld is het publiek toLowerCase methode in de Draad API:

assertEquals ("alex", "ALEX" .toLowerCase ());

We kunnen een openbare methode veilig statisch maken als deze geen instantievelden gebruikt. De parseInt methode van de Geheel getal class is een voorbeeld van een openbare statische methode:

assertEquals (1, Integer.parseInt ("1"));

Constructeurs zijn meestal openbaar, zodat we objecten kunnen instantiëren en initialiseren, hoewel ze soms privé kunnen zijn, zoals in singletons.

5. Openbare velden

Met openbare velden kunt u de status van een object rechtstreeks wijzigen. De vuistregel is dat we geen openbare velden mogen gebruiken. Daar zijn verschillende redenen voor, zoals we gaan zien.

5.1. Draad-veiligheid

Het gebruik van openbare zichtbaarheid met niet-definitieve velden of veranderlijke definitief velden is niet thread-safe. We hebben geen controle over het wijzigen van hun referenties of staten in verschillende threads.

Raadpleeg ons artikel over draadveiligheid voor meer informatie over het schrijven van draadveilige code.

5.2. Acties ondernemen bij wijzigingen

We hebben geen controle over een niet-definitief openbaar veld omdat de referentie of status direct kan worden ingesteld.

In plaats daarvan is het beter om de velden te verbergen met een privé-modifier en een openbare setter te gebruiken:

openbare klas Student {privé int. leeftijd; public void setAge (int age) {if (age 150) {throw new IllegalArgumentException (); } this.age = leeftijd; }}

5.3. Het gegevenstype wijzigen

Openbare velden, veranderlijk of onveranderlijk, maken deel uit van het contract van de klant. Het is moeilijker om de gegevensweergave van deze velden in een toekomstige release te wijzigen, omdat clients mogelijk hun implementaties moeten herstructureren.

Door velden een privébereik te geven en accessors te gebruiken, hebben we de flexibiliteit om de interne weergave te wijzigen met behoud van het oude gegevenstype:

 openbare klas Student {privé StudentGrade-cijfer; // nieuwe gegevensweergave public void setGrade (int grade) {this.grade = new StudentGrade (grade); } public int getGrade () {retourneer this.grade.getGrade (). intValue (); }}

De enige uitzondering voor het gebruik van openbare velden is het gebruik van statische laatste onveranderlijke velden om constanten weer te geven:

openbare statische laatste String SLASH = "/";

6. Conclusie

In deze tutorial hebben we gezien dat de public modifier wordt gebruikt om een ​​API te definiëren.

We hebben ook beschreven hoe overmatig gebruik van deze modifier de mogelijkheid om verbeteringen aan onze implementatie aan te brengen, kan beperken.

Ten slotte hebben we besproken waarom het een slechte gewoonte is om openbare modificatoren voor velden te gebruiken.

En, zoals altijd, zijn de codevoorbeelden van dit artikel beschikbaar op GitHub.