Membros estáticos: static

Um membro estático são os atributos e métodos compartilhados entres todos os objetos de uma classe. Isso acontece porque os membros estáticos pertencem à classe e não os objetos, como é o caso dos atributos e métodos comuns. Um membro estático pode ser público ou privado.

Os membros estáticos se diferenciam dos comuns por serem compartilhados entre todos os membros. Assim, quando modificamos um atributo estático essa modificação é visível para todos os objetos da classe.

Para declarar um membro estático devemos usar a palavra-chave antes do nome. Outro detalhe é que o conteúdo do membro estático não pode ser escrito dentro da declaração da classe.

Os membros estáticos são úteis quando queremos guardar uma informação que é importante para todos os objetos, como por exemplo, uma contagem de quantos objetos foram criados. Outra vantagem dos membros estáticos é que eles podem ser utilizados mesmo sem ter um objeto criado.

Vamos lá pessoal, essa questão é bem parecida com o que já fizemos nos tópicos passados: criar uma classe com um construtor! O diferencial aqui é que o enunciado pede pra gente usar uma variável estática para a constante.

Antigamente a gente tinha duas abordagens pro valor de . A primeira era criar uma variável global pro programa inteiro, que é uma abordagem de programação estruturada. A segunda era criar uma constante dentro da nossa classe. E agora vamos usar uma terceira alternativa, que é criar uma constante estática, afinal, o valor de vai ser o mesmo para todos os objetos, então faz sentido usá-lo como objeto compartilhado.

Então vamos nessa! Pra começar vamos fazer o cabeçalho do nosso programa. Vamos incluir o para executar as operações.

Vamos agora construir nossa classe chamada .

A questão diz que todos os parâmetros e métodos devem ser públicos, então vamos usar a palavra-chave desde o início.

Vamos começar definindo a nossa variável estática , que também deve ser constante, então vamos usar as palavras chaves e , e como é um número real, devemos usar o tipo

Por enquanto vamos deixar a constante sem valor, pois atributos estáticos sem definidos após a classe.

O segundo atributo que vamos definir é o para representar o raio do círculo

Agora que já declaramos os atributos, vamos desenvolver o método construtor. Criamos uma função sem tipo com o nome e vamos receber o parâmetro real . O corpo da função consiste em assimilar o valor recebido do raio no atributo .

Com os valores de e podemos criar uma função que retorna resultado do cálculo da área. E uma outra função chamada que retorna o resultado do cálculo do perímetro.

E agora podemos fechar a classe.

Porém, nada irá funcionar sem um valor para a constante . Então vamos definir um valor para ela. Após o fechamento da classe acessamos o atributo . Lembre-se que não devemos mais usar a palavra-chave , porém, temos que usar a definição de tipo . Em seguida invocamos a classe e com o operador acessamos o atributo e definimos o valor

E dessa forma a nossa classe está prontinha!

Show, vamos por a classe pra trabalhar!

Dentro da criamos um objeto da classe que criamos, e inicializamos esse objeto com o valor

E usando este objeto, podemos calcular a área e o perímetro da circunferência, e imprimir os resultados utilizando o .

E prontinho! Vamos rodar o programa e...

O programa roda lindão!

E é isso pessoal. Clica no botão aí em baixo pra ir pro próximo exercício!

Vamos lá pessoal, essa questão dá instruções para criar uma classe para as células de uma bateria. A primeira parte traz informações gerais da classe para criar o atributo e os métodos e .

O detalhe na questão é que ela pede pra criar um parâmetro compartilhado chamado , que é uma forma de dizer que esse é um atributo estático.

Nota o seguinte, os métodos e deve alterar o valor do atributo , mas para manter a bateria atualizada, será preciso atualizar o valor do atributo também.

Outra coisa, o atributo tem que começar em . Então sempre que uma for adicionada vamos precisar atualizar o valor da carga da bateria. Ou seja, precisamos de um método construtor.

