Estructuras fundamentales de la programación Java

Vista previa del material en texto

Ing. Marcelo Parisholon sw
Estructuras 
Fundamentales de la 
Programación JAVA
Ing. Marcelo Parisholon sw
Estructuras Fundamentales
• Programa
• Identificadores
• Tipos de Datos
• Variables
• Asignaciones e Inicializaciones
• Operadores
• Cadenas de Caracteres
• Control de Flujo de un Programa
Ing. Marcelo Parisholon sw
Programa
• Es una Clase
• Contenida en un Archivo .java
• Contiene un Método main
public class Hello {
/**
My first Java program
*/
public static void main( String[] args ){
//prints the string "Hello world" 
System.out.println("Hello world");
 }
}
Ing. Marcelo Parisholon sw
Identificadores
Un identificador es un nombre que se le asigna a 
los distintos elementos de un programa
Reglas:
• Contener digitos (0 al 9), letras ( a-z , A-Z ), 
signos _ y $
• No debe comenzar con digitos
Ing. Marcelo Parisholon sw
Palabras Reservadas
Son identificadores que tienen un 
significado especial para el compilador.
No puden ser utilizadas como identificadores 
definidos por el programador ( variables, 
etc. )
Ing. Marcelo Parisholon sw
Palabras Reservadas
Ing. Marcelo Parisholon sw
Variables
Una Variable es un identificador que referencia una posición de 
memoria.
Propiedades:
• Posición de Memoria que almacena el valor
• Tipo de Datos Almacenado
• Nombre de la posición de Memoria
Sintaxis:
<tipo de datos> <nombre1> [ ,<nombre2> …. ,<nombreN>];
Ing. Marcelo Parisholon sw
Valores Literales
Un Literal es un valor que es constante.
Existen diferentes tipos de Literales para cada tipo de dato:
• Literales Enteros
• Literales de Punto Flotante
• Literales Booleanos
• Literales de Caracteres
• Literales de Strings
Ing. Marcelo Parisholon sw
Literales de Enteros
● Literales de Enteros en diferentes formatos:
–decimal (base 10)
–hexadecimal (base 16)
–octal (base 8).
● Notación especial:
–Decimal
● No tiene notación especial
●ejemplo: 12
–Hexadecimal
●Precedido por 0x o 0X
●ejemplo: 0xC
–Octal
●Precedido por 0
●ejemplo: 014
Ing. Marcelo Parisholon sw
Literales de Números de Punto Flotante
● Representan decimales con parte fraccional
–Ejemplo: 3.1416 ( atención con el punto no coma )
● Pueden expresarse con notacion estandard o 
científica.
–Ejemplo: 583.45 (standard), 5.8345e2 (scientific)
Ing. Marcelo Parisholon sw
Literales: Boolean
• Los literales Booleanos tienen solo dos 
valores true (verdadero) o false (Falso). 
Ing. Marcelo Parisholon sw
Literales: Character
• Un literal Character representa un caracter 
Unicode simple. 
• Caracter Unicode
– es un conjunto de caracteres de 16-bits 
que reemplaza el conjunto de caracteres 
ASCII de 8-bits.
– Unicode permite la inclusión de simbolos 
y caracteres especiales para otros 
lenguajes.
Ing. Marcelo Parisholon sw
Literales: Character
• Para utilizar un litereal Character, coloque el 
caracter entre comillas simples. 
• Ejemplo
– La letra a, es representada como ‘a’. 
– Caracteres especiales como ‘newline’, se 
representa con una barra oblicua (\) 
seguida por el código de caracter. Por 
ejemplo, ‘\n’ para el caracter de nueva 
linea, ‘\r’ para el retorno de carro, ‘\b’ para 
el backspace. 
Ing. Marcelo Parisholon sw
Literales: String
• Un literal String representa multiples 
caracteres y se colocan entre comillas 
dobles. 
• Un ejemplo de un literal String es, “Hello 
World”. 
Ing. Marcelo Parisholon sw
Tipos de Datos Primitivos
• El lenguaje de programación Java define 8 
tipos de datos primitivos. 
– boolean
– char
– byte 
– short
– int 
– long
– double
– float
Ing. Marcelo Parisholon sw
T.Datos Primitivos: Logicos-boolean
• Representan 2 estados: true ( verdadero) y 
false ( Falso ).
• Ejemplo: 
boolean result = true; 
• Este ejemplo declara una variable boolean y 
le asigna un valor true (literal booleano que 
representa verdadero). 
Ing. Marcelo Parisholon sw
Tipos de Datos Primitivos: char
• El tipo de datos caracter(char), representa u simple 
caracter Unicode. 
• Debe estar encerrado entre comillas simples (’ ’). 
• Ejemplo,
‘a’ //The letter a 
‘\t’ //A tab 
• Para representar caracteres especiales como 
' (comilla simple) o " (comilla doble), se utiliza el 
caracter de escape \. Ejemplo,
 '\'' //for single quotes 
