Qual é a diferença entre público, privado, protegido e sem modificador de access?

Todos os meus anos de faculdade tenho usado o public e gostaria de saber a diferença entre public , private e protected ?

Além disso, o que a static faz em vez de não ter nada?

Modificadores de access

público

O tipo ou membro pode ser acessado por qualquer outro código no mesmo assembly ou outro assembly que faz referência a ele.

privado

O tipo ou membro só pode ser acessado por código na mesma class ou estrutura.

protegido

O tipo ou membro só pode ser acessado por código na mesma class ou struct, ou em uma class derivada.

interno

O tipo ou membro pode ser acessado por qualquer código no mesmo assembly, mas não em outro assembly.

interno protegido

O tipo ou membro pode ser acessado por qualquer código no mesmo assembly ou por qualquer class derivada em outro assembly.

Quando nenhum modificador de access é definido, um modificador de access padrão é usado. Portanto, há sempre alguma forma de modificador de access, mesmo que não esteja definida.

Estático

O modificador estático em uma class significa que a class não pode ser instanciada e que todos os seus membros são estáticos. Um membro estático possui uma versão, independentemente de quantas instâncias de seu tipo de inclusão foram criadas.

Uma class estática é basicamente igual a uma class não estática, mas há uma diferença: uma class estática não pode ser instanciada externamente. Em outras palavras, você não pode usar a nova palavra-chave para criar uma variável do tipo de class. Como não há variável de instância, você acessa os membros de uma class estática usando o próprio nome da class.

No entanto, existe algo como um construtor estático . Qualquer class pode ter uma delas, incluindo classs estáticas. Eles não podem ser chamados diretamente e não podem ter parâmetros (além de qualquer parâmetro de tipo na própria class). Um construtor estático é chamado automaticamente para inicializar a class antes que a primeira instância seja criada ou qualquer membro estático seja referenciado. Se parece com isso:

 static class Foo() { static Foo() { Bar = "fubar"; } public static string Bar { get; set; } } 

Classes estáticas são frequentemente usadas como serviços, você pode usá-las assim:

 MyStaticClass.ServiceMethod(...); 

Público – Se você puder ver a turma, poderá ver o método

Particular – Se você faz parte da turma, então você pode ver o método, caso contrário não.

Protected – O mesmo que Private, além de todos os descendentes também podem ver o método.

Estático (class) – Lembre-se da distinção entre “Classe” e “Objeto”? Esqueça tudo isso. Eles são os mesmos com “static” … a class é a única instância de si mesma.

Static (method) – Sempre que você usar esse método, ele terá um quadro de referência independente da instância real da class da qual faz parte.

Uma visão geral gráfica (resumo em poucas palavras)

Visibilidade

Para os padrões, se você não colocar nenhum modificador de access na frente, veja aqui:
Visibilidade padrão para classs e membros C # (campos, methods, etc)?

Não nested

 enum public non-nested classs / structs internal interfaces internal delegates in namespace internal class/struct member(s) private delegates nested in class/struct private 

Aninhado:

 nested enum public nested interface public nested class private nested struct private 

Quanto à questão de nada

  • Os tipos de namespace são internos por padrão
  • Qualquer membro do tipo, incluindo tipos nesteds, é privado por padrão