Um último detalhe, é que o atributo é estático e privado. Precisamos criar um método getter para acessar esse valor. Como este método só vai lidar com atributos estáticos, então poderá ser um método estático.

Pode parecer muita coisa, mas fica tranquilo que vamos fazer juntos. E pra começar, vamos fazer o cabeçalho do programa:

Então vamos começar criando a nossa classe chamada . Como descrito no enunciado temos que criar dois atributos privados para armazenar a carga da célula, e para armazenar a caga de todas as células.

Note que é um atributo compartilhado, e por isso deve ser estático.

Sempre que uma nova célula for adicionada, a carga total da bateria tem que ser atualizada. Para que algo aconteça no momento da criação de um objeto nós usamos um método construtor: uma função sem tipo com o mesmo nome que a classe. Dentro do construtor vamos atualizar o valor de carga da bateria.

Vamos agora desenvolver o método de carregamento. Quando o método for invocado ele deve aumentar a carga da bateria em . E por consequência a carga da bateria deve ser atualizada também.

De maneira semelhante temos que desenvolver o método , porém os atributos e devem ser reduzidos em 5

Ainda dentro da nossa classe, precisamos definir um método para acessar o valor da carga da bateria. Vamos criar um método do tipo chamado que retorna o valor da carga da bateria.

Com isso a nossa classe está quase concluída e já podemos fechar a classe. Mas ainda precisamos definir o valor inicial da variável estática .

Para definir o valor do atributo fora da classe não usamos a palavra-chave , apenas usamos o tipo seguido do nome da classe , do operador e então usamos o nome do atributo que estamos acessando

E com isso a nossa classe está complemente definida.

Pra finalizar a questão, vamos executar um teste.

Primeiro vamos criar os três objetos do tipo , e ..

Em seguida vamos usar os objetos e para executar o método e depois usamos o objeto para executar o método

E finalizamos a questão executando o comando para visualizar a carga total da bateria. Para isso vamos acessar o método estático .

A gente pode acessar um membro estático através de qualquer um dos objetos , ou . Porém, uma boa prática e acessar os métodos estáticos através da própria classe usando a sintaxe:

No nosso caso fica da seguinte forma:

E com isso vamos ter o seguinte resultado:

E finalizamos mais uma questão! Vlw flw!

Certo pessoal, essa é mais uma daquelas questões de encontrar erros no código. Então vamos olhar com atenção, linha-por-linha! Lets bora!

Das linhas 01 a 06 temos apenas os cabeçalhos e o início da classe. Até aqui está tudo certo

Agora observe a linha 07 e 08. Pelo comentário deixado pelo programador, podemos perceber que ele quer contar a quantidade de objetos criados. Para fazer esse tipo de contagem, é necessário que este atributo seja estático, pois só dessa forma é possível criar um atributo que seja compartilhado entre todos os objetos, permitindo assim que cada objeto altere o valor da contagem. Além disso, se você olhar pra linha 22, vai ver que de fato, o programador queria que esse fosse um membro estático.

Então o nosso primeiro erro está na linha 08. Precisão adicionar a palavra chave para informar ao compilador que a variável é estática. Outra coisa importante é que os atributos estáticos não podem ser inicializados dentro da declaração da classe.

Então vamos corrigir

Seguindo em frente vemos o construtor da classe, que recebe os valores dos atributos e incrementa o valor de contagem . Aqui não temos nenhum erro.

Porém, note o seguinte problema: A variável estática é privada. E esse programador não criou nenhum método para poder acessar essa variável.

Precisamos criar um método getter para acessar o valor contido em . Como a variável é estática, o ideal é a gente criar um método getter que seja estático também!

Então, antes de fechar a classe, vamos criar um método estático público chamado

Por enquanto vamos criar só o protótipo, e depois vamos adicionar os detalhes.

Continuando, nos deparamos com código das linhas 22 e 23. Aqui o objeto é inicializar o valor da variável estática.

Mas note o erro, a palavra-chave só deve ser usada quando declaramos o atributo dentro da classe

Corrigindo, fica dessa maneira:

Ok, antes de analisar a vamos escrever o código do método estático . Tudo que precisamos fazer aqui é retornar o valor contido no atributo , então vamos ter o seguinte código:

Pra finalizar a questão, vamos analisar a . Aqui ele cria quatro objetos para representar quatro funcionários.

Depois ele utiliza a própria classe para imprimir o valor do atributo . Contudo, esse é um atributo privado e por isso não é possível acessá-lo diretamente!

Por sorte, nós percebemos isso antes e já temos um método getter criado! Então para corrigir basta a gente usar o método getter:

Vamos nessa, pessoal. Essa questão pede pra gente criar uma classe para os produtos de uma loja, com atributos que representem o nome, quantidade e valor do produto. Por questão de boas práticas, estes atributos serão privados.

O diferencial da questão é que teremos duas variáveis que devem ser compartilhadas entre as classes: e . Para isso, estes atributos devem ser do tipo . Para seguir as boas práticas, estes atributos serão privados.

A questão também pede pra gente imprimir os valores de e , mas como estas são variáveis privadas vamos precisar criar um método para acessá-las.

Mas primeiro, vamos escrever o nosso cabeçalho. Adicionamos a classe para facilitar nossa vida.

Vamos começar a classe chamada . Vamos iniciar o escopo privado com a palavra-chave .

E agora vamos declarar os atributos: o primeiro é o do tipo , depois o valor do produto será o atributo do tipo , e a quantidade de produtos será armazenada no atributo do tipo .

Agora vamos dar atenção aos atributos estáticos. O primeiro representa a variedade de produtos disponíveis, vamos chamar de e o segundo representa a quantidade de todos os produtos no estoque, então chamaremos de .

Agora vamos dar uma olhada nos atributos públicos da classe.

O primeiro deles é o nosso método construtor, que vai receber o os parâmetros do produto: e .

Antes de concluir o método construtor temos que olhar para as variáveis estáticas.

O atributo aumenta sempre que um produto novo é inserido, então devemos atualizar esse atributo no momento da criação de um novo objeto.

Já o atributo depende da quantidade de produtos inseridos. Então vamos usar o operador para adicionar a inserida no .

A classe está quase pronta. Mas antes de fechar a classe temos que desenvolver um método capaz de acessar os atributos e . Então vamos criar o protótipo do método que será responsável por imprimir os valores.

Esse método pode ser do tipo estático pois ele só deve ter acesso as variáveis estáticas.

E com isso podemos fechar a nossa classe.

Contudo, a classe ainda não está concluída. Precisamos definir os valores iniciais dos atributos estáticos.

Então, fora da classe, nós chamamos os atributos utilizando a sintaxe . Lembre-se que fora da classe não precisamos usar a palavra-chave Veja como fica no nosso código:

Também precisamos definir o corpo do método . Para isso usamos a sintaxe: . Novamente, o uso do não é necessário.

No corpo da função vamos usar o para enviar uma mensagem legal pro usuário.

Agora sim, a classe está completamente finalizada.

Vamos por a classe pra trabalhar agora.

Vamos começar criando quatro objetos da classe . Você pode dar a eles o nome, valor e quantidades de quiser. Aqui eu escolhi alguns valores aleatórios:

Prontinho, agora basta a gente invocar o método . A gente pode usar qualquer objeto para isso, porém, as boas práticas sugerem que a melhor forma de usar um método estático é pela sintaxe: . No código fica assim:

Agora vamos rodar pra ver se deu tudo certo:

E é isso! Tudo certo! Até a próxima, pessoal.

Beleza pessoal, vamos nessa!

A questão está pedindo pra gente criar uma classe com um número máximo de objetos. Ou seja, vamos precisar contabilizar quantos objetos foram criados, quando o numero de objetos for maior que este máximo comportamento da classe vai mudar!

