Em Java, o aula é um projeto a partir do qual podemos criar um objeto individual. Java fornece um palavra-chave classe nomeada pela qual podemos declarar uma classe. Dentro da classe, definimos aula membros e funções. Não é possível criar Programas Java sem aula. Também podemos nos referir a uma classe como usuário definido Tipos de aulas

Existem sete tipos de classes em Java:

Classe estática Aula Final Classe Abstrata Classe de concreto Classe Singleton Classe POJO Classe Interna

Classe estática

Em Java, static é uma palavra-chave que gerencia objetos na memória. O objeto estático pertence à classe em vez da instância da classe.

Podemos fazer uma aula estático se e somente se for uma classe aninhada. Também podemos dizer que as classes estáticas são conhecidas como classes aninhadas. Isso significa que uma classe declarada como estática dentro de outra classe é conhecida como classe estática. A classe estática aninhada não requer referência à classe externa. O objetivo de uma classe estática é fornecer o esboço de sua classe herdada.

As propriedades da classe estática são:

• A classe possui apenas membros estáticos.
• Não pode acessar o membro (não estático) da classe externa.
• Não podemos criar um objeto da classe estática.

Vamos entender o conceito de classe estática através de um programa.

StaticClassExample.java

 public class StaticClassExample { private static String str = 'Javatpoint'; //nested class which is a Static class public static class StaticDemo { //non-static method of Static class public void show() { System.out.println(str); } } public static void main(String args[]) { StaticClassExample.StaticDemo obj = new StaticClassExample.StaticDemo(); obj.show(); } } 

Saída:

 Javatpoint 

Na classe externa do programa acima, declaramos uma variável str como estático porque estamos acessando essa variável a partir de um contexto estático. Se declararmos essa variável como não estática, o compilador mostrará um erro porque uma classe estática aninhada não pode acessar membros não estáticos da classe externa.

A segunda coisa a ser notada no programa acima é que para criar o objeto da classe aninhada não precisamos criar uma instância da classe externa. Se a classe aninhada não for uma classe estática, precisamos criar uma instância da classe externa.

Aula Final

A palavra final significa que não pode ser alterado. O final classe em Java pode ser declarada usando o palavra-chave final . Depois que declaramos uma classe como final, os valores permanecem os mesmos durante todo o programa. O objetivo da aula final é fazer com que a aula imutável como a classe String. É apenas uma maneira de tornar a classe imutável. Lembre-se que o a aula final não pode ser estendida . Isso também impede que a classe seja subclassificada .

Vamos entender o conceito da aula final através de um programa.

FinalClassExample.java

árvore binária vs bst

 //base class declared as final final class A { void printmsg() { System.out.print('Base class method is executed.'); } } //derived class //extending a final class which is not possible //it shows the error cannot inherit final class at compile time class B extends A { void printmsg() { System.out.print('Derived class method is executed.'); } } //main class public class FinalClassExample { public static void main(String[] arg) { B obj = new B(); obj.printmsg(); } } 

Saída:

 /FinalClassExample.java:11: error: cannot inherit from final A class B extends A 

Classe Abstrata

Um classe abstrata é um que é declarado com a palavra-chave abstrato . A classe pode ou não conter métodos abstratos. Não podemos criar uma instância de uma classe abstrata, mas pode ser uma subclasse. Estas classes estão incompletas, então para completar a classe abstrata devemos estender as classes abstratas para uma classe concreta. Quando declaramos uma subclasse como abstrata então é necessário fornecer a implementação de métodos abstratos. Portanto, a subclasse também deve ser declarada abstrata. Podemos conseguir ocultar dados usando a classe abstrata. Um exemplo de classe abstrata é AbstarctMap classe que faz parte da estrutura Collections.

Vamos entender o conceito de classe abstrata por meio de um programa.

AbstractClassExample.java

 //abstract class abstract class MathematicalOperations { int a=30, b=40; //abstract method public abstract void add(); } public class Operation extends MathematicalOperations { //definition of abstract method public void add() { System.out.println('Sum of a and b is: 'a+b); } public static void main(String args[]) { MathematicalOperations obj = new Operation(); obj.add(); } } 

Saída:

 Sum of a and b is: 70 

Classe de concreto

Estas são as classes Java regulares. Uma classe derivada que fornece as implementações básicas para todos os métodos que ainda não estão implementados na classe base é conhecida como concreto aula. Em outras palavras, são classes Java regulares nas quais todos os métodos de uma classe abstrata são implementados. Podemos criar um objeto da classe concreta diretamente. Lembre-se de que classe concreta e classe abstrata não são a mesma coisa. Uma classe concreta pode estender sua classe pai. É usado para requisitos específicos.

Vamos entender o conceito de classe concreta através de um programa.

ConcreteClassExample.java

 //Concrete Class public class ConcreteClassExample { //method of the concreted class static int product(int a, int b) { return a * b; } public static void main(String args[]) { //method calling int p = product(6, 8); System.out.println('Product of a and b is: ' + p); } } 

Saída:

 Product of a and b is: 48 

Classe Singleton

Uma classe que possui apenas um objeto por vez é conhecida como aula única . Ainda assim, se estivermos tentando criar uma instância pela segunda vez, essa instância recém-criada aponta para a primeira instância. Se fizermos alguma alteração dentro da classe através de qualquer instância, a modificação afetará também a variável da instância única. Geralmente é usado para controlar o acesso ao lidar com a conexão do banco de dados e a programação do soquete. Se quisermos criar uma classe singleton, faça o seguinte:

• Crie um privado construtor .
• Crie um método estático (usando a inicialização lenta) que retorne o objeto da classe singleton.

SingletonClassExample.java

 public class Singleton { private String objectState; private static Singleton instance = null; private Singleton() throws Exception { this.objectState = 'Javatpoint'; } public static Singleton getInstance() { if(instance==null) { try { instance=new Singleton(); } catch(Exception e) { e.printStackTrace(); } } return instance; } public String getObjectState() { return objectState; } public void setObjectState(String objectState) { this.objectState = objectState; } } 

Saída:

 Javatpoint 

Classe POJO

Em Java, POJO significa Objeto Java simples e antigo. Uma classe Java que contém apenas variáveis ​​privadas, setter e getter é conhecida como POJO aula. É usado para definir objetos Java que aumentam a capacidade de reutilização e legibilidade de um programa Java. A classe fornece encapsulamento. É amplamente utilizado em Java porque é fácil de entender essas classes. A classe POJO possui as seguintes propriedades:

• Não estende as classes predefinidas como Arrays, HttpServlet, etc.
• Não pode conter anotações pré-especificadas.
• Não pode implementar pré-definidos interfaces .
• Não é necessário adicionar nenhum construtor.
• Todas as variáveis ​​de instância devem ser privadas.
• O getter/setter métodos deve ser público.

Vamos entender o conceito de classe POJO através de um programa Java.

PojoClassExample.java

 class PojoDemo { //private variable private double price=89764.34; //getter method public double getPrice() { return price; } //setter method public void setPrice(int price) { this.price = price; } } //main class public class PojoClassExample { public static void main(String args[]) { PojoDemo obj = new PojoDemo(); System.out.println('The price of an article is '+ obj.getPrice()+' Rs.'); } } 

Saída:

 The price of an article is 89764.34 Rs. 

Classe interna

Java nos permite definir uma classe dentro de uma classe e essas classes são conhecidas como classes aninhadas . É usado para agrupar as classes de forma lógica e obter encapsulamento . Os membros da classe externa (incluindo private) podem ser acessados ​​pelo classe interna . A sintaxe geral para declarar a classe aninhada é a seguinte:

 class OuterClass { //code class NestedClass { //code } } 

As classes aninhadas são de dois tipos:

1. Classe aninhada estática: Uma aula que é estático e aninhado é chamada de classe aninhada estática. Ele interage com o membro da instância de sua classe externa. Podemos criar um objeto da classe estática aninhada usando a seguinte sintaxe:

 OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass(); 

2. Classe aninhada não estática: Classes aninhadas não estáticas são chamadas classes internas .

A sintaxe geral para declarar a classe aninhada estática e a classe interna é a seguinte:

 class OuterClass { ... static class StaticNestedClass { ... } class InnerClass { ... } } 

Vamos entender o conceito de classe interna por meio de um programa Java.

ciclo de programa java

InnerClassExample.java

 public class InnerClassExample { public static void main(String[] args) { System.out.println('This is outer class.'); } class InnerClass { public void printinner() { System.out.println('This is inner class.'); } } } 

Tipos de aulas internas

Java fornece os dois tipos de classes internas:

• Classes Locais ou Método Classe Interna Local
• Aulas anônimas ou Classe interna anônima

Classe Interna Local

É um tipo de classe interna definida dentro de um bloco. Aqui, bloco denota o corpo de um método (um grupo de instruções entre colchetes). Devido à definição dentro de um bloco, também é conhecido como método de classe interna local. Essas são classes não estáticas porque podem acessar os membros da instância do bloco. Podemos definir as classes internas locais no corpo de um método. Essas classes devem ser instanciadas no bloco em que estão definidas.

Quando compilamos um programa Java (um programa que contém uma classe interna), o compilador gera os dois arquivos de classe, nomeadamente Classe externa e ExteriorInner.class. Um para a classe externa e outro para a classe interna que contém uma referência à classe externa.

Vamos entender o conceito de classe interna local por meio de um programa Java.

OuterClass.java

 public class OuterClass { private void getValue() { //if you are using Java 7 make the variable final //if you are using Java 8 the code runs successfully int sum = 20; //declaring method local inner class class InnerClass { public int divisor; public int remainder; public InnerClass() { divisor = 4; remainder = sum%divisor; } private int getDivisor() { return divisor; } private int getRemainder() { return sum%divisor; } private int getQuotient() { System.out.println('We are inside the inner class'); return sum / divisor; } } //creating an instance of inner class InnerClass ic = new InnerClass(); System.out.println('Divisor = '+ ic.getDivisor()); System.out.println('Remainder = ' + ic.getRemainder()); System.out.println('Quotient = ' + ic.getQuotient()); } public static void main(String[] args) { //creating an instance of outer class OuterClass oc = new OuterClass(); oc.getValue(); } } 

Saída:

 Divisor = 4 Remainder = 0 We are inside the inner class Quotient = 5 

Classe interna anônima

É um tipo de classe interna igual às classes locais, mas a única diferença é que a classe não tem um nome de classe e um único objeto é criado a partir da classe. Isso torna o código mais conciso. É usado se quisermos usar a classe local uma vez. Podemos criar classes anônimas das duas maneiras a seguir:

• Usando uma interface
• Ao declarar a classe concreta e abstrata

Sintaxe:

 // the class may an interface, abstract or concrete class DemoClass obj = new DemoClass() { //methods //data members public void demomethod() { //statements } }; 

Observando a sintaxe acima, vemos que é igual à invocação do construtor, exceto que a classe possui uma definição contida no bloco.

AnonymousClassExample.java

 interface Score { int run = 321; void getScore(); } public class AnonymousClassExample { public static void main(String[] args) { // Myclass is hidden inner class of Score interface // whose name is not written but an object to it // is created. Score s = new Score() { @Override public void getScore() { //prints score System.out.print('Score is '+run); } }; s.getScore(); } } 

Saída:

 Score is 321 

Java também fornece outro tipo de classe Java, conhecido como classe wrapper. Vamos discutir isso em detalhes.

Classe de wrapper

Em Java, o termo classe wrapper representa uma coleção de classes Java que objetivam o tipo primitivo de Java. Isso significa que para cada tipo primitivo existe uma classe wrapper correspondente. As classes wrapper são utilizadas para realizar a conversão de um tipo primitivo para um objeto e vice-versa. A figura a seguir demonstra a hierarquia de classes do wrapper.

A tabela a seguir representa o tipo primitivo e a classe wrapper correspondente.

Vamos entender a classe wrapper por meio de um programa Java.

WrapperClassExample.java

 public class WrapperClassExample { public static void main(String args[]) { byte x = 0; //wrapping byte primitive type into Byte object Byte byteobj = new Byte(x); int y = 23; //wrapping int primitive type into Integer object Integer intobj = new Integer(y); char c='m'; //wrapping char primitive type into Character object Character charobj=c; //printing values from objects System.out.println('Byte object byteobj: ' + byteobj); System.out.println('Integer object intobj: ' + intobj); System.out.println('Character object charobj: ' + charobj); } } 

Saída:

 Byte object byteobj: 0 Integer object intobj: 23 Character object charobj: m