Qual é o ponto de definir modificadores de acesso?

https://stackoverflow.com/questions/1888521

oop
accessor

19-09-2019
|

Pergunta

Eu entendo as diferenças entre eles (pelo menos em C #). Eu sei que os efeitos que têm sobre os elementos a que estão atribuídos. O que eu não entendo é por que é importante para implementá-las - por que não ter tudo Pública?

O material que eu li sobre o assunto geralmente passa sobre como classes e métodos não devem ter acesso desnecessário para os outros, mas eu ainda tenho que vir através de um exemplo de por que / como isso seria uma coisa ruim. Parece uma coisa de segurança, mas Eu sou o programador ; Eu criar os métodos e definir o que vai (ou não) fazer. Por que eu iria gastar todo o esforço para escrever uma função que tentou mudar uma variável que não deveria, ou tentou ler informações em outra classe, se isso seria ruim?

Peço desculpas se isso é uma pergunta estúpida. É apenas algo que eu corri para sobre os primeiros artigos que já li sobre OOP, e eu nunca senti que realmente clicado.

Solução

Em primeiro lugar, nada nas forças de linguagem que você usa modificadores de acesso - você está livre para fazer tudo o público em sua classe, se desejar. No entanto, existem algumas razões para usá-los. Aqui está a minha perspectiva.

Escondendo os internos de como sua classe opera permite proteger essa classe de utilizações não previstas. Enquanto você pode ser o criador da classe, em muitos casos, você não será o único consumidor - ou mesmo mantenedor. Escondendo estado interno protege a classe para pessoas que não podem compreender seu funcionamento, assim como você. Fazendo tudo o público cria a tentação de "ajustar" o estado interno ou comportamento interno quando a classe não está agindo da maneira que você pode querer - em vez de realmente corrigir a interface pública de implementação interna. Este é o caminho para a ruína.
Escondendo internos ajuda de-desordena o namespace , e permite que ferramentas como Intellisense para exibir somente os métodos / propriedades / campos relevantes e significativas. Fazer ferramentas não desconto como Intellisense -. Eles são um meio poderoso para os desenvolvedores a identificar rapidamente o que podem fazer com sua classe
Escondendo internos permite que você estruturar um apropriado interface para o problema a classe está resolvendo. Expondo todos os internos (que muitas vezes substancialmente superam a interface exposta) torna difícil depois entender o que a classe está tentando resolver.
Escondendo internos permite-lhe concentrar seus testes na porção apropriada - a interface pública. Quando todos os métodos / propriedades de uma classe são públicos, o número de permutações você deve potencialmente teste aumenta significativamente -. Uma vez que qualquer caminho de chamada particular torna-se possível
Escondendo internos ajuda a controlar (impor) os caminhos de chamadas através de sua classe Isto torna mais fácil para garantir que seus consumidores a entender o que sua classe pode ser convidado a fazer -. E quando. Normalmente, há apenas alguns caminhos através de seu código que são significativas e úteis. Permitir que um consumidor a tomar qualquer caminho torna mais provável que eles não vão conseguir resultados significativos - e irá interpretar isso como seu código ser buggy. Limitando como seus consumidores podem usar sua classe libera na verdade eles para usá-lo corretamente.
Escondendo os liberta de implementação internas que você mude-lo com o conhecimento de que ele não vai negativamente os consumidores de impacto de sua classe - desde que a sua interface pública permanece inalterado. Se você decidir usar um dicionário em vez de uma lista internamente - ninguém deve se preocupar. Mas se você fez todas as partes internas de sua classe disponível, alguém poderia escrever código que depende do fato de que seu usar internamente uma lista. Imagine ter que mudar todos os consumidores quando se deseja alterar essas escolhas sobre sua implementação. A regra de ouro é:. Consumidores de uma classe não deve se preocupar como a classe faz o que faz

Outras dicas

I'm the programmer é uma suposição correta somente se você é o único programador.

Em muitos casos, outros programadores trabalhar com código do primeiro programador. Eles usá-lo de maneiras que ele não tinha a intenção de mexer com os valores dos campos que não devem, e eles criam um hack que funciona, mas quebra quando o produtor do código original muda-lo.

OOP é sobre a criação de bibliotecas com contratos bem definidos. Se todas as suas variáveis ??são públicas e acessíveis aos outros, então o "contrato" inclui teoricamente todos os campos no objeto (e seus sub-objetos), por isso se torna muito mais difícil de construir uma nova implementação, diferente que ainda homenageia o contrato original.

Além disso, as "partes móveis" mais do seu objeto estão expostos, o que é mais fácil para um usuário de sua classe para manipulá-lo incorretamente.

Você provavelmente não precisa disso, mas aqui está um exemplo que considero divertida:

Say você vender um carro sem capuz sobre o compartimento do motor. Venha noite, as voltas motorista sobre as luzes. Ele chega a seu destino, sai do carro e, em seguida, lembra que ele deixou a luz acesa. Ele é preguiçoso demais para destravar a porta do carro, então ele puxa o fio para as luzes apagadas a partir de onde ele está ligado à bateria. Esta multa trabalha - a luz está fora. No entanto, porque ele não usou o mecanismo destina-se, ele se encontra com um problema próxima vez que ele está dirigindo no escuro.

Viver nos EUA (vá em frente, downvote me!), Ele se recusa a assumir a responsabilidade por seu uso incorreto de entranhas do carro, e sues você, o fabricante para a criação de um produto que é seguro para dirigir no escuro, porque as luzes não pode ser ligado de forma confiável após ter sido desligado.

É por isso que todos os carros têm capuzes sobre os seus compartimentos do motor:)

