Herencia

Podemos utilizar una Clase para pasar todos sus atributos y métodos a otra. La primera se llama superclase o padre y la segunda hija. En Java no existe herencia múltiple, sino de una sola Clase a otra, y así sucesivamente.
Por ejemplo, tenemos una Clase Persona, con los atributos:
Fecha fechaNacimiento;
String poblacionNacimiento;
String nombre;
String apellidos;
String domicilio;
String telefono;

Y unos métodos setters y getters que modifican y visualizan los atributos anteriores.

Si queremos crear la Clase Alumno hija de la anterior bien completada se entiende, tendrá todos los atributos y métodos de la Clase Persona, pero le podremos añadir los que queramos, para ello necesitamos añadir una palabra a la Clase hija: extends, en la cabecera de la definición de la Clase hija:
public class Alumno extends Persona {   };

y un método: super( ), con los parámetros materiales que tenga el método constructor de la superclase, pues hace sus veces. Este método se debe incluir en el método constructor de la Clase hija y además en primer lugar. La Clase Alumno,  heredará los atributos y métodos de la Clase Persona o padre o superclase, y la completamos con los atributos y métodos que necesitemos. Tendremos también, seguramente, que completar el constructor.
De la Clase Persona podríamos extender otras Clases como Profesor, y de ésta otras, según nos interese. Pero toda Clase  extendida heredará todos los parámetros y métodos de su Clase madre, aunque podamos modificarlos, y hacer, con el casting, utilizar uno u otros de las Clases superiores.

Secuencias enlazadas. La clase Nodo

Un nodo es una estructura de Java que asocia un dato de una Clase con el enlace o referencia al siguiente nodo.

public class NodoCF{//Dos datos tipo String, una referencia al siguiente NodoCF y un contador, //variable entera de Clase

    String nombre;//Hemos elegido los miembros elegidos por el CF del Psoe, por ser públicos.

    String ciudad;

    NodoCF siguiente;

    static int k;

    public NodoCF(String n,String c){//El primer constructor solo introduce el nombre y la ciudad del //primero de la lista

      this.nombre = n;

      this.ciudad = c;

      this.siguiente = null;//como es el primer nodo construido no hay referencia a otro.

    }

     public NodoCF(String n, String c, NodoCF s){//El segundo constructor permite introducir el //nombre y la ciudad de los siguientes de la lista

      this.nombre = n;

      this.ciudad = c;

      this.siguiente = s;//como ya hay un nodo construido hay referencia a él, 

      //de modo consecutivo se utiliza repetitivamente este constructor.

    }

    

    public String toString(){//Este método permite listarlos, pero en el orden inverso al que se han //introducido

    NodoCF aux = this.siguiente; String st = null; k=1;  

    while(aux!=null){

        st= k+".- "+aux.nombre+" ("+aux.ciudad+")";

        System.out.println(st);

        aux = aux.siguiente;k++;

    } 

    return st;

    }

}

public class ProgramCF{//Programa que construye secuencialmente la lista y los escribe// en pantalla.

   

    public static void main(String[] arg){

       NodoCF sec = new NodoCF("Juan Cornejo López ","Andalucía");

        sec = new NodoCF("Joan Jesús Ros Piles ","Valencia",sec);

        sec = new NodoCF("Sergio Gutiérrez Prieto ","CLM",sec);

        sec = new NodoCF("Marisol Mateos Nogales ","Extremadura",sec);

        sec = new NodoCF("Miguel Ángel Morales Quicios ","Euskadi" ,sec);

        sec = new NodoCF("Ana Sánchez Hernandez ","CyL",sec);

        sec = new NodoCF("Gonzalo Caballero Miguez ","Galicia",sec);

        sec = new NodoCF("Gimena Llamedo González ","Asturias",sec);

        sec = new NodoCF("Carmen Barahona Prol ","Madrid",sec);

        sec = new NodoCF("Mª José Camps Orfila ","Baleares",sec);

        sec = new NodoCF("Sabrina Moh Abdelkader ","Melilla",sec);

        sec = new NodoCF(" ","",sec);

        sec.toString();      

    }

}

