Atributos e Métodos¶

Atributos¶

definição = variáveis declaradas dentro de uma classe que representam as características ou propriedades de um objeto
propósito = armazenar o estado de um objeto, contendo informações relevantes para sua descrição
declaração
- feita diretamente na classe
- geralmente com um modificador de acesso para definir visibilidade - private, public, protected ou default

public class Carro {
        // Atributos da classe Carro
        String marca;
        String modelo;
        int ano;
    }

Métodos¶

definição = funções definidas dentro de uma classe que descrevem as ações ou comportamentos que o objeto pode realizar
propósito = manipular os atributos e executar operações relacionadas ao objeto
declaração
- um modificador de acesso
- um tipo de retorno - ou void se não retornar nada
- nome do método
- parâmetros, se houver
- corpo do método

public class Carro {
        // Método da classe Carro para exibir informações
        void exibirInformacoes() {
            System.out.println("Marca: " + marca);
            System.out.println("Modelo: " + modelo);
            System.out.println("Ano: " + ano);
        }
    }

Tipos de métodos
- métodos de instância = dependem de uma instância específica (objeto) da classe para serem chamados
  - exemplo = `meuCarro.exibirInformacoes();
- métodos estáticos = pertencem à classe, não a uma instância específica, e podem ser chamados sem criar um objeto usando a palavra-chave static
  - exemplo = `Math.sqrt(9);

Quadro comparativo¶

Aspecto	Atributos	Métodos
Propósito	Armazenar o estado (características) do objeto	Executar ações ou comportamentos no objeto
Declaração	Como variáveis dentro da classe	Como funções dentro da classe
Acesso	Através do nome do objeto e ponto (`.`)	Através do nome do objeto e ponto (`.`), seguido de parênteses
Exemplo	`meuCarro.marca = "Toyota";`	`meuCarro.exibirInformacoes();`
Modificadores	`private`, `public`, `protected`	`private`, `public`, `protected`, `static`

Modificadores¶

Modificadores de acesso¶

modificadores de acesso = em Java, controlam a visibilidade e a acessibilidade de classes, atributos, métodos e construtores
os modificadores de acesso controlam quem pode acessar o membro
Eles permitem restringir ou liberar o acesso a determinadas partes do código, ajudando a proteger a integridade dos dados e promovendo o encapsulamento
aplicáveis a atributos e métodos
Java - quatro principais modificadores de acesso
public = acessível de qualquer lugar do código, em qualquer classe ou pacote
- maior visibilidade
private = acessível apenas dentro da própria classe onde é declarado
- menor visibilidade
- ideal para dados sensíveis
protected = acessível apenas dentro do mesmo pacote e por subclasses, mesmo que estejam em pacotes diferentes
- visibilidade meio-termo
default (ou package-private) = ausência de modificador específico. Acessível apenas dentro do mesmo pacote.

package acesso;

public class Exemplo {
    public int publicVar;   // Acessível de qualquer classe
    private int privateVar; // Acessível apenas dentro de Exemplo
    protected int protectedVar; // Acessível em subclasses e no mesmo pacote
    int defaultVar; // Acessível no pacote acesso
}

Modificador de Acesso	Classe Própria	Mesmo Pacote	Subclasses (outros pacotes)	Qualquer Classe
`public`	Sim	Sim	Sim	Sim
`protected`	Sim	Sim	Sim	Não
default	Sim	Sim	Não	Não
`private`	Sim	Não	Não	Não

Modificadores não acessíveis¶

modificadores não acessíveis = usados para definir características específicas de classes, métodos e atributos em Java, sem alterar sua visibilidade
usados para definir comportamentos específicos da classe/atributo/método, mas não afetam a visibilidade no código
exemplos de comportamentos
- imutabilidade
- compartilhamento entre instâncias
- exigência de implementação
podem ser combinados com modificadores de acesso

Modificador	Aplicável a	Descrição
`final`	Classe, método, atributo	Torna a classe não extensível (sem subclasses), o método não sobrescrevível e o atributo constante (imutável). Usado para evitar mudanças.
`static`	Método, atributo	Faz o método ou atributo pertencer à classe em vez de a uma instância. Compartilhado por todas as instâncias.
`abstract`	Classe, método	Define uma classe como abstrata (não pode ser instanciada) ou um método que deve ser implementado pelas subclasses.
`synchronized`	Método	Garante que o método pode ser acessado apenas por uma thread por vez, útil para sincronização em multithreading.
`volatile`	Atributo	Indica que o valor do atributo pode ser alterado por múltiplas threads simultaneamente e garante visibilidade correta.
`transient`	Atributo	Indica que o atributo não deve ser serializado, ou seja, não será persistido em arquivos serializados.
`native`	Método	Indica que o método é implementado em outra linguagem de programação, geralmente em C ou C++, fora do Java.
`strictfp`	Classe, método	Garante que operações de ponto flutuante (float e double) sigam um padrão de precisão, independente da plataforma.

usando o exemplo do static, um atributo static é associado à classe e não aos objetos. Ele existe uma única vez para todas as instâncias da classe

class Pessoa {
    // todos os objetos `Pessoa` terão acesso ao mesmo valor de contator
    static int contador = 0;
    String nome;

    Pessoa(String nome) {
        this.nome = nome;
        contador++;  // Incrementa o contador sempre que um objeto é criado
    }
}

