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){
  .....   
}