Análisis exhaustivo de los tipos de datos compatibles con Java y constantes de Java y tipos variables

Tipos de datos básicos
Las variables son ubicaciones de memoria que están reservadas para los valores de almacenamiento. Esto significa que cuando crea una variable, ocupará una cierta cantidad de espacio en la memoria.

Según el tipo de datos de variables, el sistema operativo realiza la asignación de memoria y decide qué se almacenará en la memoria reservada. Por lo tanto, al asignar diferentes tipos de datos a las variables, puede almacenar enteros, decimales o letras en estas variables.

Hay dos tipos de datos eficientes en Java:

1. Tipo de datos original
2. Tipo de datos de referencia

Tipo de datos original

Java admite 8 tipos de datos primitivos. El tipo de datos original está predefinido por el lenguaje y nombra con palabras clave. Observemos más sobre estos 8 tipos de datos a continuación.

Tipo de byte (byte)

El tipo de byte es un entero binario de 8 bits con un valor mínimo positivo y negativo es -128 (-2^7)
El valor máximo es 127 (2^7-1)
El valor predeterminado es 0
Los tipos de datos de tipo de byte se utilizan principalmente para ahorrar espacio en matrices grandes, y se utilizan principalmente para reemplazar enteros. Porque el tipo de byte es 4 veces más pequeño que los enteros.
Por ejemplo:

 byte a = 100, byte b = -50

Integer bajo (corto)

El entero corto es un entero binario de 16 bits con un valor mínimo positivo y negativo es -32768 (-2^15)
El valor máximo es 32767 (2^15-1)
Los datos de tipo entero corto también se pueden usar para ahorrar espacio como los tipos de bytes. Los enteros cortos son dos veces más pequeños que los enteros. El valor predeterminado es 0.
Por ejemplo:

 corto s = 10000, corto R = -20000

Tipo int (int)

El tipo entero es un entero binario de 32 bits con un valor mínimo positivo y negativo es: 2,147,483,648 (-2^31)
El valor máximo es 2,147,483,647 (2^31 -1)
Los tipos enteros generalmente se aplican a los valores enteros de forma predeterminada a menos que esté preocupado por la memoria insuficiente.
El valor predeterminado es 0
Por ejemplo:

 int a = 100000, int b = -200000

Tipo largo (largo)

El número entero largo es un entero binario de 64 bits con un valor mínimo positivo y negativo es -9,223,372,036,854,775,808 (-2^63)
El valor máximo es 9,223,372,036,854,775,807 (2^63 -1)
Este tipo de datos generalmente se aplica cuando se requiere un rango más grande que un tipo entero.
El valor predeterminado es 0l
Por ejemplo:

 largo A = 100000L, int b = -200000L

Flotar

Los datos del punto flotante son datos de puntos flotantes estándar de 32 bits de 32 bits de 32 bits.
Los datos del punto flotante se utilizan principalmente para guardar memoria en grandes matrices digitales de punto flotante.
El valor predeterminado es 0.0f.
Los datos del punto flotante no se pueden utilizar para datos precisos como la moneda.
Por ejemplo:

 flotante F1 = 234.5f

Tipo de doble precisión (doble)

Los datos de doble precisión son un doble precisión de 64 bits IEEE 754 Datos de punto flotante estándar.
Este tipo de datos se usa principalmente de forma predeterminada para representar el valor del decimal, y generalmente es la opción predeterminada.
Los datos de doble precisión no se pueden utilizar para datos precisos como la moneda.
El valor predeterminado es 0.0d
Por ejemplo:

 Doble D1 = 123.4

Booleano

Los datos booleanos representan un bit de información.
Tiene solo dos valores posibles: verdadero (verdadero) y falso (falso)
Este tipo de datos se usa para etiquetas simples en condiciones reales o falsas.
El valor predeterminado es falso (falso)
Por ejemplo:

 booleano uno = verdadero

Tipo de personaje (char)

Los datos de caracteres son caracteres estándar Unicode de 16 bits simples.
El valor mínimo es: '/u0000' (o 0).
El valor máximo es: '/uffffff' (o 65,535).
Los datos de caracteres se pueden usar para almacenar cualquier letra.
Por ejemplo: Carta de char (letra de caracteres a) = 'a'
Tipo de datos de referencia
El tipo de datos de referencia es definido por el editor de la clase. Se utilizan para acceder a objetos. Estas variables se definen como tipos específicos que no son alterables. Por ejemplo: empleado, cachorro, etc.
Los objetos de clase y las variables de matriz son este tipo de tipo de datos de referencia.
El valor predeterminado para cualquier tipo de datos referenciado está vacío.
Se puede utilizar un tipo de datos de referencia para cualquier objeto que declare y tipos compatibles.
Por ejemplo:

 Animal animal = nuevo animal ("jirafa");

