Datos y Variables. Operadores

Académicamente se considera un ordenador un mecanismo digital con propósito general. Es decir, una máquina digital que puede hacer cualquier cosa. Ahora bien, cuando procesa o ejecuta un determinado programa, se restringe a lo que haga ese programa.

Algoritmo es un concepto matemático: Conjunto ordenado de operaciones sistemáticas que permite hacer un cálculo y hallar la solución de un tipo de problemas.

"Ej. debes conocer el algoritmo que se emplea para hallar las raíces cuadradas":

Las calculadoras de bolsillo típicamente implementan buenas rutinas para calcular la función exponencial y el logaritmo natural; 

Hay otras muchas posibilidades de algoritmos para calcular la raíz cuadrada.

Definido un problema, de modo general y con precisión, un algoritmo que resuelve dicho problema  informático es un conjunto de instrucciones que indican cómo llevar a la práctica la resolución del problema de modo exacto, efectiva y en un tiempo finito.

Ejemplo: Calcular si un número entero y positivo es primo.
1.- Considerar toda la secuencia de números entre 2 y n-1.
2.- Para cada número de esta secuencia, comprobar si divide  a n.
3.- Si algún número divide a n, entonces n no es primo; en caso contrario, sí lo es.

 

Un programa es la utilización de un lenguaje -Java- para resolver un problema a partir de un algoritmo; por ejemplo del algoritmo anterior de número primo, un programa que lo resuelve puede ser este, mediante el BlueJ, por ejemplo:

import java.util.*;
public class Utilidades{
  
    public static void main(String[] arg){
        Scanner teclado = new Scanner(System.in).useLocale(Locale.US);
        System.out.println("Introduzca el valor de un entero para comprobar si es primo. ");
        int n = teclado.nextInt();
       
        siEsPrimoN(n);
    }  
   
    public static void siEsPrimoN(int n){
        int i = 3;
        if(n<3) System.out.println(n+" Es primo."+n);
        else{
            while(n%i!=0&&i<=n-1)
            i++;
            {
            if(i==n)System.out.println(n+" Es primo."+i);
            else System.out.println(n+" No es primo."+i);
            }
         }
    }
}

Tipos de lenguajes:

Están los lenguajes de bajo nivel, llamados ensamblador y lenguaje máquina, que ambos utilizan caracteres binarios, con referencias a las instrucciones y a los datos. Son complejos de usar.
Los lenguajes de alto nivel son mas parecidos a los lenguajes que solemos usar las personas, tanto en matemáticos como en lenguaje escrito. Estos tienen varias ventajas:
    
El programador puede dar órdenes al ordenador, a través de estos lenguajes, de forma mas sencilla y comprensible.

Son mas seguros que el código máquina y ayudan a no cometer errores.

El código de programación, código fuente, es independiente de la máquina.

Los lenguajes de alto nivel pueden ser lógicos y funcionales o imperativos.

Permiten una programación estructurada -estructuras-, y orientada a objetos (Clases); lo que los hacen superpotentes y casi ilimitada.

Cómo se traducen o convierten un lenguaje de alto nivel, escrito por el programador, -código fuente-, en un lenguaje máquina? De dos formas, mediante intérpretes y mediante compiladores. Con los intérpretes se traduce y se ejecuta a la vez el código fuente, un sólo paso. Con los programas compiladores, primero se compila, -traducen- y posteriormente se ejecuta, es decir, dos pasos.

 

El lenguaje Java:

Java es un lenguaje de alto nivel, imperativo, estructurado, orientado a Objetos, donde las instrucciones se ejecutan en el orden que aparecen.
Para manejar los datos necesarios en la ejecución del programa, Java usa variables, que son como las direcciones de los apartados de correos donde se encuentran los datos.

En Java existen precocinadas infinidad de Clases, que no tienen main, y que son un repositorio o almacén de operaciones, por ejemplo System, o Math, y otras muchas; y otras que podemos fabricar nosotros. Se llaman librerías y vienen acompañadas por su documentación o Apis.

