Hvordan fungerer klasser, objekter og konstruktører?

Question

Accepted Answer

En **class** er en mal; et **object** er en instans opprettet fra den. En **constructor** er en spesiell metode som initialiserer et nytt objekt. Sammen danner de grunnlaget for Javas objektorienterte modell.

## Definere en klasse med en konstruktør

```java
public class Person {
    private String name;        // fields (instance variables)
    private int age;

// CONSTRUCTOR — same name as the class, no return type
    public Person(String name, int age) {
        this.name = name;       // `this` distinguishes field from parameter
        this.age = age;
    }

public String greet() {     // method
        return "Hi, I'm " + name;
    }
}
```

Konstruktøren kjøres når du oppretter et objekt, og setter opp dens opprinnelige tilstand. `this` refererer til det gjeldende objektet, og skiller felter fra parametere med samme navn.

## Opprette objekter

```java
Person p = new Person("Ann", 30);   // `new` allocates the object + calls the constructor
p.greet();                           // "Hi, I'm Ann"
```

Nøkkelordet `new` allokerer minne på stacken og påkaller konstruktøren; `p` inneholder en referanse til det nye objektet.

## Konstruktør overloading og chaining

```java
public class Person {
    private String name;
    private int age;

public Person(String name, int age) {   // primary constructor
        this.name = name;
        this.age = age;
    }
    public Person(String name) {             // overloaded — different parameters
        this(name, 0);                        // calls the other constructor (chaining)
    }
}
```

Du kan ha **flere konstruktører** med ulike parameterlister (overloading), og den ene kan kalle den andre med `this(...)` for å unngå å duplisere initialisering.

## Standardkonstruktøren

```java
public class Empty {
    // no constructor defined → Java provides an implicit no-arg constructor
}
Empty e = new Empty();   // works
// BUT: once you define ANY constructor, the implicit one is gone
```

Hvis du ikke skriver noen konstruktør, leverer Java en no-argument standard. Så snart du definerer en konstruktør, forsvinner standarden (du må legge den til eksplisitt hvis nødvendig).

## Hvorfor det er viktig

Klasser, objekter og konstruktører er det absolutte grunnlaget for Java-programmering — alt du bygger består av objekter opprettet fra klasser.

Å forstå hvordan konstruktører initialiserer tilstand (`this`, rollen til `new` nøkkelordet, konstruktør overloading og chaining for fleksibel opprettelse, og standardkonstruktør-regelen) er essensielt for å korrekt opprette og initialisere objekter.

Disse konseptene ligger til grunn for alt OOP-arbeid i Java, og konstruktøradferd (spesielt den forsvinnende standarden og chaining) er en vanlig kilde til både intervjuspørsmål og virkelige bugs.