Story Transcript
Texto de Introducción a la Programación MSc. Lic. Carla Salazar Serrudo Lic. Victor Hugo Montaño Carrera de Informática y Sistemas UMSS - 2003 1
Índice
Bibliografía Introducción Algoritmos Tipos de datos y operadores Control de flujo Programación orientada a objetos (POO) Arreglos y Cadenas Características avanzadas de POO 2
Bibliografía • Manual de referencia, Mc Graw Hill Editores. Naughton, Patrick ; Schildt, Herbert (1997) • Clase LeerTeclado, Univ. Raúl Fernández • http://java.sun.com/docs/books/tutorial/index.html • Como programar en Java, Prentice-Hall Hispanoamericana, S.A., Deitel y Deitel (1998)
3
Introducción
Uso de la computadora para resolver problemas más o menos complejos. La computadora realiza operaciones tales como: aritméticas, comparaciones, almacenamiento, transferencia de datos, etc. Dichas operaciones se realizan por medio de instrucciones o comandos. 4
Instrucción
Una instrucción es una sentencia u orden Las instrucciones pueden ser:
de entrada de datos (y recuperación) operaciones sobre los datos (manipulación) de salida (presentación) de resultados y almacenamiento
5
Programa
Un programa es una lista de instrucciones. Un programa es una descripción de pasos a dar para resolver un problema. El programa (software) dirige el funcionamiento del ordenador (hardware).
6
Los algoritmos
Descripción exacta no ambigua de la secuencia de pasos a aplicar para encontrar una solución a un problema a partir de unos datos. Método de resolución general de un problema. Ej.: receta de cocina (freír papas) 7
Los algoritmos (2)
Para programar hay que analizar el problema y diseñar una estrategia de resolución. Hay que contemplar todas las alternativas lógicas posibles (no dejar cabos sueltos). Problema Æ Algoritmo Æ Programa 8
Los algoritmos (3)
Un programa es la codificación de un algoritmo en un lenguaje de programación concreto. Características:
completo robusto eficiente consistente 9
Descripción de algoritmos
Pseudocódigo
descripción verbal en lenguaje “casi natural”.
Diagramas de flujo
descripción gráfica cada símbolo representa una acción (entradas, salidas, procesos, comparaciones...) todos los símbolos tienen una flecha de entrada y otra de salida (al menos), salvo los símbolos inicial y final. 10
Ejemplo pseudocódigo
Ejemplo: sumar dos números programa Suma leer(n1) leer(n2) suma = n1 + n2 escribir(“suma es ”, suma) fin 11
Diagramas de flujo Inicio
n1, n2
suma = n1 + n2
Cálculo
suma
Entrada Salida (pantalla) Fin
12
Estructuras básicas ASIGNACION longitud = 2 * 3.14 * radio x=x+1
ENTRADA/SALIDA leer(edad) imprimir(valor)
CONDICION si (edad < 18) entonces imprimir(“No puedes votar”) si no voto = leer(“Elija su voto”) fin si 13
Estructuras básicas (2) ITERACION mientras (num != 8) hacer num = leer(“Otra vez. Número:”) fin mientras para i=1 hasta 10 paso 1 hacer imprimir(3 “x” i “=” 3*i) fin para repetir x=x+2 hasta que (x > 50) 14
Refinamiento
Refinamiento por pasos sucesivos (top-down)
Descomposición de un problema en subproblemas en etapas sucesivas. Atención al principio a los aspectos globales del sistema. Al avanzar el diseño, descomposición en subsistemas (detalles). 15
Refinamiento (2)
Composición hacia arriba (bottom-up)
Identificar conjunto primitivo de objetos, acciones y relaciones que proporcionarán una base para la solución Conceptos de alto nivel expresados en términos del conjunto de primitivos (combinaciones). Necesidad de un conjunto completo de primitivas 16
Ejemplo de refinamiento
Problema: Dibujar la función Y = X3+2x-3 Top-Down
Etapa 1.
1. Calcular puntos 2. Dibujarlos
Modularidad
17
Programando con Java MSc. Lic. Carla Salazar Serrudo Lic. Victor Hugo Montaño Carrera de Informática y Sistemas UMSS - 2003 18
Características de Java
Orientado al objeto (tendencia en boga) Simple (similar a C, sin complejidades) Multiplataforma (Windows, PowerMac, Unix) Robusto (hace chequeos, elimina punteros) Recolección de basura automática Bibliotecas estándares Realmente portable en un 100% Facilidades para programación en redes 19
Compilador e intérprete de Java
P1.java
P1.class
Salida del Prog.
Compilador de Java (específico x plataforma) javac P1.java Intérprete de Java (específico x plataforma) java P1 (class) 20
Compilador e intérprete
El compilador analiza la sintaxis del código fuente (con extensión .java). Si no hay errores, genera bytecodes
> javac P1.java
El intérprete es la Máquina Virtual Java que ejecuta los bytecodes (con extensión .class) creados por el compilador
> java P1 21
Un primer programa en Java public class Ejemplo { public static void main(String args[ ]) { System.out.println(“Introducción a la Programación con Java”); } }
22
Un primer programa en Java (2)
Todo programa se escribe en el método estático llamado main en una clase cualquiera Este método se empieza a ejecutar cuando se invoca el intérprete de Java para una clase dada args es un arreglo de Strings que contiene los parámetros con los que fue invocado el programa 23
Variables de entorno
Es necesario incluir las siguientes líneas al final del autoexec.bat Para tener accesibles el compilador y el intérprete Java:
Set PATH= %PATH%; C:\jdk1.4\bin (el directorio depende de dónde se haya instalado jdk) 24
Variables de entorno (2)
Para acceder a las clases desarrolladas por uno mismo:
Set CLASSPATH= .;%CLASSPATH% (incluye el directorio donde uno se encuentra)
25
Estructura de un programa // Este es el esqueleto de un programa en Java class { /* Definiciones globales*/
Se utiliza para abrir un bloque de instrucciones.
/* Metodo Principal*/ /* Otros Métodos*/
}
Se utiliza para cerrar un bloque de instrucciones
26
Comentarios Si sólo quiero comentario de una línea coloco
// al inicio de esta
// Este es el esqueleto de un programa en Java class { /* Definiciones globales*/
Si quiero comentario de más de una línea coloco /* al inicio del comentario y */ al final
/* Este es el Método Principal*/ /* Otros Métodos*/ } 27
Variables y métodos class {
Deben seguir las convenciones utilizadas en algoritmo.
/* Definiciones globales*/
/* Método Principal*/
/* Otros Métodos*/ }
Aquí se definen las variables que yo deseo que se puedan utilizar en todo mi programa. Cada aplicación de Java debe tener un método principal llamado main, que define donde comienza el flujo del programa.
28
Sintaxis del método main // Este es el esqueleto de un programa en Java class { /* Definiciones globales*/ public static void main (String args[]) { /* Definiciones locales*/ ... ... /* cuerpo de instrucciones */ ... ... }
Todo el código de un método estará entre la llave de apertura ( { ) y la correspondiente llave de cierre ( } ).
} 29
Sintaxis del método main // Este es el esqueleto de un programa en Java class { /* Definiciones globales*/
La palabra public es un especificador de acceso. En este caso el main debe ser declarado public ya que es llamado por código que está fuera de su clase, cuando el programa comienza.
public static void main (String args[]) {
}
}
/* Definiciones locales*/ ... ... /* cuerpo de instrucciones */ ... ...
La palabra static permite que main sea llamado por el intérprete de Java antes de que se cree cualquier objeto . La palabra void indica al compilador que main no devuelve ningún valor.
String args[], declara una variable args que es una especie de vector que puede contener cadenas de caracteres.
30
Sintaxis del método main // Este es el esqueleto de un programa en Java class { /* Definiciones globales*/ public static void main (String args[]) {
}
}
Aquí se definen las variables que solo voy a utilizar en el método principal.
/* Definiciones locales*/ ... ... /* cuerpo de instrucciones */ Después de cada instrucción se coloca ; ... ... 31
Identificadores
Nombran variables, funciones, clases y objetos Comienza con una letra, un subrayado (_) o un símbolo de dólar ($). Los siguientes caracteres pueden ser letras o dígitos No se permiten vocales acentuadas ni ñ Se distinguen las mayúsculas de las minúsculas 32
Identificadores (2)
No tienen longitud máxima La forma básica de una declaración de variable, por ejemplo, sería:
tipo identificador [ = valor] [,identificador [= valor] ...];
Ejemplo de constante:
final float PI = 3.14159; 33
Identificadores (3) No existen reglas, pero es conveniente seguir unas normas para que el código sea más legible: nombre de CLASE empieza por Mayúsculas nombre de MÉTODOS y ATRIBUTOS por minúsculas las CONSTANTES con mayúsculas completamente cuando empieza una nueva palabra la ponemos en mayúsculas ej: dibujarRectangulo 34
Variables y constantes
Variables: zona de memoria cuyos valores van a cambiar durante la ejecución
Ej: int x, y, z;
Constantes: zona de memoria cuyos valores no cambian
Ej: final double PI = 3.14159265; 35
Tipos de datos
En Java existen dos tipos de datos:
Los tipos primitivos son:
Tipos primitivos Tipos referencia Lógico (boolean), texto (char), entero (byte, short, int, long) y real (float, double)
Los tipos referencia son punteros a objetos 36
Tipos primitivos de datos
El tipo de un objeto determina cuánto espacio ocupa en memoria y cómo puede ser usado Los tipos de datos primitivos en Java son:
byte, short, int, long float, double char boolean
enteros números punto flotante caracter valores lógicos 37
Enteros
Los tipos de datos enteros pueden ser: byte, short, int y long Todos los tipos tienen signo. El cero se considera positivo. Los enteros se representan así:
Decimal: 2, 156, 564545 Octal: 077, 077700 (empiezan con cero) Hexadecimal: 0xABFF, 0xCC00 (empiezan con 0x) Long: 156L 38
Punto flotante
Existen dos tipos de datos reales: float (32 bits) y double (64 bits) Un número es de punto flotante si lleva:
Un punto decimal: 3.14159, 2.0 Una E o e (valor exponencial): 105e25, 1.05E27 Una F o f (float): 279F, 2.79f Una D o d (double): 279D, 2.79d 39
Caracteres y valores lógicos
El tipo de datos boolean (8 bits) puede tomar dos valores posibles: true y false. El tipo boolean no toma valores numéricos El tipo char (16 bits) representa sólo un carácter Unicode (caracteres gráficos de todos los idiomas).
Caracteres simples: ‘a’ Caracteres especiales: ‘\t’, `\n` Caracteres Unicode: `\u00BF` 40
Tipos de datos primitivos Tipo
Valor por defecto (atributos de la clase )
boolean char byte short int long
false ‘\u0000’ (null) (byte) 0 (short) 0 0 0L
float
0.0f
double
0.0d
Valores true o false ‘\u0000’ a ‘\uFFFF’ -128 a +127 -32,768 a +32,767 -2,147,483,648 a +2,147,483,647 -9,223,372,036,854,775,808 a +9,223,372,036,854,775,807 -3.40292347E+38 a +3.40292347E+38 -1.79769313486231570E+308 a +1.79769313486231570E+308 41
Declaraciones de variables int i, k; int j = 1, x; double pi = 3.14159; char c = ‘a’; boolean somosFelices = true; Las declaraciones de variables pueden ir en cualquier parte del programa, pero siempre antes de que la variable sea usada. 42
Declaración de variables /* Este programa declara algunas variables */ class declaraVar { public static void main (String args[]) { int x, y; float z = 3.1416; double w =8.4445; boolean bandera = true; char c; String st1 =“María”; } } 43
Asignación de valores a variables • Se puede dar valores a las variables en el momento de su declaración • O en una instrucción de asignación independiente una vez que ha sido declarada •Se utiliza el signo = en ambos casos. Ej: int x =5; boolean t; t = true; 44
Asignación de valores a variables Las asignaciones también pueden ser expresiones en notación INFIJA Ejemplo: monto = pvp * cantidad ; Donde pvp y cantidad deberán ser variables anteriormente declaradas y con valor previo asignado 45
Asignación de valores a variables (2) /* Este programa asigna valores a variables */ class AsignaValorVar { public static void main (String args[]) { int x, y, z; x = 2; y = 4; z = x * y; System.out.println(“El valor de z es “ + z); } } 46
Asignación de valores a variables (3) Algunas de las operaciones a utilizar en la asignación: () * / +,-
indica prioridad de ejecución multiplicación división decimal suma, resta
Ejemplo: impuesto = ( (pvp * cantidad) * porc) ) / 100; 47
Expresiones y asignación
Aritméticas:
Relacionales:
a > b, b >= c, c != 4, a == 0
Cadenas:
suma + 20 * c / (mod % 3)
“hola “+ nombre + “ hoy es “+ dia + “de”+mes
Casts:
(int) pi, (pi = 3.1), (int) (Math.random()*100)+1) 48
Expresiones y asignación (2)
Asignación:
Asignación como operador:
a = 1; a = b = c = d = 0; boolean cero = ( b = c - 10) == 0;
Otros:
a == 1 ? a+1 : a-1 49
Operadores Operadores
Asociatividad
Tipo
()
izquierda a derecha
paréntesis
++ -- + - !
derecha a izquierda
unarios
* / %
izquierda a derecha
multiplicativos
+ < >=
izquierda a derecha izquierda a derecha
aditivos relacionales
== !=
izquierda a derecha
de igualdad
&& ||
izquierda a derecha izquierda a derecha
AND lógico OR lógico
= += -= *= /= %=
derecha a izquierda
asignación ej. x += y Ù x = x + y;
50
Conversiones de tipo
Java no reclama si un tipo de menor rango se convierte a uno de mayor rango. byte < short < int < long < float < double
Ejemplo: int i = 1; long l = i; //ok 51
Ejemplos
l = 1000000000000; float f = l; //ok double d= 1.0e24; int i = d; // Error float f = 1.0f; int i = f; // Error short s = i; //Error 52
Ejemplos (2)
double d = 1.0; int i = (int)d; int i = 256; byte b = (byte)i;
//ok /*ok pero b ==0 */ 53
Salida de datos Para mostrar un texto por pantalla se usan las siguientes instrucciones:
• System.out.println (texto); • System.out.print (texto);
La primera imprime “texto” en la pantalla y deja el cursor en la siguiente línea La segunda imprime “texto” en la pantalla y deja el cursor inmediatamente después de texto.
54
Lectura de datos
Para obtener los valores de las variables desde teclado, usamos el programa creado llamado LeerTeclado: Variable = LeerTeclado.readTipode variable(); Ejemplos: Numero1 = LeerTeclado.readInt(); Numero2 = LeerTeclado.readDouble(); Nombre = CTeclado.readLine(); EstadoCivil = LeerTeclado.readChar(); 55
Ejemplo de programa // Programa que lee dos números y los suma import LeerTeclado; class Sumar { public static void main (String args[]){ int v1,v2; System.out.println("Introduzca v1"); v1 = LeerTeclado.readInt(); System.out.println("Introduzca v2"); v2 = LeerTeclado.readInt(); System.out.println("La suma es "+ (v1+v2)); } } 56
Programación estructurada
Simplifica la estructura de un programa Reduce las opciones y facilita la legibilidad de los programas Estructuras tienen: Un punto de entrada y ? Un punto de salida Permite estructuras anidadas Focaliza la atención en un punto cada vez
57
Agrupación de sentencias
Donde se puede escribir una sentencia, se puede escribir un grupo de sentencias agrupadas dentro de llaves
sentencia
//simple
{sentencia; sentencia; …; sentencia;}
//compuesta 58
; es un terminador
Toda sentencia en Java debe terminar con un ; Existe la sentencia vacía, por lo cual podemos poner varios ; seguidos ;;;;; Algunas estructuras como switch no van seguidas de ;
59
Programación estructurada
Estructura secuencial
Estructuras condicionales
acción1; acción2; acción3; if (condición) acción1 [else acción2] switch (selector) {case valor1; acción1; case valor2; acción2; … ; case valorn: acciónN}
Estructuras repetitivas
while (condición) acción; do {acción} while condición; for (inicialización; condición; actualización) acción; 60
Estructura condicional condición False acción2
True
if (condición) { acción1; }else { acción2; }
acción1
61
Estructuras condicionales
De acuerdo al resultado de la evaluación de una condición se realiza una acción u otra Sintaxis: if (condición) acción; if (condición) {acción1; acción 2;…;acciónN} if (condición) acción1 else acción2; if (condición) {acción1; …;acciónN} else{acción1; ..;acciónN} 62
Ejemplo de condicional … if(calif >= 70) System.out.println(“Aprobado”); else { System.out.println(“Reprobado”); System.out.println(“Cursar de nuevo materia”); } … 63
Raíces ecuación segundo grado class Raices2g { ... D=(b*b) - (4*a*c); if (D>=0) { // raices reales x1=((-b)+Math.sqrt(D))/2*a; x2=((-b)-Math.sqrt(D))/2*a; System.out.println("x1= "+x1); System.out.println("x2= "+x2);} else {//soluciones imaginarias r = -b/(2*a); i = (Math.sqrt(-D)/2*a); System.out.println("x1= "+r+" + "+i+"i"); System.out.println("x2= "+r+" - "+i+"i");} ...
64
Condiciones anidadas if (calif>=90) System.out.println(“A”) else if (calif>=80) System.out.println(“B”) else if (calif >= 70) System.out.println(“C”)…
65
Ejemplo condicionales anidados { int mes; if (mes==1) System.out println (“Enero”); else if (mes == 2) System.out.println (“ Febrero”); ... else if (mes == 12) System.out.println (“Diciembre”) else System.out.println (“ Error”); ... } 66
Condicionales anidados
Muchos if anidados dificultan la comprensión del programa Problemas de ambigüedad en el anidamiento de ifs: if (C1) if (C1) if (C2) acción1 if ( C2) acción1 else acción2 else acción2
67
Condicionales anidados
El compilador de Java siempre asocia un else con el if más cercano: if (condición1) acción; if (condición2) acción2; else acción 3; Para cambiar esta regla debemos usar llaves if (condición1) {acción1; if(condicion2) accion2; } else acción3; 68
Sentencia switch
Caso general de if switch (selector) { case valor1: acción1; case valor2: acción2; …; case valorn: acciónN; [default : acciónM] } 69
Sentencia switch int llave; ...... switch (llave) { case 3 : ...... break; case 2: ...... break; ...... case : ....... break; default:...... break; }...
llave puede ser de tipo byte, char, short, int, long Ejecuta a partir del case que cumpla. llave == valor Hay que insertar break para no ejecutar los siguientes casos El default es opcional 70
Sentencia switch: case
El selector debe ser un valor constante case 2 case 1+1 case uno + 1 // uno constante entera que vale 1 Se pueden poner varios cases juntos: case ‘d’: case ‘D’ se ejecutan las sentencias asociadas si la expresión de control coincide con alguna de los valores del case 71
Sentencia switch: case (2)
El último case no necesita break, pero se suele poner por simetría y claridad Si se escribe más de una sentencia, no se necesitan escribirlas entre llaves ({}) Si escribimos dos case con el mismo valor de selector, se produce un error en tiempo de compilación
72
Calculadora //Calculadora import LeerTeclado.*; class Calculadora { public static void main (String args[]) { char operador; int n1,n2, resultado; n1= LeerTeclado.readInt(); operador= LeerTeclado.readChar(); n2= LeerTeclado.readInt(); ... 73
Calculadora (2) switch (operador) { case ‘+’: resultado= n1 + n2; break; case ‘-’: resultado= n1- n2; break; case’/’: resultado= n1/n2; break; default: resultado=0; } System.out.println (“->” + resultado); } } 74
Estructuras repetitivas
Permiten la ejecución repetida de un grupo de sentencias Pueden ser:
while (condición) acción; do acción while (condición); for (inicialización; condición; actualización)
75
Estructura while
condición False
True
acción
while (condición) { acción; }
76
Ejemplo while public class MCD { //calculo del maximo comun divisor entre 15 y 24 public static void main(String args[ ]) { int x = 15, y = 24; while (x != y) { if (x < y) y = y - x; else x = x - y; } System.out.println(“el MCD entre 15 y 24 es “ + x); } } 77
Estructura do-while True acción
do { acción; } while (condición);
condición False 78
Ej: constante de Euler // Constante de Euler class Euler { public static void main (String arg[]) { int i; double e, ei; i=0; ei=1; //entero ->real e= ei; do { i++; ei= ei/i; // real / entero -> real e=e+ei; System.out.println (“e=” + e); } while (ei> Math.pow(1, -10)); } } 79
Estructura for Inicialización
condición
True
acción
actualización
False 80
Estructura for
for(inicialización; condición; actualización) acción; inicialización: se pueden inicializar, e incluso declarar, cualquier número de variables condición: si es verdad se sigue el ciclo (bucle) actualización: actualiza varias variables (modifica valor) for(int i=0; is2,