Em programação orientada a objetos (POO), o conceito de propriedades e comportamentos é essencial para entender como objetos são modelados e manipulados. As propriedades de um objeto definem seu estado, enquanto os comportamentos são as ações que ele pode realizar.

1. Propriedades (Estado do Objeto)

As propriedades de um objeto, ou atributos (também chamados de campos ou variáveis de instância), são características que representam o estado do objeto. O estado é a combinação dos valores atribuídos aos atributos, e esse estado pode variar ao longo da execução do programa.

Exemplo de Propriedades (Estado de um Objeto):

public class Carro {
    // Atributos (propriedades) do objeto
    String modelo;
    String cor;
    int ano;
    double velocidadeAtual;

    // Método para acelerar
    void acelerar() {
        velocidadeAtual += 10;
        System.out.println("Acelerando... Velocidade atual: " + velocidadeAtual + " km/h");
    }

    // Método para parar
    void parar() {
        velocidadeAtual = 0;
        System.out.println("O carro parou.");
    }
}

Explicação:

• Propriedades/Estado: O estado do objeto carro é definido pelos atributos modelo, cor, ano e velocidadeAtual. Esses atributos mantêm informações sobre o objeto, como o modelo do carro, sua cor, o ano de fabricação e a velocidade atual.
• Métodos/Comportamento: Os métodos acelerar e parar são comportamentos que alteram o estado do objeto, modificando o valor de velocidadeAtual.

2. Comportamento de Objetos (Métodos)

Em Java, os métodos são funções associadas a uma classe ou objeto e são responsáveis por definir o comportamento de um objeto. Eles permitem que o objeto interaja com seu estado ou com outros objetos, realizando ações ou retornando valores.

Métodos de Instância e Estáticos

Existem dois tipos de métodos em Java:

• Métodos de Instância: São métodos que operam sobre os atributos de uma instância específica da classe (ou seja, de um objeto). Eles precisam de uma instância do objeto para serem chamados.
  

  public class Calculadora {
      // Método de instância
      int somar(int a, int b) {
          return a + b;
      }
  }
  

• Métodos Estáticos: São métodos que pertencem à classe e não a uma instância específica. Eles podem ser chamados sem a necessidade de criar um objeto da classe. Métodos estáticos operam apenas em variáveis estáticas da classe, ou seja, variáveis que são compartilhadas por todas as instâncias da classe.
  

  public class Calculadora {
      // Método estático
      static int somarEstatica(int a, int b) {
          return a + b;
      }
  }
  

Exemplo de Métodos e Comportamento:

public class ContaBancaria {
    // Propriedades (estado)
    String titular;
    double saldo;

    // Construtor
    ContaBancaria(String titular, double saldoInicial) {
        this.titular = titular;
        this.saldo = saldoInicial;
    }

    // Método para depositar dinheiro
    void depositar(double valor) {
        if (valor > 0) {
            saldo += valor;
            System.out.println("Depósito de R$ " + valor + " realizado. Saldo atual: R$ " + saldo);
        } else {
            System.out.println("Valor de depósito inválido.");
        }
    }

    // Método para sacar dinheiro
    void sacar(double valor) {
        if (valor <= saldo) {
            saldo -= valor;
            System.out.println("Saque de R$ " + valor + " realizado. Saldo atual: R$ " + saldo);
        } else {
            System.out.println("Saldo insuficiente.");
        }
    }

    // Método para exibir saldo
    void exibirSaldo() {
        System.out.println("Saldo da conta de " + titular + ": R$ " + saldo);
    }
}

Explicação:

• Métodos de Instância: depositar, sacar e exibirSaldo são métodos de instância, que alteram ou acessam os atributos específicos de cada objeto da classe ContaBancaria.
• Método Estático: O método somarEstatica poderia ser chamado sem a criação de um objeto Calculadora, utilizando apenas a classe, por exemplo, Calculadora.somarEstatica(2, 3).

3. A Relação entre Estado e Comportamento

O estado de um objeto é alterado pelos comportamentos definidos por seus métodos. Esses métodos podem modificar diretamente os atributos do objeto, ou seja, o comportamento de um objeto influencia diretamente seu estado.

4. JavaScript também é Orientado a Objetos

Embora JavaScript seja uma linguagem multiparadigma, ela também suporta o paradigma orientado a objetos. Isso significa que, assim como em Java, podemos definir objetos com propriedades e comportamentos. No entanto, em JavaScript, a criação de objetos e a definição de métodos podem ser feitas de maneira mais flexível.

Em JavaScript, a orientação a objetos é implementada de maneira baseada em protótipos, ao invés de classes, como em Java. No entanto, desde a introdução das classes em ES6, JavaScript permite uma sintaxe mais similar à de linguagens orientadas a objetos clássicas.

Exemplo em JavaScript:

class Carro {
    constructor(modelo, cor, ano) {
        this.modelo = modelo;
        this.cor = cor;
        this.ano = ano;
        this.velocidadeAtual = 0;
    }

    acelerar() {
        this.velocidadeAtual += 10;
        console.log(`Acelerando... Velocidade atual: ${this.velocidadeAtual} km/h`);
    }

    parar() {
        this.velocidadeAtual = 0;
        console.log("O carro parou.");
    }
}

let carro = new Carro('Fusca', 'Azul', 1980);
carro.acelerar();
carro.parar();

Neste exemplo, o comportamento de um objeto Carro é definido pelos métodos acelerar e parar, que alteram o estado do objeto (velocidadeAtual).

5. Encapsulamento

Em Java, o conceito de encapsulamento envolve esconder os detalhes internos de implementação de um objeto, permitindo acesso aos seus atributos apenas por meio de métodos públicos. Isso é feito com o uso de modificadores de acesso, como private, protected e public, que controlam a visibilidade e a modificação dos atributos.

Exemplo de Encapsulamento:

public class Carro {
    private String modelo;
    private String cor;
    private int ano;

    public String getModelo() {
        return modelo;
    }

    public void setModelo(String modelo) {
        this.modelo = modelo;
    }

    void acelerar() {
        System.out.println("Acelerando o " + modelo);
    }
}

Aqui, os atributos modelo, cor e ano estão encapsulados com o modificador private, o que significa que não podem ser acessados diretamente fora da classe Carro. A modificação do atributo modelo deve ser feita através do método setModelo.

Para mais detalhes sobre modificadores de acesso e encapsulamento, consulte este artigo sobre modificadores de acesso explicará de uma maneira mais elaborada sobre este pilar da orientação a objetos.

Conclusão

• Propriedades (Estado): São os atributos de um objeto, que definem as características e condições do objeto.
• Comportamento (Métodos): São as ações que um objeto pode realizar. Métodos de instância operam sobre o estado do objeto, enquanto métodos estáticos pertencem à classe e não a uma instância específica.
• Encapsulamento: É a prática de restringir o acesso aos atributos de um objeto, permitindo que a manipulação de seu estado seja feita de forma controlada.