Ren arkitektur og designmønstre i praksis · Lektion

Refaktorering med design patterns

Lær systematisk at refaktorere eksisterende kodebaser ved at anvende passende design patterns for at forbedre struktur og vedligeholdelse.

Lektion 3 af 411 trin

Refaktorering med design patterns er en gratis Ren arkitektur og designmønstre i praksis-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Ren arkitektur og designmønstre i praksis, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Ren arkitektur og designmønstre i praksis-kurset indeholder 4 lektioner i alt.

Omstrukturering med udformningsmønstre

Hvad er omstrukturering? Det handler om at forbedre strukturen i eksisterende kode uden at ændre dens ydre adfærd. Hvorfor inddrage udformningsmønstre? Mønstre tilbyder gennemprøvede, genanvendelige løsninger på almindelige udformningsproblemer og gør din omstrukturering mere systematisk og effektiv. Det fører til tydeligere, mere vedligeholdelsesvenlig og udvidelig kode.

Find tegn på dårlig kode

Før du omstrukturerer, skal du vide, hvad der skal omstruktureres. Tegn på dårlig kode er indikatorer på, at noget måske er galt med udformningen af din kode. De er ikke fejl, men de kan føre til fejl eller gøre koden sværere at ændre.

Lang metode: En metode, der gør for meget.
Stor klasse: En klasse med for mange ansvarsområder.
Dubleret kode: Den samme kodelogik, der optræder flere steder.
Kompleks betingelseslogik: For mange if/else- eller switch-sætninger.

Systematiske trin til omstrukturering

Omstrukturering bør være en disciplineret proces og ikke en forhastet omskrivning. Her er et enkelt arbejdsforløb:

Find et tegn på dårlig kode: Find et område i din kode, der kan forbedres.
Vælg et udformningsmønster: Vælg et mønster, der løser det identificerede problem.
Anvend mønstret: Foretag små, trinvise ændringer, og sørg for, at testene består efter hvert trin.
Test grundigt: Kontrollér, at den ydre adfærd forbliver uændret.

Husk: "Rød, grøn, omstrukturer" er et stærkt mantra!

Strategi til betingelseslogik

Lad os tage fat på et almindeligt problem: metoder med omfattende betingelseslogik (mange if/else- eller switch-sætninger). Det gør koden svær at læse, teste og udvide. Strategimønstret hjælper ved at indkapsle varierende adfærd i separate objekter, der kan udskiftes med hinanden.

Forestil dig en simpel lommeregner:

public class SimpleCalculator {
  public int calculate(String operation, int a, int b) {
    if ("add".equals(operation)) {
      return a + b;
    } else if ("subtract".equals(operation)) {
      return a - b;
    } else if ("multiply".equals(operation)) {
      return a * b;
    }
    throw new IllegalArgumentException("Unknown operation");
  }

  public static void main(String[] args) {
    SimpleCalculator calc = new SimpleCalculator();
    System.out.println("Add: " + calc.calculate("add", 5, 3));
    System.out.println("Subtract: " + calc.calculate("subtract", 5, 3));
  }
}

Omstrukturering til strategi

For at omstrukturere lommeregneren introducerer vi grænsefladen Operation og specifikke strategiklasser for hver handling. Calculator bruger derefter en instans af en Operation-strategi. Det gør det nemt at tilføje nye handlinger uden at ændre klassen Calculator.

interface Operation {
  int execute(int a, int b);
}

class AddOperation implements Operation {
  @Override
  public int execute(int a, int b) {
    return a + b;
  }
}

class SubtractOperation implements Operation {
  @Override
  public int execute(int a, int b) {
    return a - b;
  }
}

public class RefactoredCalculator {
  private Operation operation;

  public void setOperation(Operation operation) {
    this.operation = operation;
  }

  public int calculate(int a, int b) {
    if (operation == null) {
      throw new IllegalStateException("Operation not set");
    }
    return operation.execute(a, b);
  }

  public static void main(String[] args) {
    RefactoredCalculator calc = new RefactoredCalculator();
    
    calc.setOperation(new AddOperation());
    System.out.println("Add: " + calc.calculate(5, 3));
    
    calc.setOperation(new SubtractOperation());
    System.out.println("Subtract: " + calc.calculate(5, 3));
  }
}

Tilstandsmønstret til ændring af adfærd

Et andet almindeligt problem i kode er et objekt, hvis adfærd ændrer sig baseret på dets interne tilstand, ofte styret af mange if/else- eller switch-sætninger i dets metoder. Tilstandsmønstret gør det muligt for et objekt at ændre sin adfærd, når dets interne tilstand ændrer sig, så det ser ud, som om objektet skiftede klasse.

Lad os se på et trafiklys:

public class SimpleTrafficLight {
  private String currentState;

  public SimpleTrafficLight() {
    this.currentState = "RED"; // Initial state
  }

  public void change() {
    if ("RED".equals(currentState)) {
      currentState = "GREEN";
      System.out.println("Traffic light is now GREEN.");
    } else if ("GREEN".equals(currentState)) {
      currentState = "YELLOW";
      System.out.println("Traffic light is now YELLOW.");
    } else if ("YELLOW".equals(currentState)) {
      currentState = "RED";
      System.out.println("Traffic light is now RED.");
    }
  }

