Hur fungerar klasser, objekt och konstruktorer?

Question

Accepted Answer

En **klass** är en ritning; ett **objekt** är en instans skapad från den. En **konstruktor** är en särskild metod som initialiserar ett nytt objekt. Tillsammans är de grunden för Javas objektorienterade modell.

## Definiera en klass 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;
    }
}
```

Konstruktorn körs när du skapar ett objekt och ställer in dess initialtillstånd. `this` refererar till det aktuella objektet och särskiljer fält från parametrar med samma namn.

## Skapa objekt

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

Nyckelordet `new` allokerar minne på heapen och anropar konstruktorn; `p` innehåller en referens till det nya objektet.

## Konstruktoröverlagring och kedjning

```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 **flera konstruktorer** med olika parameterlistor (överlagring), och en kan anropa en annan med `this(...)` för att undvika att upprepa initialisering.

## Standardkonstruktorn

```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
```

Om du inte skriver någon konstruktor tillhandahåller Java en standardkonstruktor utan argument. Så snart du definierar någon konstruktor försvinner den standard (du måste lägga till den explicit om det behövs).

## Varför det spelar roll

Klasser, objekt och konstruktorer är den absoluta grunden för Java-programmering — allt du bygger är sammansatt av objekt skapade från klasser.

Att förstå hur konstruktorer initialiserar tillstånd (`this`, nyckelordet `new`:s roll, konstruktoröverlagring och kedjning för flexibel skapande, och standardkonstruktorn-regeln) är väsentligt för att korrekt skapa och initialisera objekt.

Dessa koncept är grunden för allt OOP-arbete i Java, och konstruktorbeteende (särskilt försvinnandet av standard och kedjning) är en vanlig källa till både intervjufrågor och verkliga buggar.