Programación Orientada a Objetos
## Objetivos de Aprendizaje
- Comprender clases y objetos
- Dominar la encapsulación
- Trabajar con constructores
- Crear y usar métodos de instancia
## Clases y Objetos
### Clase: Plano
```java
public class Person {
// Campos (atributos)
String name;
int age;
// Métodos (comportamientos)
void speak() {
System.out.println("My name is " + name);
}
void sayAge() {
System.out.println("I am " + age + " years old");
}
}
```
### Objeto: Instancia
```java
public class Main {
public static void main(String[] args) {
Person person1 = new Person();
Person person2 = new Person();
person1.name = "Alice";
person1.age = 25;
person2.name = "Bob";
person2.age = 30;
person1.speak(); // My name is Alice
person2.speak(); // My name is Bob
}
}
```
## Encapsulación
### Campos Privados
```java
public class Person {
private String name; // No se puede acceder directamente
private int age;
}
```
### Getters y Setters Públicos
```java
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age >= 0) {
this.age = age;
}
}
}
```
### Usando Encapsulación
```java
Person person = new Person();
person.setName("Alice");
person.setAge(25);
System.out.println(person.getName()); // Alice
// person.name = "Bob"; // ¡Error de compilación!
```
## Constructores
### Constructor por Defecto
```java
public class Person {
private String name;
// Constructor sin argumentos (por defecto)
public Person() {
name = "Unknown";
}
}
```
### Constructor con Parámetros
```java
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
```
### Llamando Constructores
```java
Person p1 = new Person(); // Por defecto
Person p2 = new Person("Alice", 25); // Con parámetros
```
### Sobrecarga de Constructores
```java
public class Person {
private String name;
private int age;
public Person() {
this.name = "Unknown";
this.age = 0;
}
public Person(String name) {
this.name = name;
this.age = 0;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
```
## Palabra clave this
### Referencia al Objeto Actual
```java
public class Person {
private String name;
public Person(String name) {
this.name = name; // this.name = nombre del parámetro
}
public Person() {
this("Unknown"); // Llamar otro constructor
}
}
```
## Estático vs Instancia
### Miembros de Instancia
```java
public class Person {
private String name; // Variable de instancia (única por objeto)
public void speak() { // Método de instancia
System.out.println("I am " + this.name);
}
}
Person p1 = new Person("Alice");
Person p2 = new Person("Bob");
p1.speak(); // I am Alice
p2.speak(); // I am Bob
```
### Miembros Estáticos
```java
public class Counter {
private int count; // Variable de instancia
public static int totalCount; // Compartida por todas las instancias
public Counter() {
count++;
totalCount++;
}
public static void printTotal() {
System.out.println("Total: " + totalCount);
}
}
```
## Sobrecarga de Métodos
### Mismo Nombre, Diferentes Parámetros
```java
public class Calculator {
public int add(int a, int b) {
return a + b;
}
public double add(double a, double b) {
return a + b;
}
public int add(int a, int b, int c) {
return a + b + c;
}
}
```
## Método toString
### Representación en Cadena
```java
public class Person {
private String name;
private int age;
@Override
public String toString() {
return "Person{name='" + name + "', age=" + age + "}";
}
}
// Uso
Person p = new Person("Alice", 25);
System.out.println(p); // Imprime: Person{name='Alice', age=25}
```
## Modificadores de Acceso
| Modificador | Misma Clase | Mismo Paquete | Subclase | En Todas Partes |
|-------------|-------------|---------------|----------|-----------------|
| private | Sí | No | No | No |
| (por defecto) | Sí | Sí | No | No |
| protected | Sí | Sí | Sí | No |
| public | Sí | Sí | Sí | Sí |
## Ejemplo de Getters y Setters
```java
public class BankAccount {
private String accountNumber;
private double balance;
public BankAccount(String accountNumber, double initialBalance) {
this.accountNumber = accountNumber;
this.balance = initialBalance;
}
public String getAccountNumber() {
return accountNumber;
}
public double getBalance() {
return balance;
}
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
}
}
public boolean withdraw(double amount) {
if (amount > 0 && amount <= balance) {
balance -= amount;
return true;
}
return false;
}
}
```
## Resumen
- Las clases definen objetos; los objetos son instancias de clases
- Encapsulación: campos privados + getters/setters públicos
- Los constructores inicializan objetos; pueden estar sobrecargados
- `this` referencia el objeto actual
- Los miembros estáticos pertenecen a la clase; los de instancia pertenecen al objeto
- `toString()` proporciona representación en cadena de objetos
- Los modificadores de acceso controlan la visibilidad: private, (por defecto), protected, public
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →