Hvad er bedst - at give object med eller alle variable i metode

1) Jeg tvivler på det har så meget at sige performance mæssigt. Medmindre I selvfølgelig allokerer en helvedes masse objekter.

2) Helt klart at foretrække, da man som I selv er inde på, kan ændre i MyObject og tilføje ekstra properties, som kan være relevante at gemme - uden at skulle opdatere metodekaldet.

Jeg vil sige at svaret afhænger af dine lag. Hvis vi kigger på de 3 muligheder:

A) kaldende kode
  kaldte kode + MyObject

B) kaldende kode + MyObject
  kaldte kode

C) kaldende kode + kaldte kode + MyObject

så vil jeg sende et MyObject med over i A og C men simple argumenter i B

Hvis metoden er specifik for x og y værdien i MyObject klassen burde den metode vel ligge i selve MyObject klassen (eller i en extension til den).

Hvis metoden er generel og bruges på mange andre x og y værdier end dem i MyObject skal den ligge 'udenfor' MyObject og have x og y som parametre.

Hvis begge dele gælder, ville det nok være rigtigs at lave en statisk klasse til medtoden med selve udregningen (med x og y værdier) a la MATH klassen. og så desuden lave en metode i MyObject der kalder den metode på 'sine' x og y værdier.

eg:
static class Pytagoras {
    static public double hypotenuse( couble x, double y ) {
        return Math.pow( Math.pow(x,2) + Math.pow(y,2), 0.5 );
    }
    //...
}// endclass Pytagoras

class MyObject {      // Hvert MyObject objekt representerer en trekant
    double x, y;      // lænden på 2 sider i trekanten
    double v;        // vinkelen imellem de to sider( i grader )
    //...
    public double getHypotenuse() throws NotRightAngledException {
        if( math.abs( v ) != 90 ) {
            throw  new NotRightAngledException( this.toString() )
        } else {
            return Pytagoras.hypotenuse(x,y);
        }
    }
    ...
}// endclass MyObject

>> jakoba

Din filosofi holder vel ikke altid stik. Nu ved jeg ikke præcis hvad situationen er her, men hvis opgaven er at persistere nogle informationer som Mybject indeholder, skal klassen vel ikke selv have ansvaret for det?

Umiddelbart ville jeg vurdere at 1) var hurtigere end 2) - med mindre at vi da snakker om at objektet skal transporteres over nettet.

Ved 1) bliver der oprettet nye kopier af x og y. Der skal afsættes plads i memory til dette og de skal sendes til doSomething(). Disse værdier er value-overført.

Ved 2) bliver selve objektet overført. Eller rettere sagt, det er en reference til objektet der bliver overført. Hvis man skriver til f.eks. x inde fra doSomething(), vil man efterfølgende kunne konstatere at x faktisk er ændret i selve objektet ... også når man forlader doSomething() igen. Værdien bliver reference-overført.

Da det kun er 1 reference der skal overføres vil koden på maskinniveau (bytecodeniveau) være mere effektiv end hvis det er 2 integers der skal overføres.

I praksis er det dog næppe noget som tynger på performance.

Ud fra et rent OO-mæssigt synspunkt så vil jeg i øvrigt sige at de er 2) som er den "rigtige løsning".

Et er dog teori, og et andet er praksis ;^)

Tak for input - det er tid til at lægge nogle svar

Der kommer et her...

Svar :^)

.

Tak for inputs. Jeg har delt point lige mellem dem der har lagt svar - satser på det er ok

Takker for point :^)