Download Diapositiva 1 - Informática y Sistemas de Computación

Unidad 3.- Construcción del estado de un objeto.
3.1 Tipos de datos primitivos.
3.1.1 Numéricos.
3.1.2 Caracteres.
3.1.3 Cadenas.
3.1.4 Lógicos.
3.2 Tipos de datos no primitivos.
3.2.1 Arreglos.
3.2.2 Apuntadores.
3.3 Identificadores, variables y constantes.
DATOS
DISEÑO ESTRUCTURA
DE DATOS
= importancia
DISEÑO
ALGORITMO
DATO: expresión general que describe los objetos con los cuales opera una computadora
programa
DATOS DE ENTRADA
DATOS DE SALIDA
Características:
o nombre (identificador): característica que servirá para identificarlo.
o tipo: conjunto de valores que puede tomar el elemento.
o valor: información que almacena.
Tipo subrango (o intervalo): es un rango o intervalo de valores consecutivos
de un tipo ordinal, es un conjunto definido por comprensión
• definido a partir de un tipo ordinal
• se especifican dos constantes de ese tipo (límite inferior y límite superior)
1 .. 6
1, 2, 3, 4, 5, 6
‘C’ .. ‘I’
‘C’, ‘D’, ‘E’, ‘F’, ‘G’, ‘H’, ‘I’
‘j’ .. ‘n’
‘j’, ‘k’, ‘l’, ‘m’, ‘n’
‘4’ .. ‘9’
‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’
Tipo enumerado : lista de identificadores que determina un conjunto ordenado
de valores, es un conjunto definido por extensión.
Días = (lunes, martes, miércoles, jueves, viernes, sábado, domingo)
Colores = (azul, rojo, amarillo, verde, gris, violeta)
1.
¿Qué tipos de datos simples emplearías para almacenar la siguiente
información?:
a) Edad:
Numérico Entero
b) Nombre:
Conjunto de caracteres
c) Código Postal:
Numérico Entero o Conjunto de Caracteres
d) Meses del año:
Numérico Entero o o Subrango
e) Nº de teléfono
Numérico Entero o Conjunto de Caracteres
f) Altura:
Numérico Entero o Numérico Real
g) Sexo:
Carácter o Enumerado
h) Fecha:
una agrupación de:
Numérico Entero o Subrango (día)
Numérico Entero o Subrando (mes)
Numérico Entero o Subrango (año)
i) ¿Casado?:
Carácter, Lógico o Enumerado
j) I.V.A. a aplicar:
Numérico Real o Enumerado
•Ejercicio:
¿Qué tipos de datos simples emplearías para almacenar la
siguiente información?:
•a)
•b) Raza.
•c) Horóscopo.
•d) Peso de una persona.
•e) Ciudad donde vives.
•f)
Provincia en la que vives.
•g) Precio de una camisa.
•h)
• i)
Alumno repetidor.
Talla de camisa.
Fecha de nacimiento.
Almacenamiento de datos en variables.
El trabajo con datos es parte fundamental de cualquier programa, las
variables y sus tipos se encargan de almacenar esa información y la
memoria que es necesaria para gestionarlas.
La manera mas habitual de declarar una variable siempre contiene dos
elementos, el tipo de la variable y su nombre y terminando la
declaración con punto y coma.
Pero también se puede declarar en una misma instrucción mas de una
variable del mismo tipo siempre separadas por una coma, al igual que se
puede inicializar una variable en el momento de declararla.
Inicializar una variable consiste en almacenar un determinado valor en el
espacio de memoria reservado para ella.
int midato;
tipoVariable nombre;
int midato1 = 3, midato2 = 6,midato3 = 5;
Los deferentes tipos de variables.
Las variables en Java deben tener un tipo de dato asociado. El tipo de
dato de esa variable indicara los valores que la variable puede contener
y las operaciones que se pueden realizar con ella. Podemos diferenciar
los datos en Java en dos categorías de datos principales: los tipos
primitivos y los tipos referenciados.
Los tipos primitivos contienen un sólo valor e incluyen los tipos como los
enteros, punto flotante, los caracteres, de tipo booleano etc...
Los tipos referenciados se llaman así porque el valor de una variable de
referencia es una referencia (un puntero) hacia el valor real. En Java
tenemos los arrays, las clases y los interfaces como tipos de datos
referenciados.
Java es un lenguaje fuertemente tipado
―Cada variable y expresión tienen un tipo
―En todas la asignaciones se comprueba la compatibilidad de tipos
Tipos primitivos vs. tipos referencia
Tipos primitivos
● Representan valores básicos de los elementos de un programa
● Tienen un tamaño y formato fijos
● Se definen literales (valores constantes)
● Clasificación general:
―Números enteros
―Números reales
―Caracteres
―Booleanos
Aritméticos
Números enteros
● Números enteros positivos y negativos
● De distintos tamaños
● Formato: complemento a dos
-2,147,483,648
+2,147,483,647
Literales enteros
● Formato decimal
― Cifras decimales
― 0, 34: tipo int
― Con ‘l’ o ‘L’ tras el número: 58941623984L: tipo long
● Formato octal
― Cifras octales: 0,1,2,3,4,5,6,7
― Cada cifra octal representa 3 bits
― Los números octales comienzan por 0: 0642, 0642L
● Formato hexadecimal
― Cifras hexadecimales: 0,1,2,3,4,5,6,7, 8, 9, a, b, c, d, e, f (también sirve en
mayúsculas)
― Cada cifra hexadecimal representa 4 bits
― Los números hexadecimales comienzan por 0x: 0xa54, 0xE08DL
Enteros: Estos tipos son byte, short, int y long, que guardan el signo valor,
estos representan un número y no pueden representar elementos
fraccionarios.
Esto puede ser un buen ejemplo de declaración de tipos de datos enteros:
public class enteros
{
public static void main(String[] arg)
{
byte midato1 = 1;
short midato2 = 100;
int midato3 = 10000;
long midato4 = 100000000;
System.out .println("midato = " + midato1);
....
}
}
Números reales
● Números reales positivos y negativos
● Aritmética de punto flotante (estándar IEEE 754)
signo * mantisa * 2exponente
Literales reales
● Deben incluir
―O bien un punto decimal (cuidado, ¡no una coma!)
―O bien una ‘e’ o ‘E’ (exponencial)
􀂃 1e2 == 1*102
―Ejemplos: 0.0, 4.0, 4., .23, 1.e2, 2E-2, .4e+4
● Por defecto, son de tipo double
―Salvo que incluyan una ‘f’ o ‘F’ al final
􀂃 Ejemplos: 4.0f, 4.f, .23F, 1.e2F, 2E-2f, .4e+4f
Números de punto flotante: Estos son float y double y pueden almacenar
números con punto flotante y con signo, esto quiere decir que nos permiten
representar números decimales.
Todos los literales de punto flotante son del tipo double salvo que se especifique lo
contrario, por eso si se intenta asignar un literal en punto flotante a una variable de
tipo float el compilador nos dará un error (posible perdida de presición):
public class tipoDecimales
{
public static void main(String[] arg)
{
float valor;
valor = 2.6;
System.out .println("Valor del dato= " + valor); //esto dará un error.
}
}
Esto se solucionaría indicando que el valor 2.6 es de tipo float con una f al final 2.6f
Tipo carácter
● En realidad también es un entero (sin signo)
―Aritmética de caracteres
● Representación de un carácter por su código en formato Unicode
Literales carácter
● Un carácter se representa entre comillas simples
―‘a’, ‘A’ (son caracteres diferentes) ‘ñ’, ‘á’
● O bien como su código Unicode
―‘\u0061’ (‘a’), ‘\u0041’ (‘A’)
―Permite representar cualquier alfabeto
● Caracteres especiales (secuencias de
escape): comienzan por ‘\’
El tipo Caracter: Estos son de tipo char, que almacena la representación de los
caracteres (letras o números), un carácter esta almacenado en 16 bits, y siguen un
estándar que es el Unicoide.
Los caracteres en Java se pueden especificar de forma normal o con secuencias de
escape, utilizando la barra invertida "\" seguida de una letra:( \r) o utilizando la barra
invertida con una "u" seguida de un numero hexadecimal (\u0000d), en este caso
hemos especificado la secuencia de escape \r y su código unicoide correspondiente
del retorno de carro.
public class tipoCaracter
{
public static void main(String[] arg)
{
char valor, valor1, valor2;
valor = 'a';
// el literal de tipo carácter tiene que estar encerrado entre
// comillas simples.
valor1 = 65;
}
}
Booleanos
● Representan los valores lógicos true y false (literales)
● Base para las expresiones lógicas (condiciones)
● Los literales booleanos true y false no son equivalentes a los enteros 1 y 0
● Operaciones lógicas básicas:
A
F
V
Not A
V
F
A
F
F
V
B
F
V
F
AyB
F
F
F
A
F
F
V
B
F
V
F
AoB
F
V
V
V
V
V
V
V
V
Generalmente su utilización es muy frecuente para determinar el flujo de los
programas:
public class tipoBoolean
{
public static void main(String[] arg)
{
boolean valor1;
valor1 = false;
if (valor1)
{
System.out .println("valor1 = verdadero");
}
else
{
System.out .println("valor1 = falso");
}
}
}
Tipo
Tamaño/Formato
Descripción
byte
8-bit complemento a 2
Entero de un Byte
short
16-bit complemento a 2
Entero corto
int
32-bit complemento a 2
Entero
long
64-bit complemento a 2
Entero largo
float
32-bit IEEE 754
Coma flotante de precisión simple
double
64-bit IEEE 754
Coma flotante de precisión doble
char
16-bit Caracter
Un sólo carácter
boolean
true o false
Un valor booleano (verdadero o falso)
(Números enteros)
(Números reales)
(otros tipos)
Tipos de datos primitivos en Java
Los Arrays (Arreglos)
Java dispone de un tipo de dato de posiciones secuenciales y que cuenta de unas
comprobaciones exhaustivas para su correcta manipulación como puede ser la
comprobación de no sobrepasar los limites permitidos en la definición del array.
Los arrays permiten guardar grupos de datos similares, puesto que Java trata los
arrays como un tipo de objeto y por lo tanto este se tendra que instanciar con el
operador new.
Para crear un array tenemos que especificar una variable que se utilizara como
índice para acceder al array y el tipo de datos que este contendrá.
Antes de poder utilizar un array hay que declararlo, como Java trata este tipo como
un objeto, el array en este caso no reserva memoria para contener los datos, sino
que solamente localiza memoria para almacenar una referencia al array, por
ejemplo cuando se pasa una matriz a un metodo, sólo se pasa la referencia y no
todos los elementos de la matriz.
En este ejemplo he creado un array unidimensional del tipo int que nos permite
almacenar diez enteros, pero tambien pueden ser bidimensionales...
int miDato[] = new int[10];
Podriamos inicializar el array de la siguiente manera:
int miDato[] ={5,9,4,2,7};
String misdatos[] = new String[4];
int misdatos[][] = new int[20][10];
Y para acceder al tercer elemento utilizariamos los indices en este caso seria la
posicion elemento -1, pues Java considera el indice del primer elemento como 0.
misDatos[] = {"uno","dos","tres","cuatro“};
misDatos[1] = "dos“;
misDatos[0] = "uno”;
....
Resaltar que todos los objetos array disponen de un metodo publico "length()" que
se utiliza para determinar su tamaño.
int array[][] = new int[5][2];
array.length(); //= 5
array[0].length(); //= 2
/* Este es un ejemplo de creación de un array en este caso de dos dimensiones */
package ejemplos;
public class matrices
{
public static void main( String args[] )
{
// Decladramos el array con un tamano de 3 en su primera dimensión para
// posteriormente declarar la segunda dimensión.
int matriz[][] = new int[3][];
matriz[0] = new int[2];
matriz[1] = new int[3];
matriz[2] = new int[4];
// Ponemos datos en el array
for ( int i=0; i < 3; i++ )
{
for ( int j=0; j < matriz[i].length; j++ )
matriz[i][j] = i * j;
}
// y vemos su contenido, utilizando un bucle for
for ( int i=0; i < 3; i++ )
{
for ( int j=0; j < matriz[i].length; j++ )
System.out.print( matriz[i][j] );
System.out.println();
}
// Intetamos acceder a un elemento que esta fuera de los limites del array
System.out.println( "Elemento fuera de limites del array" );
matriz[4][0] = 7;
// El compilador lanzara una excepción de tipo ArrayIndexOutOfBounds
}
}
Tipos de datos string (las cadenas)
En realidad una variable de tipo string, más que un tipo propio de Java es una
clase tratada con todo rigor como un objeto más de Java.
Las cadenas de texto son una de las variables más utilizadas en Java, por eso hay
una forma especial abreviada de crearlas:
String s = “asdf”;
En Java el contenido de las cadenas no se pueden modificar aun que se vuelva a
definir la variable String, si en un programa se necesita modificar el contenido de
una cadena lo más correcto seria utilizar la clase StringBuffer, la cual posee
muchos métodos para este cometido como append() etc..
En este ejemplo definimos una cadena:
String miCadena = "Esto es una cadena";
No podemos modificar su contenido pero si podemos hacer que miCadena se
refiera a otra cadena nueva:
miCadena = miCadena + "otra cadena";
En este ejemplo muestra el hecho de que una cadena no puede ser modificada, y
sin embargo una variable de referencia puede modificarse para que apunte a una
nueva cadena para que parezca que se ha modificado la cadena original:
class miCadena
{
String cadena1 = "PRIMERA CADENA";
String cadena2 = "SEGUNDA CADENA";
public static void main( String args[] )
{
miCadena cad = new miCadena();
System.out.println( "Los valores originales de las cadenas son:" );
System.out.println( cad.cadena1 );
System.out.println( cad.cadena2 );
System.out.println( "Reemplaza cadena1 con otra cadena" );
cad.cadena1 = cad.cadena1 + " " + cad.cadena2;
System.out.println( "Nuevo valor de cadena1:" );
System.out.println( cad.cadena1 );
}
}
Nombres de Variables
Un programa se refiere al valor de una variable por su nombre. Por convención, en
Java, los nombres de las variables empiezan con una letra minúscula (los nombres
de las clases empiezan con una letra mayúscula).
Todas los nombres de variables de instancia o de clase deben estar constituidos
por palabras con la primera letra de la primera palabra en minúscula y la primera
letra de las palabras internas en mayúscula.
Los nombres de variables deben ser cortos y significativos. La elección de un
nombre de variable debe ser mnemotécnico, es decir, pensado para que un lector
casual al verla comprenda su uso. Se deben evitar las variables de una sola letra,
excepto en variables temporales de corto uso. Nombres comunes para este tipo de
variables son: i, j, k, m y n para enteros; c, d, y e para caracteres.
char c;
Double myMedida;
int j,k;
Identificador
Nombre que recibe un dato en memoria para poder referirnos a él dentro del programa
Características que debe reunir un identificador
– No pueden ser palabras reservadas propias del lenguaje de programación empleado.
– Deben ser significativos.
– Deben comenzar por un carácter alfabético o el símbolo de subrayado y pueden
contener caracteres alfabéticos, dígitos y el símbolo de subrayado.
CONSTANTE
dato con un identificador que
está ligado a un valor
permanente durante su
tiempo de vida
VARIABLE
dato definido y nombrado por el
programador explícitamente en un
programa y puede cambiar de valor
durante su tiempo de vida
Concepto de variable
● Las variables son los espacios de memoria reservados para
almacenar algún valor
● Las variables siempre son de un tipo determinado
―Al declarar la variable, se indica siempre el tipo y su nombre
double radio;
Valor de una variable
● El valor asignado a la variable puede ser
―Un literal (valor constante)
􀂃 a = 7.2
―Una expresión de ese tipo
􀂃a=b+c
―El resultado de un método, que sea de ese tipo
􀂃 a = sqrt (32.4)
Automatización de los datos
El primer objetivo de la automatización de los datos, es de evitar equivocaciones
durante su ingreso, haciendo que el mismo comience lo más automáticamente posible. En
diferentes situaciones se requerirán diferentes métodos y equipos.
Un segundo objetivo es evitar reingresar los mismos datos para ejecutar una tarea
diferente con ellos.
Por ejemplo, la antigua caja registradora sumará su compra y calculará el IVA. El cajero
ingresó el importe a mano (la parte de ingreso de datos). Después las cifras que arrojan
las cintas de papel tendrán que ser sumadas manualmente, o ingresadas en un programa
de computación (otro trabajo de ingreso de datos) .Para una actualización de las
cantidades de productos en existencia, alguien tendrá que ir a contar los artículos en las
góndolas (tercer ingreso de datos).
Verificar para la certeza
Una importante tarea para cualquier programa que acepte datos, es tratar de garantizar la
precisión en la entrada de los mismos. Algunas clases de errores no pueden ser detectados
pero muchas de las equivocaciones más comunes, pueden localizarse con un programa bien
diseñado.
El programa debe tratar de lo siguiente:
1.
2.
3.
4.
Probar el tipo de dato y su
formato.
Probar la razonabilidad
del dato
Probar la consistencia
del dato
Probar los errores de
transcripción y de
transposición
ej.
2/a/96 no es un dato de una fecha como corresponde
ej.
Un número de teléfono en los Estados Unidos, debe tener 10 dígitos por lo
cual, 555-123 no es aceptable.
ej.
231 no podría ser la edad de una persona
ej.
Una venta de $50.000 en chicles en un kiosco, probablemente tiene mal
colocado el punto decimal.
ej.
ej.
ej.
ej.
La fecha de la muerte de un hombre debería ser posterior a la de su
nacimiento!
La suma de los cheques emitidos mensualmente debería ser igual o menor
a la del resumen de la cuenta corriente bancaria.
Tipear 7754 en lugar de 7154 es un error de transcripción; se ha tipeado la
tecla equivocada.
Tipear 7754 en lugar de 7745 es un error de transposición al intercambiar
dos caracteres correctos.
Ambos son muy difíciles de verificar.