Torne-se um Programador

Orientação a Objetos - public, private, protected

Nesta aula iremos aprender as marcações public, private, protected e veremos as diferenças entre elas.

Assine nossa Comunidade

Modificadores de Acesso (public, private e protected)

Privada: Fica restrita ao escopo da classe.

Protegida: Fica restrita ao escopo da classe e ás classes que herdam ela.

Pública: Fica com acesso livre.

Exemplos de acesso.

      
        class Carro
        protected
          def Danilo
            # método protegida
          end
        end

Na situação acima caso fizéssemos: Carro.new.Danilo, não funcionaria pois o método está protegido.

Importante notar que:

Uma vez definido o acesso ele será aplicado a todo código abaixo, tendo que ser mudado explicitamente para outro modo caso necessário.

Você pode utilizar um método protegido dentro de um público e assim exibir o valor protegido.

E ao utilizar um método sem informar o acesso, ele será público por padrão.

      
      class Carro
        def mostrar
          # método público
        end
        private
        def olhar
          # método privado
        end
        protected
        def ver
          # método protegido
        end
      end

Fazendo um método publico receber o protegido por herança é uma forma de ter acesso ao método protected de outra classe:

      
      class Carro
      protected
        def Danilo
          # método protegido
        end
      end
      class Fiesta < Carro
        def mostrar
          # método publico
          Danilo
        end
      end
      Fiesta.new.mostrar

Lembrando que se o método Danilo fosse privado não seria possível fazer o processo acima, um método privado não pode ser herdado.

Aula Prática

Como de praxe copie o arquivo padrão da aula anterior para seguir conforme o padrão.

Para essa aula criaremos alguns arquivos de classe separados do código principal

Para o arquivo fiesta.rb faça:

        
          class Carro
            def initialize(nome = "Modelo Padrão")
              @nome = nome
            end

            attr_accessor :nome, :porta, :painel, :roda
            attr_reader :pneu

            def mostrar(marca="Marca Padrão")
              puts "Marca: #{marca} - Modelo: #{self.nome} - #{algo_mais}"
            end

            private
            def algo_mais
              "este é um método privado para retornar algo a mais"
            end
          end

Uma diferença entre o acesso do privado e o protegido é que o privado não pode ser acessado diretamente nem dentro ou fora da classe, já com o protegido não é possível criar uma nova instância para acessa-lo.

Mais testes:

          
            class Carro
              def initialize(nome = "Modelo Padrão")
                @nome = nome
              end

              attr_accessor :nome, :porta, :painel, :roda
              attr_reader :pneu

              def mostrar(marca="Marca Padrão")
                puts "Marca: #{marca} - Modelo: #{self.nome} - #{algo_mais}"
              end

              private
              def algo_mais
                "este é um método privado para retornar algo a mais"
              end

              def algo_mais2
                "este é um método privado para retornar algo a mais"
              end

              public
              def algo_mais
                "este é um método público para retornar algo a mais"
              end

              protected
              def algo_mais_protected
                "este é um método protegido para retornar algo a mais"
              end
            end

Utilizando método privado com herança.

          
          class Fiesta < Carro
            def mostrar_privado
                algo_mais
              Danilo
            end
          end
          Fiesta.mostrar_privado

Se fosse criada uma nova instância de Carro nosso código não funcionaria.

            
            class Fiesta < Carro
              def mostrar_privado
                  algo_mais
                Danilo
              end
            end
            Carro.new.algo_mais

Utilizando um método protegido.

        
          class Fiesta < Carro
            def mostrar_privado
              algo_mais
              Carro.new.algo_mais
            end
            def mostrar_protegido
              algo_mais_protected
            end
          end