insira a descrição da imagem aqui

 using System; namespace ClassLibrary1 { public class SameAssemblyBaseClass { public string publicVariable = "public"; protected string protectedVariable = "protected"; protected internal string protected_InternalVariable = "protected internal"; internal string internalVariable = "internal"; private string privateVariable = "private"; public void test() { // OK Console.WriteLine(privateVariable); // OK Console.WriteLine(publicVariable); // OK Console.WriteLine(protectedVariable); // OK Console.WriteLine(internalVariable); // OK Console.WriteLine(protected_InternalVariable); } } public class SameAssemblyDerivedClass : SameAssemblyBaseClass { public void test() { SameAssemblyDerivedClass p = new SameAssemblyDerivedClass(); // NOT OK // Console.WriteLine(privateVariable); // OK Console.WriteLine(p.publicVariable); // OK Console.WriteLine(p.protectedVariable); // OK Console.WriteLine(p.internalVariable); // OK Console.WriteLine(p.protected_InternalVariable); } } public class SameAssemblyDifferentClass { public SameAssemblyDifferentClass() { SameAssemblyBaseClass p = new SameAssemblyBaseClass(); // OK Console.WriteLine(p.publicVariable); // OK Console.WriteLine(p.internalVariable); // NOT OK // Console.WriteLine(privateVariable); // Error : 'ClassLibrary1.SameAssemblyBaseClass.protectedVariable' is inaccessible due to its protection level //Console.WriteLine(p.protectedVariable); // OK Console.WriteLine(p.protected_InternalVariable); } } } 

  using System; using ClassLibrary1; namespace ConsoleApplication4 { class DifferentAssemblyClass { public DifferentAssemblyClass() { SameAssemblyBaseClass p = new SameAssemblyBaseClass(); // NOT OK // Console.WriteLine(p.privateVariable); // NOT OK // Console.WriteLine(p.internalVariable); // OK Console.WriteLine(p.publicVariable); // Error : 'ClassLibrary1.SameAssemblyBaseClass.protectedVariable' is inaccessible due to its protection level // Console.WriteLine(p.protectedVariable); // Error : 'ClassLibrary1.SameAssemblyBaseClass.protected_InternalVariable' is inaccessible due to its protection level // Console.WriteLine(p.protected_InternalVariable); } } class DifferentAssemblyDerivedClass : SameAssemblyBaseClass { static void Main(string[] args) { DifferentAssemblyDerivedClass p = new DifferentAssemblyDerivedClass(); // NOT OK // Console.WriteLine(p.privateVariable); // NOT OK //Console.WriteLine(p.internalVariable); // OK Console.WriteLine(p.publicVariable); // OK Console.WriteLine(p.protectedVariable); // OK Console.WriteLine(p.protected_InternalVariable); SameAssemblyDerivedClass dd = new SameAssemblyDerivedClass(); dd.test(); } } } 

Hmm.

Veja aqui: Modificadores de access .

Em poucas palavras:

Public dá o método ou tipo visibilidade completa de outros tipos / classs.

Private permite apenas o tipo que contém o método privado / access variável ao método / variável particular (observe que as classs aninhadas também têm access às classs / methods privados contendo classs).

Protegido é semelhante ao privado, exceto que classs derivadas também podem acessar methods protegidos.

“Nada” é o equivalente do VB.NET para null. Embora se você está se referindo a “nada” significando “nenhum modificador de access”, então isso depende, embora uma regra prática muito grosseira (certamente em C #) seja que, se você não especificar explicitamente um modificador de access, o método / variável declaração é geralmente tão restrito quanto possível. ou seja

 public class MyClass { string s = ""; } 

é efetivamente o mesmo que:

 public class MyClass { private string s = ""; } 

O artigo do MSDN vinculado oferecerá uma descrição completa quando não houver nenhum modificador de access especificado explicitamente.

público – pode ser acessado por qualquer pessoa em qualquer lugar.
privado – só pode ser acessado na class da qual faz parte.
protected – só pode ser acessado na class ou em qualquer object que herde da class.

Nada é como null, mas em VB.
Estático significa que você tem uma instância desse object, método para cada instância dessa class.

Repostando os diagramas impressionantes desta resposta .

Aqui estão todos os modificadores de access nos diagramas de Venn, de mais limitantes a mais promíscuos:

private :
insira a descrição da imagem aqui

private protected : – adicionado em C # 7.2
insira a descrição da imagem aqui

internal :
insira a descrição da imagem aqui

protected :
insira a descrição da imagem aqui

protected internal :
insira a descrição da imagem aqui

public :
insira a descrição da imagem aqui

mmm …

Estático significa que você pode acessar essa function sem ter uma instância da class.

Você pode acessar diretamente da definição de class.

Um status de Private indica que as variables ​​só podem ser acessadas por objects da mesma class. O status protegido estende esse access para include descendentes da class também.

“da tabela acima podemos ver a deferência entre privado e protegido … acho que ambos são iguais …. então qual a necessidade para que dois comando separado”

Verifique o link MSDN para mais informações

Esses modificadores de access especificam onde seus membros estão visíveis. Você provavelmente deveria ler isto. Pegue o link dado por IainMH como ponto de partida.

Membros estáticos são um por class e não um por instância.

Cuidado ver sua acessibilidade de suas aulas. Classes e methods públicos e protegidos são, por padrão, acessíveis para todos.

Também a Microsoft não é muito explícita em mostrar modificadores de access (public, protected, etc.) quando novas classs no Visual Studio são criadas. Portanto, cuide bem e pense na sua acessibilidade à sua turma porque ela é a porta para os internos da sua implementação.

Eu acho que isso está relacionado ao bom design da OOP. Se você é um desenvolvedor de uma biblioteca, deseja ocultar o funcionamento interno de sua biblioteca. Dessa forma, você pode modificar o funcionamento interno de sua biblioteca mais tarde. Portanto, você coloca seus membros e methods auxiliares como privados e somente methods de interface são públicos. Métodos que devem ser sobrescritos devem ser protegidos.

C # tem no total 6 modificadores de access:

private : O membro declarado com essa acessibilidade pode ser visível dentro do tipo de contêiner, não é visível para nenhum tipo derivado, outros tipos no mesmo conjunto ou tipos fora do assembly contido. isto é, o access é limitado ao tipo contendo apenas.

protected : O membro declarado com essa acessibilidade pode ser visível dentro dos tipos derivados do tipo de contenção dentro do assembly contido, e os tipos derivados do tipo contido fora do assembly contido. isto é, o access é limitado a tipos derivados do tipo contendo.

internal : O membro declarado com essa acessibilidade pode ser visível dentro do assembly que contém esse membro, não é visível para nenhum assembly fora do assembly contendo. isto é, o access é limitado a conter apenas assembly.

internal protected : O membro declarado com essa acessibilidade pode ser visível dentro dos tipos derivados do tipo de contenção dentro ou fora do assembly contido, também é visível para qualquer tipo dentro do assembly contido. isto é, o access é limitado a conter conjuntos ou tipos derivados.

public : O membro declarado com essa acessibilidade pode ser visível no assembly que contém esse membro ou em qualquer outro assembly que faça referência ao assembly. ou seja, o access não é limitado.

C # 7.2 está adicionando um novo nível de acessibilidade:

private protected : O membro declarado com essa acessibilidade pode ser visível nos tipos derivados desse tipo de contenção dentro do assembly. Não é visível para qualquer tipo não derivado do tipo de contenção ou fora do assembly que o contém. ou seja, o access é limitado a tipos derivados dentro do assembly contendo.

Fonte incluindo um código de amostra do novo modificador de access protegido privado