Java-inkapseling

In deze zelfstudie leert u aan de hand van voorbeelden over inkapseling en het verbergen van gegevens in Java.

Java-inkapseling

Inkapseling is een van de belangrijkste kenmerken van objectgeoriënteerd programmeren. Inkapseling verwijst naar de bundeling van velden en methoden binnen een enkele klasse.

Het voorkomt dat buitenste klassen velden en methoden van een klasse openen en wijzigen. Dit helpt ook bij het verbergen van gegevens .

Voorbeeld 1:Java-inkapseling

class Area {

  // fields to calculate area
  int length;
  int breadth;

  // constructor to initialize values
  Area(int length, int breadth) {
    this.length = length;
    this.breadth = breadth;
  }

  // method to calculate area
  public void getArea() {
    int area = length * breadth;
    System.out.println("Area: " + area);
  }
}

class Main {
  public static void main(String[] args) {

    // create object of Area
    // pass value of length and breadth
    Area rectangle = new Area(5, 6);
    rectangle.getArea();
  }
}

Uitvoer

Area: 30

In het bovenstaande voorbeeld hebben we een klasse gemaakt met de naam Area . Het belangrijkste doel van deze les is om de oppervlakte te berekenen.

Om een ​​oppervlakte te berekenen, hebben we twee variabelen nodig:lengte en breedte en een methode:getArea() . Daarom hebben we deze velden en methoden in een enkele klasse gebundeld.

Hier zijn de velden en methoden ook toegankelijk vanuit andere klassen. Dit is dus niet het verbergen van gegevens .

Dit is slechts inkapseling . We houden vergelijkbare codes bij elkaar.

Opmerking :Mensen beschouwen inkapseling vaak als het verbergen van gegevens, maar dat is niet helemaal waar.

Encapsulation verwijst naar de bundeling van verwante velden en methoden samen. Dit kan worden gebruikt om gegevens te verbergen. Inkapseling op zich is geen gegevensverberging.

Waarom inkapseling?

• In Java helpt inkapseling ons om gerelateerde velden en methoden bij elkaar te houden, waardoor onze code schoner en gemakkelijk te lezen is.
• Het helpt om de waarden van onze gegevensvelden te controleren. Bijvoorbeeld

  class Person {
    private int age;
  
    public void setAge(int age) {
      if (age >= 0) {
        this.age = age;
      }
    }
  }

  
  Hier maken we de leeftijd variabele private en het toepassen van logica binnen de setAge() methode. Nu, leeftijd kan niet negatief zijn.
• De getter- en setter-methoden bieden alleen-lezen of alleen schrijven toegang tot onze lesvelden. Bijvoorbeeld

  getName()  // provides read-only access
  setName() // provides write-only access

• Het helpt om componenten van een systeem te ontkoppelen. We kunnen bijvoorbeeld code inkapselen in meerdere bundels.
  
  Deze ontkoppelde componenten (bundel) kunnen onafhankelijk en gelijktijdig worden ontwikkeld, getest en debuggen. En eventuele wijzigingen in een bepaald onderdeel hebben geen effect op andere onderdelen.
• We kunnen ook gegevens verbergen door middel van inkapseling. Als we in het bovenstaande voorbeeld de lengte- en breedtevariabele wijzigen in privé, is de toegang tot deze velden beperkt.
  
  En ze worden verborgen gehouden voor uiterlijke klassen. Dit heet gegevens verbergen .

Gegevens verbergen

Het verbergen van gegevens is een manier om de toegang van onze gegevensleden te beperken door de implementatiedetails te verbergen. Inkapseling biedt ook een manier om gegevens te verbergen.

We kunnen toegangsmodifiers gebruiken om gegevens te verbergen. Bijvoorbeeld,

Voorbeeld 2:Gegevens verbergen met de privéspecificatie

class Person {

  // private field
  private int age;

  // getter method
  public int getAge() {
    return age;
  }

  // setter method
  public void setAge(int age) {
    this.age = age;
  }
}

class Main {
  public static void main(String[] args) {

    // create an object of Person
    Person p1 = new Person();

    // change age using setter
    p1.setAge(24);

    // access age using getter
    System.out.println("My age is " + p1.getAge());
  }
}

Uitvoer

My age is 24

In het bovenstaande voorbeeld hebben we een private veld leeftijd . Aangezien het private . is , het is niet toegankelijk van buiten de klas.

Om toegang te krijgen tot leeftijd , we hebben public . gebruikt methoden:getAge() en setAge() . Deze methoden worden getter- en settermethoden genoemd.

leeftijd maken private stelde ons in staat om ongeautoriseerde toegang van buiten de klas te beperken. Dit is gegevens verbergen .

Als we proberen toegang te krijgen tot de leeftijd veld uit de Hoofd class, krijgen we een foutmelding.

// error: age has private access in Person
p1.age = 24;