Antes de comprender las clases y objetos de Java, introduzcamos brevemente la programación orientada a objetos. La programación es el diseño de programas a través de objetos. El objeto representa una entidad y la entidad puede identificarse claramente.
Java como lenguaje orientado a objetos. Se admiten los siguientes conceptos básicos:
Polimorfismo
heredar
Encapsulación
abstracto
amable
objeto
Ejemplo
método
análisis de mensajes
En esta sección nos centramos en los conceptos de objetos y clases.
Objeto : un objeto es una instancia de una clase y tiene estado y comportamiento. Por ejemplo, un perro es un objeto. Su estado incluye: color, nombre y raza, sus comportamientos incluyen: mover la cola, ladrar, comer, etc.
Clase : una clase es una plantilla que describe el comportamiento y el estado de una clase de objetos.
Ahora echemos un vistazo más de cerca a qué es un objeto. Si observas el mundo real que te rodea, encontrarás que hay muchos objetos a tu alrededor, como coches, perros, personas, etc. Todos estos objetos tienen su propio estado y comportamiento.
Tomemos como ejemplo un perro. Su estado incluye: nombre, raza y color, y sus comportamientos incluyen: ladrar, mover la cola y correr.
Comparando objetos reales y objetos de software, son muy similares.
Los objetos de software también tienen estado y comportamiento. El estado de un objeto de software es su atributo y su comportamiento se refleja a través de métodos.
En el desarrollo de software, los métodos operan sobre cambios en el estado interno de los objetos, y las llamadas mutuas entre objetos también se logran a través de métodos.
Las clases pueden considerarse como plantillas para crear objetos Java.
Entendamos la definición de clases en Java a través de la siguiente clase simple:
Perro de clase pública {
Raza de cuerda;
edad interna;
Color de cuerda;
ladrido vacío(){
}
anular hambre(){
}
dormir vacío(){
}
}Una clase puede contener variables de los siguientes tipos:
Variables locales : las variables definidas en métodos, constructores o bloques de instrucciones se denominan variables locales. La declaración y la inicialización de variables están todas en métodos. Una vez finalizado el método, las variables se destruirán automáticamente.
Variables miembro : las variables miembro son variables definidas en la clase y fuera del cuerpo del método. Se crean instancias de dichas variables cuando se crea el objeto. Se puede acceder a las variables miembro mediante métodos de clase, constructores y bloques de instrucciones específicos de la clase.
Variables de clase : las variables de clase también se declaran en la clase, fuera del cuerpo del método, pero deben declararse como de tipo estático.
Una clase puede tener varios métodos. En el ejemplo anterior: barking() , hungry() y sleeping() son todos métodos de la clase Perro.
Cada clase tiene métodos constructores. Si no se define explícitamente ningún constructor para una clase, el compilador de Java proporcionará un constructor predeterminado para la clase.
Al crear un objeto, se debe llamar al menos a un método constructor. El nombre del constructor debe ser el mismo que el de la clase. Una clase puede tener varios constructores.
Aquí hay un constructor de ejemplo:
Cachorro de clase pública {
públicoCachorro(){
}
Cachorro público (nombre de cadena) {
// Este constructor tiene solo un parámetro: nombre
}
} Los objetos se crean en base a clases. En Java, utilice la palabra clave new para crear un nuevo objeto. Crear un objeto requiere los siguientes tres pasos:
Declaración : declara un objeto, incluido el nombre y el tipo de objeto.
Creación de instancias : utilice la palabra clave new para crear un objeto.
Inicialización : cuando se utiliza new para crear un objeto, se llama al método constructor para inicializar el objeto.
A continuación se muestra un ejemplo de creación de un objeto:
Cachorro de clase pública {
Cachorro público (nombre de cadena) {
//Este constructor tiene solo un parámetro: nombre
System.out.println("El nombre del cachorro es:" + nombre);
}
principal vacío estático público (cadena [] argumentos) {
//La siguiente declaración creará un objeto Puppy Puppy myPuppy = new Puppy( "tommy" );
}
}Compile y ejecute el programa anterior y se imprimirán los siguientes resultados:
El nombre del cachorro es: Tommy.Acceda a las variables miembro y a los métodos miembro a través del objeto creado de la siguiente manera:
/* Instanciar objeto */
Referencia de objeto = nuevo constructor();
/*Accede a las variables */
ObjectReference.nombrevariable;
/* Acceso a métodos en la clase */
ObjectReference.MethodName();El siguiente ejemplo muestra cómo acceder a variables de instancia y llamar a métodos de miembros:
Cachorro de clase pública {
int edad del cachorro;
Cachorro público (nombre de cadena) {
// Este constructor tiene solo un parámetro: nombre
System.out.println("El nombre pasado es:" + nombre);
}
setAge público vacío (int edad) {
edadcachorro = edad;
}
público int getAge(){
System.out.println("La edad del cachorro es:" + PuppyAge);
devolver edad del cachorro;
}
principal vacío estático público (cadena [] argumentos) {
/* Crear objeto */
Cachorro miCachorro = nuevo Cachorro( "tommy" );
/* Establecer edad mediante métodos */
miCachorro.setAge(2);
/* Llama a otro método para obtener la edad */
miCachorro.getAge( );
/*También puede acceder a las variables miembro de la siguiente manera */
System.out.println("Valor variable:" + myPuppy.puppyAge);
}
}La compilación y ejecución del programa anterior produce los siguientes resultados:
El nombre pasado es: tommy
La edad del cachorro es :2
Valor variable: 2 En la parte final de esta sección, aprenderemos sobre las reglas de declaración para archivos fuente. Preste especial atención a estas reglas al definir varias clases en un archivo fuente y cuando haya declaraciones import y declaraciones package .
Sólo puede haber una clase public en un archivo fuente
Un archivo fuente puede tener varias clases no public
El nombre del archivo fuente debe ser coherente con el nombre de la clase public . Por ejemplo: el nombre de la clase public en el archivo fuente es Employee , entonces el archivo fuente debe llamarse Employee.java .
Si una clase está definida en un paquete, la declaración package debe estar en la primera línea del archivo fuente.
Si el archivo fuente contiene una declaración import , debe colocarse entre la declaración package y la definición de clase. Si no hay una declaración package , la declaración import debe estar primero en el archivo fuente.
La declaración import y la declaración package son válidas para todas las clases definidas en el archivo fuente. En el mismo archivo fuente, no se pueden dar diferentes declaraciones de paquete a diferentes clases.
Las clases tienen varios niveles de acceso, y las clases también se dividen en diferentes tipos: clases abstractas, clases final , etc. Estos se presentarán en el capítulo de control de acceso.
Además de los tipos mencionados anteriormente, Java también tiene algunas clases especiales, como clases internas y clases anónimas.
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 necesario clasificar clases e interfaces.
En Java, si se proporciona un nombre completo y completo, incluido 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 declaración Import se utiliza para proporcionar una ruta razonable para que el compilador pueda encontrar una clase determinada.
Por ejemplo, la siguiente línea de comando le indicará al compilador que cargue todas las clases en la ruta java_installation/java/io
importar java.io.*;En este ejemplo, creamos dos clases: Empleado y PruebaEmpleado.
Primero abra un editor de texto y pegue el siguiente código en él. Tenga en cuenta que el archivo se guarda como Employee.java.
La clase Empleado tiene cuatro variables miembro: nombre, edad, designación y salario. La clase declara explícitamente un método constructor con un solo parámetro.
importar java.io.*;
Empleado de clase pública {
Nombre de cadena;
edad interna;
Designación de cadena;
doble salario;
// Constructor de la clase Empleado público Empleado(nombre de cadena){
this.nombre = nombre;
}
//Establece el valor de edad public void empAge(int empAge){
edad = edad emp;
}
/*Establece el valor de la designación*/
designación emp vacía pública (String empDesig) {
designación = empDesig;
}
/*Establece el valor del salario*/
public void empSalary(doble empSalary){
salario = empSalario;
}
/* Imprimir información */
public void printEmployee(){
System.out.println("Nombre:"+ nombre);
System.out.println("Edad:" + edad);
System.out.println("Designación:" + designación);
System.out.println("Salario:" + salario);
}
} La ejecución del programa comienza desde el método main . Para ejecutar este programa, se debe incluir el método main y se debe crear un objeto de instancia.
La clase EmployeeTest se proporciona a continuación, que crea instancias de dos instancias de la clase Employee y llama a métodos para establecer los valores de las variables.
Guarde el siguiente código en el archivo EmployeeTest.java.
importar java.io.*;
prueba de empleado de clase pública {
principal vacío estático público (String args []) {
/* Crea dos objetos usando el constructor */
Empleado empOne = nuevo Empleado("James Smith");
Empleado empTwo = nuevo Empleado("Mary Anne");
// Llama a los métodos miembros de estos dos objetos empOne.empAge(26);
empOne.empDesignation("Ingeniero de software sénior");
empOne.empSalario(1000);
empOne.printEmployee();
empTwo.empAge(21);
empTwo.empDesignation("Ingeniero de software");
empTwo.empSalario(500);
empTwo.printEmployee();
}
}Compile estos dos archivos y ejecute la clase EmployeeTest. Puede ver los siguientes resultados:
C:>javacEmpleado.java
C :> vi PruebaEmpleado.java
C:>javacEmployeeTest.java
C :>javaEmpleadoPrueba
Nombre: James Smith
Edad: 26
Designación: Ingeniero de software senior
Salario:1000.0
Nombre: María Ana
Edad: 21
Designación:Ingeniero de software
Salario:500.0