En la POO, además de las variables primitivas como int, double, char, boolean, predefinidas, podemos generar todo tipo de variables complejas como hora, fecha, String, de modo ilimitado, y a éste tipo de datos les llamamos objetos, pues pueden ser también cualquier tipo de objetos: coche, ferrocarril, avión, ... mesa, silla, ventanas, habitaciones. Animales, personas, tanques,... se puede representar el universo material, y también hipotéticos. Cada tipo de dato compuesto tiene una estructura o atributos, y se le definen unas operaciones o métodos. Todos los objetos de una misma clase, poseen los mismos atributos, componentes o estructura, que todo indica lo mismo.

Las clases librerías y las clases tipo de datos, no realizan nada, están como en potencia para actuar.
Sólo las clases programa pueden ejecutar acciones, para ello tienen el método principal main.

public class Programa{

public static void main(String[] arg) {

( y realiza lo que está aquí)

}
}

Todos los datos de un programa, ya sean elementales o complejos, que se usan en la resolución de un problema se representan mediante variables. Ahora nos referimos a variables que representen datos elementales.

Declaración de variables: Es la parte del código que define el nombre de la variable y su tipo:  int n; por ejemplo: tipo entero y nombre n.

Asignación: es una instrucción n = 25, que permite dar valores a las variables o modificarlos:  n = 25+32;

double nomVariable = expresión;

La expresión es un conjunto de valores, expresiones y operaciones sintácticamente correctas, cuyo resultado final es un valor del tipo de nomVariable.

En el momento de su declaración, se puede dar un valor inicial -inicialización-

Si una variable se declara con el modificador final, el primer valor que se le asigne lo adquiere a perpetuidad y ya no se le puede cambiar. Por ello se llama también constante: double PI = 3.141593;

El nombre de la variable final suele ponerse en mayúsculas.

 

Hemos dicho que en Java hay dos tipos de variables: las variables elementales y las variables compuestas u objetos. También se emplea la palabra tipo para determinar si la variable es de un tipo -elemental o primitivo- o de otro: compuesto o complejo, u objeto.

Tipos primitivos o tipos de datos primitivos:

Hay tres tipos de datos primitivos:

1.- Numéricos; con dos tipos: enteros y reales. Y cada uno de estos, con otros tipos:

enteros: byte, short , int, long.

reales: float y double.

Dependen de su capacidad de almacenamiento.

2.- Tipo caracter: Sólo hay un tipo, char.

3. Tipo booleanos o lógicos: tipo boolean.

La palabra tipo se puede utilizar reiterativamente: tipos elementales, tipos numéricos, tipo entero, tipo byte,..., tanto para el conjunto, el subconjunto, el elemento. Es algo que sucede continuamente en informática.

Tipos elementales:

Tipo de dato	Representación	Tamaño (Bytes)	Rango de Valores	Valor por defecto	Clase Asociada
byte	Numérico Entero con signo	1	-128 a 127	0	Byte
short	Numérico Entero con signo	2	-32768 a 32767	0	Short
int	Numérico Entero con signo	4	-2147483648 a 2147483647	0	Integer
long	Numérico Entero con signo	8	-9223372036854775808 a 9223372036854775807	0	Long
float	Numérico en Coma flotante de precisión simple Norma IEEE 754	4	± 3.4x10-38 a ± 3.4x1038	0.0	Float
double	Numérico en Coma flotante de precisión doble Norma IEEE 754	8	± 1.8x10-308 a ± 1.8x10308	0.0	Double
char	Carácter Unicode	2	\u0000 a \uFFFF	\u0000	Character
boolean	Dato lógico	-	true ó false	false	Boolean
void	-	-	-	-	Void

 

DATOS NUMÉRICOS ENTEROS

En Java los representan los tipos: byte, short, int, long.

El tipo de dato numérico entero es un subconjunto finito de los números enteros del mundo real. Pueden ser positivos o negativos.

Ejemplo de declaración de variables enteras:

int a;

byte n1, n2;

short x;

 

DATOS NUMÉRICOS REALES

En Java los representan los tipos: float, double.

El tipo de dato numérico real es un subconjunto finito de los números reales. Siempre llevan un punto decimal y también pueden ser positivos o negativos. Los números reales tienen una parte entera y una parte decimal.

Por ejemplo: 0.08   -54.0001

Ejemplo de declaración de variables reales:

float peso;

double longitud;

float altura = 2.5F;

double area = 1.7E4; // equivale a 1.7 * 10⁴

double z = .123; //si la parte entera es 0 se puede omitir

 

DATOS DE TIPO CARÁCTER

En Java se representa con el tipo char.

Un dato de tipo carácter se utiliza para representar un carácter dentro del rango \u0000 a \uFFFF (números desde 0 hasta 65535) en Unicode.

En realidad un dato de tipo char contiene un número entero dentro del rango anterior que representa un carácter.

En Java se utiliza el código Unicode para la representación de caracteres. Este código actualmente representa los caracteres de la mayoría de idiomas escritos en todo el mundo.

Los 127 primeros caracteres de Unicode corresponden al código ASCII.

El Código ASCII (American Standard Code for Information Interchange o Código Estándar Americano para el Intercambio de Información) asigna valores numéricos a las letras, números, signos de puntuación y algunos otros caracteres especiales.

ASCII incluye 256 códigos divididos en dos conjuntos, estándar y extendido, de 128 cada uno. El conjunto ASCII básico, o estándar, utiliza 7 bits para cada código, lo que da como resultado 128 códigos de caracteres desde 0 hasta 127.

El conjunto ASCII extendido utiliza 8 bits para cada código, dando como resultado 128 códigos adicionales, numerados desde el 128 hasta el 255.

En el conjunto de caracteres ASCII básico, los primeros 32 valores están asignados a los códigos de control de comunicaciones y de impresora (caracteres no imprimibles) empleados para controlar la forma en que la información es transferida desde una computadora a otra o desde una computadora a una impresora. En este grupo están los códigos correspondientes a la barra espaciadora (SP por space), la tecla ENTER de retorno de carro a un nuevo renglón (CR por carry return), etc. También existen caracteres de control usados en teleprocesamiento, como ser ACK (Acknowledge - aviso de mensaje recibido), BEL (bell - aviso por señal sonora), ETX (end of text – fin de texto), STX (start of text – comienzo de texto), etc.

Los 96 códigos restantes del código básico corresponden a los caracteres imprimibles y se asignan a los signos de puntuación corrientes, a los dígitos del 0 al 9 y a las letras mayúsculas y minúsculas del alfabeto latino.

Los códigos correspondientes al ASCII extendido, del 128 al 255, se asignan a aquellos caracteres que no pertenecen al alfabeto anglosajón, por ejemplo, las vocales con tilde, la ñ, y en general todos los caracteres especiales que utilizan los distintos lenguajes.

 

Debido a lo limitado de su tamaño, el código ASCII no es suficiente para representar caracteres de alfabetos como el Japonés, Chino o árabe. La solución a este problema ha sido crear un código más grande con el que poder representar cualquier carácter de cualquier idioma: el código Unicode.

El código UNICODE proporciona una única representación numérica para cada símbolo, independientemente del ordenador, el programa o el lenguaje de programación que se use.

La codificación Unicode se ha transformado en un estándar adoptado por las principales empresas de hardware y software. Java utiliza la codificación Unicode.

La descripción completa del estándar y las tablas de caracteres están disponibles en la página web oficial de Unicode http://www.unicode.org/. La referencia completa se publica, además, en forma de libro impreso cada vez que se libera una nueva versión principal. La versión digital de este libro está disponible de forma gratuita.

Ejemplo de declaración de variables de tipo carácter:

char car;

char letra1 = 'z';

char letra = '\u0061'; //código unicode del carácter ‘a’

 

DATOS DE TIPO LÓGICO

Se representan con el tipo boolean.

Los datos de este tipo sólo pueden contener dos valores: true (verdadero) ó false (falso).

Ejemplo de declaración de variables lógicas:

boolean primero;

boolean par = false;

Los tipos de datos lógicos son también conocidos como booleanos en honor del matemático inglés George Bool, que desarrolló la teoría conocida como álgebra de bool que fue la base para la representación de los circuitos lógicos.

 

Operadores:

1.- Paréntesis: ()

2.- Operadores de Asignación: 
 v = e; (a la variable v se le asigna el valor de la expresión e, que deben de ser del mismo tipo)
 v += e; ~ v=v+e;
 v -= e;  ~ v=v-e;
 v *= e; ~ v= v*e;
 v /= e; ~ v = v/e;

v %= e; ~ v = v % e;

3.- Operadores Incrementales: Son los operadores que nos permiten incrementar las variables en una unidad. Se pueden usar delante y detrás de la variable dependiendo de lo que queramos, es decir, si queremos que incremente o decremente antes de utilizar o lo contrario.
    '++ expresión';     'expresión ++';
    ' - - expresión';     'expresión - -' ;