'\"' //for double quotes 
Ing. Marcelo Parisholon sw
Tipo de Dato Primitivo: Textos
• Aunque, String no es un tipo de dato primitivo (es 
una Clase), se introduce String en esta seccion. 
• Un String representa un tipo de datos que 
contiene múltiples caracteres. No es un tipo 
primitivo es una Clase. 
• Un literal String esta encerrado entre comillas 
dobles(“”). 
• Ejemplo, 
String message=“Hello world!”; 
Ing. Marcelo Parisholon sw
T.Datos Primitivos: Enteros – byte, short, int & long 
• Tiene 3 formatos: decimal, octal or hexadecimal. 
• Ejemplos, 
2 // valor decimal 2 
077 // inicia con 0 indica que es un valor 
 // Octal 
0xBACC // inicia con 0x indicando que es un 
 // valor hexadecimal
• Los numeros enteros por defecto son int. 
• Se puede definir un valor como long agregando la letra l o L 
al final del numero
• Ejemplo:
10L 
Ing. Marcelo Parisholon sw
• Rangos 
T.Datos Primitivos: Enteros – byte, short, int & long 
Ing. Marcelo Parisholon sw
T.Datos Primitivos: Punto Flotante – float and double 
• Los tipos de punto flotante tienen a double como tipo de 
dato por defecto.
• Un literal de punto flotante incluye el punto decimal o uno 
de los posfijos, 
E or e //(agrega valor exponencial) 
F or f //(float) 
D or d //(double) 
• Ejemplos, 
3.14 // un valor simple( double)
6.02E23 // A large floating-point value 
2.718F // A simple float size value 
123.4E+306D //Un valor double 
Ing. Marcelo Parisholon sw
• Rangos: 
T.Datos Primitivos: Punto Flotante – float and double 
Ing. Marcelo Parisholon sw
Variables
• Una variable es un item de datos que 
es utilizado para almacenar el estado 
de objetos. 
• Una variable tiene:
– Tipo de Dato
• Indica que tipo de valores puede almacenar.
– Nombre 
• El nombre sigue la reglas definidas para los 
identificadores. 
Ing. Marcelo Parisholon sw
Declarando e inicializando Variables
• Sintaxis:
<tipo de dato> <nombre> [=valor inicial];
• Nota: los valores entre <> son requeridos, mientras que 
aquellos entre [] son opcionales.
Ing. Marcelo Parisholon sw
Declarando e inicializando variables: Programa Ejemplo
1 public class VariableSamples { 
2 public static void main( String[] args ){ 
3 //declare a data type with variable name 
4 // result and boolean data type 
5 boolean result; 
7 //declare a data type with variable name 
8 // option and char data type 
9 char option; 
10 option = 'C'; //assign 'C' to option 
12 //declare a data type with variable name 
13 //grade, double data type and initialized 
14 //to 0.0 
15 double grade = 0.0; 
16 }
17 } 
Ing. Marcelo Parisholon sw
1. Siempre es bueno inicializar las variables cuando 
son declaradas. 
2. Utilice nombres descriptivos para sus variables. Por 
ejemplo, si tienen que definir una variable que 
contenga el grado de un estudiante, utilice ‘grado’ y 
no una secuencia de caracteres aleatorios que uds. 
elija. 
3. Declare una variable por linea.
Declarando e inicializando variables: Guias de Codificación
Ing. Marcelo Parisholon sw
Visualizar Variables
• Para visualizar un valor utilice el 
método println() del objeto out 
contenido en la clase System:
System.out.println() 
System.out.print() 
Ing. Marcelo Parisholon sw
Visualizar Variables: Programa Ejemplo
1 public class OutputVariable {
2 public static void main( String[] args ){
3 int value = 10;
4 char x;
5 x = ‘A’;
7 System.out.println( value );
8 System.out.println( “The value of x=“ + x );
9 }
10 } 
Este programa visualizara los siguientes textos en la pantalla:
10
The value of x=A 
Ing. Marcelo Parisholon swSystem.out.println() vs. System.out.print() 
• System.out.println()
– Avanza una linea luego de visualizar los 
datos de salida (ln‘line new’)
• System.out.print() 
– No avanza una linea
Ing. Marcelo Parisholon sw
• Programa 1:
Salida:
HelloWorld
• Programa 2:
Salida:
Hello
World
println() vs print() Ejemplo
System.out.print(“Hello”);
System.out.print(“World”);
System.out.println(“Hello”);
System.out.println(“World”);
Ing. Marcelo Parisholon sw
Variables Referenciales vs. Variables Primitivas
• Hay 2 tipos de variables en Java:
– Primitivas
– Referenciales
• Variables Primitivas
– variables con tipo de datos primitivos. 
– Almacenan el dato en la ubicación de 
memoria identificada por el nombre de la 
variable
Ing. Marcelo Parisholon sw
• Variables Referenciales
– variables que almacenan una direccion 
su ubicación de memoria.
– Apuntan otra ubicación de memoria 
donde se encuentra el dato.
– Cuando se declara una variable de cierta 
Clase, se esta declarando una variable 
de referencia a un objeto de dicha clase. 
Variables Referenciales vs. Variables Primitivas
Ing. Marcelo Parisholon sw
Ejemplo
• Suponga que tiene dos variables del tipo int 
y String. 
int num = 10; 
String name = "Hello" 
Ing. Marcelo Parisholon sw
Ejemplo
• La figura muestra la memoria de la computadora, 
donde se direccionan las ubicaciones de memoria, 
los nombres de variables y los datos que estas 
almacenan.
Ing. Marcelo Parisholon sw
Operadores
● Diferentes tipos de operadores:
– Aritméticos
– Relacionales
– Lógicos
– Condicionales
● La aplicación de los operadores en expresiones 
tienen una PRECEDENCIA. Esta le indica al 
compilador como evaluarla en el caso que 
existan múlltiples operadores en una sentencia.
Ing. Marcelo Parisholon sw
Operadores Aritméticos
Ing. Marcelo Parisholon sw
Operadores Aritméticos
●Nota: 
–Cuando un Entero y un Punto Flotante son utilizados como 
operadores con un operador aritmético, el resultado es un valor 
de Punto Flotante. El Entero es implicitamente convertido a 
flotante previo a efectuar la operación. 
Ing. Marcelo Parisholon sw
Operadores de Incremento/Decremento
● operador unitario de incremento (++) 
● operador unitario de decremento (--)
● operadores que incrementa o decrementan el valor 
almacenado en la variable por 1.
● Ejemplo, la expresión, 
count=count + 1;//increment the value of count by 1 
es equivalente a, 
count++;
Ing. Marcelo Parisholon sw
Operadores de Incremento/Decremento
Ing. Marcelo Parisholon sw
Pre/Pos de Incremento/Decremento
● cuando el operador es colocado antes del operando, 
esto causa que primero es aplicado el operador al valor de 
la variable y el nuevo valor resultante es utilizado en la 
expresión en la que forma parte.
 int i = 10;
 int j = 3;
 int k = 0;
 k = ++j + i; //will result to k = 4+10 = 14