En pantalla: (Al revés)

1.- Sabrina Moh Abdelkader  (Melilla)
2.- Mª José Camps Orfila  (Baleares)
3.- Carmen Barahona Prol  (Madrid)
4.- Gimena Llamedo González  (Asturias)
5.- Gonzalo Caballero Miguez  (Galicia)
6.- Ana Sánchez Hernandez  (CyL)
7.- Miguel Ángel Morales Quicios  (Euskadi)
8.- Marisol Mateos Nogales  (Extremadura)
9.- Sergio Gutiérrez Prieto  (CLM)
10.- Joan Jesús Ros Piles  (Valencia)
11.- Juan Cornejo López  (Andalucía)

Esta estructura de filas secuenciales permite manejar infinidad de datos.

Arrays lineales o de una dimensión

Podemos imaginar una calle mas o menos larga que tenga en uno de los lados aparcamientos señalizados y numerados secuencialmente del 0 a n-1. Los aparcamientos pueden estar en serie o en batería, para nosotros no importa. Esto es un array unidimensional de n componentes (aparcamiento).
En este array solo pueden aparcar coches en principio; se podría hacer un casting para que aparcaran furgonetas, ... ESTE ES EL PRINCIPIO FUNDAMENTAL DEL ARRAY: SOLO PUEDEN CONTENER DATOS DEL MISMO TIPO. No podemos poner bicicletas, ni contenedores, ni paradas de autobús.
De los arrays lineales podemos siempre saber el número de componentes que tiene con la variable numérica entera "length". Así, si el array antes descrito le llamamos parking, podemos saber el número de plazas de coche -solamente de coches, salvo casting- así: parking.length  y nos dá su numero de componentes o la capacidad del parking total. El array es un objeto en Java: tiene constructor, y a la vez en cada componente podemos poner un objeto, en este caso coche, pero sin ponerlo: ponemos solo la referencia o dirección de memoria en la que se encuentra el coche en el heap de memoria del ordenador: es decir, en el parking no habrá un solo coche, en cada aparcamiento tendremos un "papelito" donde está escrito donde se encuentra el objeto coche en el heap de la memoria.

Cuando en un array guardamos datos del mismo tipo, pero primitivos (int, boolean, doubles, char, ...), éstos sí se guardan directamente en las componentes del array. Los String son objetos y se guardan sus referencias, como los coches por ejemplo.

La gran ventaja de los arrays es que podemos acceder directamente a sus componentes.

Declaración de un array lineal: Se dechara poniendo el tipo de Dato u objeto, dos corchetes: [], y el nombre del array que le demos, puede ser cualquiera pero guardando las especificaciones del lenguaje java para los nombres, y que sean lo mas descriptivo posible del objeto o dato primitivo:

int [] numCoches;
double [] kilosPesoCoches;
String [] marcaCoches;
Coche [] coche;

Y se definen y crean como cualquier objeto, un poco especial, con el new:

int [] numCoches = new int[n];
double [] kilosPesoCoches = new double[n];
String [] marcaCoches = new String[n]
Coche [] coche = new Coche[n];

Se supone que nos estamos moviendo en el mismo parking con n aparcamientos.

Una clase TIPOS DE DATOS Punto sin constructor y sin métodos.

Una clase TIPO DE DATOS puede no tener estructura o atributos. Puede no tener constructor,... entonces tiene automáticamente un constructor por defecto...., o puede no tener cuerpo de métodos.
Ahora, por ejemplo tenemos una clase TIPO DE DATOS con sólo estructura. (Funcionará el constructor por defecto).

public class Punto {
           public  double x = 13.0;
           public double y = 28.7;
}
Con esto tenemos la clase TIPO DE DATOS Punto, funcional pero muy poco operatividad.
El constructor por defecto será:
         Punto p = new Punto ();

Podemos hacerla ejecutar con una clase Programa:

public class ProgramaPunto{

   public static void main(String[] arg){

    

    Punto p = new Punto();
    System.out.println("x = "+p.x +"; "+ "y= "+p.y);

    //los atributos son llamados por el punto p como si fueran métodos,

    //por ser públicos o tb si fueran friendly

    double distanciaOrigen = Math.sqrt(p.x * p.x + p.y * p.y);

    System.out.println("distancia al origen = "+distanciaOrigen);

    // distanciaOrigen no es un método, sino una variable elemental double

    }

}

Si la ejecutamos, tendremos estos resultados:

x =13.0;  y = 28.7

distancia al origen = 31.506983352901305

Si un mismo objeto del heap es referenciado por varias variables referencia, todas ellas actúan como una sola, y se puede acceder al objeto y modificarlo desde cualquiera de ellas, siendo el mismo valor del objeto para todas ellas.

Si a una de las variables referencia se le asigna el valor null, sólo ésta variable referencia toma éste valor, quedando desreferenciada y el garbage collector la elimina.

REFERENCIAS. El heap de memoria

Si en la Clase ProgramaPunto creamos un par de puntos con el operador del constructor new, de esta manera:

                   new Punto(x1,y1);
                   new Punto(x2,y2);

y ejecutamos el ProgramaPunto, dándoles valores a x1, y1; x2, y2.

Las expresiones new Punto (x1, y1); y new Punto (x2, y2), toman valores como estos: "Punto@1b786c3" y "Punto@1ff2795". Estos valores son REFERENCIAS o direcciones de memoria del heap, que es el espacio de memoria reservado específicamente para los objetos. En efecto, en el heap se reservan, al ejecutar el new, las variables de los objetos agrupadas y con los valores que les hayamos dado a x1, y1, y x2, y2. (En la foto se muestran los atributos de objeto x, y; y los valores en recuadros, y se encuentran en un montículo o heap).

                   

Si ahora asignamos las referencias de los objetos a las variables objeto p1 y p2,  de la clase Punto:

             Punto p1 = new Punto (0.0, 0.0);

             Punto p2 = new Punto (3.5, 4.2);

en los rectángulos (figurado) se guardan las referencias, o direcciones de memoria, de los objetos que están en el heap o montículo.

Clase ProgramaPunto con métodos estáticos y dinámicos

import java.util.*;//para crear el scanner y obtener datos desde teclado.

public class ClaseProgramaPunto{
   
    public static void main(String[] arg){//el método main es el principal o de arranque del programa
   
        Scanner teclado = new Scanner(System.in).useLocale(Locale.US);
       
        System.out.println("Introduzca el valor double de x para el punto p1");
        double x1 = teclado.nextDouble();
       
        System.out.println("Introduzca el valor double de y para el punto p1");
        double y1 = teclado.nextDouble();
   
        System.out.println("Introduzca el valor double de x para el punto p2");
        double x2 = teclado.nextDouble();
       
        System.out.println("Introduzca el valor double de y para el punto p2");
        double y2 = teclado.nextDouble();
       
        //creamos los puntos con los valores de las variables elementales guargados en memoria :
        Punto p1 = new Punto(x1,y1);
        Punto p2 = new Punto(x2,y2);
        //usamos los métodos de la Clase de DATOS Punto:
        double d = p1.distancia(p2);System.out.println(d);
       
        double d1 = p1.distanciaOrigen();System.out.println(d1);
        double d2 = p2.distanciaOrigen();System.out.println(d2);
       
        double dd = Punto.distancia(p1,p2);System.out.println(d);
       
        double dd1 = Punto.distanciaOrigen(p1);System.out.println(d1);
        double dd2 = Punto.distanciaOrigen(p2);System.out.println(d2);
        System.out.println(Punto.getN());
    }
}

Clase Punto con métodos dinámicos y estáticos que hacen lo mismo

El distinguir y utilizar convenientemente los métodos dinámicos y estáticos es fundamental para la POO.
Los métodos dinámicos, como son métodos también llamados de objeto, se invocan con el objeto correspondiente. Ej: p1.distancia(p2); Nos da la distancia entre los dos puntos p1 y p2;
Los métodos estáticos, también llamados de Clase, se invocan con la Clase: Punto.distancia(p1,p2); Nos da la distancia entre los dos puntos p1 y p2; También se puede invocar un método estático mediante cualquier objeto de la clase: p3.distancia(p1,p2);
Nos da la distancia entre los dos puntos p1 y p2;

import java.util.*;
//Clase de tipo de DATO:
public class Punto{//Clase Punto en el plano.
    //Estructura del objeto: el objeto punto se estructura con dos variables dobles: Es la agrupación
    //de estas dos variables o atributos.
    private double x;
    private double y;
     static private int n;

    /**
     * Constructor de los objectos de la  clase Punto
     */
    public Punto(){
        // inicialización  de una instancia u objeto de dos variables elementales. El punto se
        //encuentra en el origen.
        x = 0;
        y = 0;
        n++;
    }
 
    public Punto(double x, double y){
        // inicialización  de una instancia u objeto de dos variables elementales. El punto se
        //encuentra en los valores de x, y que le pasamos como parametros.
        this.x = x;
        this.y = y;
        n++;
    }

    //metodos para manipular los objetos punto:
    public double getX(){//conocemos el valor del atributo x del punto
      return this.x;
    }
 
    public double getY(){//conocemos el valor del atributo y del punto
      return this.y;
    }
 
    public static double getN(){//conocemos el valor de n
      return n;
    }
 
    public void setX(double x){//cambiamos el valor del atributo x del punto
      this.x = x;
    }
 
    public void setY(double y){//cambiamos el valor del atributo y del punto
       this.y = y;
    }
 
 
    public double distanciaOrigen(){
    double x1 = this.x, y1 = this.y; 
    double distancia = Math.sqrt(x1*x1+y1*y1);
    return distancia;
    }
 
    public double distancia(Punto p2){
    double x1 = this.x, y1 = this.y; 
    double x2 = p2.x, y2 = p2.y; 
    double distancia = Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
    return distancia;
    }
 
    //admite el mismo nombre porque tiene parámetros distintos
    public static double distanciaOrigen(Punto p1){
    double x1 = p1.getX(), y1 = p1.getY(); 
    double distancia = Math.sqrt(x1*x1+y1*y1);
    return distancia;
    }
 
    //admite el mismo nombre porque tiene parámetros distintos
    public static double distancia(Punto p1, Punto p2){
    double x1 = p1.getX(), y1 = p1.getY();   
    double x2 = p2.getX(), y2 = p2.getY(); 
    double distancia = Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
    return distancia;
    }
 
}

Clase Programa. Aplicación a la clase Punto

import java.util.*;//para  poder crear un objeto de tipo scanner -teclado- y obtener datos desde él.

public class ClaseProgramaPunto{
 
    public static void main(String[] arg){//el método main es el principal o de arranque del programa
 
        Scanner teclado = new Scanner(System.in).useLocale(Locale.US);//separador el " . " (punto)
     
        System.out.println("Introduzca el valor double de x para el punto p1");
        double x1 = teclado.nextDouble();
     
        System.out.println("Introduzca el valor double de y para el punto p1");
        double y1 = teclado.nextDouble();
 
        System.out.println("Introduzca el valor double de x para el punto p2");
        double x2 = teclado.nextDouble();
     
        System.out.println("Introduzca el valor double de y para el punto p2");
        double y2 = teclado.nextDouble();
     
        //creamos los puntos con los valores de las variables elementales guargados en memoria  mediante el método constructor y el operador new:
        Punto p1 = new Punto(x1,y1);
        Punto p2 = new Punto(x2,y2);
        //usamos los métodos de la Clase de DATOS Punto:
// distancia entre dos puntos:
        double d = p1.distancia(p2);System.out.println(d);
     
// distancia entre un punto y el origen:   
    double d1 = p1.distanciaOrigen();System.out.println(d1);
        double d2 = p2.distanciaOrigen();System.out.println(d2);
    }
}

Clase tipo de DATOS. Explicación mediante la clase Punto.

Tipos COMPLEJOS o REFERENCIA: OBJETOS.
Un OBJETO permite agrupar DATOS como una unidad. El objeto tipo Punto agrupa los valores que tomen las variables de objeto, o atributos, para ese punto. Éstos atributos forman lo que se llama la estructura de la clase. Son las variables de objeto x e y en nuestra clase Punto. Puede haber también variables de clase distintas a las variables de objeto.
Los objetos tipo Punto pueden tratarse y manipularse mediante los métodos u operaciones que se definen en el cuerpo de la clase.
De alguna manera definimos el ser y el obrar de los objetos de la CLASE.
En primer lugar se crea un objeto mediante el operador new aplicado al constructor.
Y en segundo lugar mediante los métodos, en nuestro caso podemos conocer la distancia entre dos puntos, o la distancia de uno al origen. Podemos obtener los valores de las variables o atributos x e y que tomen.
Todos los métodos definidos en esta primera clase de tipos de DATOS Punto son métodos de objeto, es decir, se invocan mediante un objeto de la clase Punto: p1.distancia(p2); El punto " . " es el operador de la invocación del método. Podemos definir otros como mover un punto; moverlo de modo que sea simétrico respecto el eje de abcisas...
A éstos métodos de objeto se les llaman métodos dinámicos. Existen también métodos de clase o estáticos que veremos después.

Todo depende de qué necesitamos y los métodos que definamos para ello. Por ejemplo, podríamos definir que, dados tres puntos, obtengamos el centro de gravedad de ellos... o hacer simetrías o mil posibilidades que la geometría nos permite.

Clase tipo de DATOS Punto

import java.util.*;
//Clase de tipo de DATO:
public class Punto{//Clase Punto en el plano.
    //Estructura del objeto: el objeto punto se estructura con dos variables dobles: Es la agrupación
    //de estas dos variables o atributos.
    private double x;
    private double y;

    /**
     * Constructor de los objectos de la  clase Punto
     */
    public Punto(){
        // inicialización  de una instancia u objeto de dos variables elementales. El punto se
        //encuentra en el origen.
        x = 0;
        y = 0;
    }
 
    public Punto(double x, double y){
        // inicialización  de una instancia u objeto de dos variables elementales. El punto se
        //encuentra en los valores de x, y que le pasamos como parametros.
        this.x = x;
        this.y = y;
    }

    //metodos para manipular los objetos punto:
    public double getX(){//conocemos el valor del atributo x del punto
      return this.x;
    }
 
    public double getY(){//conocemos el valor del atributo y del punto
      return this.y;
    }
 
    public void setX(double x){//cambiamos el valor del atributo x del punto
      this.x = x;
    }
 
    public void setY(double y){//cambiamos el valor del atributo y del punto
       this.y = y;
    }
 
 
    public double distanciaOrigen(){
    double x1 = this.x, y1 = this.y; 
    double distancia = Math.sqrt(x1*x1+y1*y1);
    return distancia;
    }
   
    public double distancia(Punto p2){
    double x1 = this.x, y1 = this.y; 
    double x2 = p2.x, y2 = p2.y; 
    double distancia = Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
    return distancia;
    }
    }

Desbordamiento y truncamiento de los números.

Cuando una VARIABLE del TIPO entero o decimal, adquiere un valor de inicio o en cualquier momento de la ejecución del programa mayor o menor que los que hemos indicado para cada tipo de DATOS, el programa se ejecuta, pero da un resultado equívoco. Se dice entonces que la variable se ha DESBORDADO. Quizá también es válido para el tipo char.

Si hacemos casting de un TIPO DE DATO a otro de capacidad de almacenamiento menor, el valor se puede truncar, y dar un resultado equívoco.
P.ej.

 x = 13.6*Math.pow(13.6, 13.0);

    a = (int) x;

    System.out.println(x+"; "+a);//x = 7.405335126468474E15; a = 2147483647

Ha habido un truncamiento y el valor de a es incorrecto;

Operadores sobrecargados.

Los operadores se utilizan mediante los tipos de DATOS PRIMITIVOS.
Normalmente un mismo operador se utiliza para varios tipos de datos primitivos, aunque a veces  no del mismo modo. Se dice que el operador está sobrecargado.
Hacemos un programa de prueba para analizarlo:

import java.util.*;
public class OperadoresTipos{
   public static void main(String[] arg){
    Scanner teclado = new Scanner(System.in).useLocale(Locale.US);// hacemos decimal al punto
 
    //Introduccion de DATOS segun los Tipos:
    System.out.println("Introduzca un número entero a=");
    int a = teclado.nextInt();
    System.out.println("Introduzca otro número entero b=");
    int b = teclado.nextInt();
    System.out.println("Introduzca un número decimal x=");
    double x = teclado.nextDouble();
    System.out.println("Introduzca otro número decimal y=");
    double y = teclado.nextDouble();
    System.out.println("Introduzca un caracter m");
    char m = teclado.next().charAt(0);
    System.out.println("Introduzca otro caracter n");
    char n = teclado.next().charAt(0);
    System.out.println("Introduzca un booleano s");
    boolean s = teclado.nextBoolean();
    System.out.println("Introduzca otro booleano t");
    boolean t = teclado.nextBoolean();
    //Operaciones segun los tipos: aritméticos con enteros
    int c = a + b ;System.out.println("a+b vale " +c);
    int d = a * b ;System.out.println("a*b vale " +d);
    int e = a / b ;System.out.println("a/b vale " +e);
    int f = a % b ;System.out.println("a%b vale " +f);
 
    //arirméticos con los dobles
    double z = x + y ;System.out.println("x+y vale " +z);
    double u = x * y ;System.out.println("x*y vale " +u);
    double v = x / y ;System.out.println("x/y vale " +v);
    double w = x % y ;System.out.println("x%y vale " +w);
 
    //aritméticos con los char: requieren una conversión o CASTING.
    char o = (char) (m + n) ;System.out.println("m+n vale " +o);
    char p = (char) (m * n) ;System.out.println("m*n vale " +p);
    char q = (char) (m / n) ;System.out.println("m/n vale  " +q);
    char r = (char) (m % n) ;System.out.println("m%n vale " +r);
 
    //operadores relacionales con cualquiera de los anteriores, dan resultados booleanos.
    if( m >= n) System.out.println("m>=n = "+true);else System.out.println("m>=n vale "+false);
    if( s == t) System.out.println("s==t = "+true);else System.out.println("s==t  vale"+false);
    if( a <= b) System.out.println("a <=b = "+true);else System.out.println("a <=b vale "+false);
    if( s != t) System.out.println("s!=t = "+true);else System.out.println("s!=t vale "+false);
 
 
   }
}


Ejecutando el programa OperadoresTipos:

Introduzca un número entero a vale 2
Introduzca otro número entero b vale 4
Introduzca un número decimal x vale 2
Introduzca otro número decimal y vale 4
Introduzca un caracter m vale 2
Introduzca otro caracter n vale 4
Introduzca un booleano s vale true
Introduzca otro booleano t vale false

a+b vale 6
a*b vale  8
a/b vale 0
a%b vale 2

x+y vale 6.0
x*y vale 8.0
x/y vale 0.5
x%y vale 2.0

m+n vale f
m*n vale ਨ
m/n vale
m%n vale 2

m>=n vale false
s==t vale false
a <=b vale true
s!=t vale true

Podemos ver que la división de números enteros no se comporta del mismo modo que la división de decimales o dobles:
2/4 vale 0    (división de dos enteros).
2.0/4.0 vale 0.5    (división de dos dobles).
m/0  error de ejecución.(división de un entero por 0);
0.0/0 vale NaN (Not a Number: división decimal de cero decimal por cero)
5.0/0 vale Infinity (division decimal de decimal positivo por cero).
-5.0/0 vale - Infinity (division decimal de decimal negativo por cero).

Los char se pueden comportar como los enteros, si hacemos una conversión o casting como hemos hecho arriba.

Operadores de datos PRIMITIVOS y/o COMPLEJOS

Clasificación                         Operadores
Paréntesis                                      ( )
Unarios postfijos               expr++  expr--
Unarios prefijos  ++expr --expr  +expr !expr
Creación                                          new
Conversión                            (tipo)  expr
Producto                                   *    /    %
Suma                                              +  -
Relacionales                          >  >=     <  <=
Igualdad                                      ==     !=
Conjunción   (and)                          &
Disyunción exclusiva (xor)            ^
Disyunción lógica (or)                     I
Conjunción cortocircuitada          &&
Disyunción cortocircuitada           II

Están en orden de precedencia,  dentro de la misma clasificación se evalúan de izquierda a derecha. La precedencia se puede alterar con los paréntesis.

Tipos de DATOS PRIMITIVOS.

Tipos NUMÉRICOS:
- enteros: byte, short, int, long.
- reales: float, double.
Tipo CARÁCTER: char.
Tipo LÓGICO: boolean.

El tipo configura la capacidad de almacenamiento de las variables del tipo:
Tipo   Tamaño N   Valor min.     Valor máx.

byte      8 bits.         - 2^(N-1)      - 2^(N-1) -1
short   16 bits              "                      "
int        32 bits.             "                      "
long     64 bits.             "                      "

float.    32 bits.      1.4*10^-45   3.4*10^38
double  64 bits     4.9*10^-324  1.8*10^308

char      16 bits      (Codificación Unicode)

boolean  1 bits     false/true  

IDENTIFICADORES java.

Todas las VARIABLES java tienen un NOMBRE o IDENTIFICADOR que representa la dirección de memoria donde se encuentra su VALOR o DATO. Es como la dirección de un apartado de correos donde se encuentra el VALOR.
Pero hay una diferencia grande si la variable es de tipo COMPLEJO o PRIMITIVO.  Si es de tipo primitivo es como hemos dicho del apartado de correos; pero si es de tipo COMPLEJO, en el apartado de correos ni siquiera está el dato o valor, sino una referencia a otra dirección de memoria que se encuentra en lo que se llama heap, que el ordenador reserva para guardar los OBJETOS.
La sintaxis de los identificadores es relativamente sencilla:
1.- Palabras que empiecen por una letra y a continuación una secuencia de letras o números sin espacios intercalados.
2.- Pueden incluir los signos _ y $.
3.- Descriptivas y fáciles de recordar.
4.- Distingue las mayúsculas de las minúsculas.
5.- Hay palabras reservadas, que son las del lenguaje de programación.

Variables FINAL o CONSTANTES.

Cuando una VARIABLE es declarada con el CALIFICADOR  o MODIFICADOR final, el dato con el que se INICIALIZA no puede ser cambiado. Por eso se le llama también CONSTANTE:

final String e = "enero";
No podemos hacer después e = "marzo";
Si no estuviera con el MODIFICADOR final, sí.

ESTADO de una VARIABLE y de un PROGRAMA

El ESTADO de una VARIABLE es su VALOR en un momento de la ejecución del programa.
Y el ESTADO del PROGRAMA es el conjunto de los estados de sus VARIABLES, también en un momento determinado.
La TRAZA sigue el estado de las variables del programa a lo largo de su ejecución.

Variables.

Las VARIABLES representan DATOS de un programa. Pueden tomar valores de un TIPO DE DATOS determinado. ( Es lo mismo datos que valores?). Sus valores pueden cambiar a lo largo de la ejecución del programa.

DECLARACIÓN de variables:
Se declaran mediante su TIPO DE DATO y su IDENTIFICADOR o NOMBRE.
Ejemplos:
int a; double x; String s; char t; boolean b;

ASIGNACIÓN:
La asignación de valores a una variable se realiza mediante el operador "=" , que es distinto que el "=" matemático.
ASIGNACIÓN: nombrevariable = expresión;

Se puede DECLARAR una VARIABLE e  INICIALIZARLA a la vez: ASIGNARLE un VALOR  inicial:
String s = "Hola";
String t = "cariño";
String st = s+t;
/** la variable DECLARADA  con nombre st y de tipo String vale "Hola cariño", ASIGNADO (=) mediante la EXPRESIÓN    s+t; */

Una EXPRESIÓN es una sucesión secuencial de variables, operadores, valores, cuyo resultado es un valor del tipo de la variable o compatible.

Tipos de DATOS.

TIPOS DE DATOS:
Los tipos de datos están formados por un conjunto de datos y por las operaciones que les son permitidas.
Pueden ser:
-TIPOS DE DATOS ELEMENTALES O PRIMITIVOS.
-TIPOS DE DATOS COMPLEJOS O CLASES DE OBJETOS.

Instrucciones y datos.

En lenguaje máquina, un programa es una sucesión secuencial, en código binario, que representan direcciones de memoria de instrucciones y datos.
Cada INSTRUCCION realiza una operación con el dato parejo, representados ambos por las direcciones de memoria.
Un DATO es cualquier información que pueda ser tratada por el ordenador.

Problemas, algoritmos y programas

Los PROBLEMAS se han de definir de manera general y precisa, sin resquicios para la ambiguedad.
"Dado un entero positivo n, determinar si es primo".

El ALGORITMO que ha de resolver el problema, se forma por un conjunto de reglas que deben resolver el problema de forma exacta y efectiva en tiempo finito.
"1.- Considerar todos los enteros comprendidos entre 2 y n-1.
2.- Para cada entero de esta sucesión, comprobar si divide a n.
3.- Si n es dividido por algún número, no es primo.
4.- Si n no es dividido por ninguno, es primo.

El PROGRAMA:

import java.util.*;
public class EsPrimo{
    public static void main(String[] arg){
        Scanner teclado = new Scanner(System.in).useLocale(Locale.US);
        System.out.println("CONOCER SI UN NUMERO POSITIVO ES PRIMO.");
        System.out.println("Introduzca un entero positivo cualquiera");
        int n = teclado.nextInt();
        if(n>0) System.out.println(esPrimo(n));       
        else  System.out.println("Introduzca un entero positivo cualquiera");//repite entrada n
    }
   
    public static boolean esPrimo(int n){
         int i = 2;boolean devuelve = false;
        if (n==1||n==2||n==3)devuelve = true;   
        else{
        while(i<n-1&&n%(double)i!=0.0)
            i++;
         if (i+1==n) devuelve = true;
         else devuelve = false;   
       
       }
        return devuelve;
    }
}

El lenguaje Java

Java es un lenguaje de alto nivel.

El programador trabaja con una sintaxis que no tiene nada que ver con el lenguaje máquina.

Ej.            int a = 8 x 3;

a es una variable de tipo entero. Que representa una especie de espacio de memoria donde se guarda el valor de tipo entero que se le asigna mediante la instrucción "=", del resultado de la expresión de 8 x 3; Es decir, en el lugar de memoria representado por a se guarda el valor entero 24.

Si hiciésemos      a = a + 4;

En dicho lugar de memoria representado por a se guardaría el valor 28. La variable a representa el valor que se guarda en su memoria.

Es un lenguaje IMPERATIVO, pues requiere una INSTRUCCIÓN para cambiar el valor almacenado en la variable.

Esta instrucción suele ser "=".

Ej.        double c = 2 x Math.PI x r;

Es un lenguaje SECUENCIAL, pues las INSTRUCCIONES se ejecutan en el orden de su escritura:

Ej.

    1.-    int a = 28;

    2.-         a = a+4;

    3.-   double r = a x 3.4321;

    4.-   double c = 2 x Math.PI x r;

Se ejecutan en la secuencia numerada.

La Programación Orientada a Objetos

En los lenguajes POO, como es Java, la agrupación de DATOS referenciados en una única VARIABLE, que se manipula como una unidad compleja, se llama OBJETO, (es un DATO complejo, formado por DATOS, simples y/o complejos).

Una CLASE TIPO DE DATOS define un tipo de OBJETOS con una ESTRUCTURA y unas OPERACIONES o MÉTODOS, para aplicar a los OBJETOS de su CLASE. (Ej. Clase de Java String)

Existen CLASES LIBRERÍAS predefinidas en Java o creadas por nosotros -APIS-, que son REPOSITORIOS de operaciones o MÉTODOS que podemos utilizar en otras CLASES. (Ej. Clase de Java Math).

Por último, CLASE PROGRAMA, con el método main.
Ej.:
public static void main(String[] arg){
  .....   
}