■ Abstracción
Trabajar con objetos en Java es trabajar con clases, si queremos abstraer del mundo real algo y representarlo como un objeto debemos crear una clase que lo represente, la clase sería el objeto en sí y sus características y acciones serían los atributos y métodos de la clase.
Por ejemplo si pensamos en un automóvil, lo modelaríamos en un objeto de esta forma:
■ Pasando a Java
En Java este objeto tendríamos que encapsularlo en una clase que a la que nombraríamos igual que el objeto, es decir, "Automóvil", dentro de la clase declararíamos los atributos del objeto como variables y las acciones que puede hacer el objeto serían los métodos. Esto sería así:
class Automovil {
String marca;
int año;
String color;
// Método constructor
public Automovil(String _marca, int _año, String _color) {
this.marca = _marca;
this.año = _año;
this.color = _color;
}
// Métodos
public void Encender() {
System.out.println("Auto encendido");
}
public void Apagar() {
System.out.println("Auto apagado");
}
public void Avanzar() {
System.out.println("Avanzando");
}
public void Retroceder() {
System.out.println("Retrocediendo");
}
public void Girar(String _dirección) {
System.out.println("Girando a la " + _dirección);
}
}
Nota: Los métodos también pueden llevar parámetros dependiendo de si son necesarios para realizar sus acciones, en este caso solo recibe un String con la dirección hacia donde girará el auto.
■ Usando la clase
El primer método es el llamado "método constructor", se va usar para instanciar la clase, instanciar es crear un objeto de la clase, en este caso para usar la clase "Automóvil" debemos crear un objeto de ella, este objeto tendrá implícitos los atributos y métodos de la clase, al crear este objeto debemos pasarle los atributos que tendrá.
El método constructor lo que hace es recibir los valores que tendrá el objeto que creemos y asignárselos, esto lo hace mediante la palabra reservada "this" que quiere decir "esta clase", podría leerse así "de esta clase el atributo 'marca' tomará el valor de la variable "_marca", es decir la que le estemos pasando como parámetro.
Estructura para crear el objeto:
<nombreClase> <nombreObjeto> = new <nombreClase>(atributos);
Donde:
nombreClase es el nombre que le hayamos dado a la clase.
nombreObjeto es el nombre que le queramos dar a nuestro objeto.
atributos son las variables que conforman el objeto
Cada vez que se crea un objeto es como si tuviéramos un auto distinto con sus propias características.
Creación del objeto:
Automovil auto1 = new Automovil("Toyota", 2025, "Plata");
Nuestro objeto viene siendo "auto1" y mediante él podemos acceder a sus métodos colocando punto y el método que queremos usar, por ejemplo:
auto1.Encender();
■ Setters y Getters
Además de los métodos ya mencionados, hay otros tipos de métodos conocidos como "setters" y "getters", estos nos permiten acceder a los atributos del objeto, es decir, si yo quiero saber qué marca es el automóvil?, de qué color es?, etc., debo hacerlo mediante estos métodos.
• Setters
Los métodos setters se usan para modificar los datos del objeto, cuando creamos un objeto le pasamos ciertos valores iniciales, esos valores pueden cambiarse, eso se hace con los métodos "set".
El método set es como cualquier otro método, este debe recibir un valor de acuerdo a cada atributo del objeto y su trabajo será modificar el valor actual por el que nosotros le pasemos al invocarlo, la estructura de este método es la siguiente:
public void setMarca(String _marca) {
this.marca = _marca;
}
Donde "_marca" es el parámetro que recibe el método en el cual pasaremos la nueva marca que queramos darle al objeto, lo que hará el método es tomar el valor de ese parámetro y asignárselo al atributo "marca" del objeto.
Este método podría usarse por ejemplo si al crear nuestro objeto nos equivocamos de marca, entonces invocando al método setMarca() le estaríamos pasando la marca correcta y el método la sustituiría. Lo mismo con los demás atributos por lo que se debe crear un método set para cada uno (marca, año color, etc).
• Getters
Los getters son métodos contrarios a los setters, mientras que los setters nos sirven para modificar los atributos del objeto, los getters solo nos sirven para obtener el valor del atributo, es decir, no lo modifica solo devuelve el valor que el atributo tiene, por lo cual no reciben ningún parámetro, su estructura es esta:
public String getMarca() {
return this.marca;
}
Lo que hará este método es únicamente tomar el valor del atributo "marca" del objeto y devolvermelo.
Dado que es un método propio de la clase puede acceder a sus valores y lo único que hace es regresar el valor en cuestión, en este caso la marca, que se refiere a la propia variable marca de la clase Automovil.
■ Usando los métodos
Estructura:
<nombreObjeto>.<nombreMétodo>(parámetros si es que lleva);
Así como para usar el método "Encender" lo hicimos así:
auto1.Encender();
Para usar los setters y getters es la misma forma:
auto1.setMarca("Nissan");
Este lleva en su parámetro el nuevo valor que queremos darle.
auto1.getMarca();
Este no lleva parámetro ya que solo va devolver la marca que ya le dimos al objeto, ya sea al crearlo o modificarlo, por lo que como devuelve un valor debemos asignar el método a una variable del mismo tipo del valor que devuelve o mandarlo a imprimir directamente:
String Marca = auto1.getMarca();
o
System.out.println("La marca es: " + auto1.getMarca());
■ Ejercicio completo
import java.util.Scanner;
class Automovil {
String marca;
int año;
String color;
// Método constructor
public Automovil(String _marca, int _año, String _color) {
this.marca = _marca;
this.año = _año;
this.color = _color;
}
// Métodos setters
public void setMarca(String _marca) {
this.marca = _marca;
}
public void setAño(int _año) {
this.año = _año;
}
public void setColor(String _color) {
this.color = _color;
}
// Métodos getters
public String getMarca() {
return this.marca;
}
public int getAño() {
return this.año;
}
public String getColor() {
return this.color;
}
// Métodos
public void Encender() {
System.out.println("Auto encendido");
}
public void Apagar() {
System.out.println("Auto apagado");
}
public void Avanzar() {
System.out.println("Avanzando");
}
public void Retroceder() {
System.out.println("Retrocediendo");
}
public void Girar(String _diección) {
System.out.println("Girando a la " + _dirección);
}
}
// Clase principal
public class Principal {
// Método main de la clase principal
public static void main(String[] args) {
Scanner teclado = new Scanner(System.in);
// Crear objeto de Automovil
Automovil auto1 = new Automovil("Toyota", 2025, "Plata");
String nuevoColor;
// Usar getters
System.out.println("Datos del automóvil");
System.out.println("Marca: " + auto1.getMarca());
System.out.println("Año: " + auto1.getAño());System.out.println("Color: " + auto1.getColor());
// Usar setters
System.out.println("Escriba el nuevo color");
nuevoColor = teclado.nextLine();
auto1.setColor(nuevoColor);
System.out.println("Ahora el color es");
System.out.println("Color: " + auto1.getColor());
// Acciones que se pueden hacer con el auto
auto1.Encender();
auto1.Avanzar();
auto1.Girar("derecha");
auto1.Apagar();
}
}
¿Qué hace el código?
- Crea un objeto llamado "auto1" del tipo Automovil.
- El "auto1" será un Toyota 2025 color Plata.
- Se muestran en pantalla los datos del automóvil "auto1" creado.
- Se le cambia el color a "auto1" por el nuevo color que ingresa el usuario.
- Se muestra en pantalla el nuevo color.
- Se usan los métodos de las acciones que puede hacer "auto1".
No hay comentarios:
Publicar un comentario