● cuando el operador es colocado luego del operando, el 
viejo valor de la variable es utilizada en la expresión 
donde aparece. 
int i = 10;
int j = 3; 
int k = 0; 
k = j++ + i; //will result to k = 3+10 = 13 
Ing. Marcelo Parisholon sw
Operadores Relacionales
●Los operadores relacionales comparan dos valores y 
determinan la relación estre estos. 
●El resultado de la evaluación es un valor boolean, true o 
false. 
Ing. Marcelo Parisholon sw
Operadores Lógicos
●Los operadores Lógicos tienen uno o dos operadores 
booleanos y tiene por resultado un valor también booleano.
●Existen 6 operadores lógicos:
– && (logical AND )
–& ( boolean logical AND)
–|| (logical OR)
–| (boolean logical inclusive OR)
–^ (boolean logical exclusive OR)
–! (logical NOT)
Ing. Marcelo Parisholon sw
Op.Lógicos: &&(logical) and &(boolean logical) AND
●Tabla de Verdad:
Ing. Marcelo Parisholon sw
Op.Lógicos: &&(logical) and &(boolean logical) AND
●Diferencia básica entre los operadores && y &:
–&& soporta evaluaciones de circuito corto (or evaluación parcial), 
mientras que & no las soporta. 
●Dada una expresión:
exp1 && exp2 
–&& evaluará la expresión exp1, e inmediatamente retornará false 
si el valor de la expresión exp1 es false. 
–Si exp1 es false, el operador nunca evalua la expresion exp2 
porque el resultado del operador será false sin importar que valor 
tiene la exp2. 
●Por el contrario, el operador & siempre evalua ambas 
expresiones exp1 y exp2 antes de retornar la respuesta. 
Ing. Marcelo Parisholon sw
Op.Lógicos: || (logical) and | (boolean logical) inclusive OR 
●Tabla de Verdad 
Ing. Marcelo Parisholon sw
Op.Lógicos: || (logical) and | (boolean logical) inclusive OR 
●La diferencia básica entre los operadores || y I :
–|| soporta evaluaciones de circuito corto (o evaluacion parcial), 
mientras que | no lo soporta.
●Dada la siguiente expresión:
exp1 || exp2 
–|| evaluará la expresión exp1, e inmediatamente retornará un 
valor true si la exp1 es true
–Si exp1 es true, el operador nunca evaluará la exp2 ya que el 
resultado siempre será true independiente del valor de la exp2.
–De manera diferente, el operador | simpre evaluará ambas 
expresiones, exp1 and exp2, antes de retornar la respuesta. 
Ing. Marcelo Parisholon sw
Op.Lógicos: ^ (boolean logical exclusive OR) 
●Tabla de Verdad 
●El resultado de una operacion de OR Exclusivo es 
true si y solo si un operando es true y el otro false. 
●Note que ambos operadores deben ser evaluados 
antes de calcular el resultado del OR Exclusivo. 
Ing. Marcelo Parisholon sw
Op.Lógicos: ! ( logical NOT)
●Tabla de Verdad 
●El operador de Negación utiliza un solo argumento, 
que puede ser una expresión, una variable o una 
constante.
Ing. Marcelo Parisholon sw
Op.Lógicos: Operador Condicional (?:)
●El operador condicional ?: 
– es un operador ternario. 
●Significa que utiliza tres argumentos para conformar la expresión condicional. 
–La estructura de la expresión que utiliza el operador condicional 
es 
exp1?exp2:exp3 
donde,
exp1 – es una expresión booleana que puede tener valor true o false
–El resultado:
Si exp1 es true, exp2 es el valor resultante. 
Si es false, entonces la exp3 es el valor resultante.
Ing. Marcelo Parisholon sw
Op.Lógicos: Operador Condicional (?:)
1 public class ConditionalOperator {
2 public static void main( String[] args ){
3 String status = "";
4 int grade = 80;
5 //get status of the student
6 status = (grade >= 60)?"Passed":"Fail";
7 //print status
8 System.out.println( status );
9 }
10 } 
Ing. Marcelo Parisholon sw
Op.Lógicos: Operador Condicional (?:)
Ing. Marcelo Parisholon sw
Precedencia de Operadores
Ing. Marcelo Parisholon sw
Precedencia de Operadores
● Dada una expresión compleja, 
6%2*5+4/2+88-10 
esta puede ser reescrita colocando parentesis 
basandonos en la precedencia. 
((6%2)*5)+(4/2)+88-10; 
Ing. Marcelo Parisholon sw
Funciones/Constantes Matemáticas
● Math
● pow(x,a)
● sqrt(x)
● sin(x)
● cos(x)
● tan(x)
● atan(x)
sup_circulo = Math.PI * Math.pow(radio,2);
● exp(x)
● log(x)
● PI
● E
● round(x)
● abs(x) 
Ing. Marcelo Parisholon sw
Conversiones Tipos Numéricos
byte short
char
int long
float double
Conversión sin pérdida de información
Conversión con pérdida de información
Ing. Marcelo Parisholon sw
Conversiones en Operaciones
● Se evaluan los siguentes casos: 
●Si algún operando es double el otro operando se 
convierte a double 
● Si algún operando es float el otro operando se 
convierte en float
● Si algun operando es long el otro operando se 
convierte en long
● Si no la operación se realiza como si fueran int
operando1 operacion operando2
Ing. Marcelo Parisholon sw
Conversiones explicitas
● Son conversiones en las que puede haber pérdida de 
información
● Trunca información . No rendondea.
(<tipo_dato>)variable
 double x = 9.997;
 int nx = (int)x; 
 double x = 9.997;
 int nx = (int)Math.round(x); //round retorna long
Ing. Marcelo Parisholon sw
Cadenas de Caracteres - String
● Concatenar Cadenas : +
 mensaje + “world” // Helloworld
Si aplicamos el + de un String con cualquier tipo de 
datos el resultadoes un String que concatena la 
representación String del otro tipo de datos
 int x = 10;
 String mens2 = mensaje + n; // Hello10
● 
String variable = “”;
String mensaje = “Hello”;
Ing. Marcelo Parisholon sw
Cadenas de Caracteres - Operaciones
● Subcadenas : .substring(nDes,nHas)
String m2 = mensaje.substring(0,3);// Hell
● Longuitud: .length()
 int len = mensaje.length(); // 5
 int len2 = mensaje.substring(0,3).length()
● Un caracter: .charAt(nPos)
 char unCar = mensaje.charAt(1); // e
● Existen muchas más, revisar la documentación API
String variable = “”;
String mensaje = “Hello”;
Ing. Marcelo Parisholon sw
Cadenas de Caracteres – Comparación
● Comparación : .equals(unString)
boolean igual = mensaje.equals(“hello”);
● Comparación no case-sensitive: .equalsIgnoreCase()
 mensaje.equalsIgnoreCase(“hello”)
● Comparación Referencia : ==
 mensaje == “Hello” // false
String mensaje = “Hello”;
Ing. Marcelo Parisholon sw
Cadenas de Caracteres – Modificación
● No se modifican, son inmodificables, hay que 
reasignarlas:
 mensaje = mensaje.substring(0,3);
 
●Para modificar hay que utilizar otra Clase llamada 
StringBuffer
 
String mensaje = “Hello”;