Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Industrial programming >> Java

Java aninhado e classe interna

Java aninhado e classe interna


Neste tutorial, você aprenderá sobre a classe aninhada em Java e seus tipos com a ajuda de exemplos.

Em Java, você pode definir uma classe dentro de outra classe. Essa classe é conhecida como nested class . Por exemplo,

class OuterClass {
    // ...
    class NestedClass {
        // ...
    }
}

Existem dois tipos de classes aninhadas que você pode criar em Java.

Leitura recomendada :

Vamos primeiro examinar as classes aninhadas não estáticas.

Classe aninhada não estática (classe interna)


Uma classe aninhada não estática é uma classe dentro de outra classe. Ele tem acesso aos membros da classe envolvente (classe externa). É comumente conhecido como inner class .

Desde o inner class existe dentro da classe externa, você deve instanciar a classe externa primeiro, para instanciar a classe interna.

Aqui está um exemplo de como você pode declarar classes internas em Java.

Exemplo 1:classe interna

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());
    }
}

Saída :
Processor Cache = 4.3
Ram Clock speed = 5.5

No programa acima, existem duas classes aninhadas:Processador e RAM dentro da classe externa:CPU . Podemos declarar a classe interna como protegida. Portanto, declaramos a classe RAM como protegida.

Dentro da classe principal,

Observação :Usamos o ponto (. ) para criar uma instância da classe interna usando a classe externa.

Acessando membros da classe externa dentro da classe interna


Podemos acessar os membros da classe externa usando esta palavra-chave. Se você quiser saber mais sobre essa palavra-chave, visite Java this keyword.

Exemplo 2:como acessar membros

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());
    }
}

Saída :
Engine Type for 8WD= Bigger
Engine Type for 4WD = Smaller

No programa acima, temos a classe interna chamada Engine dentro da classe externa Car . Aqui, observe a linha,
if(Car.this.carType.equals("4WD")) {...}

Estamos usando this palavra-chave para acessar o carType variável da classe externa. Você deve ter notado que em vez de usar this.carType usamos Car.this.carType .



É porque se não tivéssemos mencionado o nome da classe externa Car , então this palavra-chave irá representar o membro dentro da classe interna.

Da mesma forma, também estamos acessando o método da classe externa da classe interna.
if (Car.this.getCarName().equals("Crysler") {...}

É importante notar que, embora o getCarName() é um private método, podemos acessá-lo da classe interna.

Classe aninhada estática


Em Java, também podemos definir um static classe dentro de outra classe. Essa classe é conhecida como static nested class . Classes aninhadas estáticas não são chamadas de classes internas estáticas.

Ao contrário da classe interna, uma classe aninhada estática não pode acessar as variáveis ​​de membro da classe externa. É porque a classe aninhada estática não requer que você crie uma instância da classe externa.
OuterClass.NestedClass obj = new OuterClass.NestedClass();

Aqui, estamos criando um objeto da classe aninhada estática simplesmente usando o nome da classe externa. Portanto, a classe externa não pode ser referenciada usando OuterClass.this .

Exemplo 3:classe interna estática

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());
   }
}

Saída :
Total Ports = 3

No programa acima, criamos uma classe estática chamada USB dentro da classe MotherBoard . Observe a linha,
MotherBoard.USB usb = new MotherBoard.USB();

Aqui, estamos criando um objeto de USB usando o nome da classe externa.

Agora, vamos ver o que aconteceria se você tentasse acessar os membros da classe externa:

Exemplo 4:Acessando membros da classe externa dentro da classe interna estática

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());
   }
}

Quando tentamos executar o programa, recebemos um erro:
error: non-static variable this cannot be referenced from a static context

Isso ocorre porque não estamos usando o objeto da classe externa para criar um objeto da classe interna. Portanto, não há referência à classe externa Motherboard armazenado em Motherboard.this .

Pontos-chave a serem lembrados


Java

  1. Classe aninhada C#
  2. Variáveis ​​e literais Java
  3. Classe e objetos Java
  4. Palavra-chave final Java
  5. Java instanceof Operator
  6. Classe abstrata Java e métodos abstratos
  7. Classe estática aninhada em Java
  8. Classe anônima Java
  9. Classe Java Singleton
  10. Reflexão Java