Constantes de java
Las constantes son código fuente que representan valores fijos. Están representados directamente en forma de código sin ninguna estimación.
Las constantes se pueden asignar a cualquier tipo de variable original. Por ejemplo:

 byte a = 68; char a = 'a'

Byte, entero, largo y corto también se puede representar por sistemas decimales, hexadecimales y de conteo octales.

Cuando estos sistemas técnicos representan cantidades directas, el prefijo 0 es indicar Octal, y el prefijo 0x es indicar hexadecimal. Por ejemplo:

 int decimal = 100; int octal = 0144; int hexa = 0x64;

Las disposiciones de las constantes de cadena en Java, como la mayoría de los otros idiomas, también deben escribirse en medio de las citas dobles. Los ejemplos de cantidad directa de tipo de cadena son los siguientes:

 "Hola mundo" "dos/nlines" "/" Esto está en citas/""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""

Las constantes de carácter y de cadena pueden contener cualquier letra unicode. Por ejemplo:

 char a = '/u0001'; cadena a = "/u0001";

El lenguaje Java también admite secuencias de escape especiales de personajes y cuerdas directamente. Ellos son:

Personajes de escape	significado
/norte	Break de línea (0x0a)
/R	Ingrese (0x0d)
/F	Cambio de página (0x0c)
/b	Backspace (0x08)
/s	Espacio (0x20)
/t	pestaña
/	Citas dobles
/'	Citas individuales
/	Bartosa
/DDD	Caracteres octales (DDD)
/uxxxxx	Caracteres Unicode Hexadecimal (xxxx)

Tipo de variable
Las variables pueden proporcionarnos un almacenamiento con nombre que nuestro programa puede manipular. Cada variable en Java tiene un tipo específico, que determina el tamaño de la variable y su diseño ocupa el espacio de memoria; Los valores de estas columnas se pueden almacenar en ese espacio de memoria; Las operaciones que pueden aplicarse las variables.

Antes de usarlo, ahora debe declarar la variable que desea usar. El formato básico de declarar variables es el siguiente:

Variable de tipo de datos [= valor] [, variable [= valor] ...];
El tipo de datos aquí es un tipo de datos en Java, y la variable es el nombre de una variable. Para declarar más de un tipo de variable específico, puede usar comas para separarlo.

Los siguientes son ejemplos de declaraciones variables válidas y tareas en Java:

 int a, b, c; // declara tres ints, a, b y c.int a = 10, b = 10; // Ejemplo de inicialización byte b = 22; // Inicializa una variable de tipo de byte B.Double PI = 3.14159; // declara y asigna un valor de pi.char a = 'a'; // La variable Char A IIS se inicializó con el valor 'a'

Hay tres variables en Java:

1. Variables locales
2. Variables de instancia
3. Clase, variables estáticas

Variables locales

• Las variables locales se declaran en un método, constructor o bloque
• Las variables locales se crean cuando entra un método, constructor o bloque, y una vez que salgan, serán destruidos
• Los descriptores accesibles no se pueden usar para variables locales
• Las variables locales solo son visibles en métodos, constructores o bloques declarados
• Las variables locales se implementan dentro de la profundidad de la pila
• Las variables locales no tienen valores predeterminados, por lo que las variables locales deben ser declaradas y valores asignados antes del primer uso

ejemplo

Aquí, la edad (edad) es una variable local. Esto se define bajo el método Pupage (), y su alcance se limita a este método.

 prueba de clase pública {public void pupage () {int age = 0; edad = edad + 7; System.out.println ("La edad del cachorro es:" + edad); } public static void main (string args []) {test test = new test (); test.pupage (); }}

El código anterior generará los siguientes resultados:

 La edad del cachorro es: 7

Ejemplo El siguiente ejemplo usa la edad variable local pero no se inicializa, por lo que se mostrará un error al editar.

 prueba de clase pública {public void pupage () {int Age; edad = edad + 7; System.out.println ("La edad del cachorro es:" + edad); } public static void main (string args []) {test test = new test (); test.pupage (); }}

