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.
- Classe aninhada não estática (classe interna)
- Classe aninhada estática
Leitura recomendada :
- Modificadores de acesso Java
- Palavra-chave estática Java
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,
- criamos primeiro uma instância de uma classe externa CPU chamado cpu .
- Usando a instância da classe externa, criamos então objetos de classes internas:
CPU.Processor processor = cpu.new Processor; CPU.RAM ram = cpu.new RAM();
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 trata a classe interna como um membro regular de uma classe. Eles são como métodos e variáveis declarados dentro de uma classe.
- Como as classes internas são membros da classe externa, você pode aplicar qualquer modificador de acesso como
private,protectedpara sua classe interna, o que não é possível em classes normais. - Como a classe aninhada é membro de sua classe externa, você pode usar o ponto (
.) para acessar a classe aninhada e seus membros. - Usar a classe aninhada tornará seu código mais legível e fornecerá um melhor encapsulamento.
- Classes aninhadas não estáticas (classes internas) têm acesso a outros membros da classe externa/inclusiva, mesmo que sejam declaradas como privadas.
Java