Um exemplo mais sério: Você cria uma classe Fraction, com um campo numerador eo denominador e um monte de métodos para manipular frações. Seu construtor não deixe seu chamador criar uma fração com um 0 denominador, mas desde que os campos são públicos, é fácil para um usuário para definir o denominador da fração existente (válido) a 0, e ensues hilaridade.

É principalmente uma coisa esconderijo e partilha. Você pode produzir e utilizar todo o seu próprio código, mas outras pessoas fornecem bibliotecas, etc, para ser usado mais amplamente.

Fazendo coisas não pública permite que você defina explicitamente a interface externa de sua classe. O material não pública não é parte da interface externa, o que significa que você pode mudar o que quiser internamente sem afetar qualquer pessoa usando a interface externa,

Você só quer expor a API e manter tudo o mais escondido. Por quê? Ok, vamos supor que você quer fazer uma biblioteca Matrix incrível para que você faça

class Matrix {
   public Object[][] data //data your matrix storages
   ...
   public Object[] getRow()
}

Por padrão qualquer outro programador que usar sua biblioteca vai querer maximizar a velocidade de seu programa tocando na estrutura subjacente.

//Someone else's function
Object one() {data[0][0]}

Agora, você descobre que o uso de lista para emular a matriz irá aumentar o desempenho para que você alterar os dados de

Object[][] data => Object[] data

causas Object one() para quebrar. Em outras palavras alterando a sua implementação você quebrou compatibilidade com versões anteriores: - (

Ao encapsular você dividir implementação interna da interface externa (conseguido com um modificador private). Dessa forma, você pode mudar a execução, tanto quanto possível, sem quebrar compatibilidade com versões anteriores: D lucro !!!

Claro, se você é o único programador que está indo cada vez para modificar ou usar essa classe que você pode bem como mantê-lo público.

Nota: Não existem outros benefícios importantes para encapsular as suas coisas, este é apenas um de muitos. Consulte Encapsulation para mais detalhes

Eu acho que a melhor razão para isso é fornecer camadas de abstração em seu código.

Como o aplicativo cresce, você precisará ter os objetos que interagem com outros objetos. Tendo campos modificáveis ??publicamente torna mais difícil de quebrar a cabeça em torno de toda a sua aplicação.

Limitando o que você faz público sobre suas classes torna mais fácil abstrair seu projeto para que você possa entender cada camada do seu código.

Para algumas classes, pode parecer ridículo ter membros privados, com um monte de métodos que apenas definir e obter esses valores. A razão para isso é que vamos dizer que você tem uma classe onde os membros são públicos e directamente acessíveis:

class A 
{
    public int i;

   ....
}

E agora você vai usar isso em um monte de código que você escreveu. Agora, depois de escrever um monte de código que acessa i diretamente e agora você percebe que eu deveria ter algumas restrições sobre ele, como eu sempre deve ser> = 0 e menor que 100 (por causa do argumento). Agora, você poderia passar por todo o seu código onde você usou i e verificar se há essa restrição, mas você pode simplesmente adicionar um método SETI público que iria fazê-lo para você:

class A
{
    private int i;
    public int I 
    {
        get {return i;}
        set 
        {
            if (value >= 0 && value < 100)
                i = value;
            else
                throw some exception...
         }
    }
}

Tudo isso a verificação de erros Isto esconde. Embora o exemplo é banal, situações como estas surgem com bastante frequência.

Não está relacionado à segurança em tudo.

modificadores de acesso e alcance são todos sobre a estrutura, camadas, organização e comunicação.

Se você é o único programador, é provavelmente muito bem até que você tem tanto código, mesmo que você não consegue se lembrar. Nesse ponto, é apenas como um ambiente de equipe -. Os modificadores de acesso ea estrutura do código guiá-lo para ficar dentro da arquitetura

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow