Jak przekazać paramtery do klasy nie dziedziczącej

Witam.
Mam napisać program, który posiada klasę samochód, oraz dziedziczącą po niej klasę ciężarówka. Do tego należy dopisać klasę policjant (nie dziedziczącą), która odpowiada za zatrzymanie samochodu za przekroczenie prędkości lub zbyt duży załadunek.
Moje pytanie brzmi: Jak mam przekazać do klasy policjant parametry z jakimi jadą te samochody?

package policja;

class Samochod{
    public String marka;
    public double predkosc;

    Samochod(String marka, double predkosc){
        this.marka = marka;
        this.predkosc = predkosc;
    }

    Samochod(){
        this.marka = "złom";
        this.predkosc = 0;
    }

    public void setMarka(String marka){ this.marka = marka; }
    public String getMarka(){ return marka; }

    public void setPredkosc(double predkosc){ this.predkosc = predkosc; }
    public double getPredkosc(){ return predkosc; }

    public void pokaz(){
        System.out.println("Marka: "+marka+"\nPrędkość: "+predkosc+" km/h");
    }

}

class Ciezarowka extends Samochod {
    public int ladownosc;
    Ciezarowka(String marka, double predkosc, int ladownosc){
        super(marka, predkosc);
        this.ladownosc = ladownosc;
    }

    Ciezarowka(){
        this.ladownosc = 0;
    }

    public void setLadownosc(int ladownosc){ this.ladownosc = ladownosc; }
    public double getLadownosc(){ return ladownosc; }

    public void pokaz(){
        System.out.println("Marka: "+marka+"\nPrędkość: "+predkosc+" km/h\nŁadowność: "+ladownosc+" t");
    }
}

class Policjant{

}

public class Main {
    public static void main(String[] args) {
        Samochod s = new Samochod("BMW", 123);
        s.pokaz();
        
        System.out.println();
        System.out.println("----------");
        System.out.println();

        Ciezarowka c = new Ciezarowka("Star", 100, 25);
        c.pokaz();
    }

}

Najprościej to użyć PropertyChangeListenera, ale to może być dla ciebie trudne. Prościej jest zaimplementować wzorzec obserwatora.

Dane przekazujesz nie do klasy bo ta jest tylko szablonem do tworzenia obiektów, ale do konkretnego obiektu. Konkretny policjant pobiera np. prędkość z konkretnego samochodu przez np.

Samochód czerwonyPorsche = new Samochód(...);
Policjant wkurzony = new Policjant(...);
//...
wkurzony.skanujeRadarem(czerwonyPorshe.getPrędkość());
if(wkurzony.odczytanaPrędkość() > 140) wkurzony.zatrzymuje(czerwonyPorsche);

Oczywiście można też użyć od razu warunek czerwonyPorsche.getPrędkość() > 140. Ale wtedy będziemy mieli systemowe przekroczenie prędkości (np. fotoradar) i nie będzie można użyć np.
if (czerwonyPorshe.getKierowca().setŁapówka(200).wręcza(wkurzony) == Policjant.ŁAPÓWKA_PRZYJĘTA) czerwonyPorsche.szybkiePrzyspieszenie();
:)

Olamagato dzięki wielkie :)

Ma to wyglądać jakoś tak?

class Policjant{
    private double radar;
    private int ladunek;
    Policjant(double radar){
        this.radar = radar;
    }

    Policjant(double radar, int ladunek){
        this.radar = radar;
        this.ladunek = ladunek;
    }

    Policjant(){
        this.radar = 0;
        this.ladunek = 0;
    }

    public void akcja(){
        if(radar>100 || ladunek>25) System.out.println("Akcja: zatrzymanie!");
    }
}

public class Main {
    public static void main(String[] args) {
        Samochod s = new Samochod("BMW", 123);
        s.pokaz();
        Policjant ps = new Policjant(s.getPredkosc());
        ps.akcja();

        System.out.println();
        System.out.println("----------");
        System.out.println();

        Ciezarowka c = new Ciezarowka("Star", 100, 26);
        c.pokaz();
        Policjant pc = new Policjant(c.getPredkosc(), c.getLadownosc());
        pc.akcja();
    }

}

A czy nie lepiej przekazywać do Policjanta tylko obiekt samochodu albo nie przekazywać nic, a tylko wywoływać na jego rzecz tą metodę z konkretnym argumentem (samochodem)?

iooi napisał(a)

A czy nie lepiej przekazywać do Policjanta tylko obiekt samochodu albo nie przekazywać nic, a tylko wywoływać na jego rzecz tą metodę z konkretnym argumentem (samochodem)?

Mógłbyś przedstawić to rozwiązanie, bo gość na laborkach mówił chyba właśnie żeby w ten sposób to zrobić.

class Policjant {
    private int maxPredkosc;
    private int maxLadownosc;

    Policjant(int maxPredkosc, int maxLadownosc) { /* ... */ }

    boolean zatrzyma(Ciezarowka ciezarowka) {
        return ciezarowka.getPredkosc() > maxPredkosc) || (ciezarowka.getLadownosc() > maxLadownosc);
    }
}

// ...

Policjant normalny = new Policjant(120, 25);
Policjant wkurzony = new Policjant(60, 10);
Ciezarowka ciezarowka = new Ciezarowka("Star", 100, 15);
if (normalny.zatrzyma(ciezarowka)) System.out.println("Normalny zatrzymuje ciezarowke");
if (wkurzony.zatrzyma(ciezarowka)) System.out.println("Wkurzony zatrzymuje ciezarowke");

Krótko mówiąc możesz dane do obiektu przekazywać za pomocą jego metod (np. set... i get...) oraz przekazywać do metody (lub pola, ale to nie jest zbyt poprawne) swojego obiektu referencję do tego obiektu. Jednak w tym drugim wypadku Twoja klasa musi posłużyć się interfejsem (wszystkie dostępne metody) tego obiektu, a to znaczy, że musi go znać. Dlatego w takim wypadku dobrze jest jawnie wydzielić interfejs jaki będzie służył do komunikacji. Wtedy nie będzie obchodziło Cię jaki naprawdę obiekt będziesz przekazywał jako argument - grunt, żeby posługiwał się tym samym interfejsem. Np:

interface DowolnyKierowca
{
//...
}

interface DowolnySamochód
{
boolean maKierowcę();
int jakaPrędkość();
int jakiKierunek();
//...
}

interface DowolnyPolicjantDrogówki
{
void skanuje(final DowolnySamochód skanowany);
boolean zatrzymuje(final DowolnySamochód doZatrzymania);
void ściga(final DowolnySamochód ścigany);
boolean wlepiaMandat(final DowolnyKierowca złapany);
//...
}

Można to oczywiście rozbudować w dowolnym miejscu, dołożyć dziedziczenie interfejsów (np. interface DowolnyPolicjantDrogówki extends DowolnyPolicjant {/.../}) itd.
Wtedy posługiwanie się całymi referencjami ma wiele korzyści bo jako argumenty podajesz referencję do interfejsu, a jaki obiekt jakiej klasy będzie się pod nim krył nie będzie miało znaczenia tak długo jak interfejs będzie obsługiwany. Słowa "Dowolny" użyłem abyś załapał ideę. W większości programów nie trzeba specjalnie oznaczać interfejsów ponieważ interfejs bez implementacji nie może samodzielnie istnieć jako argument. Jedynym wyjątkiem od tej zasady jest referencja o wartości null.