  public static void main(String[] args) {
    SimpleTrafficLight light = new SimpleTrafficLight();
    light.change(); // GREEN
    light.change(); // YELLOW
    light.change(); // RED
  }
}

Omstrukturering til tilstand

Med tilstandsmønstret definerer vi en grænseflade for trafiklysets tilstand (TrafficLightState) og konkrete klasser for hver tilstand (RedState, GreenState, YellowState). Klassen TrafficLight indeholder en reference til sit aktuelle tilstandsobjekt og videredelegerer adfærden til det. Det adskiller på en ren måde den tilstandsspecifikke adfærd.

interface TrafficLightState {
  void change(TrafficLight context);
}

class RedState implements TrafficLightState {
  @Override
  public void change(TrafficLight context) {
    System.out.println("Traffic light is now GREEN.");
    context.setState(new GreenState());
  }
}

class GreenState implements TrafficLightState {
  @Override
  public void change(TrafficLight context) {
    System.out.println("Traffic light is now YELLOW.");
    context.setState(new YellowState());
  }
}

class YellowState implements TrafficLightState {
  @Override
  public void change(TrafficLight context) {
    System.out.println("Traffic light is now RED.");
    context.setState(new RedState());
  }
}

public class TrafficLight {
  private TrafficLightState currentState;

  public TrafficLight() {
    this.currentState = new RedState(); // Initial state
  }

  public void setState(TrafficLightState state) {
    this.currentState = state;
  }

  public void change() {
    currentState.change(this);
  }

  public static void main(String[] args) {
    TrafficLight light = new TrafficLight();
    light.change(); // GREEN
    light.change(); // YELLOW
    light.change(); // RED
  }
}

Valg af det rigtige mønster

Det kan være udfordrende at afgøre, hvilket mønster du skal anvende. Her er nogle almindelige kodelugte og passende mønstre:

Kompleks betingelseslogik (if/else, switch): Refaktoreres ofte med Strategy, State eller Command.
Dubleret kode: Kan ofte løses med Factory Method, Template Method eller ved at flytte fælles logik ud i en superklasse.
Tæt kobling: Facade, Mediator og Observer kan reducere afhængigheder.
Inkompatible grænseflader: Adapter-mønsteret er perfekt til dette.
Tilføjelse af funktionalitet dynamisk: Decorator-mønsteret.

Hvorfor refaktorere med mønstre?

Systematisk anvendelse af designmønstre under refaktorering giver betydelige fordele:

Bedre læsbarhed: Mønstre giver et fælles ordforråd og en fælles struktur.
Bedre vedligeholdelse: Ændringer begrænses til bestemte steder og er nemmere at implementere.
Større udvidelsesmuligheder: Nye funktioner kan ofte tilføjes uden at ændre eksisterende kode (Open/Closed-princippet).
Bedre testbarhed: Afkoblede komponenter er nemmere at enhedsteste.

Det forvandler rodet kode til et velstruktureret og robust system.

Quiz om refaktorering

Forestil dig, at du har en klasse, der håndterer forskellige formater til rapportgenerering (PDF, CSV, XML) ved hjælp af en stor switch-sætning. Du vil gøre det nemt at tilføje nye formater uden at ændre selve rapportgenerator-klassen.

Besvar den i den interaktive lektion

Opsamling: Refaktorering med mønstre

I dag lærte du, hvordan du kan gribe refaktorering systematisk an ved hjælp af designmønstre. Vi undersøgte almindelige kodelugte og så, hvordan mønstre som Strategy og State kan forvandle kompleks betingelseslogik til renere og mere udvidelige designs.

Husk, at refaktorering er en løbende proces, som med vejledning fra designmønstre kan forbedre din kodebases kvalitet og tilpasningsevne betydeligt.

Gratis at komme i gang

Lær Ren arkitektur og designmønstre i praksis med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 12
Lektioner: 48

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Refaktorering med design patterns” gratis?

Ja — hele teksten til “Refaktorering med design patterns” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Ren arkitektur og designmønstre i praksis-kurset, skal du opgradere til CoddyKit PRO. Ren arkitektur og designmønstre i praksis-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Refaktorering med design patterns”?

Lær systematisk at refaktorere eksisterende kodebaser ved at anvende passende design patterns for at forbedre struktur og vedligeholdelse. Du øver dig i Ren arkitektur og designmønstre i praksis med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Ren arkitektur og designmønstre i praksis?

Der kræves ingen tidligere erfaring. Ren arkitektur og designmønstre i praksis på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Refaktorering med design patterns”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Ren arkitektur og designmønstre i praksis-lektion?

Ja. Alle Ren arkitektur og designmønstre i praksis-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Fordybelse i Dependency Inversion
Interface Segregation i praksis
Refaktorering med design patterns
Mesterskab i Single Responsibility og Open-Closed

← Tilbage til Ren arkitektur og designmønstre i praksis