types classes java
Este tutorial irá discutir vários tipos de classes em Java como Abstract, Concrete, Final, Inner, POJO, Static e outras classes especiais com exemplos:
Em nosso tutorial anterior, discutimos classes e objetos em Java. Uma classe em Java é um modelo ou projeto. Também pode ser definido como uma coleção de objetos semelhantes. Definimos objetos do tipo classe e, em seguida, nos comunicamos por meio desses objetos.
Cada objeto é uma instância de uma classe que possui um estado e um comportamento.
=> Visite aqui a série exclusiva de tutoriais de treinamento em Java.
O que você aprenderá:
- Tipos de classe em Java - Introdução
- Tipos de classes em Java
- Outras classes especiais em Java
- Conclusão
Tipos de classe em Java - Introdução
Todos nós sabemos que a classe tem os seguintes componentes:
- Modificadores: Especifique o acesso para a classe.
- Nome da classe: Nome da turma.
- Palavras-chave: Palavras-chave que sugerem se uma classe estende ou implementa classe ou interface.
- A classe Body entre colchetes {}
Dependendo dos diferentes modificadores usados, do corpo da classe especificado e das palavras-chave usadas, temos vários tipos de classes em Java.
melhor software de remoção de vírus para pc
- Classe de concreto: Uma classe normal que possui a implementação concreta de métodos.
- Aula POJO: Este é o “Plain Old Java Object” contendo apenas variáveis de membro privadas e métodos getter setter para acessar essas variáveis.
- Classe abstrata: Esta classe possui um ou mais métodos abstratos.
- Aula final: Uma classe final não pode ser herdada.
- Classe estática: Uma classe que contém apenas membros estáticos.
- Classe interna: Uma classe interna é uma classe que é membro de outra classe.
Neste tutorial, discutiremos cada um desses tipos de classe com exemplos.
Também discutiremos alguns outros tipos de classes que são consideradas classes especiais em Java.
- Classe anônima: Uma aula sem nenhum nome.
- Classe imutável: Uma classe cujo objeto não pode ser alterado.
- Classe Singleton: Uma classe cuja única instância pode ser criada.
- Classe de objeto: A classe base de todos os recursos Java.
- Classe Wrapper: Cada tipo de dado primitivo em Java possui uma classe de wrapper.
Mas, primeiro, vamos discutir brevemente como importar uma classe em Java junto com a classe Main em Java que contém o método principal ou ponto de partida em Java.
Importar em Java
Em Java, se quisermos incluir qualquer recurso ou funcionalidade em nosso programa, podemos usar a instrução “import”. Usando a instrução import, podemos importar um pacote inteiro e usar sua funcionalidade em nosso programa ou também podemos incluir uma única classe.
A seguir está a sintaxe da instrução de importação.
import packageName/classname; Se quisermos importar o pacote java.lang e todas as suas classes, podemos escrever a seguinte instrução:
import java.lang.*; Suponha que desejemos incluir a funcionalidade da classe Arrays em nosso programa, então podemos escrever a seguinte instrução:
import java.util.Arrays; A instrução de importação é equivalente à instrução de inclusão C / C ++. A instrução import é colocada no início do programa Java como a primeira instrução. Podemos ter mais de uma instrução no programa Java.
Classe Principal em Java
Já estamos cientes de que em Java, o método main () é o ponto de partida para a execução de qualquer programa e pode ser colocado em qualquer classe desse aplicativo específico. No entanto, se tivermos um aplicativo complexo com muitos arquivos e classes, é aconselhável ter uma classe Main e colocar o método main () nessa classe Main.
class Main{ public static void main(String() args){ System.out.println(“Hello, World!”); } } Observe que a JVM não cria um objeto da classe Main. A lógica por trás disso é que, como main () é um método estático, ele pode ser chamado sem nenhum objeto de classe.
Tipos de classes em Java
Agora, vamos passar para os tipos de classes em Java. Explicaremos cada uma dessas classes, uma a uma, seguida pelos exemplos de programação.
# 1) Classe de concreto
Uma classe concreta é qualquer classe normal em um programa Java. Esta classe não terá nenhum método abstrato. Todos os métodos da classe concreta são completamente implementados.
Uma classe concreta pode herdar de outra classe, até mesmo uma classe abstrata ou implementar uma interface. Podemos instanciar a classe concreta e criar seus objetos.
Um exemplo simples de uma classe concreta é mostrado abaixo.
public class Main { // Concrete Class example static int total(int val1, int val2) { return val1 + val2; } public static void main(String args()) { int sum = total(100, 108); System.out.println('Total of two integers: ' + sum); } } Resultado
O programa acima mostra uma aula concreta. Vemos que esta classe tem uma implementação completa. Não há nada incompleto ou não implementado.
# 2) Classe POJO
Um POJO (Plain Old Java Object) é uma classe que contém apenas variáveis de membro privadas. Além das variáveis de membro privadas, ele contém apenas os métodos getter e setter usados por essas variáveis de membro.
Uma classe POJO não tem seu comportamento. No entanto, pode substituir alguns métodos como equals ou interfaces.
Propriedades da classe POJO:
- A classe POJO deve ter um método público getter e setter.
- Todos os membros ou variáveis de instância devem ser privados.
- A classe POJO não estende ou implementa classes ou interfaces que são pré-especificadas.
- Eles não contêm anotações pré-especificadas.
- Não tem um construtor sem argumentos (construtor sem argumento).
A seguir, é fornecido um programa Java que demonstra a classe POJO.
//declare a POJO class class POJO_Class { private int daysOfWeek=7; //private variable public int getdaysOfWeek() { //getter return daysOfWeek; } public void setdaysOfWeek(int dow) { //setter this.daysOfWeek = dow; } } public class Main { public static void main(String args()){ POJO_Class pojoDemo = new POJO_Class(); //instance of POJO class System.out.println('Days of the week:' + pojoDemo.getdaysOfWeek()); } } Resultado
A demonstração acima da classe POJO mostra que ela possui uma variável privada e os métodos getter setter para essa variável. Para acessar essa variável de membro, usamos o método getter. O método setter é usado para atualizar o valor.
# 3) Classe abstrata
Uma classe abstrata é uma classe incompleta ou cuja implementação não foi concluída. Uma classe abstrata não pode ser instanciada. Ele precisa ser estendido pelas outras classes e implementar seus métodos para formar uma classe concreta.
Uma classe abstrata é declarada usando a palavra-chave ‘abstract’. Uma classe abstrata pode ter métodos estáticos e finais, bem como construtores.
Vamos demonstrar uma classe abstrata em Java.
interface multiply //interface multiply { int product(int num1, int num2); } // abstract class abstract class Product implements multiply { // this is an abstract method to calculate product of two numbers public abstract int product(int num1, int num2); } // Concrete class :this will implement the abstract method above class Main extends Product { public int product(int num1, int num2) { return num1*num2; } // main method public static void main(String args()) { Main obj = new Main(); int prod = obj.product(100, 20); // print product System.out.println('Product of two numbers: ' + prod); } }Resultado
No programa acima, temos uma multiplicação de interface. Criamos uma classe abstrata Product que implementa uma interface multiplicação. Dentro do Produto, temos um método produto que não está implementado. Então, temos uma classe Main que herda a classe Product e implementa o método do produto. Posteriormente, chamamos esse método no objeto da classe Main.
# 4) Classe estática
Um estático em Java em geral significa o objeto que pertence a uma classe e não às instâncias individuais. Portanto, um membro ou método estático em Java não precisa ser acessado com um objeto, mas diretamente usando um nome de classe.
Uma classe estática em Java pode conter apenas membros estáticos. Além disso, não podemos instanciar uma classe estática.
O programa Java a seguir demonstra uma classe estática.
class Static_Class { static int total; // static variable static void sum(int val1, int val2) { // static method System.out.print('Static method to calculate sum:' + ' '); total = val1 + val2; System.out.println(val1 + '+' + val2); // print the numbers } static class Nested_Class { // static class static { // static block System.out.println('static block inside a static nested class'); } public void displaySum() { sum(25, 75); // call static method // print the value in static variable total, it holds the sum of two numbers System.out.println('Sum of two numbers:' + total); } } } public class Main { public static void main(String args()) { // declare static class object Static_Class.Nested_Class object = new Static_Class.Nested_Class(); object.displaySum(); // call displaySum method inside a static class } } Resultado
A classe acima demonstra a classe estática. Aqui temos uma classe estática que é membro de outra classe concreta. Dentro da classe estática, calculamos a soma de dois números e armazenamos o resultado em uma variável estática que é membro da classe externa.
# 5) Aula Final
Uma classe final é uma classe que não pode ser herdada ou subclassificada. Depois que uma classe é declarada final em Java, ela é uma espécie de constante e se torna imutável.
Portanto, para tornar uma classe imutável, devemos declará-la como final.
//final class final class Base_Class { void Display() { System.out.println('Base_Class::Display()'); } } //class Derived_Class extends Base_Class { //Compile-time error - can't inherit final class class Derived_Class{ void Display() { System.out.println('Derived_Class::Display()'); } } public class Main { public static void main(String() arg) { Base_Class base_obj = new Base_Class(); //create a final class object base_obj.Display(); Derived_Class deri_obj = new Derived_Class(); deri_obj.Display(); } } Resultado
O programa acima primeiro declara uma Base_Class marcada como “final”. Portanto, quando tentamos estendê-lo em Derived_Class, obtemos um erro do compilador. (A linha comentada). Mas podemos criar seu objeto e chamar o método Display.
# 6) Classe Aninhada / Classe Interna
A classe aninhada, também conhecida como classe interna em Java, é usada para aprimorar o encapsulamento. Uma classe aninhada / classe interna é uma classe encerrada em outra classe.
Assim como uma classe tem variáveis e métodos como seus membros, ela também pode ter uma classe interna como seu membro.
Uma classe aninhada tem a seguinte estrutura:
class OuterClass{ class NestedClass{ //nested class code… } //outerclass code… } As classes internas têm os seguintes subtipos:
- Classe interna aninhada
- Classe interna do método local
- Classe interna anônima
- Classe aninhada estática
# 1) Classe interna aninhada
Uma classe interna aninhada tem acesso a variáveis de membro privado de uma classe externa. Também podemos aplicar modificadores de acesso à classe interna aninhada.
# 2) Método Classe Interna Local
Esta é a classe interna declarada dentro de um método de classe externa.
# 3) Classe interna anônima
Classe interna anônima é uma classe interna declarada dentro de uma classe externa e não tem nenhum nome.
# 4) Classe aninhada estática
Da mesma forma que uma classe possui uma variável de membro estático, ela também pode ter uma classe estática como seu membro.
Um exemplo de uma classe Nested / Inner é fornecido abaixo:
public class Main { //nested/inner class enclosed inside Main class. class InnerClass { public void inner_print() { System.out.println('Inner class'); } } public static void main(String() args) { System.out.println('Main in Outer class'); } } Resultado
Outras classes especiais em Java
Classe imutável em Java
Uma classe imutável gera objetos imutáveis. Um objeto imutável é um objeto cujo conteúdo não pode ser alterado depois que o objeto é criado. Portanto, uma classe imutável é aquela cujo objeto não pode ser alterado depois de criado.
Todas as classes de wrapper em Java para tipos primitivos (Integer, Boolean, Byte, etc.) são imutáveis. A classe String também é imutável.
Também podemos ter classes imutáveis definidas pelo usuário em Java.
Para uma classe ser imutável, ela precisa ser declarada final junto com todos os seus membros de dados. Além disso, a classe deve ter um construtor parametrizado. Todas as variáveis de membro devem ter um método getter, mas não um método setter.
Todos os requisitos acima devem ser atendidos para que uma classe seja imutável.
Vamos implementar um programa Java para demonstrar a classe imutável.
final class City { final String city_name; final int cityId; //parameterised constructor public City(String name, int id) { this.city_name = name; this.cityId = id; } //getters for member variables public String getcityName() { return city_name; } public int getcityId() { return cityId; } } // Driver class class Main { public static void main(String args()) { City city = new City('New York', 1001); System.out.print('City Id:' + city.getcityId() + ' '); System.out.println('City Name:' + city.getcityName()); //city.cityId = 1002; //cannot assign a value to final variable regNo } } Resultado
No programa acima, declaramos uma classe City. Esta é uma classe final e nesta classe, declaramos duas variáveis de membro e um construtor parametrizado. Também declaramos métodos getter para essas duas variáveis de membro. Portanto, a classe City atende a todos os requisitos de uma classe imutável.
o que é modelo em cascata com exemplo
Observe a linha de código comentada no método principal. Se removermos o comentário desta linha, obteremos um erro do compilador (fornecido no comentário aqui), pois estamos tentando definir o valor de uma variável de membro.
Classe Singleton em Java
Uma classe singleton permite uma única instância por vez. Em Java, um singleton é um padrão de design. Esse padrão de design garante que apenas uma instância de uma classe exista em qualquer momento. Portanto, qualquer classe definida como um singleton tem um único ponto de acesso e é global.
Observe que o término do ciclo de vida do aplicativo não destrói uma classe singleton como as classes normais. Quando uma classe é declarada como singleton, não criamos uma nova instância toda vez que uma nova solicitação para o objeto é feita.
A mesma instância é usada repetidamente. Desta forma, podemos economizar espaço de memória principalmente no caso de aplicativos multi-threaded e de banco de dados.
Podemos usar uma classe singleton para atividades como cache, registro, etc.
O programa a seguir demonstra uma classe Singleton.
class Singleton { // static variable of type Singleton private static Singleton single_instance = null; // String variable public String str; // private constructor : restricted to this class private Singleton() { str = 'Singleton class::private constructor'; } // create instance of Singleton class using getInstance static method public static Singleton getInstance() { if (single_instance == null) single_instance = new Singleton(); return single_instance; } } class Main { public static void main(String args()) { // instantiate Singleton class with obj1 Singleton obj1 = Singleton.getInstance(); // instantiate Singleton class with obj2 Singleton obj2 = Singleton.getInstance(); System.out.println('obj1(str):' + obj1.str); System.out.println('obj2(str):' + obj2.str); // change variable of instance obj1 obj1.str = (obj1.str).toUpperCase(); System.out.println('
After changing obj1(str):'); System.out.println('obj1(str):' + obj1.str); System.out.println('obj2(str):' + obj2.str); } } Resultado
No programa acima, definimos uma classe singleton com um construtor privado. Definimos uma variável de membro do tipo String. No método principal, declaramos duas instâncias da classe singleton. Em seguida, alteramos a variável String usando uma das instâncias.
Quando imprimimos o valor String para ambas as instâncias, notamos que o valor da variável String mudou para ambas as instâncias. Portanto, embora tenhamos alterado o valor apenas para uma instância, por causa da classe singleton, as alterações são refletidas em todas as instâncias.
Sempre retornamos a mesma instância, embora pareçamos criar instâncias diferentes.
Classe de objeto em Java
A classe Object é a classe pai ou a primeira classe em Java. Ele está no nível mais alto da hierarquia Java.
Como todas as classes têm a classe Object como uma superclasse, todos os objetos Java, inclusive Arrays, implementam os métodos da classe Object. A classe de objeto está presente no pacote “java.lang”.
A declaração para java.lang.Object é:
public class Object
A tabela a seguir descreve os construtores e métodos da classe Object.
| Construtor / Método | Descrição |
|---|---|
| Classe getClass () | Retorna a classe de tempo de execução do objeto. |
| Construtor de classe de objeto | |
| Objeto() | Construtor de classe de objeto |
| Métodos de classe de objeto | |
| Clone de objeto protegido () | Retorna um clone ou cópia do objeto. |
| boolean equals (Object obj) | Verifica se um determinado objeto obj é igual a este objeto. |
| protegido void finalize () | Chamado pelo coletor de lixo quando todas as referências ao objeto são destruídas. |
| int hashCode () | Retorna o código hash para o objeto. |
| void notificar () | Use para ativar um único thread em espera. |
| void notificationAll () | Desperta todos os tópicos em espera. |
| String toString () | Retorna String equivalente ao objeto. |
| void wait () | Faz um encadeamento esperar até ser ativado pelo método de notificação por outro encadeamento. |
| void wait (longo tempo limite) | Faz com que o encadeamento espere até que o tempo determinado por 'tempo limite' passe ou seja ativado pelos métodos notificar ou notificarAll. |
| void wait (long timeout, int nanos) | Faz com que o encadeamento espere até que o tempo especificado tenha decorrido ou até notificar () ou notificarAll () seja chamado por outro encadeamento. |
Vamos implementar um programa Java de exemplo que demonstrará alguns dos métodos da classe Object.
public class Main { public static void main(String() args) { Main t = new Main(); System.out.println('Main class Object HashCode:' + t.hashCode()); t = null; // call garbage collector System.gc(); System.out.println('Main class:End'); } @Override protected void finalize() { System.out.println('Main Class::finalize method called.'); } } Resultado
Aqui temos uma classe principal. No método main () criamos um objeto da classe Main. Este objeto é descendente da classe Object e suporta todos os métodos da classe Object. Assim, usamos este objeto e chamamos alguns métodos da classe Object como hashCode (), System.GC (), finalize () etc.
Classe Wrapper em Java
Java fornece um recurso chamado classe wrapper, que possui um mecanismo que converte tipos de dados primitivos em objetos e vice-versa. Classes de invólucro são as classes que representam tipos primitivos como int, char, etc. como objetos.
Portanto, cada tipo de dado primitivo em Java tem sua classe de wrapper correspondente.
A tabela a seguir mostra os tipos de dados primitivos e sua classe de wrapper equivalente.
| Tipo primitivo | Tipo de invólucro |
|---|---|
| flutuador | Flutuador |
| boleano | boleano |
| Caracteres | Personagem |
| byte | Byte |
| baixo | Baixo |
| int | Inteiro |
| longo | Longo |
| em dobro | Dobro |
Para converter os primitivos em objetos e objetos em primitivos, temos técnicas chamadas “autoboxing” e “boxing” respectivamente. Ase Java é uma linguagem de programação orientada a objetos, sempre lidamos com objetos e também temos muitos recursos como coleções, Serialização , etc. que também precisam de objetos e tipos primitivos.
Portanto, é imperativo que sempre precisemos de objetos e tipos primitivos em Java e, portanto, exigimos essas técnicas de autoboxing e unboxing.
Autoboxing
Autoboxing é uma técnica de conversão automática de um tipo de dados primitivo em um objeto de sua classe de wrapper correspondente. Por exemplo , conversão de int para classe Integer, char para classe Character, etc. são instâncias de autoboxing.
Observação: As classes de wrapper usam o método valueOf () para converter o primitivo em objetos que são depreciados desde Java 5.
Unboxing
A conversão reversa de objetos da classe wrapper em seus tipos de dados primitivos correspondentes é chamada de “unboxing”.
Observação: Desde Java 5, o método intValue () que converte o objeto wrapper em um tipo primitivo é depreciado.
A seguir está um exemplo de boxing / unboxing.
public class Main { public static void main(String args()){ //Convert int to Integer : boxing int num=20; Integer int_class= Integer.valueOf(num);//explicit conversion from int to Integer Integer inum=num;//autoboxing System.out.println('int => Integer: ' + num+' => '+inum); //Convert Integer to int: unboxing Integer val=new Integer (3); int ival=val.intValue();//explicit conversion from Integer to int int jval=val;//unboxing System.out.println('Integer => int:' + val+' => '+jval); } } Resultado
O programa acima mostra autoboxing e unboxing no valor int. Primeiro, convertemos int em objeto Integer e, em seguida, um objeto Integer é convertido no tipo de dados int.
Vamos implementar um programa que demonstra as classes de wrapper presentes em Java.
public class Main { public static void main(String args()) { byte bbyte=10; short sshort=20; int iint=300; long llong=400; float ffloat=3.14F; double ddouble=77.2D; char cchar='A'; boolean bboolean=true; //Convert primitives into objects => Autoboxing Byte byteobj=bbyte; Short shortobj=sshort; Integer intobj=iint; Long longobj=llong; Float floatobj=ffloat; Double doubleobj=ddouble; Character charobj=cchar; Boolean boolobj=bboolean; //Print converted objects System.out.println('Primitives converted to Objects:'); System.out.println('Byte object: '+byteobj); System.out.println('Short object: '+shortobj); System.out.println('Integer object: '+intobj); System.out.println('Long object: '+longobj); System.out.println('Float object: '+floatobj); System.out.println('Double object: '+doubleobj); System.out.println('Character object: '+charobj); System.out.println('Boolean object: '+boolobj); //Convert Objects to Primitives => Unboxing byte bytevalue=byteobj; short shortvalue=shortobj; int intvalue=intobj; long longvalue=longobj; float floatvalue=floatobj; double doublevalue=doubleobj; char charvalue=charobj; boolean boolvalue=boolobj; //Print primitives System.out.println('Converting Objects to Primitives'); System.out.println('byte value: '+bytevalue); System.out.println('short value: '+shortvalue); System.out.println('int value: '+intvalue); System.out.println('long value: '+longvalue); System.out.println('float value: '+floatvalue); System.out.println('double value: '+doublevalue); System.out.println('char value: '+charvalue); System.out.println('boolean value: '+boolvalue); } } Resultado
A saída do programa acima mostra a conversão de tipos primitivos em objetos wrapper (Autoboxing) e reverte a conversão de objetos wrapper em tipos primitivos (unboxing).
perguntas frequentes
Q # 1) Qual é o tipo de dados de classe em Java?
Responda: Java fornece uma classe chamada “Class” que contém informações sobre todas as classes, objetos e interfaces do aplicativo em execução. A classe Class também representa tipos de dados primitivos e o tipo void.
A classe Class faz parte do pacote java.lang.
Q # 2) O que é a classe normal em Java?
Responda: Uma classe normal em Java é uma classe não estática. Podemos criar objetos de uma classe normal usando a nova palavra-chave. Além disso, qualquer classe normal pode ter outra classe como membro. Nesse caso, a classe de membro é chamada de classe aninhada ou interna e a classe envolvente é chamada de classe externa.
P # 3) String é uma classe Wrapper em Java?
quais são as etapas do sdlc
Responda: Não, String não é uma classe wrapper em Java. Para que uma classe seja uma classe wrapper, precisamos de seu tipo primitivo correspondente. Por exemplo, para a classe de invólucro inteiro, temos o tipo primitivo int. Para a classe String, não temos um tipo de dados primitivo correspondente.
P # 4) Qual é o benefício da classe Wrapper?
Responda: As classes de wrapper são usadas para a conversão de tipos de dados primitivos em objetos. Em outras palavras, as classes de wrapper envolvem tipos primitivos em objetos. As classes Wrapper são usadas quando certos recursos Java, como Coleções, esperam apenas objetos e não tipos de dados primitivos.
P # 5) Por que a classe Singleton é usada em Java?
Responda: Sempre que queremos um ponto de acesso global para um determinado objeto, optamos por um padrão singleton que nos permite projetar uma classe singleton na qual haverá apenas uma instância. As classes singleton são usadas em caches, pool de threads, aplicativos de banco de dados, registro, etc.
Conclusão
Neste tutorial, cobrimos os vários tipos de classes usados em Java. Vimos os tipos de classes concreto, abstrato, final, estático, aninhado, POJO, etc. Além disso, também discutimos classes Singleton, classes Immutable e discutimos seus exemplos de implementação também.
Também cobrimos classes de wrapper e classes de objeto em Java. As classes de wrapper são as classes que envolvem os tipos de dados primitivos de Java em objetos. A classe de objeto em Java é a superclasse de todas as outras classes. É a classe mais alta na hierarquia Java.
Agora que discutimos as classes e objetos em Java e os tipos de classe, no próximo tutorial iremos prosseguir com uma discussão detalhada sobre construtores em Java.
=> Confira o guia de treinamento Java perfeito aqui.
Leitura recomendada
- Interface Java e tutorial de classe abstrata com exemplos
- Java Basics: Java Syntax, Java Class e Core Java Concepts
- O que é palavra-chave estática em Java?
- Java Integer e classe Java BigInteger com exemplos
- Tutorial da classe Java Scanner com exemplos
- Java Class Vs Object - Como usar classe e objeto em Java
- Tutorial da classe Java Array - classe java.util.Arrays com exemplos
- O que é Java Vector | Tutorial da classe Java Vector com exemplos