Objetos y clases de Java

Java, como lenguaje de programación orientado a objetos, admite los siguientes conceptos básicos:

1, Clase (Class):

  • Define el modelo (blueprint) de un objeto, incluyendo atributos y métodos.
  • Ejemplo:public class Car { ... }

2. Objeto (Object):

  • Instancia de una clase, que tiene estado y comportamiento.
  • Ejemplo:Car myCar = new Car();

3. Herencia (Inheritance):

  • Una clase puede heredar atributos y métodos de otra clase.
  • Ejemplo:public class Dog extends Animal { ... }

4. Encapsulamiento (Encapsulation):

  • Privatiza el estado (campos) del objeto y accede a él mediante métodos públicos.
  • Ejemplo:
    private String name; 
    public String getName() { return name; }

5. Polimorfismo (Polymorphism):

  • Un objeto puede manifestarse en múltiples formas, principalmente mediante la sobrecarga de métodos y la sobreescritura de métodos.
  • Ejemplo:
    • Sobrecarga de métodos:public int add(int a, int b) { ... }ypublic double add(double a, double b) { ... }
    • Sobreescritura de métodos:@Override public void makeSound() { System.out.println("Meow"); }

6. Abstracción (Abstraction):

  • Usa clases abstractas e interfaces para definir métodos que deben implementarse, sin proporcionar una implementación concreta.
  • Ejemplo:
    • Clase abstracta:public abstract class Shape { abstract void draw(); }
    • Interfaz:public interface Animal { void eat(); }

7. Interfaz (Interface):

  • Define métodos que la clase debe implementar y admite herencia múltiple.
  • Ejemplo:public interface Drivable { void drive(); }

8. Método (Method):

  • Define el comportamiento de una clase; es una función contenida en la clase.
  • Ejemplo:public void displayInfo() { System.out.println("Info"); }

9. Sobrecarga de métodos (Method Overloading):

  • En la misma clase puede haber varios métodos con el mismo nombre, pero con diferentes parámetros.
  • Ejemplo:
    public class MathUtils {
        public int add(int a, int b) {
            return a + b;
        }
    
        public double add(double a, double b) {
            return a + b;
        }
    }
    

En esta sección nos centramos en los conceptos de objeto y clase.

  • Objeto: Un objeto es una instancia de una clase (un objeto no es buscar una novia), tiene estado y comportamiento. Por ejemplo, un perro es un objeto; su estado incluye: color, nombre, raza; su comportamiento incluye: mover la cola, ladrar, comer, etc.
  • Clase: Una clase es una plantilla que describe el comportamiento y el estado de un tipo de objetos.

En la siguiente figura,niño (boy)、niña (girl)Paraclase (class), y cada persona concreta es unobjeto (object) de esa clase:

En la siguiente figura,automóvilParaclase (class), y cada automóvil concreto es unautomóvilde la claseobjeto (object), el objeto incluye el color, la marca, el nombre, etc. del automóvil.


Objetos en Java

Ahora profundicemos en qué es un objeto. Mira el mundo real que te rodea; verás que hay muchos objetos a tu alrededor: coches, perros, personas, etc. Todos estos objetos tienen su propio estado y comportamiento.

Tomemos como ejemplo un perro; sus estados son: nombre, raza, color; sus comportamientos son: ladrar, mover la cola y correr.

Comparando los objetos reales con los objetos de software, son muy similares entre sí.

Los objetos de software también tienen estado y comportamiento. El estado de un objeto de software son sus atributos, y el comportamiento se refleja a través de métodos.

En el desarrollo de software, los métodos operan sobre el cambio del estado interno del objeto, y la interacción entre objetos también se realiza mediante métodos.

Clases en Java

Una clase puede considerarse como una plantilla para crear objetos Java.

Creemos una clase sencilla como la de la figura anterior para entender la definición de una clase en Java:

public class Dog { String breed; int size; String colour; int age; void eat() { } void run() { } void sleep(){ } void name(){ } }