Vamos começar com o cabeçalho do código.

E vamos também criar uma constante global que contem o número máximo permitido de monstros.

Vamos desenvolver a estrutura da classe.

Vamos declarar a classe

E como atributos privados vamos declarar a string e os inteiros e .

Vamos mudar para o encapsulamento público. Aqui vamos declarar o atributo estático inteiro . Vai ser esse o atributo responsável por efetuar a contagem de monstros.

E em seguida vamos declarar os métodos da classe. Vamos precisar construtor que vai inicializar os três atributos da classe, e que vai aumentar a contagem de a cada novo objeto criado.

E também de uma função que vai diminuir a contagem de monstros sempre que um inimigo for derrotado.

Prontinho! A estrutura geral da classe está feita. Vamos agora desenvolver os detalhes.

A primeira coisa a fazer é determinar o valor inicial do atributo estático . Pra isso a gente chama o atributo fora da classe e inicializa:

Show!

Agora vamos desenvolver os métodos. O primeiro é o construtor, que vai receber e inicializar os atributos da classe. Para facilitar o processo de criar objetos, vamos colocar valores padronizados para os parâmetros do construtor.

Nós também temos que atualizar a contagem de monstros. Um novo monstro foi criado, então o valor de aumenta mais um:

E o construtor ainda não acabou! Aqui a gente tem que lembrar que a quantidade máxima de monstros é . E o que impede a existência ? Até agora, nada! Então vamos adicionar aqui uma condição para eliminar automaticamente os monstros excedentes.

Para isso vamos usar um que quando o número de monstros passar do máximo, automaticamente o método vai ser executado, eliminando o monstro extra no momento da criação!

Agora temos que desenvolver o método . Um monstro morre quando sua vida chega a zero. Então o objetivo desse método será setar a do monstro para , e em seguida atualizar a contagem de monstros em menos um.

Pro jogo ficar mais dinâmico, vamos adicionar também uma mensagem informando que o monstro foi derrotado.

Prontinho! A classe e seus métodos estão concluídos!

Show de bola, agora vamos testar essa classe.

Primeiro, vamos exibir a quantidade de monstros inicial. Esse valor tem de ser zero.

Em seguida, vamos criar a quantidade máxima de monstros permitida, para testar se a contagem está ocorrendo como deveria, e exibimos a nova quantidade de monstros.

E depois precisamos conferir se o limitador de monstros funciona. Então vamos criar mais um objeto da classe e ver o que acontece quando o atributo

Agora vamos rodar o programa e ver o resultado:

Viu que legal? A quantidade de monstros foi contada corretamente! E assim que um monstro excedente foi criado, automaticamente ele foi eliminado do jogo.

E aí, galera! Vamos desenvolver mais um exercício de fixação.

A questão fala que um tanque é alimentado por canais que fornecem um certo valor de vazão individual cada um, e que somados oferecem uma vazão total para o tanque. Então uma boa solução é criar uma classe que represente canais e depois instanciar a quantidade de objetos necessários.

Mas antes, vamos começar com o cabeçalho da questão. Vamos aproveitar para declarar uma constante global que guarda o valor da vazão máxima permitida:

Vamos desenvolver a classe que representa os canais.

No encapsulamento privado, vamos criar um tributo que represente a vazão desse canal:

A de cada canal deve ser ajustada de acordo com a vazão total do tanque, então vamos declarar um atributo que armazena a vazão total do tanque. Acontece que o valor de é composto pela soma de todos os canais, como gerenciar isso sem saber a quantidade de canais que serão utilizados? Simples, o atributo deve ser estático:

Belezinha! Agora vamos pro encapsulamento público onde vamos definir alguns métodos importantes.

Primeiro o construtor, que recebe como parâmetro o valor da vazão individual de cada canal.

Depois criamos métodos e para que a gente possa visualizar os atributos privados. Detalhe interessante é que o pode ser do tipo estático, pois ele acessa apenas atributos estáticos.

E também vamos declarar um método que irá atualizar o valor da vazão quando necessário. Esse método recebe um parâmetro pois o ajuste de vazão será proporcional a um determinado fator.

E com isso podemos fechar a classe.

Show. Agora que o esqueleto da classe foi desenvolvido, a gente pode desenvolver os detalhes.

Primeiro, vamos inicializar o atributo estático , pra isso a gente chama ele sem utilizar a palavra chave e inicializa com valor zerado.

Em seguida, vamos desenvolver o construtor da classe. O construtor receberá o parâmetro vazão (que tem valor padrão zero), o parâmetro recebido será usado para inicializar o atributo e em seguida atualiza o valor da do sistema.

Em seguida, a gente desenvolve os getters que simplesmente retornam o conteúdo dos atributos privados.

O ponto chave é o método . Esse método recebe um valor de proporção que é calculado de acordo com o excedente de vazão.

Então, para evitar que a vazão de um mesmo canal seja contabilizada duas vezes, primeiro removemos de o valor atual de deste canal. Em seguida, a vazão deste canal é atualizada de acordo com o valor de . E por fim, adicionamos a vazão atualizada deste canal na vazão total do sistema.

E pronto! Todos os métodos e atributos da classe estão definidos.

Agora vamos testar.

Primeiro, vamos criar três instâncias de com valores quaisquer de vazão.

Vamos exibir a vazão total para o usuário.

Em seguida, vamos usar uma estrutura para verificar se a vazão total excede a máxima permitida.

Caso a vazão seja excedente, nós informamos isso ao usuário e calculamos um valor proporcional de redução que deve ser aplicada nos canais para atingir o valor permitido:

Com o valor calculado, a gente passa a taxa de redução como parâmetro do método de cada um dos canais. E depois informamos isso ao usuário.

E pra finalizar, é só a gente imprimir o valor de vazão total e de cada um dos canais.

E o resultado é:

E é isso! Até a próxima!

E aí, pessoal, tudo certinho?

A questão é de boas.

A gente precisa desenvolver uma classe que sempre que instanciar um novo objeto vai contabilizar um ingresso adicional. Quando precisamos contar a quantidade de objetos criados, a melhor forma é utilizar membros estáticos.

Mas antes vamos começar com o cabeçalho da questão.

Vamos iniciar a nossa classe :

Dentro do encapsulamento privado, a gente vai declarar os atributos estáticos. A gente precisa contabilizar a quantidade de ingressos vendidos para a pista e também para a área VIP. Então vamos criar dois atributos estáticos e . Para isso é só adicionar a palavra chave :

Agora vamos mudar o encapsulamento para público onde iremos desenvolver o construtor, uma função sem tipo com o mesmo nome da classe. O construtor vai receber apenas um único valor booleano que define se o ingresso vendido é ou não do tipo VIP.

Dentro do construtor vamos utilizar uma estrutura que caso incrementa o atributo estático caso o parâmetro seja , e incrementa o atributo estático caso o parâmetro seja :

Para garantir o acesso aos membros estáticos vamos criar um getter para cada um dos atributos. Note que esses getters vão acessar apenas membros estáticos, então o ideal é que estes sejam métodos estáticos. Para isso é só adicionar a palavra chave :

Show. A estrutura da classe está pronta, podemos fechar a nossa classe!

Agora precisamos inicializar os membros estáticos. Lembre-se, membros estáticos não podem ser inicializados dentro dos parêntesis da classe.

Então, logo após a classe vamos invocar os atributos estáticos e inicializa-los com o valor inicial zerado. Lembre-se que não é necessário usar a palavra-chave novamente.

Logo em seguida, podemos inicializar definir o comportamento dos métodos estáticos. Estes são métodos getters simples, que apenas retornam o conteúdo das variáveis estáticas.

E pronto! A classe está pronta e os membros estáticos estão definidos!