da mesma forma, um método static também pertence à classe, não a instâncias específicas. Ele pode ser chamado diretamente pela classe, sem precisar de um objeto
métodos static podem ser usados para acessar ou modificar atributos static ou executar operações que não dependem do estado do objeto
- não podem acessar diretamente atributos e métodos não estáticos da classe

class Calculadora {
    static int somar(int a, int b) {
        return a + b;
    }
}

// Chamada direta sem criar um objeto
int resultado = Calculadora.somar(2, 3);

acesso a membros static de fora da classe = diretamente pela classe ou por instâncias, mas é recomendado acessar usando o nome da classe para indicar que o membro é compartilhado entre todas as instâncias

// Acessando o atributo static diretamente pela classe
System.out.println(Pessoa.contador);

já de dentro da classe, os membros static podem ser acessados diretamente, seja em métodos estáticos ou não estáticos.
- porém, métodos não estáticos não podem acessar membros estáticos diretamente se estiverem sendo chamados de um contexto estático
sobre o static, algumas observações importante
- atributos e métodos estáticos são comuns a todas as instâncias = se um objeto modificar um atributo static, a modificação será refletida para todos os objetos daquela classe
- não é possível acessar membros não estáticos de métodos estáticos = métodos estáticos não têm acesso direto ao estado específico de objetos, pois não são vinculados a nenhum objeto em particular

class Exemplo {
    int atributoNaoStatic;  // Atributo não estático
    static int atributoStatic;  // Atributo estático

    static void metodoStatico() {
        // Não é possível acessar 'atributoNaoStatic' aqui diretamente
        atributoStatic = 10;  // Pode acessar atributo estático
    }
}

Uso comum de static
- métodos utilitários = métodos static são frequentemente usados em classes que possuem funções auxiliares, como a classe Math em Java, que contém métodos como Math.pow()
- atributos de contagem ou configuração global = atributos static são usados para armazenar informações compartilhadas entre objetos, como contadores ou configurações de aplicação
static e o Garbage Collector = como os membros static pertencem à classe e não às instâncias, eles não são coletados pelo Garbage Collector enquanto a classe estiver carregada na memória
- permanecem na memória durante a execução do programa

Exercícios¶

Questões¶

Atributos de uma classe podem ser declarados fora de qualquer método, mas sempre dentro da classe.
Os atributos de uma classe são usados para armazenar o estado dos objetos.
Métodos podem ser chamados diretamente a partir de outros métodos dentro da mesma classe sem a necessidade de um objeto.
A palavra-chave static em um atributo ou método significa que ele é compartilhado entre todas as instâncias da classe.
Métodos em Java podem retornar valores ou serem do tipo void, caso não retornem nada.
É possível declarar atributos dentro de um método em Java, mas eles não pertencem à classe, apenas ao método em que foram declarados.
O modificador de acesso protected permite que um atributo ou método seja acessado por outras classes no mesmo pacote e por subclasses, mesmo que estejam em pacotes diferentes.
A palavra-chave final em um método significa que ele pode ser sobrescrito em subclasses.
Um método pode ser sobrecarregado, desde que o nome seja o mesmo, mas os tipos ou o número de parâmetros sejam diferentes.
Métodos getter e setter são usados para acessar e modificar os valores de atributos privados em uma classe.
Os atributos de uma classe podem ser acessados diretamente por qualquer outro código fora da classe, se forem declarados como public.
Um atributo de classe (estático) pode ser acessado através de qualquer instância de um objeto da classe, mas é recomendado acessá-lo diretamente pela classe.
Métodos podem ser chamados diretamente sem o uso de um objeto se forem declarados como static.
A sobrecarga de métodos permite a criação de métodos com o mesmo nome, mas com diferentes tipos de retorno.
Em Java, o modificador private pode ser usado em métodos para impedir que sejam acessados fora da classe.

Gabarito¶

Verdadeiro: os atributos são definidos dentro da classe, mas fora de qualquer método.
Verdadeiro: atributos representam o estado do objeto, como suas propriedades e características.
Falso: para chamar um método, é necessário criar um objeto, a menos que o método seja static.
Verdadeiro: atributos e métodos static pertencem à classe, e não a uma instância específica, sendo compartilhados por todas as instâncias.
Verdadeiro: métodos podem ter um tipo de retorno ou ser do tipo void quando não retornam nenhum valor.
Verdadeiro: atributos declarados dentro de um método são variáveis locais e existem apenas dentro do método.
Verdadeiro: protected permite acesso dentro do mesmo pacote e em subclasses de pacotes diferentes.
Falso: final em um método significa que ele não pode ser sobrescrito em subclasses.
Verdadeiro: a sobrecarga ocorre quando métodos com o mesmo nome têm diferentes números ou tipos de parâmetros.
Verdadeiro: getters e setters são métodos especiais usados para acessar ou modificar atributos privados.
Verdadeiro: atributos public podem ser acessados diretamente fora da classe, mas isso é considerado uma má prática.
Verdadeiro: atributos static pertencem à classe e não a objetos específicos, podendo ser acessados diretamente pela classe.
Verdadeiro: métodos static podem ser chamados diretamente pela classe, sem a necessidade de criar um objeto.
Falso: a sobrecarga de métodos depende de parâmetros diferentes (número ou tipo), não do tipo de retorno, que deve ser o mesmo.
Verdadeiro: private em um método impede que ele seja acessado fora da classe, garantindo o encapsulamento.