Java kapslad och inre klass (med exempel)

I denna handledning lär du dig om den kapslade klassen i Java och dess typer med hjälp av exempel.

I Java kan du definiera en klass inom en annan klass. Sådan klass är känd som nested class. Till exempel,

 class OuterClass ( //… class NestedClass ( //… ) )

Det finns två typer av kapslade klasser som du kan skapa i Java.

  • Icke-statisk kapslad klass (inre klass)
  • Statisk kapslad klass

Rekommenderad läsning :

  • Java Access Modifiers
  • Statisk Java-nyckelord

Låt oss först titta på icke-statiska kapslade klasser.

Icke-statisk kapslad klass (inre klass)

En icke-statisk kapslad klass är en klass inom en annan klass. Den har tillgång till medlemmar i den omslutande klassen (yttre klass). Det är allmänt känt som inner class.

Eftersom det inner classexisterar inom den yttre klassen, måste du först instansera den yttre klassen, för att få den inre klassen.

Här är ett exempel på hur du kan förklara inre klasser i Java.

Exempel 1: Inre klass

 class CPU ( double price; // nested class class Processor( // members of nested class double cores; String manufacturer; double getCache()( return 4.3; ) ) // nested protected class protected class RAM( // members of protected nested class double memory; String manufacturer; double getClockSpeed()( return 5.5; ) ) ) public class Main ( public static void main(String() args) ( // create object of Outer class CPU CPU cpu = new CPU(); // create an object of inner class Processor using outer class CPU.Processor processor = cpu.new Processor(); // create an object of inner class RAM using outer class CPU CPU.RAM ram = cpu.new RAM(); System.out.println("Processor Cache = " + processor.getCache()); System.out.println("Ram Clock speed = " + ram.getClockSpeed()); ) )

Utgång :

 Processorns cache = 4,3 RAM Klockhastighet = 5,5

I ovanstående program finns två kapslade klasser: Processor och RAM i den yttre klassen: CPU. Vi kan förklara den inre klassen som skyddad. Därför har vi förklarat RAM-klassen som skyddad.

Inne i huvudklassen,

  • vi skapade först en instans av en CPU av yttre klass som heter cpu.
  • Med hjälp av förekomsten av den yttre klassen skapade vi sedan objekt av inre klasser:
     CPU.Processor processor = cpu.new Processor; CPU.RAM ram = cpu.new RAM();

Obs! Vi använder dot ( .) -operatören för att skapa en instans av den inre klassen med hjälp av den yttre klassen.

Åtkomst till medlemmar i ytterklassen inom den inre klassen

Vi kan komma åt medlemmarna i den yttre klassen genom att använda detta nyckelord. Om du vill lära dig mer om detta nyckelord, besök Java detta nyckelord.

Exempel 2: Åtkomst till medlemmar

 class Car ( String carName; String carType; // assign values using constructor public Car(String name, String type) ( this.carName = name; this.carType = type; ) // private method private String getCarName() ( return this.carName; ) // inner class class Engine ( String engineType; void setEngine() ( // Accessing the carType property of Car if(Car.this.carType.equals("4WD"))( // Invoking method getCarName() of Car if(Car.this.getCarName().equals("Crysler")) ( this.engineType = "Smaller"; ) else ( this.engineType = "Bigger"; ) )else( this.engineType = "Bigger"; ) ) String getEngineType()( return this.engineType; ) ) ) public class Main ( public static void main(String() args) ( // create an object of the outer class Car Car car1 = new Car("Mazda", "8WD"); // create an object of inner class using the outer class Car.Engine engine = car1.new Engine(); engine.setEngine(); System.out.println("Engine Type for 8WD= " + engine.getEngineType()); Car car2 = new Car("Crysler", "4WD"); Car.Engine c2engine = car2.new Engine(); c2engine.setEngine(); System.out.println("Engine Type for 4WD = " + c2engine.getEngineType()); ) )

Utgång :

 Motortyp för 8WD = större motortyp för 4WD = mindre

I programmet ovan har vi den inre klassen som heter Motor inuti den yttre klassen Bil. Här, se raden,

 if(Car.this.carType.equals("4WD")) (… )

Vi använder thisnyckelord för att få tillgång till variabeln carType i den yttre klassen. Du kanske har märkt att i stället för att använda har this.carTypevi använt Car.this.carType.

Det beror på att om vi inte hade nämnt namnet på den yttre klassen Bil, kommer thisnyckelordet att representera medlemmen i den inre klassen.

På samma sätt har vi också tillgång till metoden för den yttre klassen från den inre klassen.

 if (Car.this.getCarName().equals("Crysler") (… )

Det är viktigt att notera att även om det getCarName()är en privatemetod kan vi komma åt den från den inre klassen.

Statisk kapslad klass

I Java kan vi också definiera en staticklass i en annan klass. Sådan klass är känd som static nested class. Statiska kapslade klasser kallas inte statiska inre klasser.

Till skillnad från inre klass kan en statisk kapslad klass inte komma åt den yttre klassens medlemsvariabler. Det beror på att den statiska kapslade klassen inte kräver att du skapar en instans av den yttre klassen.

 OuterClass.NestedClass obj = new OuterClass.NestedClass();

Här skapar vi ett objekt av den statiska kapslade klassen genom att helt enkelt använda klassnamnet på den yttre klassen. Därför kan den yttre klassen inte hänvisas till med OuterClass.this.

Exempel 3: Statisk inre klass

 class MotherBoard ( // static nested class static class USB( int usb2 = 2; int usb3 = 1; int getTotalPorts()( return usb2 + usb3; ) ) ) public class Main ( public static void main(String() args) ( // create an object of the static nested class // using the name of the outer class MotherBoard.USB usb = new MotherBoard.USB(); System.out.println("Total Ports = " + usb.getTotalPorts()); ) )

Utgång :

 Totalt antal hamnar = 3

I ovanstående program har vi skapat en statisk klass med namnet USB inuti klassen MotherBoard. Lägg märke till raden,

 MotherBoard.USB usb = new MotherBoard.USB();

Här skapar vi ett USB-objekt med namnet på den yttre klassen.

Låt oss nu se vad som skulle hända om du försöker komma åt medlemmarna i den yttre klassen:

Exempel 4: Åtkomst till medlemmar av yttre klass inom statisk inre klass

 class MotherBoard ( String model; public MotherBoard(String model) ( this.model = model; ) // static nested class static class USB( int usb2 = 2; int usb3 = 1; int getTotalPorts()( // accessing the variable model of the outer classs if(MotherBoard.this.model.equals("MSI")) ( return 4; ) else ( return usb2 + usb3; ) ) ) ) public class Main ( public static void main(String() args) ( // create an object of the static nested class MotherBoard.USB usb = new MotherBoard.USB(); System.out.println("Total Ports = " + usb.getTotalPorts()); ) )

När vi försöker köra programmet får vi ett fel:

 fel: icke-statisk variabel detta kan inte hänvisas från ett statiskt sammanhang

This is because we are not using the object of the outer class to create an object of the inner class. Hence, there is no reference to the outer class Motherboard stored in Motherboard.this.

Key Points to Remember

  • Java treats the inner class as a regular member of a class. They are just like methods and variables declared inside a class.
  • Since inner classes are members of the outer class, you can apply any access modifiers like private, protected to your inner class which is not possible in normal classes.
  • Since the nested class is a member of its enclosing outer class, you can use the dot (.) notation to access the nested class and its members.
  • Using the nested class will make your code more readable and provide better encapsulation.
  • Icke-statiska kapslade klasser (inre klasser) har tillgång till andra medlemmar i den yttre / omslutande klassen, även om de förklaras privata.

Intressanta artiklar...