Identificadores

Un identificador es una secuencia de caracteres que se utiliza para nombrar clases, interfaces, métodos, variables, etc.

Reglas

• Compuesto por letras mayúsculas y minúsculas del inglés.
• Puede contener dígitos, guion bajo (_) y símbolo de dólar ($).
• No puede comenzar con un dígito.
• No puede ser una palabra reservada de Java.
• Distingue entre mayúsculas y minúsculas.
• Debe tener un nombre significativo.
• No debe contener caracteres especiales excepto _ y $.

Convenciones de nomenclatura

Paquetes (capretas para resolver conflictos de nombres de clases)

• En minúsculas: shujia
• Anidados: com.shujia.day01

Clases o interfaces

• Cada palabra inicia con mayúscula, el resto en minúscula: Student, HighStudent

Métodos y variables

• Primera palabra completamente en minúsculas, siguientes palabras con la primera letra mayúscula: eat, playGame

Constantes

• Todas las letras en mayúsculas, palabras separadas por guion bajo: NAME, FIRST_NAME

Comentarios

/*
Los comentarios explican el código.
- Línea única: //
- Bloque: /* ... */
- Documentación: /** ... */
*/

Clases

En un archivo .java puede haber varias clases. Cada clase produce un archivo .class. Solo una clase puede ser pública y debe tener el mismo nombre que el archivo.

Palabras reservadas (keywords)

Son palabras con significado especial en Java, todas en minúsculas. Los IDE como IntelliJ las resaltan con colores.

Constantes

Son valores que no cambian durante la ejecución del programa.

Tipos de constantes literales

• Enteras: Números naturales. Representaciones:
  • Binario: 0b (ej. 0b100)
  • Octal: 0 (ej. 0100)
  • Decimal: por defecto (ej. 100)
  • Hexadecimal: 0x (ej. 0x100)
• Decimales: 12.34
• Cadenas: "hola"
• Caracteres: 'a'
• Booleanos: true, false
• Nulo: null (se explica con arreglos)
• Constantes definidas por el usuario: se ven en POO.

Ejemplo:

public class ConstantesDemo {
    public static void main(String[] args) {
        System.out.println(100);
        System.out.println(0b100);   // binario
        System.out.println(0100);    // octal
        System.out.println(100);     // decimal
        System.out.println(0x100);   // hexadecimal
        System.out.println(12.34);
        System.out.println("hola");
        System.out.println('a');
        System.out.println(true);
        System.out.println(false);
    }
}

Variables

Java es fuertemente tipado: cada dato tiene un tipo fijo.

Tipos de datos primitivos

Tipos de datos de referencia

Arreglos, clases, interfaces (se ven más adelante).

Declaración de variable

tipo nombre = valor_inicial;

Reglas:

• No repetir nombres en el mismo ámbito.
• Los enteros literales son int por defecto; para long agregar L: 100000L.
• Los decimales son double por defecto; para float agregar F: 12.34F.
• Una variable debe tener un valor inicial antes de usarse.

Ejemplo:

public class VariablesDemo {
    public static void main(String[] args) {
        byte valorByte = 100;
        short valorShort = 1000;
        int valorInt = 10000;
        long valorLong = 10000000000000L;
        float valorFloat = 12.34F;
        double valorDouble = 12.34;
        char caracter = 'J';
        boolean esVerdad = true;

        System.out.println(valorByte);
        System.out.println(valorShort);
        System.out.println(valorInt);
        System.out.println(valorLong);
        System.out.println(valorFloat);
        System.out.println(valorDouble);
        System.out.println(caracter);
        System.out.println(esVerdad);
        System.out.println(false);

        // Ámbitos
        {
            int variableInterna = 200;
            System.out.println(variableInterna);
        }

        int variableExterna = 300;
        System.out.println(variableExterna);

        // Declaración sin inicialización (luego se asigna)
        int variableSinInicial;
        variableSinInicial = 100;
        System.out.println(variableSinInicial);

        // Múltiples variables del mismo tipo
        int a, b, c;
    }
}

Conversión forzada (casting)

public class CastingDemo {
    public static void main(String[] args) {
        // byte b = 140; // Error: fuera de rango
        byte b = (byte) 140;   // Resultado: -116
        System.out.println(b);
    }
}
/* 
140 en binario: 10001100
Como int: 00000000 00000000 00000000 10001100
Al truncar a byte: 10001100 (complemento a 2)
Para obtener el valor: complemento a 2 -> -116
*/

Operador + con cadenas y caracteres

public class ConcatenacionDemo {
    public static void main(String[] args) {
        System.out.println('a');                     // a
        System.out.println('a' + 1);                 // 98 (código ASCII de 'a' + 1)
        System.out.println("hola" + 'a' + 1);        // holaa1
        System.out.println('a' + 1 + "hola");        // 98hola
        System.out.println("5+5=" + 5 + 5);          // 5+5=55
        System.out.println(5 + 5 + "=5+5");          // 10=5+5
    }
}
/*
Regla: Si uno de los operandos es String, se concatena.
La evaluación es de izquierda a derecha.
Si no hay String, se realiza suma aritmética.
*/