Liczenie pola

Witam. Mam do napisania program liczący pole figur. Mam jednak problem z kompilacją...

package Pole_figur;



abstract class Figura {
    
 public abstract double pole ( ) ;
}


class Pole extends Figura
{
    public final double pol;
    public Pole(double p)
    {
        pol=p;
    }
    @Override
    public double pole()
    {
        return pol;
    }
    
}

class Kwadrat extends Figura
{
    public final Figura a1;
   public Kwadrat(Figura bok)
    {
        a1=bok;
    }
    
    @Override
    public double pole()
    {
        return a1.pole();
        
    }
}

class Prostokat extends Figura
{
    public Figura b1;
    public Figura c;
    public Prostokat(Figura bok, Figura bok1)
    {
        b1=bok;
        c=bok1;
    }
    
    @Override
    public double pole()
    {
        return b1.pole() * c.pole();        
    }
}









public class Pole_figur {

    /
    public static void main(String[] args) {
       
        System.out.println("Obliczenia");
        
       
       System.out.println((new Pole(new Prostokat(2.0,4.0))).pole());//Wynik - 8.0
       System.out.println((new Pole(new Kwadrat(2.0))).pole());//Wynik - 4.0
      
    }
    
}

Przede wszystkim masz kłopot ze zrozumieniem na czym polega dziedziczenie.
Klasa Pole jest, moim zdaniem, zupełnie niepotrzebna. Klasa Prostokat winna zawierać dwa pola numeryczne do przechowywania długości boków, klasa Kwadrat jedno pole numeryczne.

class Kwadrat extends Figura
{
      private double bok;
      public Kwadrat(double bok)
      {
            this.bok = bok;
     }
 
     @Override
     public double pole()
     {
           return bok*bok; 
     }
}

Mysle nawet, ze dziedziczenie jest tu zbedne. Wystarczyla by klasa Kwadrat i Prostokat, tak jak bogdans napisal i klasa main. Metody na obliczanie pola kazda figura ma inne wiec i tak je musisz przeciazac.

 
public class Main {
	public static void main(String[] args){
		Kwadrat a = new Kwadrat(2.0);
		Prostokat b = new Prostokat(2.0, 4.0);
		
		
		System.out.println("Obliczenia");
		System.out.println();
		System.out.println("Pole Kwadratu = " + a.obliczPole());
		System.out.println("Pole Prostokata = " + b.obliczPole());
	}
}
public class Kwadrat {
	private double bokA;
	
	public Kwadrat(double a){
		this.bokA = a;
	}
	
	public double obliczPole(){
		return bokA * bokA;
	}
}
public class Prostokat {
	private double bokA;
	private double bokB;
	
	public Prostokat(double a, double b){
		this.bokA = a;
		this.bokB = b;
	}
	
	public double obliczPole(){
		return bokA * bokB;
	}
}

Ale jezeli musi to byc z dziedziczeniem to ja bym to widzial tak:

public class Main {
	public static void main(String[] args){
		Kwadrat a = new Kwadrat(2.0);
		Prostokat b = new Prostokat(2.0, 4.0);
		
		System.out.println("Obliczenia");
		System.out.println();
		System.out.println("Pole kwadratu = " + a.obliczPole());
		System.out.println("Pole prostokata = " + b.obliczPole());
	}
}
public class Figura {
	double bokA;
	double bokB;
//	double srednica, wysokosc i wszystkie inne zmienne potrzebne do obliczen
}
public class Kwadrat extends Figura {
	public Kwadrat(double a) {
		super.bokA = a;
	}

	double obliczPole(){
		return super.bokA * super.bokA;
	}
}
public class Prostokat extends Figura {
	public Prostokat(double a, double b) {
		super.bokA = a;
		super.bokB = b;
	}

	double obliczPole(){
		return super.bokA * super.bokB;
	}
}
 

@PanKalmar w pokazanym przykładzie i tak wydaje mi się, że dziedziczenie jest bez sensu bo trzeba stworzyć osobną metodą do liczenia pola kwadratu i prostokąta, oraz różne konstruktory. Ja bym to zrobił w ten sposób:

public class Rectangle
{
	protected double bok1 = 0;
	protected double bok2 = 0;
	
	//========================================
	
	public Rectangle(int... boki)
	{
		if(boki.length == 1)
			bok1 = bok2 = boki[0];
		else if(boki.length > 1)
		{
			bok1 = boki[0];
			bok2 = boki[1];
		}
	}
	
	//========================================
	
	public double obliczPole()
	{
		return bok1*bok2;
	}
	
	//========================================
}

Dzięki tak napisanej klasie macierzystej, nie ma potrzeby definiowania ani różnych konstruktorów ani różnych metod liczenia pola dla kwadratu i prostokąta :)

Jeżeli natomiast program ma operować na różnych innych figurach takich jak trójkąt, trapez itd. Wówczas wydaje mi się, że klasą macierzystą powinna być klasa podobna do tego:

public abstract class Figura
{
	protected double pole;
	protected double obwod;
	protected double wysokosc;
        ....itd.
}

i po czyms takim powinny dziedziczyć figury, udostępniając własne konstruktory i metody. Zawsze też można zrobić dziedziczenie wielokrotne i po klasie Figura może dzidziczyć klasa Prostokąt (nie abstrakcyjna) i po klasie prostokąt może dzidziczyć kwadrat w podobny sposób jak to pokazałem wyżej.

 public Rectangle(int... boki)
    {
        if(boki.length == 1)
            bok1 = bok2 = boki[0];
        else if(boki.length > 1)
        {
            bok1 = boki[0];
            bok2 = boki[1];
        }
    }

Ta konstrukcja nie ma sensu. Kwadrat ma cztery boki, a kod nie powinien się tylko kompilować, ale również być zgodny z tym czego oczekuje się "na zdrowy rozsądek".

Nie rażą mnie nazwy, ale to że mogę dać 200 parametrów konstruktorze, który powinien przyjmować dwa parametry.

public Rectangle(int a,int b)
    {
        if(a < 0 || b < 0) {
           throw new IllegalArgumentException("a i b muszą być większe od 0");
        }

        this.a = a;
        this.b = b;
    }

tak, możesz dać 200 parametrów, ale i tak zostaną przyjęte max 2 pierwsze więc nie ma z tym raczej problemu

public static void main(String ...args) {
     Rectangle r = new Rectangle(null); //teraz też nie ma problemu w Twojej implementacji?

}

class Rectangle {

    int bok1,bok2;

    public Rectangle(int a)
    {
        if(a <= 0 ) {
            throw new IllegalArgumentException("a musi być większe od 0");
        }
        this.bok1 = a;
        this.bok2 = a;
    }
}