4.- Operadores de conversión o creación:

(tipo) expresión; new

5.- Operadores Unarios: El mas (+) y el menos (-) cambian el signo del operando.

6.- Operadores Aritméticos:
 Suma +
 Resta - 
 Multiplicación * 
 División / 
 Resto de la División %

7.- Operador Instanceof: Nos permite saber si un objeto pertenece a una clase o no.
        NombreObjeto instanceof NombreClase

8.- Operadores Relacionales: Permiten comparar variables según relación de igualdad/desigualdad o relacción mayor/menor. Devuelven siempre un valor boolean.
     '>'   Mayor que
     '<'   Menor que
     '==' Iguales
    ' ¡='  Distintos
     '>='   Mayor o igual que
     '<='  Menor o igual que

9.- Operadores Lógicos: Nos permiten construir expresiones lógicas.
    '&&' (& cortocircuitado) devuelve true si ambos operandos son true, si el primero no lo es, no evalúa al segundo.
    '||'  ( '|' cortocircuitado) devuelve true si uno de los operandos es true. Si el primero lo es, no evalúa al segundo.
   '!'   Niega el operando que se le pasa.
   '&'  devuelve true si ambos operandos son true, evaluándolos ambos.
    '|' devuelve true uno de los operandos es true, evaluándolos ambos.
    '^' xor exclusiva: 

10.- Operador de concatenación con cadena de caracteres '+':Por Ejemplo: System.out.println("El total es"+ result +"unidades");

Prioridad de los operadores: si en una expresión aparecen operaciones del mismo grupo, se evalúan con asociatividad por la izquierda. La procedencia puede alterarse con los paréntesis de modo habitual.

Operadores sobrecargados: Cuando un mismo operador sirve para distintos tipos de datos y se comporta de modo desigual. Por ejemplo, el operador división ( / ), se comporta de manera diferente si es una división entera o decimal:
10/3 = 3;
10/3.0 = 3.3;
3/10 = 0;
3.0/10 = 0.3;
10/0 = error de ejecución: /by cero.
10/0.0 = Infinity.
0/0.0 = NaN. (Not a Number).

 

Aplicación:

public class SegundosA{
    /**
     ¿Una cantidad de segundos: cuantos días, horas, minutos y segundos son?
     Para poder utilizar la mayor cantidad de segundos utilizamos el tipo long.
     Las operaciones especificas son:
            long l = s;      
            long dias = s/(24*60*60);
            s = s %(24*60*60);
            long horas = s/(60*60);
            s = s % (60+60);
            long minutos = s/60;
            s = s % 60;
            System.out.println(l+" Segundos, son "+días+" días, mas "+horas+" horas "+minutos+" minutos, y "+s+" segundos");

Todo el código restante es para que funcione sin errores.
     */
    public static void main(String[] arg){
        Scanner teclado = new Scanner(System.in).useLocale(Locale.US);
        boolean repetir = true; long s = 0;
        while (repetir){      
        System.out.println("Introduzca, en un entero, la cantidad de segundos  [0.. 2E63-1.");

        try{
         s = teclado.nextLong();
         }

        catch(InputMismatchException e){
            teclado.nextLine();
            System.out.println("error: fuera de rango"); repetir = true;
        }
          
         if(s<0) {System.out.println("error: fuera de rango");  repetir = true;
        }
         else{
            long l = s;      
            long dias = s/(24*60*60);
            s = s %(24*60*60);
            long horas = s/(60*60);
            s = s % (60+60);
            long minutos = s/60;
            s = s % 60;
            System.out.println(l+" Segundos, son "+dias+" dias, mas "+horas+" horas "+minutos+" minutos, y "+s+" segundos");
            repetir = false;
        }
    }
  }
}

 

Operadores, desbordamiento. Casting.

Cuando se sobrepasa el valor máximo o mínimo correspondiente a un tipo numérico determinado, se obtiene un desbordamiento, que produce un resultado no deseado o error lógico.
int n = 2000000 * 2000000 = 2147483647 (error lógico).
double x = 1e-432/10.0 = 0.0
Se producen errores lógicos, imposibles de detectar.

