När dina metoder returnerar generiska typer bryter du upp samtalskedjan 
 
 TL;DR: Undvik metoder som returnerar Object, Any eller null i stället för specifika typer. TL;DR: Undvik metoder som returnerar Object, Any eller null i stället för specifika typer. Problem 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Förlorad polymorfism Tät koppling Överdriven noll kontroll Förvirrande returer Bräcklig kod Svårt att testa Förlorad typ av säkerhet Ifs föroreningar Bruten polymorphism Runtime fel Oklara kontrakt Svårigheter att testa Dålig underhållbarhet Lösningar 
 
 
 
 
 
 
 
 
 Polymorfiska typer återvänder Använd nollobjektmönster Undvik att återvända någon Be om undantag för fel Renovering för klarhet Returnerar specifika typer eller gränssnitt Använd rätt abstraktioner Skapa meningsfulla föremål Återhämtning ️ https://hackernoon.com/code-refactoring-tips-no-015-remove-null?embedable=true sammanhanget När du skriver en metod som kan returnera många typer, till exempel en eller a Du förlorar polymorphism. Någon noll noll Polymorphism låter dig behandla objekt som delar ett gränssnitt eller en bastyp utbytbart, vilket förenklar din kod. Att returnera null tvingar dina samtalare att skriva extra kontroller och hantera speciella fall, vilket förvirrar koden och ökar kopplingen. Att returnera någon (eller en typ som raderar faktisk typinformation) gör det svårare att förstå vad metoden faktiskt returnerar, vilket orsakar buggar och förvirring. Du tvingar samtalare att utföra typkontroll och . Castning Detta bryter mot den grundläggande principen om polymorphism där föremål ska bete sig enligt sina egenskaper. . Kontrakt Metoder bör returnera specifika typer som tydligt kommunicerar sin avsikt och tillåter kompileraren att verifiera korrektheten vid kompileringstidpunkten. Kom ihåg 
 
 Två metoder är polymorfa om deras signaturer är desamma, argumenten är polymorfa, OCH returen är också polymorfik. Två metoder är polymorfa om deras signaturer är desamma, argumenten är polymorfa, OCH returen är också polymorfik. Sample kod Felaktigt 🙂 public class DatabaseConnection {
    public Object execute(String sql) {
        if (sql.startsWith("SELECT")) {
            return new ResultSet();
        } else if (sql.startsWith("INSERT")) {
            return Integer.valueOf(42);
        } else if (sql.startsWith("UPDATE")) {
            return Boolean.TRUE;
        }
        return null;
        // The billion dollar mistake
    }
}

public class QueryHandler {
    public void handle(String sql, DatabaseConnection db) {
        Object result = db.execute(sql);
        // The caller needs to be aware of many different types
        if (result instanceof ResultSet) {
            System.out.println("Fetched rows");
        } else if (result instanceof Integer) {
            System.out.println("Inserted " + result);
        } else if (result instanceof Boolean) {
            System.out.println("Updated " + result);
        } else {
            System.out.println("Unknown result");
        }
    }
}

// This second class has a method execute()
// which is NOT polymorphic since it returns 
// another types
public class NonRelationalDatabaseConnection {
    public Object execute(String query) {
        if (query.startsWith("FIND")) {
            return new Document();
        } else if (query.startsWith("INSERT")) {
            return Integer.valueOf(1);
        } else if (query.startsWith("UPDATE")) {
            return Boolean.TRUE;
        }
        return null; // The billion dollar mistake
    }
}
 Rätt 🙂 interface QueryResult {
    void display();
}

class SelectResult implements QueryResult {
    public void display() {
        System.out.println("Fetched rows");
    }
}

class InsertResult implements QueryResult {
    private final int count;
    InsertResult(int count) { this.count = count; }
    public void display() {
        System.out.println("Inserted " + count);
    }
}

class UpdateResult implements QueryResult {
    private final boolean ok;
    UpdateResult(boolean ok) { this.ok = ok; }
    public void display() {
        System.out.println("Updated " + ok);
    }
}

class DocumentResult implements QueryResult {
    public void display() {
        System.out.println("Fetched documents");
    }
}

interface DatabaseConnection {
    QueryResult execute(String query);
}

public class RelationalDatabaseConnection 
  implements DatabaseConnection {
    public QueryResult execute(String sql) {
        // execute() is now polymorphic and returns a QueryResult
        if (sql.startsWith("SELECT")) {
            return new SelectResult();
        } else if (sql.startsWith("INSERT")) {
            return new InsertResult(42);
        } else if (sql.startsWith("UPDATE")) {
            return new UpdateResult(true);
        }
        // You remove null
        throw new IllegalArgumentException("Unknown SQL");
    }
}

public class NonRelationalDatabaseConnection 
  implements DatabaseConnection {
    public QueryResult execute(String query) {
        // execute() is now polymorphic and returns a QueryResult
        if (query.startsWith("FIND")) {
            return new DocumentResult();
        } else if (query.startsWith("INSERT")) {
            return new InsertResult(1);
        } else if (query.startsWith("UPDATE")) {
            return new UpdateResult(true);
        }
        throw new IllegalArgumentException("Unknown query");
    }
}

public class QueryHandler {
    public void handle(String sql, DatabaseConnection db) {
        QueryResult result = db.execute(sql);
        result.display();
    }
}
 Upptäckten 
 
 Halvautomatiska Leta efter metoder med returtyper som Object, Any, void* eller frekventa null returnerar. Kontrollera också för spridda if-null-kontroller eller typkontroller efter metodsamtal. Verktyg och statiska analyser varnar ibland för metoder som returnerar någon eller null utan dokumentation. Sök efter instanceof kontroller eller typ gjutning efter metod samtal. Se upp för metoder som returnerar olika typer baserat på parametrar eller deras interna tillstånd. Undantag 
 
 
 Generiska kollektionsramar Serialiseringsbibliotek Dagar ️ 
 
 Polymorfism Nivå 
 
 mellanliggande Varför det är så viktigt ️ När en metod alltid returnerar en typ som anpassar sig till det koncept som den representerar, behöver programmerare inte speciella fall. Bryta detta genom att returnera någon eller null skapar tvetydighet. Bijection Kallkoden måste gissa den faktiska typen eller hantera null, öka buggar och underhållskostnader. objekt har specifika typer och beteenden. Realvärlden Den här generationen AI-generatorer producerar ibland metoder som returnerar noll eller noll eftersom de prioriterar flexibilitet eller enkelhet över stark typning och polymorphism. Detektion AI-verktyg kan fixa denna lukt när instruktioner ges för att genomdriva skrivna returneringar och föreslå eller valfria mönster. Noll objekt De kan refactor null returnerar i polymorf retur hierarkier automatiskt om guidad. Enkla uppmaningar om "förbättring av returtyper" hjälper ofta AI att föreslå bättre alternativ. Prova dem! Kom ihåg: AI-assistenter gör många misstag 
 
 Föreslagna prompt: Ersätt metoder som returnerar Object, Any eller null med specifika returneringstyper Skapa lämpliga abstraktioner och nullobjektmönster Säkerställ typsäkerhet och tydliga kontrakt Föreslagna prompt: Ersätt metoder som returnerar Object, Any eller null med specifika returneringstyper Skapa lämpliga abstraktioner och nullobjektmönster Säkerställ typsäkerhet och tydliga kontrakt 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Without Proper Instructions 
 With Specific Instructions 
 
 
 
 ChatGPT 
 ChatGPT 
 
 
 
 Claude 
 Claude 
 
 
 
 Perplexity 
 Perplexity 
 
 
 
 Copilot 
 Copilot 
 
 
 
 You 
 You 
 
 
 
 Gemini 
 Gemini 
 
 
 
 DeepSeek 
 DeepSeek 
 
 
 
 Meta AI 
 Meta AI 
 
 
 
 Grok 
 Grok 
 
 
 
 Qwen 
 Qwen Chattar Chattar Claude är Claude är förvirring förvirring Barnpilot Barnpilot du du Tvillingar Tvillingar djupt sökande djupt sökande Målet för AI Målet för AI Grekiska Grekiska Kvinna Kvinna Slutsats Metoder bör returnera specifika typer som tydligt kommunicerar sitt syfte och möjliggör kompileringstidskontroll. När du ersätter icke-polymorfa returneringar med lämpliga abstraktioner skapar du säkrare, mer underhållbar kod som uttrycker sin avsikt tydligt. Relationer https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-ix-7rr33ol https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-iii-t7h3zkv https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-iii-t7h3zkv https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-ix-7rr33ol https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxvi Mer information https://hackernoon.com/how-to-get-rid-of-annoying-ifs-forever-zuh3zlo?embedable=true https://hackernoon.com/null-the-billion-dollar-mistake-8t5z32d6?embedable=true https://en.wikipedia.org/wiki/Design_by_contract?embedable=true Disclaimer Doften är min . åsikt Krediter Foto från är Följ Randy Fath Unsplash 
 
 Gå tillbaka till rätt typ, alltid. Gå tillbaka till rätt typ, alltid. Författaren Brian Goetz https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true Denna artikel är en del av CodeSmell-serien. https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-i-xqz3evd?embedable=true

Winner of Noonies 2020 for the award Hacker Noon Contributor of the Year - REFACTORING.

2020 - Hacker Noon Contributor of the Year in REFACTORING

2022 - HackerNoon Contributor of the Year - Clean Code

2022 - HackerNoon Contributor of the Year - Debugging

2022 - HackerNoon Contributor of the Year - Github

2022 - HackerNoon Contributor of the Year - Machine Learning

2022 - HackerNoon Contributor of the Year - Quality Assurance

2022 - HackerNoon Contributor of the Year - Refactoring

2022 - HackerNoon Contributor of the Year - Software Architecture

2022 - the Greatest Storyteller

Buy My Book

Share your ideas with me!

Read My Stories

Buy Me a Coffee

Software Engineer and Book Author

Det här ljudet är producerat på berättelsens originalspråk!

För länge; Att läsa

Make resilience your competitive advantage

Code Smell 308 - Nyckeln till säkrare, renare, mer polymorf kod

Code Smell 308 - Nyckeln till säkrare, renare, mer polymorf kod

About Author

KOMMENTARER

HÄNG TAGGAR

DENNA ARTIKEL PRESENTERAS I

Related Stories

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps