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;
    }
    }