Una clase puede contener los siguientes tipos de variables:

  • Variables locales: Las variables definidas en métodos, constructores o bloques de sentencias se denominan variables locales. La declaración e inicialización de la variable se realizan en el método; cuando el método termina, la variable se destruye automáticamente.
  • Variables miembro: Las variables miembro son variables definidas en la clase, fuera del cuerpo del método. Este tipo de variable se instancia al crear el objeto. Las variables miembro pueden ser accedidas por los métodos, los constructores y los bloques de sentencias de una clase específica.
  • Variables de clase: Las variables de clase también se declaran en la clase, fuera del cuerpo del método, pero deben declararse como tipo static.

Una clase puede tener varios métodos; en el ejemplo anterior: eat(), run(), sleep() y name() son métodos de la clase Dog.


Métodos constructores

Cada clase tiene un método constructor. Si no se define explícitamente un constructor para la clase, el compilador de Java proporcionará un constructor predeterminado.

Al crear un objeto, se debe invocar al menos un método constructor. El nombre del constructor debe ser igual al de la clase; una clase puede tener varios constructores.

A continuación se muestra un ejemplo de constructor:

public class Puppy{ public Puppy(){ } public Puppy(String name){ //Este constructor tiene un solo parámetro: name } }

Creación de objetos

Los objetos se crean a partir de clases. En Java, se utiliza la palabra clave new para crear un nuevo objeto. La creación de un objeto requiere los siguientes tres pasos:

  • Declaración: Declarar un objeto, incluyendo el nombre del objeto y el tipo del objeto.
  • Instanciación: Usar la palabra clave new para crear un objeto.
  • Inicialización: Al usar new para crear un objeto, se invoca el constructor para inicializar el objeto.

A continuación se muestra un ejemplo de creación de objetos:

public class Puppy{ public Puppy(String name){ //Este constructor tiene un solo parámetro: name System.out.println("El nombre del cachorro es:" + name ); } public static void main(String[] args){ //La siguiente sentencia creará un objeto Puppy Puppy myPuppy = new Puppy( "tommy" ); } }

Compile y ejecute el programa anterior; se imprimirá el siguiente resultado:

小狗的名字是 : tommy

Acceso a variables de instancia y métodos

A través del objeto creado se accede a las variables miembro y métodos miembro, como se muestra a continuación:

/*Instanciar el objeto*/ Object referenceVariable = new Constructor(); /*Acceder a las variables de la clase*/ referenceVariable.variableName; /*Acceder a los métodos de la clase*/ referenceVariable.methodName();

Declarar una variable de tipo Object solo permite acceder a los métodos y propiedades de la clase Object en tiempo de compilación; pero en tiempo de ejecución, se puede convertir a un tipo específico mediante una conversión de tipos forzada para acceder a los métodos y propiedades de ese tipo específico.


Ejemplo

El siguiente ejemplo muestra cómo acceder a variables de instancia y llamar a métodos miembro:

Código del archivo Puppy.java:

public class Puppy { private int age; private String name; //Constructor public Puppy(String name) { this.name = name; System.out.println("El nombre del cachorro es:" + name); } //Establecer el valor de age public void setAge(int age) { this.age = age; } //Obtener el valor de age public int getAge() { return age; } //Obtener el valor de name public String getName() { return name; } //Método principal public static void main(String[] args) { //Crear el objeto Puppy myPuppy = new Puppy("Tommy"); //Establecer age mediante un método myPuppy.setAge(2); //Llamar a otro método para obtener age int age = myPuppy.getAge(); System.out.println("La edad del cachorro es:" + age); //También se puede acceder directamente a las variables miembro (mediante métodos getter) System.out.println("Valor de la variable:" + myPuppy.getAge()); } }

Compile y ejecute el programa anterior, se produce el siguiente resultado:

小狗的名字是 : tommy
小狗的年龄为 : 2
变量值 : 2

Reglas de declaración del archivo fuente

En la parte final de esta sección, aprenderemos las reglas de declaración del archivo fuente. Cuando se definen varias clases en un archivo fuente y además hay sentencias import y package, se debe prestar especial atención a estas reglas.

