Los tipos primitivos son los que permiten

manipular valores numéricos (con distintos grados de

precisión), caracteres y valores booleanos (verdadero /
falso). Los tipos primitivos están agrupados en cuatro
grupos:
1. Lógico

• boolean : Puede contener los valores true o false.

Ejemplo: boolean a = true;

boolean b = false;

2. Carácter

• char: Tipo definido para el manejo de caracteres, con

capacidad de almacenamiento de 16-bits.

Ejemplo: char c = ‘a’;

3. Integral

• byte: Enteros con capacidad de almacenamiento de 8-bits.

Rango de valores entre -128 y 127 (Esto es -27 a 27 -1).
Ejemplo: byte b = 50;

• short: Enteros con capacidad de almacenamiento de 16-bits.

Rango de valores entre -32.768 y 32.767 (Esto es -215 a
215 -1).
Ejemplo: short s = 25000;
3. Integral (cont.)

• int: Enteros con capacidad de almacenamiento de 32-bits.

Rango de valores entre -2.147.483.648 y 2.147.483.647 (Esto
es -231 a 231 -1).
Ejemplo: int i = 1000000;

• long : Enteros con capacidad de almacenamiento de 64-bits.

Rango de valores entre: 9.223.372.036.854.775.808 y
9.223.372.036.854.775.807 (Esto es -263 a 263 -1).
Ejemplo: long l = 100000000L;
Nota:
Cuando se especifica un valor literal para un tipo de datos long, se debe
colocar la letra L a la derecha del valor para especificar explícitamente
que este sea considerado como un entero largo de 64 bits. Cuando se
omite la letra L a la derecha del valor literal este será considerado por el
compilador como un entero de 32 bits (int).

Ejemplo : -2036985775L
1L
4. Punto Flotante

• float: Números en coma flotante con capacidad de

almacenamiento de 32-bits.

• double: Números en coma flotante con capacidad de

almacenamiento de 64-bits.

Nota:
Cuando se especifica un valor literal para un tipo de dato float, se debe
colocar la letra F a la derecha del valor para especificar explícitamente que
este sea considerado como un número de punto flotante de 32 bits y no un
valor de tipo double (64 bits).
Ejemplo : -2036.77F
Es considerado como un valor float.
-2036.77
Es considerado como un valor double.
Valor por defecto de los tipos primitivos

Tipo Valor Default

boolean false

byte 0

short 0

char ‘\u0000’

int 0

float 0.0f

double 0.0d

long 0L
 Antes de poder usar una variable, ésta de contener un
valor correspondiente a un tipo de dato específico. Esto
incluye un proceso de dos pasos: declarar el nombre y el
tipo de dato de la variable y asignarle valor.

 El proceso de asignar un valor inicial a una variable (que

pueda ser cambiado más adelante) se llama inicialización.
1. Declaración de la variable, esto es darle nombre y
tipo.
Sintaxis:
[modificador] tipo identificador [ , identificador];

Nota:

•Los corchetes indican que el ítem que contiene es opcional.

Reconocimiento de asignaciones e identificadores no
permitidos.

Escribir código para declarar, asignar valores a

variables de tipo primitivo y utilizar constantes en un
programa.
Ejemplo:
byte contador;
private int codigo, otroCodigo;
float costoInscripcion;
char sexo;

Nota:

• Si se declara una variable dentro de un método, ésta se

debe inicializar antes de usarla, pero si es declarada fuera
del método, un valor inicial por defecto será asignado a la
misma, en caso de no haberla inicializado.
2. Asignación del valor a la variable, de acuerdo al tipo con
el que fue definida.

Para hacer la asignación de un valor a una variable se utiliza el

operador igual (=).

Sintaxis:
Identificador = valor;

Ejemplo:
contador = 1;
codigo = 5698712;
costoInscripcion = 45694756.50F;
sexo = 'F';
• Es posible declarar y asignar valores a una variable
en la misma línea.

Ejemplo:
byte contador = 1;
int codigo = 5698712;
float costoInscripcion = 45694756.50F
char sexo = 'F’, otroValorChar = ’M’;
Un literal es un valor especificado en el programa fuente a
diferencia de aquéllos que son obtenidos en tiempo de
ejecución. Un literal puede aparecer solamente en el lado
derecho del operador de asignación.

Ejemplo:

boolean aprobado = true;

boolean esNumeroPrimo = false;

Los tipos de literales se corresponden con los tipos

de datos primitivos y con el tipo de datos String.
Literales Caracter:
Un literal carácter es expresado mediante la especificación
del carácter entre comillas sencillas (' ').

Ejemplo:

char letraA = ‘A’;

También se pueden expresar mediante la especificación en

Unicode, esto es, la secuencia \u seguida de 4 números
hexadecimales.

Ejemplo:

char letraUnicode = ‘\u4b67’;

Literales char

Los caracteres especiales (de control y no imprimibles) se

representan con una barra invertida ('\') seguida del código
carácter.
 \n: Usado para denotar una nueva línea.
 \r: Usado para denotar un retorno de carro.
 \t: Usado para denotar un tab.
 \b: Usado para denotar un espacio en blanco.
 \f: Usado para denotar alimentación de formularios.
 \': Usado para denotar comilla simple.
 \\: Usado para denotar un backslash.
Literales Integrales:

 Los literales enteros son expresados en decimal,

hexadecimal u octal.

 Para expresar un literal octal es necesario el prefijo 0.

 Para expresar un literal hexadecimal se requiere el

prefijo 0x ó 0 X .
Literales Integrales:

Ejemplo:
int nOctal = 0640;
int hDecimal = 0x5B;
int a = 0x1519;
long b = 98L;
int c = 45;
Literales Integrales:

Nota
Cuando se especifica un valor literal para un tipo
de datos long, se debe colocar la letra L a la
derecha del valor para especificar explícitamente
que este sea considerado como un entero largo de
64 bits. Cuando se omite la letra L a la derecha
del valor literal este será considerado por el
compilador como un entero de 32 bits (int).
Ejemplo : -2036985775L
1L
 Literales de Punto Flotante:

Un valor literal flotante se corresponde con alguno de los

siguientes tipos:

1. Con punto decimal, double PI = 3.1416;

2. Notación científica, float f = 4.53e+21;

3. Con el sufijo f, float real = 15.1364f;

4. Con el sufijo d, double d = 16.98d;

Literales de Punto Flotante:

Nota
Cuando se especifica un valor literal para un tipo de datos
float, se debe colocar la letra F ó f a la derecha del valor
para especificar explícitamente que este sea considerado
como un número de punto flotante de 32 bits y no un valor
de tipo double (64 bits). Los valores literales para los tipos
de punto flotante son asumidos por el compilador como tipo
double a menos que se especifique lo contrario usando la
letra F ó f como se indicó anteriormente.
Ejemplo : -2036.77F Es considerado como un valor float.
-2036.77 Es considerado como un valor double.
Literales String:

Los literales String (cadena) son secuencias de caracteres

encerrados entre comillas dobles (“ ").

Ejemplo:

String s = “Hola mundo!!”;

String cadena = “Lenguaje Java de ” + “programación”;

 Deben ser simples pero descriptivos.

 Deben comenzar con una letra, carácter de subrayado (_) o

el signo de dólar ($) y a partir de la segunda letra se pueden
incorporar números. Si se utilizan dos o más palabras en un
identificador se sugiere que el comienzo de cada palabra se
haga con una letra mayúscula.

 Son case-sensitive y no tienen una longitud máxima.

 No pueden ser una palabra reservada de la tecnología Java.

 No puede incluir el caracter espacio en blanco.

 No se pueden utilizar acentos.

Ejemplos:

int entero; // Identificador válido.

char _caracter; // Identificador válido.

float $dinero; // Identificador válido.

int 2_nodo3; // Identificador no válido.

boolean case; // Identificador no válido

String !direccion // Identificador no válido.

String Mi credencial // Identificador no válido.

 Las palabras reservadas son identificadores especiales que
el lenguaje Java se ha reservado para controlar su
estructura y definición interna.

abstract boolean break byte case

catch char class const continue
default do double else extends
false final finally float for
goto if implements import instanceof
int interface long native new
null package private protected public
return short static super strictpf
switch synchronized this throw throws
transient true try void volatile
while
De acuerdo con el tipo de información que contienen, en Java
hay dos tipos principales:

1. Variables de tipos primitivos.

2. Variables referencia.

Desde el punto de vista de su papel en el programa, las

variables pueden ser:

1. Variables miembro de una clase.

2. Variables locales.
 A una variable se le puede asignar valores literales.

Ejemplo:

byte contador = 1;

short litrosVendidos = 5698743;

int identificador = 98712;

float costoInscripcion = 75694756.50; // Error

 A una variable se le puede asignar el valor de otra variable de
tipo de dato primitivo, siempre que sean compatibles en tipo.

Ejemplo:
int identificador = 98712;
int identificador2 = identificador;
 A una variable se le puede asignar el resultado de
expresiones aplicadas sobre variables de tipo boolean,
integrales y punto flotante.

Ejemplo:

short operando1 = 589456;

short operando2 = 5698741;

int resultado = (operando1 * operando2);

 A una variable se le puede asignar el resultado de la
llamada a un método.

Ejemplo:

boolean estaInscrito;

estaInscrito = validarInsEstudiante(12.698.366);

 A una variable se le puede asignar la dirección de un

objeto en memoria.
Desde el punto de vista de alcance, las variables pueden
clasificadas en tres categorías:

 Variables locales: todas las variables declaradas de

dentro de un método. Su alcance es el método. En otras
palabras ellas pueden ser accedidas únicamente dentro
del método en que fueron declaradas y son destruidas
cuando el método termina su ejecución.
 Variables de instancia: todas las variables declaradas
dentro de una clase pero fuera de cualquier método. Su
alcance es la instancia de la clase en la cual fueron
declaradas.

 Variables estáticas: variables declaradas con el

modificador static. Su alcance es la clase en la cual son
declaradas.
 Son utilizadas para representar valores que no cambian a
lo largo de la ejecución de un programa.

 Para informar al compilador que el valor que se define es

constante, se utiliza la palabra reservada final.

Sintaxis:

final [modificador] tipo identificador = valor ;

Ejemplo:

final double TASA_PORCENTUAL = 14.5;

// En otro punto del Programa:

double precioTotal;

precioTotal = precioArticulo * TASA_PORCENTUAL;

TASA_PORCENTUAL = 15.5; // Error

Nota
 Por convención se acostumbra colocar el
identificador de las constantes en mayúsculas
y utilizar caracteres de subrayado (_) para
separar las palabras que la conforman.
Clases:

 Los nombres de clases deben ser nombres o sustantivos,

con mayúsculas y minúsculas, siempre con la primera letra
de cada palabra en mayúscula.

Ejemplo: class CuentaDeAhorros

 Si el nombre tiene varias palabras ponerlas todas juntas

(sin separar con - o _ ) y poner la primera letra de cada
palabra en mayúsculas.

Ejemplo: class InstrumentoMusical

Métodos:

Los nombres de los métodos, con mayúsculas y

minúsculas, con la primera letra en minúscula, y cada
palabra posterior inicia con mayúsculas.

Evitar el uso de _

Ejemplo:

calcularBalance()
 Variables:

Los nombres de las variables, con mayúsculas y minúsculas,

con la primera letra en minúscula, y cada palabra posterior
inicia con mayúsculas. Evitar el uso _ y $.

Ejemplo: clienteActual

Constantes:

Para las constantes usar nombres en mayúsculas,

separando las palabras con caracter de subrayado ( _ ).

Ejemplo: MAXIMA_LONGITUD
Paquetes:

Los nombres de paquetes deben ser nombres o sustantivos en

minúsculas.

Ejemplo: package embarque.objetos;

Interfaces:

Los nombres deben comenzar con mayúscula, como los

nombres de clase.

Ejemplo: interface Cuenta