TIPOS DE DATOS NO PRIMITIVOS EN JAVA

Los tipos de datos definen el tipo de datos que se almacenan en la variable. El tipo especifica el tipo de datos (diferentes tamaños y valores).

El lenguaje de programación Java tiene dos tipos de tipos de datos.

Tipos de datos no primitivos
A diferencia de los tipos de datos primitivos, estos no están predefinidos. Estos son tipos de datos definidos por el usuario creados por programadores. Estos tipos de datos se utilizan para almacenar múltiples valores.
dormir en js

Por ejemplo, considere un Matriz que almacena un grupo de valores. La clase también es un tipo primitivo que almacena diferentes métodos y variables. Por lo tanto, también se denominan como tipos de datos avanzados en Java.

Siempre que se define un tipo de datos no primitivo, se refiere a una ubicación de memoria donde se almacenan los datos en la memoria del montón, es decir, se refiere a la ubicación de memoria donde se coloca un objeto. Por lo tanto, una variable de tipo de datos no primitivo también se llama tipo de datos referenciado o simplemente variable de referencia de objeto .

Una variable de referencia de objeto vive en la memoria de la pila y el objeto al que apunta siempre vive en la memoria del montón. La pila contiene un puntero al objeto en el montón.

En la programación Java, todos los tipos de datos no primitivos se denominan simplemente objetos que se crean al crear una instancia de una clase.

Puntos clave:
1. El valor predeterminado de cualquier variable de referencia es nulo.
2. Siempre que pasamos un tipo de datos no primitivo a un método, pasamos la dirección de ese objeto donde se almacenan los datos.
Tipos de tipos de datos no primitivos

Hay cinco tipos de datos no primitivos en Java. Son los siguientes:
1. Clase
2. Objeto
3. Cadena
4. Formación
5. Interfaz
1. Clase y objetos:

A clase en Java es un tipo de datos definido por el usuario, es decir, lo crea el usuario. Actúa como plantilla para los datos que constan de variables miembro y métodos.

Un objeto es la variable de la clase, que puede acceder a los elementos de la clase, es decir, métodos y variables.

Ejemplo:
CSS centrando una imagen

En el siguiente ejemplo, estamos creando una clase que contiene las variables y métodos ( agregar() y sub() ). Aquí accedemos a los métodos utilizando el objeto de la Clase. objeto .

ClassExample.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(); } } 
```
Producción:
```
 Addition of numbers is: 30 Subtraction of numbers is: 10 
```
2. Interfaz:

Un interfaz es similar a una clase, sin embargo, la única diferencia es que sus métodos son abstractos por defecto, es decir, no tienen cuerpo. Una interfaz tiene sólo las variables finales y las declaraciones de métodos. También se le llama clase completamente abstracta.
unirse a la actualización de mysql

Nota: Si la clase implementa una interfaz, debe implementar todos los métodos de esa interfaz. Si no, debemos declarar la clase como abstracta.

Ejemplo:

En el siguiente ejemplo, estamos creando la interfaz CalcInterface con dos métodos abstractos ( multiplicar() y dividir() ). Aquí, la clase InterfaceExample implementa la interfaz y define con más detalle los métodos de esa interfaz. Luego, el objeto de clase se utiliza para acceder a esos métodos.

InterfaceExample.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. Cadena:

Una cadena representa una secuencia de caracteres, por ejemplo, 'Javatpoint', 'Hola mundo', etc. String es la clase de Java.

Una de las formas de crear una cadena y almacenar un valor en ella se muestra a continuación:
```
 String str = &apos;You&apos;re the best&apos;; 
```
Aquí, variable de tipo cadena cadena tiene el valor 'Eres el mejor'. Haga clic aquí para entender más sobre Cadena en Java .

Ejemplo:
tipos de datos primitivos en java

En el siguiente ejemplo, estamos creando una cadena con un valor. Aquí, estamos usando uno de los métodos de la clase String, subcadena() que imprime la parte indexada especificada de la cadena.

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); } } 
```
Producción:
```
 Hello! This is 
```
4. Matriz:

Un formación es un tipo de datos que puede almacenar múltiples variables homogéneas, es decir, variables del mismo tipo en una secuencia. Se almacenan de forma indexada comenzando con el índice 0. Las variables pueden ser tipos de datos primitivos o no primitivos.

El siguiente ejemplo muestra cómo declarar una matriz de tipo de datos primitivo En t :
```
 int [ ] marks; 
```
El siguiente ejemplo muestra cómo declarar una matriz de tipo de datos no primitivo:
```
 Student [ ] students; 
```
dónde, Alumno es el nombre de la clase y [] crea una matriz de objetos estudiantes .
centos vs sombrero rojo

Ejemplo:

En el siguiente ejemplo, estamos creando dos matrices básicas, en las que una se inicializa y la otra se declara (la entrada se lee del usuario). Además, estamos imprimiendo esas matrices usando el bucle 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;>
```
Diferencia entre tipos de datos primitivos y no primitivos en Java
1. En Java, los tipos de datos primitivos están definidos por el sistema, sin embargo, tenemos que crear y definir los tipos de datos no primitivos.
2. En el tipo de datos primitivo, las variables solo pueden almacenar un valor a la vez. Sin embargo, en tipos de datos no primitivos, se pueden almacenar múltiples valores del mismo tipo o de tipo diferente, o ambos.
3. Todos los datos de las variables de tipo primitivo se almacenan en la pila mientras que, para los tipos de referencia, la pila contiene un puntero al objeto en el montón.
4. Un tipo primitivo comienza con una letra minúscula, mientras que los tipos no primitivos comienzan con una letra mayúscula.
5. El tamaño de un tipo primitivo depende del tipo de datos, mientras que los tipos no primitivos tienen todos el mismo tamaño.

TechCodeview

Tipos de datos no primitivos en Java

Puntos clave:

Tipos de tipos de datos no primitivos

1. Clase y objetos:

2. Interfaz:

Nota: Si la clase implementa una interfaz, debe implementar todos los métodos de esa interfaz. Si no, debemos declarar la clase como abstracta.

3. Cadena:

4. Matriz:

Diferencia entre tipos de datos primitivos y no primitivos en Java