  • En un archivo fuente solo puede haber una clase public
  • Un archivo fuente puede tener varias clases no public
  • El nombre del archivo fuente debe ser igual al nombre de la clase public. Por ejemplo: si el nombre de la clase public en el archivo fuente es Employee, entonces el archivo fuente debe llamarse Employee.java.
  • Si una clase se define en un paquete, la sentencia package debe estar en la primera línea del archivo fuente.
  • Si el archivo fuente contiene sentencias import, deben colocarse entre la sentencia package y la definición de la clase. Si no hay sentencia package, las sentencias import deben estar al principio del archivo fuente.
  • Las sentencias import y package son válidas para todas las clases definidas en el archivo fuente. En el mismo archivo fuente, no se pueden declarar diferentes paquetes para diferentes clases.

Las clases tienen varios niveles de acceso, y también se dividen en diferentes tipos: clases abstractas, clases final, etc. Esto se presentará en el capítulo de control de acceso.

Además de los tipos mencionados anteriormente, Java tiene algunas clases especiales, como:Clases internas、Clases anónimas。


Paquetes en Java

Los paquetes se utilizan principalmente para clasificar clases e interfaces. Al desarrollar programas Java, es posible escribir cientos o miles de clases, por lo que es muy necesario clasificar las clases e interfaces.

Sentencia import

En Java, si se proporciona un nombre completamente calificado, que incluya el nombre del paquete y el nombre de la clase, el compilador de Java puede localizar fácilmente el código fuente o la clase. La sentencia import se utiliza para proporcionar una ruta razonable para que el compilador pueda encontrar una clase.

Por ejemplo, la siguiente línea de comandos le indicará al compilador que cargue todas las clases en la ruta java_installation/java/io.

import java.io.*;

Un ejemplo sencillo

En este ejemplo, creamos dos clases:EmployeeyEmployeeTest。

Primero abra el editor de código, pegue el siguiente código y guarde el archivo como:Employee.java。

La clase Employee tiene cuatro variables miembro: name, age, designation y salary. Esta clase declara explícitamente un método constructor con un solo parámetro.

Código del archivo Employee.java:

import java.io.*; public class Employee { private String name; private int age; private String designation; private double salary; //El constructor de la clase Employee public Employee(String name) { this.name = name; } //Establecer el valor de age public void setAge(int age) { this.age = age; } //Obtener el valor de age public int getAge() { return age; } //Establecer el valor de designation public void setDesignation(String designation) { this.designation = designation; } //Obtener el valor de designation public String getDesignation() { return designation; } //Establecer el valor de salary public void setSalary(double salary) { this.salary = salary; } //Obtener el valor de salary public double getSalary() { return salary; } //Imprimir información public void printEmployee() { System.out.println(this); } //Sobrescribir el método toString @Override public String toString() { return "Nombre:" + name + "\n" + "Edad:" + age + "\n" + "Cargo:" + designation + "\n" + "Salario:" + salary; } }

La ejecución de los programas Java comienza desde elmainmétodo; para poder ejecutar este programa, se debe incluir el método main y crear un objeto de instancia.

A continuación se muestra la clase EmployeeTest, que crea dos instancias de la clase Employee y llama a los métodos para establecer los valores de las variables.

Guarde el siguiente código en el archivo EmployeeTest.java.

Código del archivo EmployeeTest.java:

import java.io.*; public class EmployeeTest { public static void main(String[] args) { //Usar el constructor para crear dos objetos Employee empOne = new Employee("EJEMPLO1"); Employee empTwo = new Employee("EJEMPLO2"); //Llamar a los métodos miembro de estos dos objetos empOne.setAge(26); empOne.setDesignation("Programador senior"); empOne.setSalary(1000); empOne.printEmployee(); empTwo.setAge(21); empTwo.setDesignation("Programador novato"); empTwo.setSalary(500); empTwo.printEmployee(); } }

Compile estos dos archivos y ejecute la clase EmployeeTest; podrá ver el siguiente resultado:

$ javac EmployeeTest.java Employee.java
$ java EmployeeTest 
名字:EJEMPLO1
年龄:26
职位:高级程序员
薪水:1000.0
名字:EJEMPLO2
年龄:21
职位:Ejemplo程序员
薪水:500.0
Otras extensiones