POO - Protegidos e Internos

Atributos e métodos protegidos são acessados por outras classes que herdam desta classe, e na própria classe em que foram criados. Não é possivel acessá-los na instância do objeto, ou seja, o acesso ocorre somente dentro da classe (Pai ou filha). São declarados com o nome protected.

Abaixo, vamos criar uma classe com um método protected.

      
        namespace Classes
        {
          public class Cliente
          {
            //método criado com a palavra protected
            protected int CalcularUmMaisDois()
            {
              return 1 + 2;
            }
          }
        }
      
    

Vamos instanciar o objeto da classe Cliente no programa principal e perceber que não é possivel chamar o método CalcularUmMaisDois(). Ao tentar compilar o código abaixo, ocorrerá o erro: is inaccessible due to its protection level.

      
            
        namespace console_app  
          class Program 
            {
              static void Main(string[] args)
              {
                Cliente c = new Cliente();
                // O método CalcularUmMaisDois() não aparece na lista dos métodos disponíveis deste objeto 
                // porque é um método protected
                c.CalcularUmMaisDois(); 
              }
            }
    
       
    

Agora vamos mostrar um exemplo em que é possível chamar o método protected, dentro da classe Usuario , que herda de Cliente.

Para isso utilizamos a palavra this

      
        namespace Classes
        {
          public class Usuario : Cliente
          {
            
            public Override void Olhar()
            {
              //utilizamos o this para chamar o método dentro da classe filha.
              int resultado = this.CalcularUmMaisDois();
            }
          }
        }
      
    

POO - Private

Atributos e Métodos privados são acessados somente na classe em que são declarados, com o nome private.

Vamos mostrar um exemplo com o método private (CalcularUmMaisDois2), em que só é possivel utilizá-lo dentro da classe em que foi criado, ou seja, somente dentro da classe Cliente.

     
       namespace Classes
       {
         public class Cliente
         {
           
          protected int CalcularUmMaisDois()
          {
            return 1 + 2;
          }
          //declaração do método private
          private int CalcularUmMaisDois2()
          {
            return 1 + 2;
          }

           public Override void Olhar()
           {
             //método CalcularUmMaisDois2 sendo chamado dentro da própria classe Cliente
             int resultado = this.CalcularUmMaisDois2();
           }
         }
       }
     
   

POO - Internal

Métodos e atributos internos podem ser acessados nas classes em que foram criados, nas classes que herdaram destas classes e também na instância da classe, ou seja, o internal é visivel dentro do projeto em que foi criado.

Abaixo, vamos criar uma classe com um método internal.

      
        namespace Classes
        {
          public class Cliente
          {
            //método criado com a palavra internal
            internal int CalcularUmMaisDois4()
            {
              return 1 + 2;
            }
          }
        }
      
    

      
        //Ao instânciar a classe Cliente acima, o método CalcularUmMaisDois4 fica disponível.
        namespace console_app  
          class Program 
            {
              static void Main(string[] args)
              {
                Cliente c = new Cliente();
                // O método CalcularUmMaisDois4() aparece na lista dos métodos disponíveis. 
                c.CalcularUmMaisDois4(); 
              }
            }
    
       
    

Para entender melhor sobre métodos internal, vamos entender o que é um assembly.

Um assembly ou DLL, ou Class Library é basicamente um projeto, uma aplicação. Dentro deste projeto existem classes que podem ser herdadas e utilizadas em outros lugares.

Para criar um projeto assembly, vamos clicar no menu :

1. New -> New Project
2. Class Library
3. Inserir um nome para o projeto, que será Componentes

Abaixo, mostraremos o assembly Componentes e criar um método internal.

      
        namespace Componentes
        {
          public class Ferramentas
          {

            internal string MetodoSomenteParaMeuAssembly()
            
            {
              return "Este método só pode ser acessado dentro deste assembly componentes.";
            }

            
            public string MetodoParaTodosQUeUtilizarOAssembly()
            {
              return "Este método é para todos";
            }


          }
        }
      
    

Vamos fazer uma referência do projeto console.app dentro do projeto Componentes:

1. Clicar com botão direito do mouse em References no projeto Componentes
2. Add References
3. Selecionar o projeto console.app

Dentro da classe Ferramentas, tentaremos utilizar a classe de Cliente, inserindo using Classes.

Ao instanciar a classe Cliente e chamar o método CalcularUmMaisDois4 (que foi declarado como internal), este método não irá aparecer, ou seja, só é possivel utilizar o método internal dentro do projeto em que foi criado. Neste projeto ficará acessível somente os métodos públicos.

      
        using Classes;

        namespace Componentes
        {
          public class Ferramentas
          {

            internal string MetodoSomenteParaMeuAssembly()
            
            {
              return "Este método só pode ser acessado dentro deste assembly componentes.";
            }

            
            public string MetodoParaTodosQUeUtilizarOAssembly()
            {

              Cliente c = new CLiente();
              C.CalcularUmMaisDois4(); //este método não está visivel.É acessado somente no projeto em que foi criado.

              return "Este método é para todos";
            }


          }
        }