TIPOS DE DADOS NÃO PRIMITIVOS EM JAVA

Os tipos de dados definem o tipo de dados armazenados na variável. O tipo especifica o tipo de dados (diferentes tamanhos e valores).

A linguagem de programação Java possui dois tipos de dados

Tipos de dados não primitivos
Ao contrário dos tipos de dados primitivos, estes não são predefinidos. Estes são tipos de dados definidos pelo usuário, criados por programadores. Esses tipos de dados são usados para armazenar vários valores.
listas de látex

Por exemplo, considere um array que armazena um grupo de valores. A classe também é um tipo primitivo que armazena diferentes métodos e variáveis. Portanto, estes também são chamados de tipos de dados avançados em Java.

Sempre que um tipo de dados não primitivo é definido, ele se refere a um local de memória onde os dados são armazenados na memória heap, ou seja, refere-se ao local de memória onde um objeto é colocado. Portanto, uma variável de tipo de dados não primitiva também é chamada tipo de dados referenciado ou simplesmente variável de referência de objeto .

Uma variável de referência de objeto reside na memória da pilha e o objeto para o qual ela aponta sempre reside na memória heap. A pilha contém um ponteiro para o objeto na pilha.

Na programação Java, todos os tipos de dados não primitivos são simplesmente chamados de objetos criados pela instanciação de uma classe.

Pontos chave:
1. O valor padrão de qualquer variável de referência é nulo.
2. Sempre que passamos um tipo de dados não primitivo para um método, estamos passando o endereço desse objeto onde os dados estão armazenados.
Tipos de dados não primitivos

Existem cinco tipos de tipos de dados não primitivos em Java. Eles são os seguintes:
1. Aula
2. Objeto
3. Corda
4. Variedade
5. Interface
1. Classe e objetos:

A aula em Java é um tipo de dados definido pelo usuário, ou seja, é criado pelo usuário. Ele atua como um modelo para os dados que consiste em variáveis e métodos de membros.

Um objeto é a variável da classe, que pode acessar os elementos da classe, ou seja, métodos e variáveis.

Exemplo:
topologias

No exemplo a seguir, estamos criando uma classe contendo as variáveis e métodos ( adicionar() e sub() ). Aqui, estamos acessando os métodos usando o objeto da Classe obj .

ClasseExample.java
```
 public class ClassExample { // defining the variables of class int a = 20; int b = 10; int c; // defining the methods of class public void add () { int c = a + b; System.out.println(&apos;Addition of numbers is: &apos; + c); } public void sub () { int c = a - b; System.out.println(&apos;Subtraction of numbers is: &apos; + c); } // main method public static void main (String[] args) { // creating the object of class ClassExample obj = new ClassExample(); // calling the methods obj.add(); obj.sub(); } } 
```
Saída:
```
 Addition of numbers is: 30 Subtraction of numbers is: 10 
```
2. Interface:

Um interface é semelhante a uma classe, porém a única diferença é que seus métodos são abstratos por padrão, ou seja, não possuem corpo. Uma interface possui apenas as variáveis finais e declarações de métodos. Também é chamada de classe totalmente abstrata.
Rajinikanth

Nota: Se a classe implementar uma interface, ela deverá implementar todos os métodos dessa interface. Caso contrário, devemos declarar a classe como abstrata.

Exemplo:

No exemplo a seguir, estamos criando a interface CalcInterface com dois métodos abstratos ( multiplicar() e dividir() ). Aqui, a classe InterfaceExample implementa a interface e define ainda mais os métodos dessa interface. Então, o objeto da classe é usado para acessar esses métodos.

InterfaceExemplo.java
```
 interface CalcInterface { void multiply(); void divide(); } public class InterfaceExample implements CalcInterface { // defining the variables of class int a = 10; int b = 20; int c; // implementing the interface methods public void multiply() { int c = a * b; System.out.println(&apos;Multiplication of numbers is: &apos; + c); } public void divide() { int c = a / b; System.out.println(&apos;Division of numbers is: &apos; + c); } // main method public static void main (String[] args) throws IOException { InterfaceExample obj = new InterfaceExample(); // calling the methods obj.multiply(); obj.divide(); } } 
```
3. Corda:

Uma string representa uma sequência de caracteres, por exemplo 'Javatpoint', 'Hello world', etc. String é a classe de Java.

Uma das maneiras de criar uma string e armazenar um valor nela é mostrada abaixo:
```
 String str = &apos;You&apos;re the best&apos;; 
```
Aqui, variável do tipo String str tem o valor 'Você é o melhor'. Clique aqui para entender mais sobre String em Java .

Exemplo:
string de corte java

No exemplo a seguir, estamos criando uma string com um valor. Aqui, estamos usando um dos métodos da classe String, substring() que imprime a parte indexada especificada da string.

StringExample.java
```
 public class StringExample { public static void main(String[] args) { // creating a string and initializing it String str = &apos;Hello! This is example of String type&apos;; // applying substring() on above string String subStr = str.substring(0,14); // printing the string System.out.println(subStr); } } 
```
Saída:
```
 Hello! This is 
```
4. Matriz:

Um variedade é um tipo de dados que pode armazenar múltiplas variáveis homogêneas, ou seja, variáveis do mesmo tipo em uma sequência. Elas são armazenadas de forma indexada começando com o índice 0. As variáveis podem ser tipos de dados primitivos ou não primitivos.

O exemplo a seguir mostra como declarar um array de tipo de dados primitivo interno :
```
 int [ ] marks; 
```
O exemplo a seguir mostra como declarar um array de tipo de dados não primitivo:
```
 Student [ ] students; 
```
onde, Estudante é o nome da classe e [] cria uma matriz de objetos estudantes .
string separada em java

Exemplo:

No exemplo a seguir, estamos criando dois arrays básicos, nos quais um é inicializado e o outro é declarado (a entrada é lida pelo usuário). Além disso, estamos imprimindo esses arrays usando o loop for.

ArrayExample.java
```
 // importing required packages import java.io. * ; import java.util. * ; public class ArrayExample { public static void main(String[] args) throws IOException { int i; Scanner sc = new Scanner(System. in ); // declaring and initializing an array int arr[] = {1, 2, 3, 6, 9}; // defining another array arr1 int arr1[] = new int[5]; // reading values from the user System.out.println(&apos;Enter the numbers (size = 5) :&apos;); for (i = 0; i <5; i++) { arr1[i]="sc.nextInt();" } system.out.println('previous array with initialized size is: '); for (i="0;" i < 5; system.out.print(arr[i] + ' system.out.println('
the new we have entered is:'); system.out.print(arr1[i] pre> <p> <strong>Output:</strong> </p> <pre> Enter the numbers (size = 5) : 56 43 22 1 7 Previous array with initialized size is: 1 2 3 6 9 The new array we have entered is: 56 43 22 1 7 </pre> <h2>Difference between Primitive and Non-primitive Data types in Java</h2> <ol class="points"> <li>In Java, the primitive data types are system defined however we have to create and define the non-primitive data types.</li> <li>In primitive data type, variables can store only one value at a time. However in non-primitive data types, either multiple values of the same type or different type or both can be stored.</li> <li>All the data for primitive type variables are stored on the stack whereas, for reference types, the stack holds a pointer to the object on the heap.</li> <li>A primitive type starts with a lowercase letter, while non-primitive types start with an uppercase letter.</li> <li>The size of a primitive type depends on the data type, while non-primitive types have all the same size.</li> </ol> <hr></5;>
```
Diferença entre tipos de dados primitivos e não primitivos em Java
1. Em Java, os tipos de dados primitivos são definidos pelo sistema, porém temos que criar e definir os tipos de dados não primitivos.
2. No tipo de dados primitivo, as variáveis podem armazenar apenas um valor por vez. No entanto, em tipos de dados não primitivos, vários valores do mesmo tipo ou de tipos diferentes ou ambos podem ser armazenados.
3. Todos os dados para variáveis de tipo primitivo são armazenados na pilha, enquanto, para tipos de referência, a pilha contém um ponteiro para o objeto na pilha.
4. Um tipo primitivo começa com uma letra minúscula, enquanto os tipos não primitivos começam com uma letra maiúscula.
5. O tamanho de um tipo primitivo depende do tipo de dados, enquanto os tipos não primitivos têm todos o mesmo tamanho.

TechCodeview

Tipos de dados não primitivos em Java

Pontos chave:

Tipos de dados não primitivos

1. Classe e objetos:

2. Interface:

Nota: Se a classe implementar uma interface, ela deverá implementar todos os métodos dessa interface. Caso contrário, devemos declarar a classe como abstrata.

3. Corda:

4. Matriz:

Diferença entre tipos de dados primitivos e não primitivos em Java