El siguiente error se generará durante la edición:

 Test.java:4: Número variable podría no haber sido inicializado = edad + 7;^1 Error

Variables de instancia

• Una variable de instancia se declara en la clase, pero está fuera de un método, constructor o bloque.
• Cuando se asigna un objeto en el montón un espacio, se crea la ubicación de cada variable de instancia.
• La variable de instancia se crea cuando el objeto se crea con la palabra clave "nueva", y cuando el objeto se destruye, también se destruye.
• El valor de una variable de instancia debe ser referenciado por más de un método, constructor o bloque o partes importantes del estado del objeto que debe aparecer en la clase.
• Las variables de instancia se pueden declarar a nivel de clase antes o después de su uso.
• Se puede acceder a las variables de instancia con un descriptor accesible.
• Una variable de instancia es visible para todos los métodos, constructores o bloques en la clase. En términos generales, se recomienda privar estas variables (nivel de acceso). Sin embargo, la visibilidad de la subclase se puede dar a esas variables con descriptores de accesibilidad.
• Las variables de instancia tienen valores predeterminados. El valor predeterminado de un número es cero, el valor predeterminado de un tipo booleano es falso y el valor predeterminado de una referencia de objeto está vacío. Las tareas se pueden realizar en una declaración o constructor.
• Se pueden acceder a las variables de instancia directamente en la clase. Sin embargo, los nombres totalmente calificados deben usarse en métodos estáticos y diferentes clases (se puede acceder a variables de instancia). Objectreference.variablename

ejemplo

 import java.io.*; empleado de clase pública {// Esta variable de instancia es visible para cualquier clase infantil. nombre de cadena pública; // La variable salarial es visible solo en la clase de empleados. salario doble privado; // La variable de nombre se asigna en el constructor. Public Employee (String EmpName) {name = empname; } // La variable salarial se le asigna un valor. public void setsalary (doble empsal) {salario = empsal; } // Este método imprime los detalles del empleado. public void printemp () {system.out.println ("name:" + name); System.out.println ("Salario:" + salario); } public static void main (string args []) {Employee Empone = New Employee ("Ransika"); empone.setsalary (1000); empone.printemp (); }}

El código anterior generará los siguientes resultados:

 Nombre: Ransikasalario: 1000.0

Clase, variables estáticas

• Las variables de clase también se llaman variables estáticas. Se declaran en la clase con la palabra clave estática, pero son métodos, constructores o bloques externos.
• Solo hay una variable de clase en cada clase, sin importar cuántos objetos tenga esta clase.
• Además de ser declaradas como constantes, las variables de clase rara vez se usan. Las constantes son variables declaradas como públicas, privadas, finales y estáticas. El valor inicial de la variable de instancia no se cambiará.
• Las variables estáticas se almacenan en la memoria estática, y las variables estáticas rara vez se usan en lugar de declarar un fin o usar una pública o privada constante.
• Las variables estáticas comienzan y terminan con el principio y el final del programa.
• La visibilidad es similar a las variables de instancia. Sin embargo, la mayoría de las variables estáticas se declaran públicas porque deben ser utilizadas por el consumidor de la clase.
• El valor predeterminado es similar a la variable de instancia. El valor predeterminado para los números es cero, el valor predeterminado del booleano es falso y el valor predeterminado de la referencia del objeto está vacío. Las tareas se pueden realizar en una declaración o constructor. Además, los valores se pueden asignar en un área especial de inicialización estática.
• Se puede acceder a las variables estáticas con el nombre de la clase. Classname.variablename
• Cuando una variable estática se declara como una final estática pública, los nombres de las variables (constantes) deben estar en mayúsculas. Si la variable estática no es pública y final, su método de nombres es el mismo que la variable de instancia y la variable local.

ejemplo

 import java.io.*; empleado de clase pública {// La variable salarial es una variable estática privada salario doble privado estático; // El departamento es un departamento constante de cadena final pública estática = "Desarrollo"; public static void main (string args []) {salary = 1000; System.out.println (Departamento+"Salario promedio:"+salario); }}

El código anterior generará los siguientes resultados:

 Salario promedio de desarrollo: 1000

Nota: Si se accede a una variable desde fuera de la clase, se debe acceder a la constante como empleado.