Casting:
Por defecto, los literales (-1, 1, -2, 2 ...) el compilador los toma como números enteros del tipo int; y los decimales (-1.0, 1.0, -2.0, 2.0,....) los toma como doubles.
El casting es la conversión de tipos. Hay una conversión implícita y otra explícita.
La conversión implícita se produce cuando hay una expresión de un tipo inferior al contexto donde se encuentra. Por ejemplo: 5/2.0, el 5 entero lo convierte en double, ya que el contexto es double, y el resultado es 2.5, double.
El casting explícito es forzado. La conversión de un tipo inferior a uno superior no tiene ningún problema. La viceversa puede producir truncamiento.
Ej: (double) 1234567; convierte el entero en double.
(int) 123456890987654321.987654; no convierte el tipo double en entero. Lo trunca, por los decimales y por el tamaño.
Esto que hemos visto de modo fácil con los enteros y doubles, sucede de la misma manera con cualquier tipo, incluso con los de tipo referencia u objetos. ( En éste último caso se precisa el uso del concepto herencia.)

 

El tipo carácter:

Nombre: char
Tamaño en bits: 16
Codificación: Unicode

El tipo char permite representar caracteres individuales como letras, números, y caracteres especiales. Internamente se representan como un valor entero positivo de hasta 16 bits. Java utiliza la codificación Unicode, asociando a cada valor Unicode un número entero, pudiendo tener millones de valores Unicode. Los 256 primeros son los caracteres ASCII/ANSI de 8 bits.
Además, al asociarse internamente con números enteros, hay compatibilidad entre los char y los int, y se puede operar con ellos mediante la aritmética de enteros.
También se puede hacer un casting implícito entre un char y un int. Y un casting explícito entre un int y un char.
char c1 = 'X';
char letraY = (char) (c1+1);

char letraZ = 'Y' + 1;
(int)  letraZ = 'Z'; (90 = 'Z')

Secuencias de escape: 
Son caracteres de control no visibles, pero realizan una acción especial.

\t      tabulador.
\n     new line.
\'       comillas simples
\"      comillas dobles
\\      barra invertida
\r     retroceso de carro
\f      comienzo fe página
\b      borrado a la izquierda.

"\t Este es\r un ejemplo \n de secuencias \f de escape\\"

 

 

 

El tipo lógico:

 

Nombre: boolean.
Tamaño bits: 1 bit.
Valores: true (verdadero), false (falso).

Una expresión es del tipo boolean, cuando al evaluarse resulta un valor true o false.

Se obtienen a partir de expresiones numéricas cuando se relacionan con operadores relacionales.
O a partir de expresiones lógicas si se relacionan con operadores lógicos.

Operadores relacionales
Operador	Utilización	Resultado
>	A > B	verdadero si A es mayor que B
>=	A >= B	verdadero si A es mayor o igual que B
<	A < B	verdadero si A es menor que B
<=	A <= B	verdadero si A es menor o igual que B
==	A == B	verdadero si A es igual a B
!=	A != B	verdadero si A es distinto de B

 

Operadores lógicos
Operador	Utilización	Resultado
!        not	A ! B	verdadero si A es distinto que B
|           or	A | B	verdadero si A o B es verdadero
&      and	A & B	verdadero si A y B son verdaderos
^       xor	A ^ B	verdadero si A y B son distintos
||      or cortocircuitado	A || B	verdadero si A es verdadero sin mirar a B
&&      and cortocircuitado	A && B	verdadero si A es verdadero y B también. Pero es falso si A es falso sin mirar a B

 

 

Ejemplos tipo lógico:

7<4  && 7/0 > 3          - se evalúa a false.
7<4 & 7/0 > 3              - da error de ejecución:       división por 0.

(v >=15) & ( v<=30) - se evalúa a true si v              está en [15,30]
(v >=15) I I ( v<=30) - se evalúa a true si v               es >= 15
(v >=0) && ( v<30)  ll (v >=45) && ( v<=50) && v%2 != 1
Se evalúa a true si v [0,30[ o v [45,50] y es par.

7.88<47%40 ll 7*3-9 < 13 && 54>= 'c'; (true)
(7.88<47%40 ll 7*3-9 < 13 ) && 54>= 'c'; (false)

7< x  < 11; produce error de compilación.
Debe escribirse:

7 < x  &  x < 11;