Clase y Objeto
Hay muchos lenguajes de programación y casi tantos estilos de programación (a veces llamados paradigmas). Los programas que hemos escrito hasta ahora son principalmente procedimentales, ya que el énfasis ha sido en especificar procedimientos computacionales. La mayoría de los programas en Java son orientados a objetos, lo que significa que el enfoque está en los objetos y sus interacciones. Aquí están algunas de las características de la programación orientada a objetos:
Los objetos a menudo representan las entidades del mundo real. La mayoría de los métodos son métodos de objeto (como los métodos que invocas en String) en lugar de métodos de clase (como los métodos de Math). Los métodos que hemos escrito hasta ahora han sido métodos de clase. En este capítulo, escribiremos algunos métodos de objeto.
Los objetos están aislados entre sí limitando las formas en que interactúan, especialmente evitando que accedan a variables de instancia sin invocar métodos. Las clases se organizan en árboles genealógicos donde nuevas clases extienden clases existentes, agregando nuevos métodos y reemplazando otros.
En Java, cada clase extiende alguna otra clase, excepto la clase Object. La clase más básica es la clase Object. No contiene variables de instancia, pero proporciona los métodos equals y toString, entre otros.
Muchas clases extienden Object, incluyendo casi todas las clases que hemos escrito y muchos tipos (types) de Java como Integer, Double, String, arrays, etc. Cualquier clase que no nombre explícitamente a una clase padre extiende Object por defecto. El “árbol genealógico” de las clases se llama jerarquía de clases (class hierarchy). Object generalmente aparece en la parte superior, con todas las clases hijas (child classes) debajo.
Las clases y los objetos generalmente tienen algunos atributos que se utilizan para describir estas clases/objetos, y los métodos se utilizan para realizar algunas funciones específicas. Aquí te damos un ejemplo para mostrarte cómo es una clase. Guarda el código en objectTest.java y utiliza la línea de comandos para ejecutar el código.
Ejemplo:
Escribe el siguiente código en el archivo /home/labex/project/objectTest.java:
// use keyword 'class' to create a new class named Person
class Person
{
/*
* there are four properties,
* name of string type, age of int type
* gender of string type, weight of float type
*/
private String name;
private int age;
private String gender;
private float weight;
// this is a constructor with no return type, the same name as the class, no parameters
public Person(){
}
//this is a constructor with two parameters
public Person(String name, int age){
// use parameters to set object's name and age
this.name = name;
this.age = age;
}
// this is a constructor with four parameters
public Person(String name, int age, String gender, float weight){
// use parameters to set object's name, age, gender and weight
this.name = name;
this.age = age;
this.gender = gender;
this.weight = weight;
}
// this is an object method
public void personInfo(){
System.out.println("Name: " + this.name + "\nAge: "+ this.age + "\nGender: " + this.gender + "\nWeight: "+this.weight);
}
}
public class objectTest{
public static void main(String[] args){
// use 'new' to create an instance of class Person
Person p = new Person("aaa",18,"male",50.5f); // p refers to an object
/* you can try these two different construction methods, and see what the output is.
* Person p = new Person();
* Person p = new Person("aaa",18);
*/
// use object to invoke method personInfo()
p.personInfo();
}
}
Salida:
Ejecuta el archivo objectTest.java utilizando los siguientes comandos:
javac /home/labex/project/objectTest.java
java objectTest
Ver la salida:
Name: aaa
Age: 18
Gender: male
Weight: 50.5
Hay cuatro atributos en la clase Person. Todos los atributos son privados, por lo que no se pueden acceder desde fuera (solo se pueden usar dentro de la clase). Hay un método de objeto llamado personInfo que se utiliza para imprimir información personal y hay tres constructores con el mismo nombre que la clase Person. La única diferencia entre ellos son sus parámetros. Este comportamiento se llama sobrecarga (overloading).
