Conceptos basicos de programacion

Para desarrollar cualquier aplicación, es necesario utilizar diferentes conceptos que se ofrecen en cualquier lenguaje y paradigma.

Operadores

En los lenguajes de programación, existen diferentes tipos de operadores que permiten realizar diferentes procesos. Estos operadores se clasifican en aritméticos, de asignación, lógicos y de comparación.

Operadores Aritméticos

Los operadores aritméticos resuelven las operaciones básicas de suma, resta, multiplicación, división y modulo, el cual entrega el residuo de la división.

Estos operadores se pueden aplicar a variables numéricas. Sin embargo, el operador suma se puede aplicar a variables que contengan cadenas de caracteres generando concatenación de la información.

Existen operadores especiales de incremento y decremento que permiten sumar y restar el valor 1 respectivamente a la variable.

Los símbolos de las operaciones aritméticas se presentan en la siguiente tabla.

Operador	Símbolo	Implementación
Suma	+	B+C
Resta	-	B-C
Multiplicación	*	B*C
División	/	B/C
Modulo	%	B%C
Incremento	++	A++
Decremento	--	A--

Operadores de Asignación

Los operadores de asignación permiten depositar un valor en una variable. En muchos casos, es necesario realizar una operación aritmética de dos variables cuyo resultado debe depositarse en una de esas variables. Para estos casos, también se puede aplicar un operador especial.

Los símbolos de los operadores de asignación se presentan en la siguiente tabla.

Operador	Símbolo	Implementación
Asignación	=	A=10
Asignación con Suma	+=	A+=B ó A=A+B
Asignación con Resta	-=	A-=B ó A=A-B
Asignación con Multiplicación	*=	A*=B ó A=A*B
Asignación con División	/=	A/=B ó A=A/B
Asignación con Modulo	%=	A%=B ó A=A%B

Operadores Lógicos

Los operadores lógicos resuelven expresiones booleanas. El resultado de estas operaciones será siempre verdadero ‘true’ o falso ‘false’. Las operaciones booleanas básicas son AND, OR y NOT.

La operación lógica NOT, se aplica siempre sobre una premisa, que en un lenguaje de programación estará descrita en una variable booleana. Esta operación consiste en cambiar el valor de la premisa de falso a verdadero y viceversa. El comportamiento de esta operación lógica se define en la siguiente tabla de verdad

Entrada	NOT
Falso	Verdadero
Verdadero	Falso

La operación lógica AND, indica que la salida será verdadera si y solo si todas sus entradas son verdaderas. El comportamiento de esta operación lógica se define en la siguiente tabla de verdad

Entrada 1	Entrada 2	AND
Falso	Falso	Falso
Falso	Verdadero	Falso
Verdadero	Falso	Falso
Verdadero	Verdadero	Verdadero

La operación lógica OR, indica que la salida será falsa si y solo si todas sus entradas son falsas. El comportamiento de esta operación lógica se define en la siguiente tabla de verdad

Entrada 1	Entrada 2	OR
Falso	Falso	Falso
Falso	Verdadero	Verdadero
Verdadero	Falso	Verdadero
Verdadero	Verdadero	Verdadero

La operación lógica XOR, indica que la salida será verdadera si el número de entradas verdaderas es impar. El comportamiento de esta operación lógica se define en la siguiente tabla de verdad

Entrada 1	Entrada 2	XOR
Falso	Falso	Falso
Falso	Verdadero	Verdadero
Verdadero	Falso	Verdadero
Verdadero	Verdadero	Falso

Los símbolos de las operaciones lógicas se presentan en la siguiente tabla.

Operador	Símbolo	Implementación	Descripción
NOT	!	!A	Negación
AND	&&	A && B	Si A es falso, no se evalúa B
OR	||	A || B	Si A es verdadero, no se evalúa B
AND	&	A & B	Si A es falso, siempre evalúa B
OR	|	A | B	Si A es verdadero, siempre evalúa B

Operadores de Comparación

Los operadores de comparación permiten la verificación de dos variables determinando si una de ellas es mayor, igual, menor o diferente de la otra. El resultado de estas operaciones será siempre verdadero ‘true’ o falso ‘false’.

Los símbolos de las operaciones de comparación se presentan en la siguiente tabla.

Operador	Símbolo	Implementación
Igual	==	A==B
Diferente	!=	A!=B
Mayor	>	A>B
Menor	<	A<B
Mayor o Igual	>=	A>=B
Menor o Igual	<=	A<=B

Operadores a nivel de bits

Los operadores a nivel de bits, permiten aplicar operaciones a los bits de los datos.

Los símbolos de los operadores a nivel de bits se presentan en la siguiente tabla.

Símbolo	Implementación	Descripción
>>	A >> B	Desplaza los bits de A a la derecha una distancia B
<<	A << B	Desplaza los bits de A a la izquierda una distancia B
&	A & B	AND a nivel de bits
|	A | B	OR a nivel de bits
^	A ^ B	XOR a nivel de bits
~	~A	Complemento a nivel de bits

Tipos Primitivos de Datos

Todo programa requiere la creación de variables las cuales permitirán el almacenamiento de información temporal en memoria dinámica. Cada una de las variables creadas, deben tener características definidas por tipos de datos para poder almacenar información. La siguiente tabla presenta los tipos primitivos de datos y sus características principales.

Tipo	Descripción	Tamaño	Posibles Valores
byte	Numero entero con signo	1 byte	-128 a 127
short	Numero entero con signo	2 bytes	-32768 a 32767
int	Numero entero con signo	4 bytes	-2.147.483.648 a 2.147.483.647
long	Numero entero con signo	8 bytes	-9.223.372.036.854.775.808 a 9.223.372.036.854.775.807
float	Numero flotante con signo, con precisión simple	4 bytes	-3.402823E38 a -1.401298E-45 y 1.401298E-45 a 3.402823E38
double	Numero flotante con signo, con precisión doble	8 bytes	-1.79769313486232E308 a -4.94065645841247E-324 y 4.94065645841247E-324 a 1.79769313486232E308
char	Carácter de código ASCII	2 bytes	Símbolos Unicode
boolean	Cantidad booleana	1 byte	True, false

Conversión de tipos primitivos de datos

La conversión entre tipos primitivos se realiza de modo automático en conversiones implícitas de un tipo a otro de más precisión, por ejemplo de int a long o float a double. Estas conversiones se hacen necesarias en el momento de involucrar variables de diferentes tipos en expresiones matemáticas. Así mismo en el momento en que se requiere ejecutar sentencias de asignación en las que el término izquierdo tiene un tipo diferente que el resultado de evaluación en el término derecho. Las siguientes sentencias ejemplifican el uso de conversión implícita.

int dato1=1000;
int dato2=10000;
long resultado;
resultado=dato1*dato2;

Nótese en el ejemplo anterior, que dato1 y dato2 son tipo int, entonces su resultado es tipo int. Sin embargo el tipo long, tiene mayor capacidad que el tipo int, entonces de forma implícita se realiza la conversión de tipo.

Las conversiones de un tipo de mayor precisión a otro de menor precisión requieren una sentencia explícita, debido a que estas conversiones pueden generar perdida de información. A estas conversiones explícitas de tipo se les llama “cast” o “casting”. El “cast” se hace colocando el tipo al que se desea transformar entre paréntesis, previo  a la expresión a la que va a realizarse la conversión. Las siguientes sentencias ejemplifican el uso de conversión implícita.

long dato1=1000;
long dato2=10000;
int resultado;
resultado=(int)(dato1*dato2);

Nótese en el ejemplo anterior, que dato1 y dato2 son tipo long, entonces su resultado es tipo long. Entonces como el tipo long, tiene mayor capacidad que el tipo int, es necesario realizar la conversión de tipo de forma explícita para que no se presenten errores en la compilación de la aplicación.

Estructuras de Programacion

Las estructuras de programación o también llamadas estructuras de control permiten implementar procesos, tomar decisiones y realizar procesos con varias repeticiones.

Sentencias

Una expresión es un conjunto de variables unidas por operadores. Equivalen a instrucciones que el computador interpreta para realizar un proceso determinado. Una sentencia es una expresión que tiene al final punto y coma (;). Es posible incluir varias sentencias en una línea, sin embargo, se considera una buena práctica utilizar una línea para cada sentencia. Las siguientes líneas son ejemplos de sentencias en un programa.

int a;
int b;
int c;
b=10;
c=20;
a=b+c;

Comentarios

Existen dos formas diferentes de introducir comentarios entre el código de la aplicación. Los comentarios son útiles para documentar el código implementado.

Los comentarios se realizan de dos formas. La primera consiste en colocar el símbolo “//” en una línea de código y en seguida el texto del comentario. La segunda consiste en incluir el símbolo “/*” al inicio del comentario y el símbolo “*/” al final del comentario. Esta segunda forma, permite hacer comentarios en varias líneas de código.

//Este es un comentario en una línea de código

/*
Este es un comentario
En diferentes líneas de código
*/

Estructura de condición if

La estructura de condición “if” se compone de una condición la cual siempre debe arrojar un valor booleano, es decir, verdadero o falso. Esta condición debe encontrarse entre paréntesis. Esta permite ejecutar un conjunto de instrucciones si se cumple la condición establecida. Este conjunto de instrucciones deben estar incluidos entre los símbolos “{” y “}”. Sin embargo, si solo se desea ejecutar una instrucción, no es necesario incluir los símbolos “{” y “}”. La sintaxis de esta sentencia es:

if(condición){
 instrucción 1;
 instrucción 2;
 ..
 instrucción n;
}

O también

if(condición)
 instrucción;

Ejemplo:

/* Imprime en consola el mensaje entre paréntesis en la instrucción System.out.println() */
if(n==5){
 System.out.println("El valor de n es cinco"); 
}

Estructura de condición if else

La estructura de condición “if” “else” se compone de una condición la cual siempre debe arrojar un valor booleano, es decir, verdadero o falso. Esta condición debe encontrarse entre paréntesis. Esta permite ejecutar un conjunto de instrucciones si se cumple la condición establecida y permite ejecutar otro conjunto de instrucciones diferentes si no se cumple la condición establecida. Este conjunto de instrucciones deben estar incluidos entre los símbolos “{” y “}”. La sintaxis de esta sentencia es:

if(condición){
instrucción 1.1;
instrucción 1.2;
..
instrucción n1;
}else{
instrucción 2.1;
instrucción 2.2;
..
instrucción n2;
}

Ejemplo:

if(n==5){
 System.out.println("El valor de n es cinco");
}else{
 System.out.println("El valor de n es diferente de cinco");
}

La estructura de condición “if” “else”, se puede implementar con una sintaxis avanzada que permite la codificación en una sola línea. Esta sintaxis se debe aplicar si y solo si se cuenta con un solo proceso en el if y el else y tienen el mismo comportamiento. La sintaxis de esta sentencia es:

(condición) ? instrucción 1 : instrucción 2;

Ejemplo:

System.out.println((n==5) ? "El valor de n es cinco" : "El valor de n es diferente de cinco");

Estructura de condición if else if

La estructura de condición “if” “else if” se compone de múltiples condiciones las cuales siempre deben arrojar un valor booleano, es decir, verdadero o falso. Estas condiciones deben encontrarse entre paréntesis. Esta permite ejecutar un conjunto de instrucciones si se cumple la condición establecida y permite ejecutar otro conjunto de instrucciones diferentes si se cumple la otra condición establecida y así sucesivamente. Este conjunto de instrucciones deben estar incluidos entre los símbolos “{” y “}”. Esta estructura permite tener opcionalmente al final una estructura else, la cual se ejecuta si ninguna de las condiciones fueron verdaderas. Si una condición es verdadera, se ejecuta las instrucciones correspondientes y no consulta las siguientes condiciones. La sintaxis de esta sentencia es:

if(condición 1){
 instrucción 1.1;
 instrucción 1.2;
..
instrucción n1;
}else if(condición 2){
instrucción 2.1;
instrucción 2.2;
..
instrucción n2;
}else if(condición 3){
 instrucción 3.1;
 instrucción 3.2;
 ..
 instrucción n3;
}

Ejemplo:

if(n==1){
 System.out.println("El valor de n es uno");
}else if(n==2){
 System.out.println("El valor de n es dos");
}else if(n==3){
 System.out.println("El valor de n es tres");
}else{
 System.out.println("El valor de n es mayor que tres");
}

Estructura de condición switch case

La estructura de condición “switch” “case” se compone de múltiples condiciones sobre una misma variable las cuales siempre deben arrojar un valor booleano, es decir, verdadero o falso. La variable sujeto de la condición debe encontrarse entre paréntesis posterior a la sentencia “swich”. Los valores de la variable deben estar posterior a la sentencia “case” seguida de “:”. Posterior a cada “case”, se implementan las instrucciones del proceso correspondiente. Al finalizar las instrucciones, se debe colocar la sentencia “break” con el fin de salir del proceso. En caso de que no se coloque la sentencia “break” en un proceso, se ejecutara el proceso del siguiente “case” hasta que se encuentre la sentencia “break”. Opcionalmente el último caso puede contener la sentencia “default”, la cual ejecutaría el correspondiente conjunto de instrucciones si ninguno de los anteriores es verdadero. Por otro lado, la variable de la sentencia “switch”, solo puede ser de tipo int o tipo char. La sintaxis de esta sentencia es:

switch(n){
 case 1:
  instrucción 1.1;
  instrucción 1.2;
 ..
instrucción n1;
  break;
case valor 2:
instrucción 2.1;
instrucción 2.2;
..
instrucción n2;
break;
 default:
instrucción 3.1;
instrucción 3.2;
..
instrucción n3;
break; 
}

Ejemplo:

switch(variable){
 case 1:
  System.out.println("El valor de n es uno");
  break;
 case 2:
  System.out.println("El valor de n es dos");
  break;
 case 3:
  System.out.println("El valor de n es tres");
  break;
 default:
  System.out.println("El valor de n es mayor que tres");
  break;
}

Estructura de repetición while

La estructura de repetición “while” define un proceso iterativo, es decir, un proceso que se repetirá mientras que una condición tenga el valor verdadero. La sintaxis de esta sentencia es:

while(condición) {
 instrucción 1;
 instrucción 2;
..
instrucción n; 
}

Ejemplo:

int i=1;
while(i<=5) {
 System.out.println(i); //imprime los números del 1 al 5. 
 i++;
}

NOTA: Es posible abortar el proceso iterativo mediante la sentencia “break”;

Ejemplo:

int i=1;
while(i>0) {
 System.out.println(i);
 if(i==10){
  break;
 } 
 i++;
}

Estructura de repetición for

La estructura de repetición “for” define un proceso iterativo. La estructura “for”, se compone de inicialización, condición e incremento. La inicialización, debe incluir al menos una variable y un valor, la condición debe involucrar la variable de la inicialización con el fin de tener un mecanismo de terminar el proceso iterativo y el incremento debe también involucrar la variable de la inicialización. En la inicialización, es posible declarar la variable correspondiente. La sintaxis de esta sentencia es:

for(inicialización; condición; incremento) {
 instrucción 1;
 instrucción 2;
..
instrucción n; 
}

Ejemplo:

for(i=1; i<=5; i++) {
 System.out.println(i); //imprime los números del 1 al 5. 
}

Ejemplo con declaración:

for(int i=1; i<=5; i++) {
 System.out.println(i); //imprime los números del 1 al 5. 
}

NOTA: Es posible abortar el proceso iterativo mediante la sentencia “break”;

Estructura de repetición do while

La estructura de repetición “do” “while” define un proceso iterativo. Contiene una diferencia con respecto a la estructura “while” que consiste en que el “do” “while” primero ejecuta y luego consulta mientras que el “while” primero consulta y luego ejecuta. La sintaxis de esta sentencia es:

do{
 instrucción 1;
 instrucción 2;
..
instrucción n; 
}while(condición);

Ejemplo:

int i=1
do {
 System.out.println(i); //imprime los números del 1 al 5. 
 i++;
}while(i<=5);

NOTA: Es posible abortar el proceso iterativo mediante la sentencia “break”;

Secuencias de Escape

Una secuencia de escape es una sentencia que sirve para representar caracteres especiales. Estos caracteres inician con el símbolo “\” lo que indica que a continuación se representa un carácter especial.

Secuencia	Descripción
\b	BackSpace
\t	Tabulación
\n	Salto de línea
\”	Comilla doble
\’	Comilla sencilla
\\	BackSlash