Para calcular el volumen de una pirámide en Java vamos a crear tres archivos:

1. Una interface,que contenga el método para obtener el volumen de una pirámide en Java.
2. Una clase que implemente la interface
3. Una clase principal para visualizar el resultado

Dentro de la interface vamos a definir un método para el cálculo del volumen en Java.

interface Servicios{
  public static final int M=3; // se pude definir una constante
  public abstract double volumen(); //método para obtener el volumen de la pirámide
}

La fórmula del volumen de una pirámide es la siguiente:

volumen= (ab*h)/3;

La clase que implementa la interface requiere dos atributos: la base y la altura.

class Piramide implements Servicios{
    private double base;
    private double altura;
...
...
 }

Ahora definimos dos constructores, uno vacío y otro con parámetros.

    public Piramide(){}
 
    public Piramide(double b,double h){
        this.base=b;
        this.altura=h;
    }

Agregamos el método «volumen()».

    @Override
    public double volumen(){
        return (base*altura)/M;
    }

Finalmente la clase principal donde se visualiza el resultado de calcular el volumen de una pirámide en Java.

public class VolumenPiramide{
//definimos un atributo de tipo "Servicios"
    Servicios servicio;
 
    public Ejemplos(){}
 
    public Ejemplos(Servicios serv){
        this.servicio=serv;
    }
 // con este método visualizamos el resultado
    public void activa(){
        System.out.println("volumen obtenido: "+servicio.volumen());
    }
 
    public static void main(String[] args) {
        Servicios piramide=new Piramide(10,15);// base:10, altura:15
        new Ejemplos(piramide).activa();
    }
}

Para calcular el volumen de un cilindro en Java emplearemos la función Math.PI de la clase java.lang.Math en la siguiente fórmula:

volumen= Math.PI*(r*r)*h

Donde r es el radio del cilindro y h su altura. Vamos a crear un método que obtenga el volumen de un cilindro en Java y le llamaremos «volumen()», y otro que muestre el resultado que llamaremos «ver()» dentro de una interface.

interface Servicios{
  public abstract double volumen();
  public abstract void ver();
}

En las interfaces todos los métodos son abstractas y se puede omitir las palabras public y abstract.

Necesitamos ahora una clase que implemente esa interface.

class Cilindro{
   public Cilindro(){}
}

Es necesario agregarle dos miembros (radio y altura) y definir un constructor con parámetros.

class Cilindro implements Servicios{
 	private double radio;
 	private double altura;

 	public Cilindro(){}

 	public Cilindro(double _radio,double _altura){
 		this.radio=_radio;
 		this.altura=_altura;
 	}

  }

Una vez hecho esto le agregamos los métodos de la interface:

@Override
public void ver(){
 	System.out.println(toString());
}

public String toString(){
	return String.format("volumen obtenido : %f",volumen());
}

@Override
public double volumen(){
	return Math.PI*(radio*radio)*altura;
}

Es de notarse que el método «toString()» es propio de la clase Cilindro.

Para mostrar el resultado tenemos la clase principal «VolumenCilindro».

public class VolumenCilindro{
        //Interface nombreInstancia= new ClaseImpl();
        Servicios cilindro=new Cilindro(2,6);
 		cilindro.ver();
}

Ya tenemos nuestro programa que calcula el volumen de un cilindro en Java.