Em Java, um objeto possui propriedades e comportamentos que são fundamentais para o modelo de programação orientada a objetos. As propriedades de um objeto são representadas por atributos (também chamados de campos ou variáveis de instância), enquanto os comportamentos são definidos por métodos (funções que representam ações que o objeto pode realizar).
1. Propriedades (Estado do Objeto)
As propriedades de um objeto definem seu estado. O estado de um objeto é a combinação de valores que seus atributos possuem em determinado momento da execução do programa.
Exemplo de Propriedades (Estado de um Objeto):
class Carro {
// Propriedades (atributos) 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.");
}
}
public class TesteCarro {
public static void main(String[] args) {
// Criando um objeto Carro
Carro carro = new Carro();
// Inicializando as propriedades do objeto
carro.modelo = "Fusca";
carro.cor = "Azul";
carro.ano = 1980;
carro.velocidadeAtual = 0;
// Exibindo o estado inicial do objeto
System.out.println("Modelo: " + carro.modelo);
System.out.println("Cor: " + carro.cor);
System.out.println("Ano: " + carro.ano);
System.out.println("Velocidade: " + carro.velocidadeAtual + " km/h");
// Modificando o estado do objeto através de métodos
carro.acelerar();
carro.acelerar();
carro.parar();
}
}
Explicação:
Propriedades/Estado: Os atributos
modelo,cor,anoevelocidadeAtualsão as propriedades que definem o estado do objetocarro. Cada instância deCarropode ter valores diferentes para esses atributos, representando diferentes "estados" do objeto ao longo do tempo.Métodos/Comportamento: Os métodos
acelerarepararalteram o estado do objeto (modificam o valor develocidadeAtual). Esses métodos representam os comportamentos do objeto e são chamados para alterar ou interagir com seu estado.
2. Comportamento de Objetos (Métodos)
O comportamento de um objeto é definido pelos métodos que ele contém. Em Java, métodos são funções associadas a uma classe ou a um objeto e realizam ações sobre o estado do objeto ou interagem com outros objetos. Esse conceito de método em Java pode ser entendido como algo muito semelhante ao conceito de função em linguagens imperativas, como JavaScript.
Em JavaScript, temos uma função que realiza uma tarefa específica:
function somar(a, b) {
return a + b;
}
Em Java, essa mesma ideia é representada por um método dentro de uma classe, que pode operar sobre os atributos do objeto:
class Calculadora {
int somar(int a, int b) {
return a + b;
}
}
Embora em JavaScript as funções possam ser definidas de forma independente, em Java, métodos são sempre associados a objetos ou classes. Isso significa que os métodos em Java geralmente operam sobre os atributos (ou estado) de um objeto. Esse conceito de método está mais alinhado à ideia de orientação a objetos, onde o comportamento está diretamente vinculado ao estado do objeto.
Exemplo de Métodos e Comportamento:
class ContaBancaria {
// Propriedades
String titular;
double saldo;
// Construtor para inicializar a conta
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);
}
}
public class TesteContaBancaria {
public static void main(String[] args) {
// Criando uma conta bancária
ContaBancaria conta = new ContaBancaria("João", 1000.0);
// Exibindo o saldo inicial
conta.exibirSaldo();
// Depositando e sacando dinheiro, alterando o estado do objeto
conta.depositar(500.0);
conta.sacar(200.0);
conta.sacar(1500.0); // Tentando sacar mais do que o saldo
}
}
Explicação:
Propriedades/Estado: O estado da conta bancária é representado pelos atributos
titularesaldo. Esses atributos armazenam informações sobre o titular da conta e o valor presente nela.-
Comportamento/Métodos:
- O método
depositarmodifica o saldo da conta, alterando o estado do objeto. - O método
sacartambém altera o saldo, mas com uma verificação de que o valor a ser sacado não pode ser superior ao saldo disponível. - O método
exibirSaldopermite visualizar o estado atual do objeto sem modificá-lo.
- O método
3. A Relação entre Estado e Comportamento
O estado de um objeto é alterado pelos comportamentos definidos por seus métodos. Isso reflete a ideia de que os objetos possuem características (estado) que podem ser modificadas ou manipuladas por meio de ações (comportamento). O estado e o comportamento de um objeto são intimamente relacionados, já que as ações dos métodos impactam diretamente o estado dos atributos.
Por exemplo, no código da ContaBancaria, o estado da conta é modificado sempre que o método depositar ou sacar é chamado. Cada vez que esses métodos são executados, o estado do objeto conta muda, mas apenas por meio do comportamento que os métodos oferecem.
4. Encapsulamento
Em Java, é uma boa prática encapsular o estado de um objeto, ou seja, tornar os atributos privados e fornecer métodos públicos para acessá-los e modificá-los. Isso ajuda a proteger o estado interno do objeto e permite controle sobre como ele é alterado.
Exemplo de Encapsulamento:
class Carro {
// Atributos privados (encapsulados)
private String modelo;
private String cor;
private int ano;
// Método público para acessar o modelo
public String getModelo() {
return modelo;
}
// Método público para modificar o modelo
public void setModelo(String modelo) {
this.modelo = modelo;
}
// Métodos de comportamento (acelerar, parar, etc.)
void acelerar() {
System.out.println("Acelerando o " + modelo);
}
}
public class TesteCarro {
public static void main(String[] args) {
Carro carro = new Carro();
carro.setModelo("Fusca"); // Usando o setter para modificar o estado
System.out.println("Modelo do carro: " + carro.getModelo()); // Usando o getter para acessar o estado
carro.acelerar();
}
}
No exemplo acima:
- O estado do objeto
carroé mantido privado, mas pode ser acessado e modificado por meio dos métodos públicosgetModeloesetModelo. - Isso permite maior controle sobre o que pode ser alterado e garante que o objeto permaneça em um estado válido.
Conclusão
- Propriedades (Estado): São os atributos de um objeto, que representam as características e condições do objeto em um dado momento. O estado de um objeto pode ser alterado ao longo do tempo.
- Comportamento (Métodos): São as ações que
um objeto pode realizar. Métodos são funções associadas a uma classe ou objeto e permitem que o objeto interaja com seu estado e com outros objetos, modificando suas propriedades.
- A relação entre estado e comportamento é fundamental na programação orientada a objetos, pois os comportamentos de um objeto geralmente alteram ou acessam o seu estado.
- Encapsulamento é uma técnica que ajuda a controlar o acesso ao estado de um objeto, promovendo a integridade e segurança da informação.
Gostaria de enfatizar que o comportamento desses fundamentos, não se restringem somente a linguagem java, e sim a todas em que se é empregado o paradigma de orientação a objetos.
Top comments (0)