Tema 3 - Tipos y operaciones básicas (2016)

Apunte Español
Universidad Universidad Politécnica de Madrid (UPM)
Grado Ingeniería de Tecnologías y Servicios de Telecomunicación - 1º curso
Asignatura Programación
Año del apunte 2016
Páginas 8
Fecha de subida 25/09/2017
Descargas 0
Subido por

Vista previa del texto

TEMA 3: TIPOS Y OPERACIONES BÁSICAS 3.1. Datos y Tipos *Dato: La representación de un elemento de información en la memoria del ordenador.
*Tipo: Es la definición de un conjunto de valores mediante su rango o dominio y representando las operaciones permitidas en ese conjunto. Existen lenguajes no tipados y lenguajes tipados (como java; significa que cada elemento es de un tipo, y no podemos cambiar el tipo).
*Valor: Es la representación de un elemento del tipo.
*Variable: Es un contenedor para un valor de un cierto tipo que no se puede cambiar. Ocupan memoria.
int = número entero int nAlumnos = 55; nombreTipo variable = valor; Para cambiar la variable más adelante: nAlumnos = nAlumnos + 1; //El “igual” significa asignación matemática, no una //igualdad. Entonces, el nuevo número se guarda en //la variable de la izq. : nAlumnos ahora vale 56.
nAlumnos == 56 => Comprobación. Igualdad. Sería verdadero.
nAlumnos != 56 => Desigualdad. Sería falso nAlumnos = ( (nAlumnos + 1) * (3 + nAlumnos) ) * (nAlumnos * 5600); --Las variables solo se pueden operar si son del mismo tipo.
Nombre variable  Inicial minúscula Nombre clases  Inicial mayúscula Los tipos |simples, básicos, primitivos| están predefinidos, vienen con el compilador y no se pueden modificar.
3.2. Tipo Lógico boolean estaLloviendo = false; estaLloviendo = true; Solo dos posibles valores: true o false.
Funciona como una pregunta, ¿está lloviendo? Las variables lógicas ocupan 1 bit: 0 ó 1.
*Operador AND: && estaLloviendo = estaLloviendo && true; //Solo devuelve true, si los dos son true.
*Operador OR: || estaLlovienvo = estaLloviendo || false; //Solo da falso, si los dos son falsos. Si uno es //true y otro false, devuelve true.
*Operador NOT: ! estaLloviendo = ! estaLloviendo; Ejemplo: AñoBisiesto …..
int year = ….
boolean bisiesto = ( (year % 400) == 0) || ( ( (year % 4) == 0) && ( (year % 100) != 0) ); 3.3. Tipos Enumerados Un tipo enumerado representa un conjunto de pocos valores definidos al programar, y escritos como una lista de valores en MAYÚSCULAS.
enum ColorSemaforo { ROJO, AMBAR, VERDE, ---- 0 ---- 1 ---- 2 } ColorSemaforo miSemaforo = ColorSemaforo.ROJO; miSemaforo = ColorSemaforo.VERDE; miSemaforo == ColorSemaforo.AMBAR; System.out.println (miSemaforo.toString () ); System.out.println (miSemaforo.ordinal () ); => Dará false.
=> Imprime el color actual: Verde => Número 2 3.4. Tipo Letra String: clase que nos permite manejar textos.
String m = “Hola a todos”; String m = new String (“Hola a todos”); (1) y (2) son igualmente válidas.
(1) (2) Concatenación: System.out.println (“nombre: ” + “Guillermo”); System.out.println (“nombre: “ + nombre); //Si nombre es una variable ya definida.
*Tipo letra: Valen para almacenar una sola letra.
char letraDNI = ‘V’; letraDNI = ‘v’; letraDNI = ‘0’; //Con comillas simple //Es un cero Cada letra ocupa 2 bytes. Corresponde a una tabla UNICODE cuyos primeros 256 caracteres son de la tabla ASCII, que a cada carácter le corresponde un número binario. Aunque no podemos usar ni “ñ” ni acentos.
Para los caracteres especiales: ‘\n’ => Salto de línea.
‘\t’ => Tabulador ‘\’‘ => Comilla simple ‘\”‘ => Comilla doble ‘\\’ => \ Ejemplo: Para escribir varios renglones “------------ \n” “------------ \n” “------------ \n” Character.isLowerCase (char); => Nos devuelve true si la letra es minúscula Character.isUpperCase (char); => Nos devuelve true si la letra es mayúscula Character.toUpperCase (char); => Devuelve la letra en mayúsculas Character.toLowerCase (char); => Devuelve la letra en minúsculas Lower => minúscula Upper => Mayúscula 3.5. Tipos Enteros Todos los enteros (-Infinito, +Infinito) no caben en el ordenador. Si el resultado de una operación es mayor que el número máximo admitido o menor que el mínimo da un error de desbordamiento (overflow).
Hay 4 tipos: (long > int > short > byte) long = 8 bytes.
int = 4 bytes.
short = 2 bytes.
byte = 1 byte. => Del -126 al 127.
Usaremos siempre int para numeros enteros salvo indicación contraria o excepto: -Si son números muy grandes (long).
-Si tenemos poca memoria (short / byte).
Definir una variable de tipo byte, short, int, long: byte nAlumnos = 65 b; long billonesDeficit = 487524349 L; short n = 655 s; int nGrupos = 6; int n… = 0xFA; //Hexadecimal int n… = O48; //Octal. Es la letra “o”.
En principio solo operaremos enteros con enteros. Operaciones: int columna = 2; int fila = 3; System.out.println (fila + columna) = 5; System.out.println (fila – columna) = 1; System.out.println (fila * columna) = 6; System.out.println (fila / columna) = 1; System.out.println (fila % columna) = 1; ( - fila) = -3; (Math.abs (fila)) = 3; (Math.pow (fila,2) = 3^2 = 9; => Solo da el cociente => Da el resto => Valor absoluto.
=> Eleva el primer numero al segundo.
Operaciones-asignaciones compactas: Operan y cambian el valor de la variable.
++a => pre-incremento => a = a+1; a++ => post-incremento => a = a+1; --a => pre-decremento => a = a-1; a-- => post-decremento => a = a-1; //Si queremos usar sumar antes de usar la “a”.
//Si queremos usar la “a” antes de sumar.
int a = 0; System.out.println (++a); System.out.println (a++); System.out.println (--a); System.out.println (a--); System.out.println (a); => Imprime 1 y guarda a=1; => Imprime 1 y guarda a=2; => Imprime 1 y guarda a=1; => Imprime 1 y guarda a=0; => Imprime 0 y guarda a=0; 3.6. Tipos Reales Hay dos tipos: -float: 4 bytes.
-double: 8 bytes.
(double > float) Error de representación = desprecio de decimales float b = 4.0 f; double a = -5.0; double a = 23E8; double a = -23E-8; //A la izquierda de la E: numero entero o decimal. A la derecha: entero // 23E8 = 23*10^8 // -23E-8 = -23*10^(-8) Las operaciones con los reales nunca dan problemas / errores (no paran el programa). Pueden dar como resultado: + - infinito o NaN (Not a Number).
Para representar numeros más grandes : BigNumber o BigDecimal (casos especiales).
3.7. Conversiones Java es fuertemente tipado, todas las expresiones tienen tipo.
3.2 * 6 => double * int => La disciplina estrica de tipos NO permite esta operación.
a) Conversiones implícitas o automáticas.
byte < short < int < long < float < double ----->------>------>-------->------>------>----- 3.2 * 6 --------> 3.2 * 6.0 => Ahora si se realiza double * int -------> double * double El compilador convierte automáticamente el int en double.
Este proceso se hará siempre si va del más pequeño al más grande.
Las conversiones automáticas sólo se aplican a la derecha de la asignación.
int a = 32 * 6; // No se puede guardar un double en un int => Error de compilación.
b) Conversiones explícitas o forzadas (casting) byte < short < int < long < float < double -------<-------<--------<--------<---------<-------int a = (int) 6.8; => a=6 (char)( ( (int) ‘a’) + 10); //Guarda un double en un int perdiendo la información //decimal. No redondea, trunca.
//Convierte un char en un int para devolverlo a letra public char siguiente (char c) { return (char)( ( (int) c)+1); } public char anterior (char b) { return (char) ( ( (int) b)+1); } Clases envoltorio boolean -------------> Boolean byte -------------> Byte short -------------> Short int -------------> Integer long -------------> Long float -------------> Float Double -------------> Double int a = -10; Integer A = new Integer (-10); //A=-10 Permite usarlo como un objeto, es decir, usarlo con referencia.
Integer i = 3; int j = i++; //Boxing //Unboxing | La suma de los dos: | autoboxing Integer.MAX_INTEGER; Integer.MIN_INTEGER; int i = Integer.parseInt (“34”); double d = Double.valueOf().doubleValue(“0.6”); 3.8. Arrays Un array es una agrupación de variables indexadas (con índice) del mismo tipo.
-Array de Dimensión 1: Vector (Usado para las comunicaciones).
-Array de Dimensión 2: Matriz (Usado para imágenes).
-Array de Dimension 3: Rejilla o espacio (Simulación de fenómenos).
ELEMENTOS DE UN ARRAY: -Tipo base: tipo de todas las casillas (entero, real, String, …).
-Índice: Son números enteros, y tiene tantos como dimensiones tengamos. Empieza con el 0 y acaba en n-1. Por ejemplo: (Con dimensión 2) = (2,3) --> Es la segunda columna, tercera fila.
-Tamaño.
Se manejan mediante referencias.
tipo base – Dimension – referencia = new – tipo base – casillas (( - columnas – profundidad )) Ejemplos: Direccion [] direcciones = new Direccion [100]; int [] vector = new int [100]; int [] [] matriz = new int [100] [100]; double [] [] [] espacio = new double [10] [10] [10]; Crear un array “al vuelo”: int [] [] cuadro = { {1,2}, {3,4} }; Dar valores: vector [0] = 61; vector [1] = vector [0]; vector [0] = 74; // A la casilla nº 0 se le asigna el 61; //Se le copia (no enlaza) el valor de la casilla 0 a la casilla 1 //El valor de la casilla 1 no cambia!! Para meter el valor en la última casilla: vector.length => devuelve 100 vector [vector.length – 1] = vector [0]; //La última casilla copia el valor de la casilla 0 int [] [] imagen = new int [20] [20]; imagen [0][0] = 100; imagen [1][1] = imagen [0][0]; imagen [imagen.length-1] [imagen [imagen.length – 1].length – 1] = imagen [0][0]; 3.9. Atributos y Variables class Punto { private double x; private double y; public Punto (double x, double y) { this.x = x; this.y=y; } public double getX () { return this.x; } public double getY () { return this.y; } public void setX (double x) { this.x = x; } public void setY (double y) { this.y = y; } } public double distancia (Punto p) { double distancia = Math.sqrt ( ( (this.x - p.getX() ) * (this.x-p.getY() ) + ( (this.y - p.getY() ) * (this.y – p.getY() ) ) ); return distancia; } Para crear constantes: en mayusculas: Una constante no puede modificarse nunca.
private final int ORIGEN = 0; private final int PI = 3.14159; Una variable dentro de un método se destruye tras el fin de este. Sólo su método puede acceder a él. No hay que dar valores inicialmente a los atributos, pero sí a las variables de dentro de un método.
...

Comprar Previsualizar