Básicos de Introducción de Java: sintaxis básica de Java y tipos de datos compatibles con Java

Una aplicación Java puede definirse como una colección de objetos que se comunican llamando a sus respectivos métodos. Echemos un vistazo a qué clases, objetos, métodos y variables de entidad significan.

Objeto: los objetos tienen estado y comportamiento. Por ejemplo: un perro tiene su estado: color, nombre, raza y también tiene comportamiento: mover su cola, ladrar y comer. Una instancia de una clase de tiempo de objeto.
Clase: una clase se puede definir como una plantilla o plan que describe el comportamiento y el estado de los tipos respaldados por un objeto.
Método: el método es un comportamiento básico. Hay muchos métodos que pueden incluirse en la clase. En el método, se puede escribir la lógica, los datos se pueden manipular y se pueden realizar acciones.
Variables de entidad: cada objeto tiene su conjunto especial de variables de entidad, y el estado de un objeto está determinado por los valores asignados por esas variables de entidad.
El primer programa Java
Echemos un vistazo al siguiente código que puede generar "Hola mundo".

 clase pública myFirstJavaprogram { /* Este es mi primer programa Java. * Esto imprimirá 'Hello World' como la salida */ public static void main (string [] args) {System.out.println ("Hello World"); // Imprime Hello World}}

Veamos cómo guardar este archivo y compilar y ejecutar este programa. Siga estos pasos:

Abra el bloc de notas Agregue el código anterior para guardar el archivo con myfirstjavaprogram.java. Abra la ventana del símbolo del sistema para ir a la ubicación donde guardó la clase. Suponga que es c:/
Ingrese javac myfirstjavaprogram.java en la ventana y presione ENTER para compilar su código. Si su código no tiene errores, el símbolo del sistema irá a la siguiente línea (suponiendo: la variable de ruta se establece correctamente).
Ahora ingrese a Java MyFirstJavaprogram para ejecutar su programa y verá "Hello World" que se muestra en la pantalla

 C:> javac myfirstjavaprogram.javac:> java myfirstjavaprogram

 Hola Mundo

Sintaxis básica
Con respecto a los programas Java, es importante recordar algunos puntos.

Sensibilidad de casos: Java es un lenguaje sensible al caso, lo que significa que Hello y Hello representan diferentes significados en Java.
Nombramiento de la clase: la carta inicial de todas las clases debe ser capitalizada.
Si el nombre de la clase contiene varias palabras, la primera letra de cada palabra debe ser capitalizada.
Por ejemplo, clase myFirstJavaclass
Nombramiento del método: todos los nombres de métodos deben comenzar con letras minúsculas.
Si el nombre del método contiene varias palabras, la primera letra de cada palabra debe ser capitalizada.
Por ejemplo, public void mymethodName ()
Nombre del archivo del programa: el nombre del archivo del programa debe coincidir exactamente con el nombre de la clase.
Pero al guardar el archivo, debe guardarlo como nombre de clase (tenga en cuenta que es sensible a la caja) y agregar el sufijo .java después del nombre del archivo (si el nombre del archivo y el nombre de la clase no coinciden, entonces su programa no podrá ser compilado).
Por ejemplo: suponiendo que el nombre de la clase sea myfirstjavaprogram, entonces el nombre del archivo debe ser myfirstjavaprogram.java.
Public static void main (String args []): los programas Java comienzan con el método main (), que es una parte obligatoria del programa Java.
Identificadores de Java
Todos los componentes de Java deben tener sus propios nombres. Los nombres de clases, variables y métodos se denominan identificadores.

En Java, debe recordar los siguientes puntos sobre identificadores. como sigue:

Todos los identificadores deben comenzar con letras (A a Z o A a Z), caracteres de divisas ($) o subrayadores (_).
Cualquier combinación de letras se puede encontrar después del primer identificador.
Las palabras clave no se pueden usar como identificadores.
La mayoría de los identificadores deben ser sensibles a los estuches.
Ejemplos de identificadores legales: edad, $ salario, _value, __1_Value
Ejemplo de identificador ilegal: 123ABC, -Salario
Modificadores de Java
Al igual que su lenguaje, los métodos, las clases, etc. pueden modificarse por modificadores. Hay dos modificadores en Java:

Modificadores de acceso: predeterminado, público, protegido, privado
Modificadores sin acceso: Final, Abstract, StrictFP
Continuaremos aprendiendo sobre modificadores en la siguiente sección.

Palabras clave Java
Las siguientes son las palabras clave conservadas en Java. Estas palabras clave no pueden usarse como nombres para constantes, variables y otros identificadores.

Comentarios en Java
Java admite comentarios de una sola línea o múltiples como C y C ++. El compilador Java ignoran todas las cartas en los comentarios.

 clase pública myFirstJavaprogram { /* Este es mi primer programa Java. * Esto imprimirá 'Hello World' como la salida * Este es un ejemplo de comentarios de múltiples líneas. * / public static void main (string [] args) {// Este es un ejemplo de comentario de línea única /* Este también es un ejemplo de comentario de una sola línea. */ System.out.println ("Hello World"); }}

Usar líneas vacías
Una línea con solo espacios puede ser un comentario. Tal línea se llama línea en blanco, y Java la ignorará por completo.

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:

• Tipo de datos original
• 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 positivo y negativo

• El valor mínimo 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 positivo y negativo

• El valor mínimo 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 positivo y negativo

• El valor mínimo 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 entero largo es un entero binario de 64 bits con positivo y negativo

• El valor mínimo 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: Float 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: Boolean One = True

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: