Definição: Um objeto deve manter o menor entendimento de outros objetos.
A origem do problema: a relação entre as classes está se aproximando cada vez mais e o acoplamento está ficando cada vez maior. Quando uma classe muda, quanto maior o impacto em outra classe.
Solução: Minimize o acoplamento entre as classes o máximo possível.
Desde que entramos em contato com a programação, conhecemos os princípios gerais de design de software, baixo acoplamento e alta coesão. Seja orientado a objetos ou orientado ao processo, o grau de acoplamento deve ser o mais baixo possível para melhorar a taxa de reutilização do código. Mas como programar o baixo acoplamento?
Não importa o quão complexa seja a lógica, para classes dependentes, tente encapsular a lógica dentro da classe e não divulgue nenhuma informação para o exterior, exceto os métodos públicos fornecidos. Há também uma definição mais simples: apenas se comunique com amigos diretos. Primeiro, vamos explicar o que é um amigo direto; Cada objeto será acoplado a outros objetos. Digamos que exista um relacionamento de acoplamento entre esses dois objetos. Digamos que esses dois objetos tenham um relacionamento de amigo. Existem muitas maneiras pelas quais o acoplamento ocorre, como dependência, associação, composição, agregação, etc. Entre eles, chamamos a classe que aparece variáveis de membros, parâmetros de método e valores de retorno de método chamados amigos diretos, enquanto a classe que aparece nas variáveis locais não são amigos diretos. Ou seja, é melhor não aparecer dentro da classe como variáveis locais;
Por exemplo, em uma escola, existem vários professores nela, numerados em sequência. Existem vários alunos abaixo, numerados ao mesmo tempo. Agora peça para imprimir todos os IDs de professores e alunos.
Primeiro, viole o princípio de baixo acoplamento e alta coesão
O código é o seguinte.
pacote test1; importar java.util.ArrayList; importar java.util.list; classe professor {privatestring id; publicVoidSetId (string id) {this.id = id;} publicsTring getId () {return id;}} classe {private string id; public void setId (string) {{) StudentManage {publicList <Dudent> getAllStudent () {list <very Student> list = newArrayList <vertudy> (); para (int i = 0; i <100; i ++) {Student = new Student (); Student. {List <fora> list = newArrayList <Profess> (); for (inti = 0; i <100; i ++) {professor = novo professor (); professor.setId ("Número do professor"+i); list.addd (professora);} Lista de retorno;} public void PrintallPerson (StudentManagerManager); {System.out.println (s.getId ());} list <frofess> list2 = this.getAlltEacher (); para (professor t: list2) {System.out.println (t.getId ());}}} public ClassClient {publicstaticVoidMain (String [] args) {professorManagetM = newTeacherManage (); tm.printallPerson (new StudentManage ());}} O principal problema desse design agora aparece na aula de professores. De acordo com a baixa lei de acoplamento e alta coesão, ela se comunica apenas com amigos diretos. A aula de estudante não é um amigo direto na aula de professores. Esse acoplamento de relacionamento com amigos não diretos deve ser evitado na classe.
Após a modificação, o código é o seguinte:
pacote test2; importar java.util.ArrayList; importar java.util.list; classe professor {privatestring id; publicVoidSetId (string id) {this.id = id;} publicstring getId () {retornar id; StudentManage {publicList <Dudent> getAllStudent () {list <denty> list = newArrayList <vertent> (); para (int i = 0; i <100; i ++) {Student = new Student (); Student.setId ("número do aluno é"+i); list.add (); Student;} Lista de retorno; {List <very Student> list1 = this.getAllStudent (); para (Student S: List1) {System.out.println (s.getId ());}}} classe professorManage {publicList <Profess> (INTI (Inti = 0 = 0; Professor (); professor.setId ("Número do professor"+i); list.add (professor);} Lista de retorno;} publicVoidPrintallTeacher () {list <festrower> list2 = this.getallTeacher (); para (professor t: list2) {System.out.println (t.getid ());}}} {ProfessorManagetM = newTeacherManage (); tm.printalLteacher (); StudentManagesm = newStudentManage (); sm.printallStudent ();}}Após a modificação, o aluno adicionou um novo método de identificação do aluno e o professor pode chamá -lo diretamente. Isso evita o acoplamento com os alunos. A intenção original do princípio de baixo acoplamento e alta coesão é reduzir o acoplamento entre as classes. Como cada classe reduz dependências desnecessárias, é realmente possível reduzir o relacionamento de acoplamento. No entanto, tudo tem um diploma. Embora a comunicação com classes indiretas possa ser evitada, a fim de se comunicar, os relacionamentos ocorrerão inevitavelmente através de um "intermediário". Usar esta regra pode obter estrutura clara, alta coesão e baixo acoplamento,
Acoplamento e coesão são dois padrões qualitativos para independência do módulo. Ao dividir os sistemas de software em módulos, tente obter alta coesão e baixo acoplamento o máximo possível para melhorar a independência do módulo e estabeleça as bases para projetar estruturas de software de alta qualidade.
Há um exemplo fácil de entender: um programa possui 50 funções, e este programa é executado muito bem; No entanto, depois de modificar uma das funções, as outras 49 funções precisam ser modificadas, o que é a conseqüência do alto acoplamento.
Resumir
O exposto acima é todo o conteúdo deste artigo sobre a análise de código do código de exemplo de alta coesão e baixa lei de acoplamento. Espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!