1.

Clases e interfaces en Java

Los nombres de las clases deben ser sustantivos, en mayúsculas y minúsculas, con la primera letra
de cada palabra interna en mayúscula. El nombre de las interfaces también debe estar en
mayúscula (la primera) al igual que los nombres de las clases. Use palabras completas y debe evitar
acrónimos y abreviaturas.
× Acostumbraremos a escribir ciertas palabras en Inglés, con el fin de que usted se familiarice con
ese idioma.
Por ejemplo:
Interface Bicycle
Class MountainBike implements Bicyle

Interface Sport
Class Football implements Sport

2. Métodos en Java
Los métodos deben ser verbos, en mayúsculas y minúsculas, con la primera letra de cada palabra
interna (a partir de la segunda) en mayúscula.
Por ejemplo:
void changeGear(int newValue);
void speedUp(int increment);
void applyBrakes(int decrement);

3. Variables en Java
Los nombres de las variables deben ser cortos pero significativos.
• No debería comenzar con un guión bajo (‘_’) o caracteres, como por ejemplo, un signo de
dólar ‘$’.
• Debe ser mnemotécnico, es decir, diseñado para indicar al observador casual la intención
de su uso.
• Se deben evitar los nombres de variable de un carácter, excepto para variables
temporales.
• Los nombres comunes para las variables temporales son: i, j, k, m y n para enteros; c, d y e

para los caracteres. Por ejemplo: Object 1

// variables para la clase MountainBike
int speed = 0;
int gear = 1;

4. Variables constantes en Java

Debería estar todo en mayúsculas con palabras separadas por guiones bajos (“_”).
• Hay varias constantes utilizadas en clases predefinidas como Float, Long, String, etc.
Por ejemplo:
static final int MIN_WIDTH = 4;

// Algunas variables constantes utilizadas en la clase Float predefinida

public static final float POSITIVE_INFINITY = 1.0f / 0.0f;
public static final float NEGATIVE_INFINITY = -1.0f / 0.0f;
public static final float NaN = 0.0f / 0.0f;

5. Paquetes en Java
El prefijo de un nombre de paquete único siempre se escribe en letras ASCII en minúsculas y
debe ser uno de los nombres de dominio de nivel superior, como por ejemplo: com, edu, gov, mil,
net, org.
• Los componentes posteriores del nombre del paquete varían de acuerdo con las
convenciones internas de nombres de la organización.
Por ejemplo:
[Link]
[Link].v2

// [Link] packet in JDK

[Link]

En resumen, las convenciones de nombre anteriormente vistas para Java son importantes al
momento de empezar a programar. Es una buena práctica de cómo escribir clases, métodos,
variables, etc. tanto para el que desarrolla código como para el que lo interpreta. ¡A tenerlo en
cuenta!

Tipos de Datos Primitivos en Java

Tipo Descripción Bytes Rango Valor por
default
byte Entero muy corto 1 -128 a 127 0
short Entero corto 2 -32,768 a 32,767 0
int Entero 4 -2,147,483,648 a 0
2,147,483,647
long Entero largo 8 -9,223,372,036,854,775,808 0L
a
9,223,372,036,854,775,807
float Numero con 4 +/-1.4E-45 (+/-1.4 times 10- 0.0f
punto flotante de 45)a +/-3.4E38 (+/-3.4
precisión
times 1038
individual con
hasta 7 dÃgitos
significativos
double Numero con 8 +/-4.9E-324 (+/-4.9 times 0.0d
punto flotante de 10-324) a +/-1.7E308 (+/-1.7
precisión doble times 10308)
con hasta 16 dÃ-
gitos
significativos
char Carácter 2 \u0000 a \uFFFF ‘\
Unicode u0000’
boolean Valor Verdadero 1 true o false false
o Falso

Ejemplos
?
1 public class Example {
2
3 public static void main(String[] args) {
4 //declarar variables
5 byte mes = 12;
6 int contador = 0;
7 double pi = 3.1415926535897932384626433832795;
8 float interes = 4.25e2F;
9 char letra = 'Z';
10 boolean encontrado = true;
11
12 //imprimir valores
13 [Link](mes); //imprimirá 12
14 [Link](contador); //imprimirá 0
15 [Link](pi); //imprimirá 3.141592653589793
16 [Link](interes); //imprimirá 425.0
17 [Link](letra); //imprimirá Z
18 [Link](encontrado); //imprimirá true
19 }
20
21 }

Convenciones sobre identificadores en Java

Identificador Convención Ejemplo
Comienza por letra minúscula, y si tienen más de una
Nombre de
palabra se colocan juntas y el resto comenzando por numAlumnos, suma
variable.
mayúsculas.
 Identificador Convención Ejemplo
En letras mayúsculas, separando las palabras con el
Nombre de TAM_MAX, PI
guión bajo, por convenio el guión bajo no se utiliza
constante.
en ningún otro sitio.
Nombre de una String, MiTipo
Comienza por letra mayúscula.
clase.
Nombre de modifica_Valor,
Comienza con letra minúscula. obtiene_Valor
función.

1. Reglas para definir identificadores de Java

Existen ciertas reglas para definir un identificador java válido. Estas reglas deben seguirse, de lo
contrario obtenemos un error en tiempo de compilación. Estas reglas también son válidas para otros
lenguajes como C, C++.
• Los únicos caracteres permitidos para los identificadores son todos los caracteres
alfanuméricos (, , ), “$” (signo de dólar) y ‘_’ (guión bajo). Por ejemplo, “java@” no es un
identificador de Java válido ya que contiene “@” – carácter especial.
• Los identificadores no deben comenzar con dígitos (). Por ejemplo, “123java” no es un
identificador de Java válido.
• Los identificadores de Java distinguen entre mayúsculas y minúsculas.
• No hay límite en la longitud del identificador, pero es aconsejable usar solamente una
longitud óptima de 4 a 15 caracteres.
• Las palabras reservadas no se pueden usar como un identificador. Por ejemplo, es una
declaración inválida ya que es una palabra reservada. Hay 53 palabras reservadas en Java.

Todas las Palabras Claves Reservadas en Java:

Tabla de Palabras Claves Reservadas en Java
abstract assert boolean break byte case catch char class const continue
default do double else enum extends false final finally float for
goto if implements import instanceof int interface long native new null
package private protected public return short static strictfp String super switch
synchronized this throw throws transient true try void volatile while

open module requires transitive

exports opens to uses
provides with

2. Ejemplos de identificadores válidos

MyVariable
MYVARIABLE
myvariable
x
i
x1
i1
_myvariable
$myvariable
sum_of_array
javadesdecero

3. Ejemplos de identificadores inválidos

My Variable // Contiene un espacio
123java // Comienza con un dígito
a+c // El signo más (+) no es un carácter alfanumérico
variable-2 // El guión (-) no es un carácter alfanumérico
sum_&_difference // ampersand (&) no es un carácter válido

Operadores lógicos en Java

Operador Ejemplo en Java Significado

! !op Devuelve true si el operando es false y viceversa.
& op1 & op2 Devuelve true si op1 y op2 son true
| op1 | op2 Devuelve true si op1 u op2 son true
^ op1 ^ op2 Devuelve true si sólo uno de los operandos es true
&& op1 && op2 Igual que &, pero si op1 es false ya no se evalúa op2
|| op1 || op2 Igual que |, pero si op1 es true ya no se evalúa op2

Evaluación de operadores en Top Previous Next

múltiples
Sean Var1, Var2, Var3 tres variables de tipo múltiple, y consideremos que TRUE es el resultado de
cumplirse la condición y FALSE es el caso contrario (no cumplirse la condición).

Operador ‘=’
Evalúa todas y cada una de las menciones y comprueba que están incluidas en otra
[Link] TRUE si todas y cada una de las menciones y comprueba que están incluidas en
la otra vble. En caso contrario, es decir, si alguna de las menciones ni esta en la otra variable
devuelve FALSE.

Var2 = Var1

Var1 = (1;2;3;4;5)

Si Var2=(1;2)->TRUE
Si Var2=(6) ->FALSE

Si Var2=(5;6) >FALSE (No todas las menciones de Var2 están en Var1)

Tiene la propiedad conmutativa Var1=Var2 es equivalente a Var2=Var1. no importa la posición de la

variable respeto al operador, siempre compara la más pequeña con la más grande.

Var2 = Var1

Var1:=(1;2;3;4;5)

Si Var2=(1;2;6) ->FALSE

Si Var2=(1;2;3;4;5;6)->TRUE (El 6 no está en Var1 pero todas las menciones de Var1 sí están en
Var2)

Cuando evalúa comparará la más corta (menos menciones) con la más larga. Si se quisiera controlar
esto (posición de la variable respecto al operador) y que el caso anterior (Var2:=(1;2;3;4;5;6))
hubiera devuelto FALSE tendríamos que haber controlado número de menciones y añadir al control
una expresión del tipo (MENCIONES(Var2)<=MENCIONES(Var1)).

Operador ‘!=’
Evalúa todas y cada una de las menciones y comprueba si alguna está incluida en la otra variable.
Devuelve TRUE si alguna de las menciones de Var2 está contenida en Var1. Devuelve FALSE
únicamente su ninguna de las menciones de Var2 está contenida en Var1. Tiene la propiedad
conmutativa: Var1=Var2 es equivalente a Var2=Var1.

Var2 != Var1

Var1:= (1;2;3;4;5)

Si Var2:=(1;2)->TRUE

Si Var2:=(6) ->FALSE

Si Var2:=(5;6) ->TRUE

Ejemplos de aplicación
Por ejemplo, tenemos 3 vbles Var1, Var2 i Var3, sobre las cuales queremos aplicar los
• siguientes controles de grabación. Los valores registrados en Var2 tienen que estar grabados
en Var1. Para eso definiremos el siguiente control en la vble Var2: NO VAR2=VAR1
•Los valores grabados en Var3 han de estar registrados en Var1 pero no en Var2. Definimos el
siguiente control en Var3: NO (VAR3 = VAR1 Y NO VAR3 != VAR2). Apreciar que la
utilización del operador ‘!=’ sin el cual no seria posible la aplicación correcta del control.
En Java, las variables se pueden clasificar en:
• Variables locales.
• Parámetros.
• Variables de Instancia (Non-Static Fields o Campos No Estáticos).
• Variables de Clase (Static Fields o Campos Estáticos).
Para efectos prácticos y de aprendizaje, en este artículo solo describiré las variables locales, ya que
para las otros tipos de variables, primero se tienen que entender conceptos clave de Programación
Orientada a Objetos (POO) que abordaré en otro artículo.

Convenciones para nombrar a una variable en

Java
En todo lenguaje de programación es importante tener cierto criterio al momento de ponerle nombre
a nuestras variables. Si bien no es algo que se deba seguir al pie de la letra, es recomendable seguir
las buenas prácticas de programación que Java propone para seguir creciendo como profesionales.
Cada lenguaje de programación tiene sus propias reglas para nombrar a una variable, en Java se
pueden resumir las siguientes convenciones:
1. Comienza el nombre de tu variable siempre con una letra. Con excepción de los números
y signos de puntuación, Java permite el uso de cualquier identificador válido de letras para
comenzar a nombrar una variable. También el símbolo de pesos (o dólares, según el país) $
y el guión bajo _ se admiten como inicio de nombre de variable, pero no se recomienda su
uso. Por ejemplo, la variable edad puede ser nombrada de forma válida también como
$edad, _edad, ed4d, edad_29 pero nunca como 3dad, 10edad, 7_edad, etc. ya que
estos últimos inician con un dígito. Tip extra: ¡nunca uses acentos!
2. Los nombres de las variables distinguen entre mayúsculas y minúsculas. Una variable
llamada miCredito y otra MiCredito son distintas entre si, ya que una inicia con letra
minúscula y la otra con mayúscula.
3. Usa nombres descriptivos para nombrar tus variables. Evita en la medida de lo posible
usar abreviaturas o usar nombres poco claros para nombrar tus variables. Usar un nombre
descriptivo hace que la lectura de tu código sea más fácil de comprender. Una variable
llamada incrementoVelocidad es más sencilla de entender sobre qué tipo de dato
almacena o su función que una variable llamada iV o incr_Vel por poner un ejemplo.
4. El nombre de tu variable no debe coincidir con alguna palabra reservada. Las palabras
reservadas son aquellas que son propias de la sintaxis del lenguaje de programación que
utilices. Java tiene una serie de palabras reservadas que nunca debes usar, en el siguiente
enlace puedes encontrar la lista completa: Java Language Keywords.
5. Usa el estilo de escritura CamelCase para nombrar tus variables. El estilo de escritura
CamelCase se refiere a que, si una variable se compone de más de una palabra, la primer
letra de la siguiente palabra se debe escribir con mayúscula. En Java, si la variable se
 compone de una palabra, se recomienda escribir todas sus letras en minúscula: las variables
años, dias, mes y numero por ejemplo se escriben con todas sus letras en minúscula
porque se forman con una sola palabra. Por otro lado, las variables mayoriaDeEdad,
litrosAguaPotable, velocidadFinalAutomovilRojo y numeroDeAlumnos
comienzan con minúscula pero en la siguiente palabra inician con la primer letra en
mayúscula.
6. Si tu variable almacena un valor constante, escribe su nombre completamente en
mayúsculas. Si la variable con valor constante se compone de más de una palabra, sepáralas
con guión bajo _. Por ejemplo, si sabes que el valor de pi siempre vale 3.1416 renombra
tu variable como PI o VALOR_PI si es que se compone de más de una palabra.

[Link]
[Link]
[Link]
Usa el estilo de escritura CamelCase para nombrar tus variables. Este estilo se asemeja a las jorobas
de un camello, de ahí su nombre en inglés. Créditos de la imagen: Pexels

Concepto de declarar e inicializar una variable

Si ya iniciaste en el mundo de la programación, seguramente ya has escuchado hablar de dos
términos muy comunes, que tienen que ver con el uso de las variables: declarar e inicializar.
Declarar es identificar con un nombre y un tipo a una variable. El tipo de una variable puede
ser: entero, decimal, una cadena de texto, booleano, entre otros. Cada lenguaje de programación es
distinto y admite determinado tipo de dato en sus variables.
Puedes pensar en el tipo de una variable como una clasificación u orden de las mismas. Retomando
la analogía de la primer sección, no es lo mismo una caja con zapatos deportivos que una caja con
chocolates: el espacio en memoria es distinto (el tamaño de la caja) y el tipo de dato (zapato o
chocolate) también.
Inicializar significa asignarle un valor inicial a una variable. En otras palabras, significa darle un
valor de inicio a tus variables para comenzar a realizar operaciones con ellas.
Para imaginar esto, podemos suponer que recibes de regalo de cumpleaños una caja de chocolates,
la abres y observas que hay n cantidad de chocolates en su interior: este valor n es el valor inicial
de tu variable, el cual (muy seguramente) va a disminuir luego de que comas algunos de ellos
(operaciones).
Una variable se declara indicando su nombre y su tipo. Puedes darle un valor de inicio a una
variable inicializándola. Créditos de la imagen: Pexels

Declarar una variable en Java

Java es un lenguaje de programación estrictamente tipado lo que significa que todas las variables
deben ser primero declaradas antes de que puedan ser usadas. En este artículo no veremos
todos los tipos de dato que puedes utilizar en Java al declarar tus variables, pero puedes consultar la
documentación oficial desde el siguiente enlace:
Primitive Data Types — Java Documentation
This beginner Java tutorial describes fundamentals of programming in the Java
programming language
[Link]
Para declarar una variable, puedes seguir las siguientes normas para implementar en tu código al
programar:
A) Puedes declarar tus variables, una a una, en diferentes líneas, indicando primero su tipo y
luego su nombre, finalizando siempre la declaración con un punto y coma ;:

• Variables de tipo entero int:

Variables de tipo entero “int”
• Variables de tipo cadena de texto String:
Variables de tipo cadena de texto “String”
• Variables de tipo booleanas boolean:
Variables de tipo booleanas “boolean”
B) También puedes declarar tus variables en una sola línea, pero cada variable tiene que
pertenecer al mismo tipo de dato y separando cada variable con una coma. Cuando no existan
más variables que declarar, finaliza con un punto y coma ; :
Variables de distinto tipo declaradas en una sola línea, dependiendo su tipo

Inicializar una variable en Java

Para inicializar una variable en Java, se utiliza el signo de igual en su forma simple = para
asignarle un valor inicial. La inicialización para cada variable se realiza en una sola línea o en
varias.
A) Inicialización al declarar la variable. Sucede cuando la inicialización de la variable se realiza
en la misma línea donde se declaró la variable.
Se realiza primero la declaración de la variable, sustituyendo el punto y coma con el signo de = ,
seguido del valor que se le otorgará a la variable y finalizando, ahora si con punto y coma, la
inicialización:
Inicialización de las variables al declararlas
B) Inicialización de la variable después de declararla. En este caso, la inicialización de la
variable ocurre después de que la variable ya se declaró, es decir, ocurre en distintas líneas en el
código.
Primero se hace la declaración de la variable. Luego, en otra línea de tu código, la inicialización se
realiza únicamente escribiendo el nombre de la variable, seguido del signo igual = y el valor o dato
que almacenará. Al final se cierra la inicialización con un punto y coma ; :
Inicialización de las variables en distintas líneas de código.
Resumen gráfico: Sintaxis de una variable en
Java

Sintaxis de una variable en Java. En la imagen, la variable nombreAlumno esta siendo declarada e
inicializada en una sola línea.

Conclusión
Uno de los pilares de la programación es el uso adecuado de las variables para realizar operaciones.
Declararlas e inicializarlas correctamente, utilizando las buenas prácticas de programación
recomendadas y convenciones en Java, te ayudará a cometer menos errores y mantener un código
más limpio en tus proyectos.

public class Variables {

public static void main(String[] args) {
// DECLARA TUS VARIABLES
// Variables de tipo entero:
int a;
int edad;
int numero;
// En una sola línea:
// int a, edad, numero;
// Variables de tipo cadena de texto:
String nombre;
String unaFrase;
String domicilioCompletoEmpresa;
// En una sola línea:
// String nombre, unaFrase, domicilioCompletoEmpresa;
// Variables de tipo booleanas:
boolean valorFalso;
boolean asistencia;
boolean autoEncendido;
// En una sola línea:
// boolean valorFalso, asistencia, autoEncendido;
// INICIALIZA TUS VARIABLES
// Declara e inicializa tus variables en una sola línea:
int mayoriaEdad = 18;
String apellidoMaterno = "Selvera";
boolean interruptorLampara = false;
// Declara e inicializa tus variables en distintas líneas:
// Declaro mis variables enteras
int b, c, d;
// Inicializo mis variables b, c y d
b = 0;
c = 29;
d = 100;
// Declaro mis variables de cadena:
String calle, colonia, ciudad;
// Inicializo mis variables calle, colonia y ciudad:
calle = "Av. Principal";
colonia = "Canales";
ciudad = "Matamoros";
// Declaro mis variables booleanas:
boolean apagaMotor, enciendeTurbina;
// Inicializo mis variables apagaMotor y enciendeTurbina:
apagaMotor = false;
enciendeTurbina = true;
}
}