Qu'est-ce qu'un exemple du principe de Responsabilité Unique? [fermé]

le moyen le plus efficace pour casser les applications il pour créer Dieu classes. Qui sont des classes qui conserve la trace de beaucoup d'informations et ont plusieurs responsabilités. Un changement de code affectera très probablement d'autres parties de la classe et donc indirectement toutes les autres classes qui l'utilisent. Cela entraîne à son tour un gâchis de maintenance encore plus important puisque personne n'ose y apporter d'autres changements que d'y ajouter de nouvelles fonctionnalités.

le l'exemple suivant est une classe TypeScript qui définit un Person , cette classe ne devrait pas inclure la validation de courrier électronique parce que ce n'est pas lié à un comportement de personne:

class Person {
    public name : string;
    public surname : string;
    public email : string;
    constructor(name : string, surname : string, email : string){
        this.surname = surname;
        this.name = name;
        if(this.validateEmail(email)) {
          this.email = email;
        }
        else {
            throw new Error("Invalid email!");
        }
    }
    validateEmail(email : string) {
        var re = /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i;
        return re.test(email);
    }
    greet() {
        alert("Hi!");
    }
}

nous pouvons améliorer la classe ci-dessus en supprimant la responsabilité de la validation du courriel de la classe Personne et en créant une nouvelle classe Email qui aura cette responsabilité:

class Email {
    public email : string;
    constructor(email : string){
        if(this.validateEmail(email)) {
          this.email = email;
        }
        else {
            throw new Error("Invalid email!");
        }        
    }
    validateEmail(email : string) {
        var re = /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i;
        return re.test(email);
    }
}

class Person {
    public name : string;
    public surname : string;
    public email : Email;
    constructor(name : string, surname : string, email : Email){
        this.email = email;
        this.name = name;
        this.surname = surname;
    }
    greet() {
        alert("Hi!");
    }
}

S'assurer qu'une classe a une seule responsabilité la rend par défaut également plus facile de voir ce qu'il fait et comment vous pouvez augmenter/améliorer.

Principe de Responsabilité Unique (SRP) indique qu'une classe ou d'une méthode ne doit être en train de faire une chose qu'il ne faut pas tout faire tout ce qui est lié. Une classe ne doit avoir qu'une seule raison de changer.

un exemple typique pourrait Une classe EmailSender:

• cela devrait simplement traiter de l'envoi d'un e-mail.
• ceci ne doit pas être responsable du chargement du contenu de l'e-mail à partir de la base de données ou même du formatage de l'e-mail le contenu sera envoyé.

Ici est un article sur ce sujet.

Une classe ne doit avoir qu'une seule raison de changer.

ce principe stipule que si nous avons deux raisons de changer de classe, nous devons diviser la fonctionnalité en deux classes. Chaque classe va gérer qu'une seule responsabilité et si dans l'avenir, nous avons besoin de faire un changement que nous allons faire dans la classe qui gère.

S'il y a deux raisons différentes de changer, il est concevable que deux équipes différentes puissent travailler sur le même code pour deux raisons différentes. Chacun aura le déploiement de sa solution, qui, dans le cas d'un langage compilé (comme C++, C# ou Java), peut conduire à des modules incompatibles avec d'autres équipes ou d'autres parties de l'application.

ce principe est étroitement lié aux concepts de couplage et de cohésion. Le couplage renvoie à la façon dont différents aspects d'une application sont inextricablement liés, tandis que la cohésion renvoie à la façon dont étroitement lié le contenu d'une classe ou d'un paquet particulier peut-être. Tous les contenus d'une même classe sont étroitement liés entre eux, puisque la classe elle-même est une [unité unique][1] qui doit être entièrement utilisée ou pas du tout.

mon billet de blog sur ceci:

http://javaexplorer03.blogspot.in/2016/12/single-responsibility-principle.html