Hvordan fungerer klasser, objekter og konstruktorer?

Question

Accepted Answer

En **klasse** er en skabelon; et **objekt** er en instans skabt ud fra den. En **konstruktor** er en speciel metode, der initialiserer et nyt objekt. Sammen danner de grundlaget for Javas objektorienterede model.

## Definition af en klasse med en konstruktor

```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 køres, når du opretter et objekt, og sætter dets initialtilstand op. `this` refererer til det aktuelle objekt og disambiguerer felter fra parametre med samme navn.

## Oprettelse af objekter

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

Nøgleordet `new` allokerer hukommelse på heap'en og påkalder konstruktøren; `p` holder en reference til det nye objekt.

## Konstruktor 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 have **flere konstruktorer** med forskellige parameterlister (overloading), og en kan kalde en anden med `this(...)` for at undgå at duplikere 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 en konstruktor, leverer Java en standardkonstruktor uden argumenter. Så snart du definerer en konstruktor, forsvinder denne standard (du skal tilføje den eksplicit hvis nødvendigt).

## Hvorfor det betyder noget

Klasser, objekter og konstruktorer er det absolutte grundlag for Java-programmering — alt, hvad du bygger, består af objekter skabt ud fra klasser.

At forstå, hvordan konstruktorer initialiserer tilstand (`this`, `new` nøgleordets rolle, konstruktor overloading og chaining for fleksibel oprettelse, og standardkonstruktørreglen), er vigtig for korrekt at skabe og initialisere objekter.

Disse koncepter ligger til grund for alt OOP-arbejde i Java, og konstruktøradfærd (især den forsvindende standard og chaining) er en hyppig kilde til både interviewspørgsmål og rigtige bugs.