# data[].attributes.body
Escribe aquí tu investigación.

Además, puedes hacer clic en los iconos habilitados, con los que podrás cargar un documento, imagen, enlace, entre muchas otras cosas más... diviértete explorando la herramienta si es que no la conoces.

Si realizas algún cambio, no olvides presionar el botón Actualizar, para que se reflejen tus cambios.

No olvides ingresar la(s) URL de consulta

# data[].attributes.body
Debido a que Java es un lenguaje de programación orientado a objetos, todos los elementos que utilizamos en este lenguaje son objetos. Lo que los distingue es que cada uno tiene un nombre diferente y pertenece a una clase única que establece el modelo general de los objetos que la componen. Por ejemplo, podemos tener muchos automóviles que representen objetos, pero todos ellos pertenecen a fin de cuentas a la misma clase: la de los automóviles.

Cada clase tiene un nombre particular que permite crear instancias u objetos dentro de ella. Lo que hace una clase es definir los estados y comportamientos del objeto para que todas las instancias dentro de ella tengan las mismas propiedades.

https://blog.hubspot.es/website/que-es-objeto-java

# data[].attributes.attachment_link.readable_text
Muchos lenguajes de programación trabajan con el concepto de "objeto", pero cada uno lo maneja de diferente manera y le da un significado específico. Por ejemplo, en JavaScript los objetos sirven para almacenar datos complejos. En Java, por su parte, los objetos tienen muchas más funciones. En este artículo revisaremos algunas de ellas.

Continúa leyendo para descubrir qué es un objeto en Java, para qué sirve y cómo usarlo. Exploraremos cómo identificar los componentes de los objetos en este lenguaje de programación y algunos ejemplos de código que te dejarán ver cómo funcionan estos elementos.

¿Qué es un objeto en Java?

Un objeto en Java es una entidad que representa información sobre una cosa dentro del código de un programa. Como tal, los objetos en este lenguaje son instancias o miembros de una clase definida, que tienen propiedades, atributos y características que los distinguen del resto, tal como los objetos en el mundo real.

¿Qué elementos definen a un objeto en Java?

Los objetos en Java tienen tres características primarias: identidad, estado y comportamiento. Con estas propiedades se pueden construir bloques de objetos. Veamos cómo trabajan en conjunto estas características:

1. Identidad: la identidad de un objeto es un identificador único, tal como la dirección de almacenamiento, el ID del usuario o incluso un nombre.

2. Estado: el estado controla aspectos específicos del objeto. Por ejemplo, si queremos describir un ventilador, podemos tener los estados "encendido", "apagado" o "alta potencia".

3. Comportamiento: se relaciona con los estados en cuanto que estos modifican el comportamiento del objeto. Sirve para describir lo que hacen los objetos referidos.

Como puedes ver, estas tres características trabajan en conjunto y son indisociables. No puedes tener un objeto sin nombre, tampoco puede tener un comportamiento sin un estado.

En la vida real, nos encontramos con objetos todo el tiempo. Imagina que Java imita esos objetos. Por ejemplo, muchos desarrolladores comparan estos elementos con automóviles, que tienen identidades, estados y comportamientos.

Piensa en cualquier automóvil. No importa cuál tengas en mente: fue producido por una empresa en particular, es un modelo específico y tiene un número de serie. Estos elementos definen su identidad. Asimismo, el automóvil puede tener diferentes estados: apagado, neutral, reversa, etcétera. Estos estados conllevan comportamientos definidos; por ejemplo, si usas tu acelerador, el vehículo se pondrá en movimiento debido a sus mecanismos internos.

Java permite crear objetos de este tipo dentro de clases; estos elementos son también conocidos como instancias. Veamos qué relación guardan las clases y los objetos.

Clases y objetos en Java

Debido a que Java es un lenguaje de programación orientado a objetos, t odos los elementos que utilizamos en este lenguaje son objetos. Lo que los distingue es que cada uno tiene un nombre diferente y pertenece a una clase única que establece el modelo general de los objetos que la componen. Por ejemplo, podemos tener muchos automóviles que representen objetos, pero todos ellos pertenecen a fin de cuentas a la misma clase: la de los automóviles.

Cada clase tiene un nombre particular que permite crear instancias u objetos dentro de ella. Lo que hace una clase es definir los estados y comportamientos del objeto para que todas las instancias dentro de ella tengan las mismas propiedades.

¿Cómo crear un objeto en Java?

Para crear una instancia dentro de una clase, lo que debes hacer es identificar en cuál de ellas quieres crear un objeto. Para continuar con nuestro ejemplo: una buena estrategia es comenzar creando una clase especial para los automóviles. Para crear esta clase puedes utilizar el siguiente código:

public class Automovil{

private String NoSerie;

private boolean Encendido;

private int velocidad;

public Automovil(String NoSerie) {

}

public void setIs Encendido() {

this.is Encendido = !is Encendido;

}

public boolean getIs Encendido() {

return is Encendido;

}

public void set velocidad(int velocidad) {

this. velocidad = velocidad;

}

public int get velocidad() {

return velocidad; }

}

En este ejemplo, podemos notar que hemos ingresado la información esencial para instanciar un objeto dentro de la clase: su identidad (número de serie), su estado (encendido) y su comportamiento (velocidad). Ahora es momento de crear el objeto que nos interesa. Para ello deberemos definir los valores de cada uno de estos elementos.

public class Main {

public static void main(String[ ] args) {

Automovil my Automovil = new Automovil("vhjujhm16513hgtfs5rf82f");

my Automovil.setIs Encendido( );

my Automovil. velocidad = 35;

String automovilSerie = "El No de Serie de mi automovil es: " + my AutomovilSerie;

String automovilEstado = "The car's running state is: " + my Automovil.Is Encendido;

String automovilVelocidad = "Current speed: " + my Automovil.velocidad;

System.out.println( automovilSerie);

System.out.println( automovilEstado);

System.out.println( automovilVelocidad);

}

}

Con este código has creado tu clase principal. Incluso has dado la instrucción al programa de imprimir el objeto una vez que se hayan llenado los campos solicitados. A partir de este punto, para crear objetos únicamente deberás escribir una línea de código como la siguiente que indica una nueva instanciación:

Automovil my Automovil = new Automovil("vhjujhm16513hgtfs5rf82f");

Automáticamente el sistema creará un objeto nuevo con ese número de serie, que funcionará como un identificador único. Posteriormente, tendrás listo tu objeto para acceder a su información y modificar su estado (encendido o no) y su comportamiento (la velocidad a la que avanza).

Programar con objetos en Java

Con toda la información que hemos revisado tienes las nociones básicas para comenzar a utilizar objetos en Java. Sustituye valores en las líneas de código que te hemos compartido y crea más comportamientos y estados para probar tus conocimientos.

Ten en mente que esto es apenas el principio. Aún debes aprender en detalle qué es una clase en Java y comprender cómo complementar ambos aspectos para mejorar tu código y crear increíbles proyectos en Java.

# data[].attributes.attachment_link.title
Qué es un objeto en Java, cuáles son sus elementos y cómo crearlo

# data[].attributes.attachment_link.description
Conoce los conceptos básicos para trabajar con objetos en Java y observa un ejemplo para comprender qué elementos están detrás de su funcionamiento.

# data[].attributes.body
Los atributos son las caracterísiticas individuales que diferencian un objeto de otro y determinan su apariencia, estado u otras cualidades. Los atributos se guardan en variables denominadas de instancia, y cada objeto particular puede tener valores distintos para estas variables.

Las variables de instancia también denominados miembros dato, son declaradas en la clase pero sus valores son fijados y cambiados en el objeto.

# data[].attributes.attachment_link.readable_text
Introduccin El proyecto La clase Los objetos La vida de un objeto Identificadores
Cuando se escribe un programa en un lenguaje orientado a objetos, definimos una plantilla o clase que describe las caractersiticas y el comportamiento de un conjunto de objetos similares. La clase automvil describe las caractersticas comunes de todos los automviles: sus atributos y su comportamiento. Los atributos o propiedades se refieren a la marca o fabricante, el color, las dimensiones, si tienen dos, tres, cuatro o ms puertas, la potencia, si utiliza como combustible la gasolina o gasoil, etc. El comportamiento se refiere a la posibilidad de desplazarse por una carretera, frenar, acelerar, cambiar de marcha, girar, etc.

Luego, tenemos automviles concretos, por ejemplo el automvil propio de una determinada marca, color, potencia, etc, el automvil del vecino de otra marca, de otro color, etc, , el automvil de un amigo, etc.

Una clase es por tanto una pantilla implementada en software que describe un conjunto de objetos con atributos y comportamiento similares.

Una instancia u objeto de una clase es una representacin concreta y especfica de una clase y que reside en la memoria del ordenador.
Atributos
Los atributos son las caractersiticas individuales que diferencian un objeto de otro y determinan su apariencia, estado u otras cualidades. Los atributos se guardan en variables denominadas de instancia, y cada objeto particular puede tener valores distintos para estas variables.

Las variables de instancia tambin denominados miembros dato, son declaradas en la clase pero sus valores son fijados y cambiados en el objeto.

Adems de las variables de instancia hay variables de clase, las cuales se aplican a la clase y a todas sus instancias. Por ejemplo, el nmero de ruedas de un automvil es el mismo cuatro, para todos los automviles.
Comportamiento
El comportamiento de los objetos de una clase se implementa mediante funciones miembro o mtodos. Un mtodo es un conjunto de instrucciones que realizan una determinada tarea y son similares a las funciones de los lenguajes estructurados.

Del mismo modo que hay variables de instancia y de clase, tambin hay mtodos de instancia y de clase. En el primer caso, un objeto llama a un mtodo para realizar una determinada tarea, en el segundo, el mtodo se llama desde la propia clase.

El proyecto consta de dos archivos, el primero contiene la clase Rectangulo que se guarda en el archivo Rectangulo.java y no tiene el mtodo main. La ltima casilla del asistente de creacin de clases New Java File debe de estar desactivada.

La otra clase, es la que describe la aplicacin RectanguloApp1 y se guarda en el archivo RectanguloApp1.java, esta clase tiene que tener el mtodo main, por lo tanto, la ltima casilla del asistente de creacin de clases New Java File debe de estar activada.

Un proyecto puede constar de varias clases (normalmente se sita cada clase en un archivo) pero solamente una tiene el mtodo main y representa la aplicacin. Para distinguir la clase que describe la aplicacin de las dems le hemos aadido el sufijo App.

rectangulo1: Rectangulo.java, RectanguloApp1.java

Para crear una clase se utiliza la palabra reservada class y a continuacin el nombre de la clase. La definicin de la clase se pone entre las llaves de apertura y cierre. El nombre de la clase empieza por letra mayscula.

class Rectangulo{
	//miembros dato
	//funciones miembro
}

Los miembros dato

Los valores de los atributos se guardan en los miembros dato o variables de instancia. Los nombres de dichas variables comienzan por letra minscula.

Vamos a crear una clase denominada Rectangulo, que describa las caractersticas comunes a estas figuras planas que son las siguientes:

El origen del rectngulo: el origen o posicin de la esquina superior izquierda del rectngulo en el plano determinado por dos nmeros enteros x e y.

Las dimensiones del rectngulo: ancho y alto, otros dos nmeros enteros.

class Rectangulo{
	int x;
	int y;
	int ancho;
	int alto;
	//faltan las funciones miembro
}

En el lenguaje C++ las funciones miembro se declaran, se definen y se llaman. En el lenguaje Java las funciones miembro o mtodos solamente se definen y se llaman.

El nombre de las funciones miembro o mtodos comieza por letra minscula y deben sugerir acciones (mover, calcular, etc.). La definicin de una funcin tiene el siguiente formato:

tipo nombreFuncion(tipo parm1, tipo parm2, tipo parm3){
	//...sentencias
}

Entre las llaves de apertura y cierre se coloca la definicin de la funcin. tipo indica el tipo de dato que puede ser predefinido int, double, etc, o definido por el usuario, una clase cualquiera.

Para llamar a un funcin miembro o mtodo se escribe

	retorno=objeto.nombreFuncion(arg1, arg2, arg3);

Cuando se llama a la funcin, los argumentos arg1, arg2, arg3 se copian en los parmetros parm1, parm2, parm3 y se ejecutan las sentencias dentro de la funcin. La funcin finaliza cuando se llega al final de su bloque de definicin o cuando encuentra una sentencia return.

Cuando se llama a la funcin, el valor devuelto mediante la sentencia return se asigna a la variable retorno.

Cuando una funcin no devuelve nada se dice de tipo void. Para llamar a la funcin, se escribe

	objeto.nombreFuncion(arg1, arg2, arg3);

Estudiaremos ms adelante con ms detalle como se definen las funciones.

Una funcin suele finalizar cuando llega al final del bloque de su definicin

void funcion(....){
//sentencias...
}

Una funcin puede finalizar antes del llegar al final de su definicin

void funcion(....){
//sentencias...
	if(condicion) return;
//sentencias..
}

Una funcin puede devolver un valor (un tipo de dato primitivo o un objeto).

 double funcion(....){
	double suma=0.0;
//sentencias...
	return suma;
}

Cualquier variable declarada dentro de la funcin tiene una vida temporal, existiendo en memoria, mientras la funcin est activa. Se trata de variables locales a la funcin. Por ejemplo:

void nombreFuncion(int parm){
	//...
	int i=5;
	//...
}

La variable parm, existe desde el comienzo hasta el final de la funcin. La variable local i, existe desde el punto de su declaracin hasta el final del bloque de la funcin.

Se ha de tener en cuenta que las funciones miembro tienen acceso a los miembros dato, por tanto, es importante en el diseo de una clase decidir qu variables son miembros dato, qu variables son locales a las funciones miembro, y qu valores les pasamos a dichas funciones. Los ejemplos nos ayudarn a entender esta distincin.

Hemos definido los atributos o miembros dato de la clase Rectangulo, ahora le vamos aadir un comportamiento: los objetos de la clase Rectangulo o rectngulos sabrn calcular su rea, tendrn capacidad para trasladarse a otro punto del plano, sabrn si contienen en su interior un punto determinado del plano.

La funcin que calcula el rea realizar la siguiente tarea, calcular el producto del ancho por el alto del rectngulo y devolver el resultado. La funcin devuelve un entero es por tanto, de tipo int. No es necasario pasarle datos ya que tiene acceso a los miembros dato ancho y alto que guardan laanchuray la altura de un rectngulo concreto.

class Rectangulo{
	int x;
	int y;
	int ancho;
	int alto;
   int calcularArea(){
	return (ancho*alto);
   }
}

A la funcin que desplaza el rectngulo horizontalmente en dx, y verticalmente en dy, le pasamos dichos desplazamientos, y a partir de estos datos actualizar los valores que guardan sus miembros dato x e y. La funcin no devuelve nada es de tipo void.

class Rectangulo{
	int x;
	int y;
	int ancho;
	int alto;
   void desplazar(int dx, int dy){
	x+=dx;
	y+=dy;
   }
}

La funcin que determina si un punto est o no en el interior del rectngulo, devolver true si el punto se encuentra en el interior del rectngulo y devolver false si no se encuentra, es decir, ser una funcin del tipo boolean. La funcin necesitar conocer las coordenadas de dicho punto. Para que un punto de coordenadas x1 e y1 est dentro de un rectngulo cuyo origen es x e y, y cuyas dimensiones son ancho y alto, se deber cumplir a la vez cuatro condiciones

x1>x y a la vez x1<x+ancho

Tambin se debe cumplir

y1>y y a la vez y1<y+alto

Como se tienen que cumplir las cuatro condiciones a la vez, se unen mediante el operador lgico AND simbolizado por&&.

class Rectangulo{
	int x;
	int y;
	int ancho;
	int alto;
   boolean estaDentro(int x1, int y1){
	if((x1>x)&&(x1<x+ancho)&&(y1>y)&&(y1<y+ancho)){
		return true;
	}
	return false;
   }
}

En el lenguaje Java, si la primera condicin es falsa no se evalan las restantes expresiones ya que el resultado es false. Ahora bien, si la primera es verdadera true, se pasa a evaluar la segunda, si sta el falsa el resultado es false, y as sucesivamente.

Los contructores

Un objeto de una clase se crea llamando a una funcin especial denominada constructor de la clase. El constructor se llama de forma automtica cuando se crea un objeto, para situarlo en memoria e inicializar los miembros dato declarados en la clase. El constructor tiene el mismo nombre que la clase. Lo especfico del constructor es que no tiene tipo de retorno.

class Rectangulo{
	int x;
	int y;
	int ancho;
	int alto;
   Rectangulo(int x1, int y1, int w, int h){
	x=x1;
	y=y1;
	ancho=w;
	alto=h;
   }
}

El constructor recibe cuatro nmeros que guardan los parmetros x1, y1, w y h, y con ellos inicializa los miembros dato x, y, ancho y alto.

Una clase puede tener ms de un constructor. Por ejemplo, el siguiente constructor crea un rectngulo cuyo origen est en el punto (0, 0).

class Rectangulo{
	int x;
	int y;
	int ancho;
	int alto;
   Rectangulo(int w, int h){
	x=0;
	y=0;
	ancho=w;
	alto=h;
   }
}

Este constructor crea un rectngulo de dimensiones nulas situado en el punto (0, 0),

class Rectangulo{
	int x;
	int y;
	int ancho;
	int alto;
   Rectangulo(){
	x=0;
	y=0;
	ancho=0;
	alto=0;
   }
}

Con estas porciones de cdigo definimos la clase, y la guardamos en un archivo que tenga el mismo nombre que la clase Rectangulo y con extensin .java.

public class Rectangulo {
    int x;
    int y;
    int ancho;
    int alto;
    public Rectangulo() {
        x=0;
        y=0;
        ancho=0;
        alto=0;
    }
    public Rectangulo(int x1, int y1, int w, int h) {
        x=x1;
        y=y1;
        ancho=w;
        alto=h;
    }
    public Rectangulo(int w, int h) {
        x=0;
        y=0;
        ancho=w;
        alto=h;
    }
    int calcularArea(){
	return (ancho*alto);
   }
   void desplazar(int dx, int dy){
	x+=dx;
	y+=dy;
   }
   boolean estaDentro(int x1, int y1){
	if((x1>x)&&(x1<x+ancho)&&(y1>y)&&(y1<y+ancho)){
		return true;
	}
	return false;
   }
}

Para crear un objeto de una clase se usa la palabra reservada new.

Por ejemplo,

	Rectangulo rect1=new Rectangulo(10, 20, 40, 80);

new reserva espacio en memoria para los miembros dato y devuelve una referencia que se guarda en la variable rect1 del tipo Rectangulo que denominamos ahora objeto. Dicha sentencia, crea un objeto denominado rect1 de la clase Rectangulo llamando al segundo constructor en el listado. El rectngulo estar situado en el punto de coordenadas x=10, y=20; tendr una anchura de ancho=40 y una altura de alto=80.

	Rectangulo rect2=new Rectangulo(40, 80);

Crea un objeto denominado rect2 de la clase Rectangulo llamando al tercer constructor, dicho rectngulo estar situado en el punto de coordenadas x=0, y=0; y tendr una anchura de ancho=40 y una altura de alto=80.

	Rectangulo rect3=new Rectangulo();

Crea un objeto denominado rect3 de la clase Rectangulo llamando al primer constructor, dicho rectngulo estar situado en el punto de coordenadas x=0, y=0; y tendr una anchura de ancho=0 y una altura de alto=0.

Acceso a los miembros

Desde un objeto se puede acceder a los miembros mediante la siguiente sintaxis
objeto.miembro;
Por ejemplo, podemos acceder al miembro dato ancho, para cambiar la anchura de un objeto rectngulo.

	rect1.ancho=100;

El rectngulo rect1 que tena inicialmente una anchura de 40, mediante esta sentencia se la cambiamos a 100.

Desde un objeto llamamos a las funciones miembro para realizar una determinada tarea. Por ejemplo, desde el rectngulo rect1 llamamos a la funcin calcularArea para calcular el rea de dicho rectngulo.

    rect1.calcularArea();

La funcin miembro area devuelve un entero, que guardaremos en una variable entera medidaArea, para luego usar este dato.

	int medidaArea=rect1.calcularArea();
	System.out.println("El rea del rectngulo es "+medidaArea);

Para desplazar el rectngulo rect2, 10 unidades hacia la derecha y 20 hacia abajo, escribiremos

	rect2.desplazar(10, 20);

Podemos verificar mediante el siguiente cdigo si el punto (20, 30) est en el interior del rectngulo rect1.

	if(rect1.estaDentro(20,30)){
		System.out.println("El punto est dentro del rectngulo");
	}else{
		System.out.println("El punto est fuera del rectngulo");
	}

rect1.dentro() devuelve true si el punto (20, 30) que se le pasa a dicha funcin miembro est en el interior del rectngulo rect1, ejecutndose la primera sentencia, en caso contrario se ejecuta la segunda.

Como veremos ms adelante no siempre es posible acceder a los miembros, si establecemos controles de acceso a los mismos.

public class RectanguloApp1 {
     public static void main(String[] args) {
        Rectangulo rect1=new Rectangulo(10, 20, 40, 80);
        Rectangulo rect2=new Rectangulo(40, 80);
        Rectangulo rect3=new Rectangulo();
 	int medidaArea=rect1.calcularArea();
	System.out.println("El rea del rectngulo es "+medidaArea);

 	rect2.desplazar(10, 20);

        if(rect1.estaDentro(20,30)){
	        System.out.println("El punto est dentro del rectngulo");
        }else{
	        System.out.println("El punto est fuera del rectngulo");
        }
    }
}

En el lenguaje C++, los objetos que se crean con new se han de eliminar con delete. new reserva espacio en memoria para el objeto y delete libera dicha memoria. En el lenguaje Java no es necesario liberar la memoria reservada, el recolector de basura (garbage collector) se encarga de hacerlo por nosotros, liberando al programador de una de las tareas que ms quebraderos de cabeza le producen, olvidarse de liberar la memoria reservada.

Veamos un ejemplo

public class UnaClase {
     public static void main(String[] args) {
        Image granImagen=creaImagen();
	mostrar(graImagen);

	while(condicion){
		calcular();
	}
    }
}

El objeto granImagen, continua en memoria hasta que se alcanza el final de la funcin main, aunque solamente es necesario hasta el bucle while. En C o en C++ eliminariamos dicho objeto liberando la memoria que ocupa mediante delete. El equivalente en Java es el de asignar al objeto granImagen el valor null.

public class UnaClase {
     public static void main(String[] args) {
        Image granImagen=creaImagen();
	mostrar(graImagen);
	granImagen=null;

	while(condicion){
		calcular();
	}
    }
}

A partir de la sentencia marcada en letra negrita el recolector de basura se encargar de liberar la memoria ocupada por dicha imagen. As pues, se asignar el valor null a las referencias a objetos temporales que ocupen mucha memoria tan pronto como no sean necesarios.

Creamos dos objetos de la clase rectngulo, del mismo modo que en el apartado anterior

	Rectangulo rect1=new Rectangulo(10, 20, 40, 80); Rectangulo rect3=new Rectangulo();

Si escribimos

	rect3=rect1;

En rect3 se guarda la referencia al objeto rect1. La referencia al objeto rect3 se pierde. El recolector se encarga de liberar el espacio en memoria ocupado por el objeto rect3.

La destruccin de un objeto es una tarea (thread) de baja prioridad que lleva a cabo la Mquina Virtual Java (JVM). Por tanto, nunca podemos saber cuando se va a destruir un objeto.

Puede haber situaciones en las que es necesario realizar ciertas operaciones que no puede realizar el recolector de basura (garbage collector) cuando se destruye un objeto. Por ejemplo, se han abierto varios archivos durante la vida de un objeto, y se desea que los archivos estn cerrados cuando dicho objeto desaparece. Se puede definir en la clase un mtodo denominado finalize que realice esta tarea. Este mtodo es llamado por el recolector de basura inmeditamente antes de que el objeto sea destrudo.

Cmo se escriben los nombres de la variables, de las clases, de las funciones, etc., es un asunto muy importante de cara a la comprensin y el mantenimiento de cdigo. En la introduccin a los fundamentos del lenguaje Java hemos tratado ya de los identificadores.

El cdigo debe de ser tanto ms fcil de leer y de entender como sea posible. Alguien que lea el cdigo, incluso despus de cierto tiempo, debe ser capaz de entender lo que hace a primera vista, aunque los detalles internos, es decir, cmo lo hace, precise un estudio detallado.

Vemos primero un ejemplo que muestra un cdigo poco legible y por tanto, muy difcil de mantener

public class Cuen{
	private int ba;

	Cuen(int ba){
		this.ba=ba;
	}
	public void dep(int i){
		ba+=i;
	}
	public boolean ret(int i){
		if(ba>=i){
			ba-=i;
			return true;
		}
		return false;
	}
	public int get(){
		return ba;
	}
}

Las abreviaciones empleadas solamente tienen significado para el programador en el momento de escribir el cdigo, ya que puede olvidarse de su significado con el tiempo. Otros programadores del grupo tienen que descifrar el significado del nombre de cada variable o de cada funcin. El tiempo extra que se gasta en escribir con claridad el nombre de los diversos elementos que entran en el programa, se ahorra ms adelante durante su desarrollo, depuracin, y mejora, es decir, durante todo el ciclo de vida del programa.

public class CuentaBancaria{
	private int balance;

	CuentaBancaria(int balance){
		this.balance=balance;
	}
	public void depositar(int cantidad){
		balance+=cantidad;
	}
	public boolean retirar(int cantidad){
		if(balance>=cantidad){
			balance-=cantidad;
			return true;
		}
		return false;
	}
	public int obtenerBalance(){
		return balance;
	}
}

Este es una programa sencillo de una cuenta bancaria. El tipo de dato puede ser entero ( int o long), si la unidad monetaria tiene poco valor como la peseta, o un nmero decimal ( double) si la unidad monetaria es de gran valor como el Euro y el Dlar.

El cdigo de las funciones miembro es muy sencillo y su significado se hace evidente al leer el programa. La funcin retirar es de tipo boolean, ya que no ( false) estamos autorizados a retirar una cantidad mayor que la existente en ese momento en el banco. Sin embargo, si ( true) estamos autorizados a retirar una cantidad menor que la que tenemos en la cuenta.

# data[].attributes.attachment_link.title
Conceptos bsicos de la Programacin Orientada a Objetos

# data[].attributes.attachment_link.description
Introduccin El proyecto La clase Los objetos La vida de un objeto Identificadores Cuando se escribe un programa en un lenguaje orientado a objetos, definimos una plantilla o clase que describe las caractersiticas y el comportamiento de un conjunto de objetos similares. La clase automvil describe las caractersticas comunes de todos los automviles: sus atributos y su comportamiento.

# data[].attributes.body
>Un método en Java es un conjunto de instrucciones definidas dentro de una clase, que realizan una determinada tarea y a las que podemos invocar mediante un nombre.

>Un método es una abstracción de una operación que puede hacer o realizarse con un objeto. Una clase puede declarar cualquier número de métodos que lleven a cabo operaciones de lo más variado con los objetos.

# data[].attributes.attachment_link.readable_text
Un método es una abstracción de una operación que puede hacer o realizarse con un objeto. Una clase puede declarar cualquier número de métodos que lleven a cabo operaciones de lo más variado con los objetos. En esta sección los métodos se clasifican en dos grupos: los métodos de instancia y los métodos de clase.

14.1 Métodos de instancia

Las clases pueden incluir en su declaración muchos métodos o no declarar ninguno. Los métodos pueden clasificarse en métodos de instancia y métodos de clase.

Los métodos de instancia operan sobre las variables de instancia de los objetos pero también tienen acceso a las variables de clase. La sintaxis de llamada a un método de instancia es:

// Llamada tipica a un metodo de instancia
idReferencia.idMetodo (parametros) ;

Todas las instancias de una clase comparten la misma implementación para un método de instancia. La instancia que hace la llamada al método es siempre un parámetro o argumento implícito. Dentro de un método de instancia, el identificador de una variable de instancia hace referencia al atributo de la instancia concreta que hace la llamada al método (suponiendo que el identificador del atributo no ha sido ocultado por el de un parámetro).

En el ejemplo anterior en la declaración de la clase CuentaBancaria, los métodos saldo y transferencia son métodos de instancia.

Ejemplos de llamada a estos métodos dentro de PruebaCuentaBancaria:

14.2 Métodos de clase

En principio, los métodos de clase no operan sobre las variables de instancia de los objetos. Los métodos de clase pueden trabajar con las variables de clase pero no pueden acceder a las variables de instancia declaradas dentro de la clase, a no ser que se crea una nueva instancia y se acceda a las variables de instancia a través del nuevo objeto. Los métodos de clase también pueden ser llamados precediendolos con el identificador de la clase, sin necesidad de utilizar el de una instancia.

IdClase.idMetodo (parametros) ; // Llamada tipica a un metodo de clase

La palabra static determina la declaración de un método de clase. Por defecto, si no se indica la palabra static, el método declarado se considera un método de instancia.

En el ejemplo anterior en la declaración de la clase CuentaBancaria, el método incCuentas es un método de clase.

Un ejemplo de llamada a este método dentro de PruebaCuentaBancaria sería:

Las diferencias entre los métodos de instancia y los de clase se resumen aquí:

Los métodos de clase o estáticos se pueden considerar equivalentes a las rutinas (globales) de otros lenguajes de programación como Pascal o C. Como ejemplos típicos de métodos estáticos pueden indicarse los métodos de Java correspondientes a las funciones matemáticas sin, cos, exp, pow... de la clase java.lang.Math. Las llamadas a estos métodos se realizan anteponiendo el identificador de la clase Math al identificador del método: Math.sin(angulo)...

# data[].attributes.attachment_link.description
Un método es una abstracción de una operación que puede hacer o realizarse con un objeto. Una clase puede declarar cualquier número de métodos que lleven a cabo operaciones de lo más variado con los objetos. En esta sección los métodos se clasifican en dos grupos: los métodos de instancia y los métodos de clase.

# data[].attributes.body
Una clase en Java se puede entender como un prototipo que define las variables y los métodos comunes a un cierto tipo de instancias, una clase define todo lo que caracteriza y pueden hacer una o varias instancias.

En java las clases son las matrices de las que luego se pueden crear múltiples instancias del mismo tipo. La clase define las variables y los métodos comunes a las instancias de ese tipo (el tipo de la clase creada), pero luego, cada instancia de esta clase tendrá sus propios valores (su propio molde, color y receta) y compartirán las mismas funciones.

En java, primero deberemos crear una clase antes de poder crear instancias o ejemplares de esa clase.

# data[].attributes.attachment_link.readable_text
Cuando comenzamos con este curso de Java, hice una introducción en la cual expliqué los principales conceptos de la programación orientada a objetos y en específico en el lenguaje Java. Vimos la definición y algún ejemplo sobre clases en Java y también vimos qué son y para qué son útiles los objetos en Java.

Voy a retomar parte de las definiciones y el ejemplo que usé en la introducción para profundizar aquí sobre las clases y los objetos en Java, los constructores y los métodos y algunas otras cosas particulares de estos.

Un ejemplo para clases y objetos en Java

Vamos a imaginar que somos los dueños o administradores de una fábrica de galletas, vendemos diferentes tipos de galletas con diferentes formas, sabores y colores, evidentemente al tener diferentes formas para nuestras galletas necesitaremos varios moldes para las galletas que fabricamos (un molde para cada forma), necesitaremos diferentes recetas para el sabor de cada una y por último diferentes maneras de darle color a las galletas.

¿Qué son las clases en Java?

Una clase en Java se puede entender como un prototipo que define las variables y los métodos comunes a un cierto tipo de instancias, una clase define todo lo que caracteriza y pueden hacer una o varias instancias.

En nuestro ejemplo de la fábrica de galletas, la clase sería uno de los moldes para galletas, junto con los métodos para colorearlas y la receta (método para prepararlas). Quiere decir que en nuestro programa de Java tendremos una manera de especificar las características de la galleta dado que hay diferentes moldes de galletas.

En java las clases son las matrices de las que luego se pueden crear múltiples instancias del mismo tipo. La clase define las variables y los métodos comunes a las instancias de ese tipo (el tipo de la clase creada), pero luego, cada instancia de esta clase tendrá sus propios valores (su propio molde, color y receta) y compartirán las mismas funciones.

En java, primero deberemos crear una clase antes de poder crear instancias o ejemplares de esa clase. Evidentemente primero necesitamos los moldes y demás para poder hacer las galletas.

¿Qué son los objetos en Java?

En Java, un objeto es básicamente una instancia de una clase (las instancias de las que hablábamos hace un momento). Para el ejemplo de la fábrica de galletas, los objetos vendrían siendo cada una de las diferentes galletas obtenidas de los moldes definidos (clases), creados por medio de un proceso o "constructor" de galletas.

Muy bien, ya hemos hecho un repaso sobre el concepto de clase y objeto en Java, sin embargo aún no sabemos cómo crearlos ni usarlos, así que vamos a ello.

¿Cómo crear una clase en Java?

Como dije anteriormente la clase es la que nos dice los componentes del ejemplar que vamos a crear, es decir, una clase contiene los atributos y los métodos que conformarán al ejemplar o instancias, de este modo al momento de crear una clase en Java, debemos especificar el tipo y el nombre (como mínimo) de los atributos y adicionalmente debemos especificar (si existen) los métodos o funciones, el tipo de dato que retornan, el nombre y los parámetros que reciben dichos métodos.

Veamos la estructura básica de una clase en Java y luego veamos unos ejemplos de clases en java un poco más complejos e ilustrativos.

Estructura básica de una clase en Java
//Le damos un nombre "MiClase" a la clase public class MiClase { //Atributos de la clase private String atributo1; private int atributo2; private float atributo3; //Constructor con el mismo nombre de la clase public MiClase(){} //Métodos de la clase public void metodo1() { //Método vacío } public String metodo2() { return "metodo2"; } }
En el ejemplo anterior hemos creado una clase en Java llamada "MiClase" la cual posee un total de tres atributos (todos ellos privados) y son de tipo String, int y float respectivamente. Adicionalmente esta clase tiene un constructor (que siempre por norma, debe tener el mismo nombre de la clase) el cual no recibe ningún parámetro, aunque pueden recibir todos los parámetros que nosotros deseemos, también tiene un método llamado "metodo1" que no retorna valor alguno (es de tipo void) y otro método llamado "metodo2" que retorna una cadena de caracteres (es de tipo String) con el valor "metodo2". Cabe resaltar que una clase en Java puede tener o no métodos y atributos, sin embargo lo más normal en la mayoría de los casos es que tenga tanto métodos como atributos que la caractericen.

Veamos ahora un ejemplo un poco más completo e ilustrativo.

Ejemplo de clases en Java
package misClases; //Se le declara un paquete public class Animal { private String raza; private String nombre; private int edad; public Animal(String nuevoNombre) { nombre = nuevoNombre; //Se le da un nombre al animal } //Método para obtener la edad del animal public int getEdad() { return edad; } //Método para establecer la edad del animal public void setEdad(int nuevaEdad) { edad = nuevaEdad; } //Método para obtener el nombre del animal public String getNombre() { return nombre; } }
La clase Java que hemos creado para este ejemplo tiene como nombre "Animal", pertenece al paquete "misClases" y posee los atributos raza, nombre y edad, adicionalmente tenemos un constructor que recibe un nombre y se lo asigna al animal y tres métodos encargados de obtener y establecer la edad del animal y el restante para obtener el nombre.

Objetos en Java

Muy bien, ya hemos aprendido a la perfección cómo crear clases en java, y cuáles son sus componentes esenciales, ahora vamos a aprender a crear objetos en Java, cómo se hace, veremos brevemente la utilidad y funcionamiento de los constructores y como usar los métodos

¿Cómo crear objetos en Java?

Al momento de crear objetos en Java, debemos tener claras dos cosas indispensables, la primera es el nombre de la clase para la cual vamos a crear el objeto y segundo el constructor que dicha clase posee, es decir, si el constructor recibe o no parámetros.

Para crear objetos en Java, el lenguaje nos proporciona el comando new, con este comando le decimos a Java que vamos a crear un nuevo objeto de una clase en especifico y le enviamos los parámetros (en caso de ser necesario) según el constructor, veamos un ejemplo.

Ejemplo de objetos en java

Vamos a crear un objeto o instancia en Java para la clase que hemos creado al comienzo llamada MiClase. Esta clase tiene un constructor que no recibe parámetros, por lo cual no es necesario enviar algún tipo de valor al momento de crear el objeto, veamos entonces la sintaxis para crear un objeto del tipo MiClase en java.
MiClase miObjeto; //Declaramos una variable del tipo de la clase miObjeto = new MiClase(); //Aquí ya hemos creado un objeto de MiClase
Otra forma de hacer y que también es válida es la siguiente:
MiClase miObjeto = new MiClase(); //Declaramos y creamos el objeto en una línea
Ejemplo 2 de objetos en Java

Vamos ahora a crear un objeto o instancia para la clase Animal (la del ejemplo dos), en esta ocasión tenemos un constructor que recibe un parámetro (el nombre del animal) y que posee tres métodos de los cuales haremos uso para este ejemplo.
import misClases.Animal; //Importamos la clase Animal para poder usarla public class Ejemplo { public static void main(String[] args) { //Creamos un animal cuyo nombré será Falco Animal miAnimal = new Animal("Falco"); //Le establecemos 3 años de edad a Falco. miAnimal.setEdad(3); //Mostraremos el nombre del animal por pantalla System.out.println("El nombre es: " + miAnimal.getNombre()); //Mostramos la edad del animal por pantalla System.out.println(" y tiene " + miAnimal.getEdad() + " años"); //Este código deberia imprimir "El nombre es: Falco y tiene 3 años" } }
Nota: Es importante notar que es similar hacer uso de método set para establecer atributos y usar el constructor enviandole parámetros, es decir, el resultado es el mismo al usar un constructor vacío y luego establecer los valores de los atributos por medio de una función set o usar un constructor que reciba una serie de parámetros que usará para establecer valores a los atributos. La diferencia radica esencialmente en la agilidad y número de líneas, al usar el constructor y enviar los parámetros, el constructor hace todas las asignaciones por nosotros y usamos una sola línea de código (normalmente) mientras que al usar métodos set debemos usar un método set por cada atributo y si tenemos cinco o más atributos ya se vuelve un poco molesto hacerlo además de tener que usar un constructor de todas formas. Veamos un corto ejemplo para estar más claros.

Constructor vs mutador (set)

En programación se conoce como método set al método encargado de establecerle un valor a un atributo según un parámetro recibido (ver setEdad(...) en el ejemplo de clases en Java).

Una pregunta que nos puede surgir es si debemos usar un constructor con parámetros o los métodos set de los atributos para establecer los valores de los atributos del objeto. En realidad es lo mismo en cuanto a resultados u términos generales veamos:

Ejemplo 1: Usando constructor
public class Aclaracion { private int atributo1; private int atributo2; private String atributo3; //Declaramos un constructor public Aclaracion(int attr1, int attr2, String attr3) { atributo1 = attr1; atributo2 = attr2; atributo3 = attr3; } public static void main(String[] args) { Aclaracion ac = new Aclaracion(5, 10, "x");//Creamos un objeto enviando parámetros al constructor System.out.println(ac.atributo1 + ", " + ac.atributo2 + ", " +ac.atributo3);//Mostramos el valor de los atributos //Imprime '5, 10, x' } }
En este ejemplo hemos hecho uso del constructor para establecerle los valores a los atributos del objeto. Ahora hagamos lo mismo usando métodos set o accediendo directamente a cada atributo.

Ejemplo 2: Usando métodos set
public class Aclaracion { private int atributo1; private int atributo2; private String atributo3; public void setAtributo1(int attr1) { atributo1 = attr1; } public void setAtributo2(int attr2) { atributo2 = attr2; } public void setAtributo3(String attr3) { atributo3 = attr3; } public static void main(String[] args) { Aclaracion ac1 = new Aclaracion();//Creamos un objeto con constructor vacío Aclaracion ac2 = new Aclaracion();//Creamos otro objeto con constructor vacío //Establecemos los valores de los atributos usando métodos set de cada uno ac1.setAtributo1(5); ac1.setAtributo2(10); ac1.setAtributo3("x"); //Establecemos los valores de los atributos accediendo directamente a cada uno ac2.atributo1 = 5; ac2.atributo2 = 10; ac2.atributo3 = "x"; System.out.println(ac1.atributo1 + ", " + ac1.atributo2 + ", " +ac1.atributo3);//Mostramos el valor de los atributos de ac1 //Imprime '5, 10, x' System.out.println(ac2.atributo1 + ", " + ac2.atributo2 + ", " +ac2.atributo3);//Mostramos el valor de los atributos de ac2 //Imprime '5, 10, x' } }
Como podrás evidenciar hacer ambas cosas nos permiten llegar al mismo resultado, sin emabrgo en el ejemplo 2, podemos ver como el número de líneas aumentó considerablemente y fue más engorroso programarlo. En todo caso siempre es buena práztica declarar los métodos set y get para cada atributo, pues si debemos modificar el valor de un atributo cualquiera, debemos hacerlo por medio de un método get y no creando un objeto nuevo.

Nota: En el ejemplo 2, podrás ver que hicimos uso de los métodos set para establecer valores en el objeto ac1 mientras que para el objeto ac2 hicimos asignaciones directas. Esto lo pudimos hacer debido a que los atributos son privados y estamos accediendo a ellos desde la propia clase. Eso mismo no se podría hacer desde otra clase, pues deberíamos usar el método set (que son públicos). Para más información respecto a esto de acceso, publico, privado y demás, puedes ingresar al artículo sobre modificadores de acceso.

Muy bien, ha sido todo en esta sección. En este punto debemos saber cómo crear una clase, qué son atributos y métodos de una clase en Java, qué es y para qué sirve un constructor (al menos en una forma muy básica), cómo crear objetos en Java y cómo hacer uso de los métodos de una clase desde los objetos de la misma. Espero entonces que todo haya quedado claro y sin fallas. De igual forma si tienes alguna duda, comentario y/o sugerencia, siempre puedes hacer uso de la sección de comentarios y allí con gusto responderé a cualquier comentario o duda que surja.

# data[].attributes.attachment_link.title
Crear objetos y clases en Java. Constructores, class y new

# data[].attributes.attachment_link.description
Las clases y los objetos en Java: Antes de programar en Java, tómate un momento para aprender sobre objetos, clases y, constructores en Java

# data[].attributes.body
Java es una plataforma informática de lenguaje de programación creada por Sun Microsystems en 1995. Ha evolucionado desde sus humildes comienzos hasta impulsar una gran parte del mundo digital actual, ya que es una plataforma fiable en la que se crean muchos servicios y aplicaciones. Los nuevos e innovadores productos y servicios digitales diseñados para el futuro también siguen basándose en Java.

# data[].attributes.attachment_link.readable_text
Java es una plataforma informática de lenguaje de programación creada por Sun Microsystems en 1995. Ha evolucionado desde sus humildes comienzos hasta impulsar una gran parte del mundo digital actual, ya que es una plataforma fiable en la que se crean muchos servicios y aplicaciones. Los nuevos e innovadores productos y servicios digitales diseñados para el futuro también siguen basándose en Java.

¿Es gratuita la descarga de Java?

¿Por qué debería actualizar al último parche de Java cuando se publica trimestralmente?

¿Qué obtendré al descargar el software Java desde java.com?

¿Qué es el software Java Plugin?

He oído hablar de Java Virtual Machine y JVM. ¿Se trata de software de Java?

Java Virtual Machine es solo una parte del software de Java que se encarga de ejecutar una aplicación. Java Virtual Machine está incluido en la descarga del software Java, forma parte de JRE y ayuda a ejecutar aplicaciones Java.

El software Java Plugin es un componente de Java Runtime Environment (JRE). JRE permite que algunas aplicaciones escritas en lenguaje de programación Java se inicien a través de ciertos navegadores. El software Java Plugin no es un programa independiente y no puede instalarse por separado.

Al descargar el software Java desde java.com, obtendrá la versión 8 de Java Runtime Environment (JRE).

JRE incluye Java Virtual Machine (JVM), las clases del núcleo de la plataforma Java y bibliotecas de la plataforma Java de compatibilidad. JRE representa la parte de tiempo de ejecución del software Java, que es todo lo que necesita para ejecutar las aplicaciones de Java WebStart desde un navegador web compatible. Sin embargo, no incorpora herramientas de desarrollo, dado que ya forman parte de Java Development Kit (JDK).

Los últimos parches de Java contienen mejoras importantes para aumentar el rendimiento, la estabilidad y la seguridad de las aplicaciones Java que ejecute en su máquina. La instalación de estas actualizaciones garantizará que las aplicaciones Java sigan ejecutándose con la versión más reciente.

Sí, la descarga de Java para uso personal es gratuita.
Java también es gratuito para el desarrollo: los desarrolladores encontrarán todos los kits de desarrollo y otras herramientas útiles en https://www.oracle.com/javadownload/.

Aunque la mayoría de aplicaciones Java modernas combinan el tiempo de ejecución y la aplicación de Java, todavía existen algunas aplicaciones e incluso sitios web que no funcionan sin instalar Java para escritorio. El sitio web Java.com está pensado para consumidores que todavía necesitan Java en sus aplicaciones de escritorio, sobre todo las aplicaciones que tienen como destino Java 8. Los desarrolladores y los usuarios que quieran aprender sobre programación Java, deben consultar el sitio web dev.java y los usuarios profesionales, oracle.com/java para obtener más información.

# data[].attributes.body
Java Development Kit (JDK) es un software para los desarrolladores de Java. Incluye el intérprete Java, clases Java y herramientas de desarrollo Java (JDT): compilador, depurador, desensamblador, visor de applets, generador de archivos de apéndice y generador de documentación.

El JDK le permite escribir aplicaciones que se desarrollan una sola vez y se ejecutan en cualquier lugar de cualquier máquina virtual Java. Las aplicaciones Java desarrolladas con el JDK en un sistema se pueden usar en otro sistema sin tener que cambiar ni recompilar el código. Los archivos de clase Java son portables a cualquier máquina virtual Java estándar.

# data[].attributes.attachment_link.readable_text
Java™ Development Kit (JDK) es un software para los desarrolladores de Java. Incluye el intérprete Java, clases Java y herramientas de desarrollo Java (JDT): compilador, depurador, desensamblador, visor de applets, generador de archivos de apéndice y generador de documentación.

El JDK le permite escribir aplicaciones que se desarrollan una sola vez y se ejecutan en cualquier lugar de cualquier máquina virtual Java. Las aplicaciones Java desarrolladas con el JDK en un sistema se pueden usar en otro sistema sin tener que cambiar ni recompilar el código. Los archivos de clase Java son portables a cualquier máquina virtual Java estándar.

Para obtener más información sobre el JDK actual, consulte la versión del IBM® Developer Kit para Java en su servidor.

Puede consultar la versión del IBM Developer Kit para Java predeterminado de la máquina virtual Java (JVM) en el servidor, entrando uno de estos mandatos:

java -version en el indicador de mandatos de Qshell.

RUNJVA CLASS(*VERSION) en la línea de mandatos CL.

Luego busque la misma versión del JDK de Oracle en The Source for Java Technology , para localizar documentación específica. El IBM Developer Kit para Java es una implementación compatible de la tecnología Java de Oracle, por lo que debe de estar familiarizado con la correspondiente documentación del JDK.

Paquetes Java

El paquete Java es una forma de agrupar clases e interfaces relacionadas en Java. Los paquetes Java son similares a las bibliotecas de clases que están disponibles en otros lenguajes.

Los paquetes Java, que proporcionan las interfaces API Java, están disponibles como parte del Java Development Kit (JDK) de Oracle. Para obtener una lista completa de los paquetes Java e información sobre las API Java, vea: Paquetes de la plataforma Java 2.

Herramientas Java

Para obtener una lista completa de las herramientas proporcionadas por el Java Development Kit de Oracle, consulte la Referencia de herramientas de Oracle. Para obtener más información sobre cada herramienta individual soportada por IBM Developer Kit para Java, vea: Herramientas Java soportadas por IBM Developer Kit para Java.

# data[].attributes.attachment_link.description
Java Development Kit (JDK) es un software para los desarrolladores de Java. Incluye el intérprete Java, clases Java y herramientas de desarrollo Java (JDT): compilador, depurador, desensamblador, visor de applets, generador de archivos de apéndice y generador de documentación.

# data[].attributes.body
Java Runtime Environment, o JRE, es una capa de software que se ejecuta sobre el software del sistema operativo de una computadora y proporciona las clases de bibliotecas y otros recursos que un programa Java específico necesita para ejecutarse.

El JRE es uno de los tres componentes interrelacionados para desarrollar y ejecutar programas Java. Los otros dos componentes son los siguientes:

1.  Java Development Kit, o JDK

2. Java Virtual Machine, oJVM

# data[].attributes.attachment_link.readable_text
¿Qué es Java Runtime Environment (JRE)?

Descubra qué hace Java Runtime Environment (JRE) y cómo funciona con otros componentes de la plataforma Java para ejecutar aplicaciones Java.

Suscríbase al boletín de noticias de IBM

Java Runtime Environment, o JRE, es una capa de software que se ejecuta sobre el software del sistema operativo de una computadora y proporciona las clases de bibliotecas y otros recursos que un programa Java específico necesita para ejecutarse.

El JRE es uno de los tres componentes interrelacionados para desarrollar y ejecutar programas Java. Los otros dos componentes son los siguientes:
Java Development Kit, o JDK
Es un conjunto de herramientas para desarrollar aplicaciones Java. Los desarrolladores eligen los JDK por versión de Java y por paquete o edición: Java Enterprise Edition (Java EE), Java Special Edition (Java SE) o Java Mobile Edition (Java ME). Cada JDK siempre incluye un JRE compatible, porque ejecutar un programa Java es parte del proceso de desarrollo de un programa Java.
Java Virtual Machine, o JVM
Ejecuta aplicaciones Java en vivo. Cada JRE incluye un JRE predeterminado, pero los desarrolladores tienen la libertad de elegir otro que satisfaga las necesidades específicas de recursos de sus aplicaciones.

El JRE combina el código Java creado utilizando el JDK con las bibliotecas necesarias para ejecutarlo en una JVM y luego crea una instancia de la JVM que ejecuta el programa resultante. Las JVM están disponibles para varios sistemas operativos y los programas creados con JRE se ejecutarán en todos ellos.

De esta manera, Java Runtime Environment es lo que permite que un programa Java se ejecute en cualquier sistema operativo sin modificaciones.

Puede descargar el JDK, incluyendo un JRE compatible, en Oracle (enlace externo a ibm.com).

JDK y JRE interactúan para crear un entorno de ejecución duradero que permite la ejecución perfecta de aplicaciones basadas en Java en prácticamente cualquier sistema operativo. Los siguientes elementos conforman la arquitectura de tiempo de ejecución de JRE:

ClassLoader

Java ClassLoader carga dinámicamente todas las clases necesarias para ejecutar un programa Java. Dado que las clases de Java solo se cargan en la memoria cuando son necesarias, JRE usa ClassLoaders para automatizar este proceso bajo demanda.

Verificador de código de bytes

El verificador de código de bytes garantiza el formato y la precisión del código Java antes de que pase al intérprete. En el caso de que el código viole la integridad del sistema o los derechos de acceso, la clase se considerará corrupta y no se cargará.

Intérprete

Una vez que el código de bytes se carga correctamente, el intérprete de Java crea una instancia de la JVM que permite que el programa Java se ejecute de forma nativa en la máquina subyacente.

Además de Java Virtual Machine, JRE se compone de una variedad de otras herramientas y funciones de software de apoyo para aprovechar al máximo sus aplicaciones Java.

Soluciones de implementación

Como parte de la instalación de JRE se incluyen tecnologías de implementación como Java Web Start y Java Plugin que simplifican la activación de aplicaciones y brindan soporte avanzado para futuras actualizaciones de Java.

Conjuntos de herramientas de desarrollo

El JRE también contiene kits de herramientas diseñados para ayudar a los desarrolladores a mejorar su interfaz de usuario. Algunos de estos kits de herramientas incluyen:
Java 2D
Una interfaz de programación de aplicaciones (API) que se utiliza para dibujar gráficos bidimensionales en lenguaje Java. Los desarrolladores pueden crear ricas interfaces de usuario, efectos especiales, juegos y animaciones.
Abstract Window Toolkit (AWT)
Una GUI (interfaz gráfica de usuario) que se utiliza para crear objetos, botones, barras de desplazamiento y ventanas.
Swing
Otra GUI liviana que utiliza un amplio conjunto de widgets para ofrecer personalizaciones flexibles y fáciles de usar.

Bibliotecas de integración

Java Runtime Environment proporciona una serie de bibliotecas de integración para ayudar a los desarrolladores a crear conexiones de datos integradas entre sus aplicaciones y servicios. Algunas de estas bibliotecas incluyen:
Java IDL (CORBA)
Utiliza la arquitectura de solicitud de objeto común para admitir objetos distribuidos escritos en lenguaje de programación Java.
Java Database Connectivity (JDBC) API
Proporciona herramientas para que los desarrolladores escriban aplicaciones con acceso a bases de datos de relaciones remotas, archivos planos y hojas de cálculo.
Java Naming and Directory Interface (JNDI)
Una interfaz de programación y un servicio de directorio que permite a los clientes crear aplicaciones portátiles que pueden obtener información de bases de datos mediante convenciones de nomenclatura.

Bibliotecas de idiomas y utilidades

Con el JRE se incluyen java.lang. y java.util. paquetes que son fundamentales para el diseño de aplicaciones Java, control de versiones, administración y monitoreo de paquetes. Algunos de estos paquetes incluyen:
Collections Framework
Una arquitectura unificada compuesta por una colección de interfaces diseñadas para mejorar el almacenamiento y el proceso de los datos de la aplicación.
Concurrency Utilities
Un paquete de marco potente con utilidades de subprocesamiento de alto rendimiento.
Preferences API
Una API persistente liviana y multiplataforma que permite a varios usuarios en la misma máquina definir su propio grupo de preferencias de aplicaciones.
Logging
Produce informes de registro, como fallas de seguridad, errores de configuración y problemas de rendimiento, para un análisis más detallado.
Java Archive (JAR)
Un formato de archivo independiente de la plataforma que permite agrupar varios archivos en formato JAR, lo que mejora significativamente la velocidad de descarga y reduce el tamaño del archivo.

Soluciones relacionadas

Desarrolle y modernice aplicaciones
Proporcione las habilidades y herramientas que su equipo necesita para impulsar la innovación y hacer avanzar su negocio.
Explore la creación y modernización de aplicaciones

OpenJDK e IBM Runtimes for Business
IBM Runtimes for Business proporciona soporte para entornos de tiempo de ejecución Java de código abierto, además de supervisión y gestión para aplicaciones Java.
Explore OpenJDK e IBM Runtimes for Business

IBM® WebSphere Hybrid Edition
Descubra cómo impulsar el desarrollo nativo de la nube, la modernización de aplicaciones y el soporte para aplicaciones existentes con WebSphere® Hybrid Edition.
Explore IBM® WebSphere Hybrid Edition

¿Que es Java?

Descubra por qué Java sigue siendo una plataforma de desarrollo tan popular y cómo acelera los proyectos y admite una amplia variedad de tecnologías emergentes.

¿Qué es Java Spring Boot?

Descubra cómo Java Spring Boot simplifica el desarrollo de aplicaciones web y microservicios con Java Spring Framework.

Para muchas organizaciones, Java sigue siendo una parte vital del desarrollo de aplicaciones y proporciona una base sólida al crear soluciones portátiles y escalables. Explore OpenJDK e IBM Runtimes for Business, que proporcionan soporte comercial confiable y rentable para implementar, supervisar y gestionar aplicaciones Java.
Descubra más acerca de OpenJDK e IBM Runtimes for Business

# data[].attributes.attachment_link.title
¿Qué es JRE (Java Runtime Environment)? | IBM

# data[].attributes.attachment_link.description
JRE es una capa de software que se ejecuta sobre el software del sistema operativo de una computadora y proporciona los recursos que un programa Java necesita.

# data[].attributes.body
Un entorno de desarrollo integrado (IDE) es un sistema de software para el diseño de aplicaciones que combina herramientas del desarrollador comunes en una sola interfaz gráfica de usuario (GUI)

# data[].attributes.body
IntelliJ IDEA es un entorno de programación especial o entorno de desarrollo integrado (IDE) destinado principalmente a Java. Este entorno se utiliza especialmente para el desarrollo de programas. Es desarrollado por una compañía llamada JetBrains, que se llamó formalmente IntelliJ.

# data[].attributes.attachment_link.title
¿Qué es la idea intellij? - definición de techopedia - Desarrollo 2023

# data[].attributes.attachment_link.description
IntelliJ IDEA es un entorno de programación especial o entorno de desarrollo integrado (IDE) destinado principalmente a Java. Este entorno se utiliza especialmente para el desarrollo de programas. Es desarrollado por una compañía llamada JetBrains, que se llamó formalmente IntelliJ. Está disponible…

# data[].attributes.body
Las APIs, o Interfaces de Programación de Aplicaciones, ofrecen un método para que diferentes programas de software se comuniquen entre sí, permitiendo que diferentes aplicaciones compartan datos y funcionalidad, lo que las hace trabajar juntas de manera fluida.

# data[].attributes.attachment_link.title
Interfaces de Programación de Aplicaciones (API) | Interactive Chaos

# data[].attributes.attachment_link.description
Las APIs, o Interfaces de Programación de Aplicaciones, ofrecen un método para que diferentes programas de software se comuniquen entre sí, permitiendo que diferentes aplicaciones compartan datos y funcionalidad, lo que las hace trabajar juntas de manera fluida.

# data[].attributes.body
Las excepciones son situaciones anómalas que pueden ocurrir durante la ejecución de las aplicaciones, como por ejemplo, acceder a un posición de un vector fuera rango.

# data[].attributes.attachment_link.readable_text
Las excepciones son situaciones anómalas que pueden ocurrir durante la ejecución de las aplicaciones, como por ejemplo, acceder a un posición de un vector fuera rango.

En algunos casos las excepciones no se podrán gestionar, por ejemplo los de la propia JVM, y en otros casos sí.

Java proporciona un mecanismo de gestión de excepciones en los casos en los que estemos obligados a gestionarlas. En caso de que no queramos gestionar algún tipo de excepción estaremos obligados a indicarlo explícitamente. No podremos compilar el código a menos que gestionemos la excepción, o indiquemos explícitamente que no lo queremos hacer.

La definición de excepciones propias se hace a través del mecanismo de extensión de clases, la Herencia.

1. Big Java Secciones 10.3 1 10.8.

2. El lenguaje de programación Java Capítulo 8.

3. Desarrollo de proyectos informáticos con tecnología Java Capítulo 5.

1. Que es una excepción.

2. Tipos de excepciones.

3. Cómo se gestiona una excepción.

4. Creación de excepciones propias.

5. Pruebas unitarias sobre excepciones.

6. Resumen.

El siguiente ejemplo de código muestra un caso muy común de excepción:

int[] array = new int[10];
System.out.println(array[10]);

Estamos intentando acceder a una posición fuera del rango del array.

FileReader fichero = new FileReader("este fichero no existe");

Las excepciones, como todo en Java durante la ejecución de nuestras aplicaciones, son instancias de clases concretas.

Java nos informa de que algo ha ido mal porque recibimos un objeto de una clase que representa un determinado error.

int[] array = new int[10];
System.out.println(array[10]);

Para informarnos del error anterior, Java nos hace llegar una instancia de la clase ArrayIndexOutOfBoundsException.

FileReader fichero = new FileReader("este fichero no existe");

Java representa las excepciones como clases. Existe una jerarquía de clases que representan errores en Java.

Excepciones irrecuperables: Hijas deError. Son errores de la propia máquina virtual de Java.

Excepciones que NO es necesario gestionar: Hijas deRunTimeException. Son excepciones muy comunes, por ejemploNullPointerException,ArrayIndexOutOfBoundsException.

Excepciones que es necesario gestionar: Hijas deException. Todas las demás, por ejemploIOException.

Java proporciona un mecanismo para la gestión de excepciones: los bloques try...catch[...finally]

try{
    FileReader fichero = new FileReader("nombre del fichero");
} catch (FileNotFoundException e) {
    e.printStackTrace();
}

Como ves, el bloque finally es opcional.

Un buen estilo de programación implica cerrar los ficheros una vez que hemos acabado de trabajar con ellos.

FileReader fichero = null;
try{
    fichero = new FileReader("nombre del fichero");
} catch (FileNotFoundException e) {
    e.printStackTrace();
} finally {
    if(fichero != null) fichero.close();
}

Pero, el método close() también puede producir un error de tipo IOException, luego me exige un nuevo bloque try...catch.

Lo podemos escribir del siguiente modo:

FileReader fichero = null;
try{
    fichero = new FileReader("nombre del fichero");
} catch (FileNotFoundException e) {
    e.printStackTrace();
} finally {
    try {
        if(fichero != null)fichero.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

El bloque anterior de código es bastante obtuso.

El truco es el siguiente:

try {
try { fichero = new FileReader("Hola"); } finally { fichero.close(); } } catch(FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }

Además, fíjate en el orden de los catch:

try {
    try {
        fichero = new FileReader("Hola");
    } finally {
        fichero.close();
    }
} catch(FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }

FileNotFoundException es hija de IOException.

¿Funcionaría igual si cambiamos el orden?

¿Y si no queremos gestionar una excepción en el lugar donde se produce?

void metodo() throws IOException { try { try { fichero = new FileReader("Hola"); } finally { fichero.close(); } } catch(FileNotFoundException e) { e.printStackTrace(); } }

Usamos la palabra reservada throws indicando cual es la excepción que no gestionamos.

Desde Java 7, podemos listar varias opciones dentro del mismo bloque catch(...), y si existe relación padre-hija entre ellas, basta con indicar el padre.

try {
    try {
        fichero = new FileReader("Hola");
    } finally {
        fichero.close();
    }
} catch (IOException e) { e.printStackTrace(); }

La gestión de errores es más sucinta.

También, desde Java 7 se puede utilizar recursos en los bloques try...catch

try(FileWriter fw = new FileWriter("src/main/resources/adios.txt")) {
    fw.write("Adios");
} catch (IOException e) {
    e.printStackTrace();
}

No me preocupo de cerrar el fichero, ya que FileWriter, por herencia, implementa el interface Closeable cuyo único método es close() y lo invoca automáticamente la máquina virtual.

Podemos decir que un método tiene dos puntos de salida, el usual si no se genera ninguna excepción durante su ejecución, o devolver una excepción en el punto en que esta se produzca, si es que no la gestionamos dentro del método.

int metodo() throws IOException {
    ....
}

Este método puede devolver un entero o una excepción.

Joshua Bloch. Effective Java. Capítulo 8.

Si estamos creando nuestro propio API, puede que existan casos excepcionales en los que nos interese lanzar una excepción que describe un error al utilizar nuestro API.

Java nos permite definir nuestras propias excepciones, una vez definidas, su gestión es la misma que para el resto de excepciones, los bloques try...catch.

Los pasos son:

1. Definir una clase que represente a nuestra excepción.

2. Lanzarla en las situaciones de error.

3. Gestionarla en la clase cliente como cualquier otra excepción.

Para definir una excepción basta con crear una clase hija de Exception:

public class TemperaturaNoValidaException extends Exception { public TemperaturaNoValidaException() { super("La temperatura no puede ser inferior a -273º Celsius"); } }

El texto de la excepción se puede recuperar con el método getMessage() definido en la clase Throwable.

El siguiente paso es "lanzar" una instancia de la clase anterior cuando se produzca una situación anómala en nuestro API.

public class Conversor {
    public double celsiusAFharenheit(float celsius)
        throws TemperaturaNoValidaException {
if(celsius < -273) throw new TemperaturaNoValidaException(); return 9.0/5.0*celsius + 32; } }

En este caso, ninguna temperatura puede ser inferior al cero absoluto.

Finalmente, la clase cliente estará obligada a gestionar la posible excepción:

Conversor conversor = new Conversor();
try {
    conversor.celsiusAFharenheit(-300);
} catch (TemperaturaNoValidaException e) {
    e.printStackTrace();
}

Lo que veremos por consola será:

conversor.TemperaturaNoValidaException: La temperatura no puede
ser inferior a -273º Celsius
    at conversor.Conversor.celsiusAFharenheit(Conversor.java:6)
    at temperatura.Principal.main(Principal.java:10)

Si queremos dar más información en el error, podemos definir un nuevo constructor:

public class TemperaturaNoValidaException extends Exception {
    public TemperaturaNoValidaException() {
        super("La temperatura no puede ser inferior a -273º Celsius");
    }

    public TemperaturaNoValidaException(double temperaturaActual) {
        super("La temperatura no puede ser inferior a -273º Celsius " +
                "la actual es " + temperaturaActual);
    }
}

Y cuando lanzamos la excepción proporcionamos el valor de la temperatura errónea:

public class Conversor {
    public double celsiusAFharenheit(float celsius)
        throws TemperaturaNoValidaException {
if(celsius < -273) throw new TemperaturaNoValidaException(celsius); return 9.0/5.0*celsius + 32; } }

La gestión de la excepción sigue siendo la misma:

Conversor conversor = new Conversor();
try {
    conversor.celsiusAFharenheit(-300);
} catch (TemperaturaNoValidaException e) {
    e.printStackTrace();
}

Y la información de la excepción más detallada:

conversor.TemperaturaNoValidaException: La temperatura no puede
ser inferior a -273º Celsius la actual es -300.0
    at conversor.Conversor.celsiusAFharenheit(Conversor.java:11)
    at temperatura.Principal.main(Principal.java:10)

Aunque hemos visto con detalle cómo crear nuestras propias excepciones, no abuses de ello, siempre es mejor buscar alguna excepción ya predefinida y pasarle un mensaje descriptivo de lo que ha ido mal.

En el caso de la temperatura no valida, podemos utilizar la clase ya definida en el API de Java IllegalArgumentException y lanzar una instancia de esta clase.

public class Conversor {
    public double celsiusAFharenheit(float celsius)
    throws IllegalArgumentException {
        if(celsius < -273) throw new
            IllegalArgumentException("La temperatura no puede " +
            "ser inferior a -273º Celsius la actual es " + celsius);
        return 9.0/5.0*celsius + 32;
    }
}

En JUnit 5 disponemos de un nuevo modo de probar que se producen excepciones, distinto de JUnit 4.

@Test
public void test() {
    Conversor conversor = new Conversor();
    assertThrows(TemperaturaNoValidaException.class,
        () -> conversor.celsiusAFharenheit(-300));
}

Pero ten en cuenta que cualquier otra excepción hija de TemperaturaNoValidaException también pasará el test.

La excepciones son situaciones anómalas que se pueden dar durante la ejecución de nuestras aplicaciones.

En el API de Java existen tres tipos de excepciones: las de la máquina virtual, las que no necesitamos gestionar, y las que estamos obligados a gestionar.

Para el último caso Java proporciona un mecanismo bien definido, los bloques try...catch[...finally].

Nosotros también podemos definir nuestras propias excepciones extendiendo a la clase adecuada, y el mecanismo para gestionarlas es el mismo que con las del API de Java.

Finalmente, no debes olvidar hacer las pruebas unitarias para tus excepciones.

# data[].attributes.attachment_link.description
Las excepciones son situaciones anómalas que pueden ocurrir durante la ejecución de las aplicaciones, como por ejemplo, acceder a un posición de un vector fuera rango. En algunos casos las excepciones no se podrán gestionar, por ejemplo los de la propia JVM, y en otros casos sí.

# data[].attributes.body
En la programación orientada a objetos, POO para abreviar, la herencia se usa, entre otras cosas, para desarrollar una nueva clase como una extensión de las clases existentes. La clase existente se conoce como la clase base o superclase.

# data[].attributes.attachment_link.readable_text
En la programación orientada a objetos, POO para abreviar, la herencia se usa, entre otras cosas, para desarrollar una nueva clase como una extensión de las clases existentes. La clase existente se conoce como la clase base o superclase. La nueva clase heredada se llama subclase.

En la programación orientada a objetos y el desarrollo de aplicaciones, la herencia debe entenderse como un procedimiento en el que una clase, miembros de otra clase, se hace cargo. Las propiedades transferidas incluyen atributos, métodos y eventos.

En el caso de la herencia, una nueva clase o subclase se desarrolla como una extensión de una o más clases existentes (superclases). Por tanto, el objetivo de la herencia es reutilizar las propiedades de clase de nivel superior.

Con el procedimiento de herencia, es posible definir y definir los atributos, métodos y eventos comunes a varias clases en un punto central. Las propiedades de una clase que ya se han definido no deberían tener que redefinirse. Esto es especialmente cierto cuando las clases ya son muy similares.

Estructura de funcionalidad y herencia

Básicamente, hay dos clases involucradas en la herencia, para las cuales hay varios nombres. La clase heredada también se conoce como superclase o clase padre. La clase heredera conoce los nombres de clase derivada, subclase o clase hija. En la estructura de herencia, las subclases pueden ser a su vez superclases para otras clases derivadas en sentido descendente.

La jerarquía de herencia resultante también se denomina jerarquía de clases. Se puede representar visualmente en una estructura en forma de árbol conocida como herencia o diagrama de clases. La herencia múltiple es un caso especial de herencia. En tal caso, las clases tienen varias clases principales.

Por lo general, la herencia se usa de tal manera que las subclases formadas tienen habilidades más específicas que sus respectivas clases principales. Por lo tanto, derivar una clase es un proceso también conocido como especialización. La clase superior contiene propiedades y capacidades que pueden ser utilizadas por todas las subclases. Sobre la base de esto, las subclases se especializan en habilidades adicionales.

Cada clase derivada puede ser una superclase de otras subclases, cada una de las cuales tiene su propia especialización. Algunos lenguajes de programación prevén excepciones en esta estructura de herencia que impiden derivaciones posteriores. En este caso estamos hablando del final de la jerarquía de clases.

Diferencias y demarcación

Debe hacerse una distinción básica entre herencia única y múltiple. La herencia única estipula que cada clase tiene exactamente una superclase. En el caso de herencia múltiple, son posibles varias superclases por subclase.

La herencia múltiple no suele estar prevista en lenguajes de programación más modernos como Java o C # (C-Sharp). Esto tiene que ver con el hecho de que el beneficio de la herencia múltiple suele ser menor que el de los problemas asociados. Un lenguaje de programación que brinda soporte para herencia múltiple es C ++.

La herencia repetida es el proceso de heredar las mismas características varias veces en función de una clase padre múltiple. Las propiedades de una superclase múltiple también pueden estar presentes varias veces en las clases derivadas, según la semántica de la herencia. El uso múltiple resultante de los nombres de las propiedades de las superclases y subclases puede dar lugar a conflictos con la herencia repetida.

Casos de uso de herencia en desarrollo

En el desarrollo de aplicaciones, la herencia permite el modelado que debería acercarse lo más posible a la imaginación humana. La estructura de herencia conoce diferentes escenarios de aplicación.

Un caso común de herencia es la herencia de subtipos. La clase derivada es un subtipo de la superclase. Es un tipo de datos abstracto en el que un objeto del subtipo se puede utilizar básicamente en cualquier punto donde se espera un objeto del tipo básico. El conjunto de características del subtipo derivado es un subconjunto del conjunto de características del tipo básico.

Otro caso de herencia es el apoyo de habilidades básicas generales. En términos puramente formales, es un caso especial de herencia de subtipo. Se trata de establecer el soporte de las funcionalidades básicas de la biblioteca de clases o la arquitectura de la aplicación. Las funcionalidades como la comparabilidad (identificador "Comparable") o la serializabilidad (identificador "Serializable") son declaradas por una clase o interfaz abstracta. La implementación de los requisitos de la interfaz tiene lugar en la clase derivada.

Implementaciones estándar

Las estructuras de herencia también pueden referirse a implementaciones estándar. Se trata de la implementación de funcionalidades generales en clases centrales. Estas funcionalidades se pueden utilizar para varios tipos y se utilizan para la reutilización pragmática de componentes generales del programa.

Otro caso de uso es la herencia para expandir funciones. Aquí, se agregan nuevas funcionalidades en la subclase, que complementan las funciones básicas de la superclase. La extensión incluye atributos adicionales. Esta variante de herencia también implica adaptaciones mediante métodos de sobrescritura. De esta manera, se pueden agregar o complementar funcionalidades que no juegan un papel en la superclase.

Esta estructura de herencia también tiene en cuenta el caso de que la funcionalidad de una clase particular se implemente solo parcialmente en la clase derivada. En este caso, la superclase y la clase derivada son clases abstractas. En este caso, las implementaciones adicionales son objeto de más especializaciones.

# data[].attributes.attachment_link.title
¿Qué es la herencia en Poo? | Programación - Tecno Simple

# data[].attributes.attachment_link.description
La herencia en OOP se usa, entre otras cosas, para desarrollar una nueva clase como una extensión de las clases existentes.

# data[].attributes.body
Una subclase, también llamada como clase derivada, puede redefinir cualquier método heredado de su clase padre, siempre que sea necesario que su comportamiento en la subclase sea diferente.
Redefinir un método heredado significa volverlo a escribir en la subclase con el mismo nombre, la misma lista de parámetros y el mismo tipo de valor retornado que tenía en la superclase (clase base); su cuerpo será adaptado a las necesidades de la subclase. Una subclase puede asimismo ser una superclase de otra clase, y así sucesivamente

# data[].attributes.attachment_link.readable_text
Se producía el nacimiento del físico y químico británico Ernest Rutherford ( Spring Grove, Nueva Zelanda, 1871 - Cambridge, 1937).
Se le considera uno de los fundadores de la física nuclear moderna. Investigó sobre radiactividad empleando los mismos métodos que Becquerel y comprobó que las radiaciones del uranio se dividían en tres tipos de partículas bajo la acción de los campos eléctricos: unas positivas de gran masa ( alfa), otras negativas de masa pequeña ( beta) y unas ondas electromagnéticas de alta frecuencia ( gamma).

Google publicaba en su sitio web el primer Doodle, en conmemoración del Burning Man. Luego, el resto de los diseños serían creados por Dennis Hwang, cuyo primer logotipo representaba el Día de la Bastilla.
Por todos los usuarios frecuentes del buscador Google es sabido que, ante ciertos eventos o fechas significativas, este cambia su logo tradicional exponiendo en su lugar otro que sirve de recuerdo u homenaje del evento en cuestión. Detrás del trabajo de diseño gráfico de estos logos, conocidos como Doodles de Google, se encuentra Dennis Hwang, que comenzó su andadura en la compañía en el año 2000 como webmaster, y cuyas dos grandes pasiones son, según él, la tecnología y el arte.

# data[].attributes.attachment_link.title
Glosario informático - Definición de términos informáticos

# data[].attributes.attachment_link.description
Glosario de Informática e Internet. Diccionario tecnológico. Términos informáticos divididos por categoría. Redes, Informática, Base de Datos, Programación, Multimedia. Glosario actualizado.

# data[].attributes.body
consiste en instanciar en una clase base algún(os) método(s) los cuales serán sobreescritos en la(s) clase(s) derivadas (derivación inmediata o no) con el mismo nombre del método usado en la clase base, de esta forma el método llamado dependerá del tipo del objeto que llame al método (el cual es llamado IGUAL y recibe LOS MISMOS PARÁMETROS y DEL MISMO TIPO), es importante resaltar que estos métodos sobreescritos pertenecen a la interfaz de ambas clases y el método en la clase derivada sobreescribe al de la clase base.

# data[].attributes.attachment_link.readable_text
El término sobre escritura de funciones o métodos es comúnmente usado en la herencia de la POO, consiste en instanciar en una clase base algún(os) método(s) los cuales serán sobreescritos en la(s) clase(s) derivadas (derivación inmediata o no) con el mismo nombre del método usado en la clase base, de esta forma el método llamado dependerá del tipo del objeto que llame al método (el cual es llamado IGUAL y recibe LOS MISMOS PARÁMETROS y DEL MISMO TIPO), es importante resaltar que estos métodos sobreescritos pertenecen a la interfaz de ambas clases y el método en la clase derivada sobreescribe al de la clase base.

class Punto
{
//..... atributos y otros métodos miembros
public:
void imprimir(){cout<<"llamada a clase base punto "} //método imprimir //clase base
};

class circulo : public Punto //clase circulo hereda de Punto
{
//..... atributos y otros métodos miembros
public:
void imprimir(){cout<<"llamada a clase derivada circulo "}
//método sobreescrito en clase derivada
};

Se observa que en la clase derivada circulo el método imprimir se escribe igual que en su clase base recibe el mismo numero y tipo de parámetros y retorna lo mismo por lo tanto en la clase derivada se esta sobreescribiendo la implementación de la función imprimir de la clase base si en el programa principal.

Una subclase hereda todos los métodos de su superclase que son accesibles a dicha subclase a menos que la subclase sobreescriba los métodos.

Una subclase sobreescribe un método de su superclase cuando define un método con las mismas características ( nombre, número y tipo de argumentos) que el método de la superclase.

Las subclases emplean la sobreescritura de métodos la mayoría de las veces para agregar o modificar la funcionalidad del método heredado de la clase padre.

# data[].attributes.attachment_link.description
El término sobre escritura de funciones o métodos es comúnmente usado en la herencia de la POO, consiste en instanciar en una clase base algún(os) método(s) los cuales serán sobreescritos en la(s) clase(s) derivadas (derivación inmediata o no) con el mismo nombre del método usado en la clase base, d…

# data[].attributes.body
La sobrecarga de Métodos se apoya de métodos y constructores, los destructores no se pueden sobrecargar ya que sólo debe haber uno por clase.

La sobrecarga de métodos hace que un mismo nombre pueda representar distintos métodos con distinto tipo y número de parámetros, manejados dentro de la misma clase. En el ámbito de la POO, la sobrecarga de métodos se refiere a la posibilidad de tener dos o más métodos con el mismo nombre pero distinta funcionalidad.

# data[].attributes.body
El método de programación orientada a objetos (POO) consiste en la creación de objetos que interactúan entre sí para realizar operaciones y resolver problemas. En la POO se modela el mundo real a través de la definición de objetos, los cuales poseen propiedades (atributos) y comportamientos (métodos).

Los objetos son instancias de una clase y una clase es una plantilla que define la estructura y el comportamiento de un objeto. Cada objeto tiene un estado (valor de sus atributos) y un comportamiento (acciones que realiza por medio de sus métodos), y puede interactuar con otros objetos mediante el intercambio de mensajes.

# data[].attributes.attachment_link.title
Qué es una instancia de clase en Java y cómo crearla

# data[].attributes.attachment_link.description
Descubre qué es una instancia de clase en Java en el contexto de la programación orientada a objetos.

# data[].attributes.body
Lo que debes saber en primer lugar es que el método main() es el punto de entrada de la aplicación, es decir, es el punto en el que comienza la ejecución de esta. Es por ello que ha de ser public y static.
Ha de ser público y estático.

public: Un método público es accesible desde fuera de la clase.

static: Un método estático es aquel que se puede ejecutar sin una instancia de la clase.

Al ser el punto de entrada, ha de ser accesible desde fuera de la clase en la que se encuentra. Además, al ser lo primero que se ejecuta, ha de ser posible su ejecución antes de instanciar un objeto.

Además, ha de tener un tipo de devolución void.

Como consecuencia directa de ser la primera línea de código que se ejecuta, no tiene sentido que tenga un tipo de devolución distinto de void, ya que no hay un código anterior que pueda hacer algo con ese valor. El método main() en Java siempre tiene un tipo de devolución void.

El método main() ha de llamarse main, en minúscula. A la hora de ejecutar el código, el entorno de ejecución de Java (JRE) busca el punto de entrada predeterminado. El JRE solo sabe que es un método llamado main. Si no lo encuentra, no puede acceder. Es por ello que puedes considerar main como una palabra clave de acceso. Si la cambias, tu aplicación no se ejecutará.

El método main() acepta un parámetro (y solo uno): una matriz de tipo String. Esta matriz recoge los valores que introduzcas a la hora de ejecutar tu aplicación desde la línea de comandos. Da igual el valor que introduzcas; el JRE lo transformará a String.

El método main() no se ejecutará cuando no respete las reglas que te he enunciado. Si ves que el método es private en lugar de public, si le falta ser static, si se llama Main, si el parámetro es String en lugar de String[]... Asegúrate de que el método main() sigue las reglas.

public static vs. static public

Las palabras clave public y static son intercambiables, de manera que pueden aparecer en cualquier orden.

El método main() puede ser final y, junto con public y static, puede aparecer en cualquier orden.

# data[].attributes.attachment_link.readable_text
Este es el primer artículo en el que voy a tratar dificultades del examen de certificación OCAJ8P. En este en concreto, te voy a explicar en qué consiste el método main() en Java y, lo que es más importante, te voy a señalar las variantes válidas que existen de este método.

¿Qué vas a aprender en este artículo?

¿Por qué es importante hilar tan fino?

Sí, ya sé que es probable que en el 99% de ocasiones en las que te encuentres este método lo vas a ver tal y como aparece en el gif, pero el examen de certificación de Oracle tiende a poner trampas en las que puede caer cualquiera. ¿Y sabes por qué? Porque a menudo el examen parece que te está preguntando sobre una cosa, pero en realidad el problema está en otra parte. Por ejemplo, imagínate que tienes ante ti unas cuantas líneas de código, con unas cuantas lambdas. Miras y remiras las lambdas y llegas a la conclusión, correcta, de que no hay ningún error. Y de ahí deduces que el código funciona a la perfección.

Pues no, resulta que el código compila pero no se ejecuta porque el método m ain() en Java no se puede llamar Main():

En este caso se ve muy claro, pero en el examen estás demasiado nervioso, y demasiado centrado en las lambdas, como para fijarte.

Estructura del método main() en Java

Lo que debes saber en primer lugar es que el método main() es el punto de entrada de la aplicación, es decir, es el punto en el que comienza la ejecución de esta. Es por ello que ha de ser public y static.

Ha de ser público y estático

public: Un método público es accesible desde fuera de la clase.

static: Un método estático es aquel que se puede ejecutar sin una instancia de la clase.

Al ser el punto de entrada, ha de ser accesible desde fuera de la clase en la que se encuentra. Además, al ser lo primero que se ejecuta, ha de ser posible su ejecución antes de instanciar un objeto.

Además, ha de tener un tipo de devolución void

Como consecuencia directa de ser la primera línea de código que se ejecuta, no tiene sentido que tenga un tipo de devolución distinto de void, ya que no hay un código anterior que pueda hacer algo con ese valor. El método main() en Java siempre tiene un tipo de devolución void.

A continuación, ha de llamarse main(), en minúscula

El método main() ha de llamarse main, en minúscula. A la hora de ejecutar el código, el entorno de ejecución de Java ( JRE) busca el punto de entrada predeterminado. El JRE solo sabe que es un método llamado main. Si no lo encuentra, no puede acceder. Es por ello que puedes considerar main como una palabra clave de acceso. Si la cambias, tu aplicación no se ejecutará.

Por último, ha de aceptar un único parámetro: una matriz String[]

El método main() acepta un parámetro (y solo uno): una matriz de tipo String. Esta matriz recoge los valores que introduzcas a la hora de ejecutar tu aplicación desde la línea de comandos. Da igual el valor que introduzcas; el JRE lo transformará a String.

Hasta aquí, he explicado el mínimo básico que tienes que saber sobre el método main() en Java. No obstante, existe una serie de momentos a los que tienes que prestar atención. El método main() tiene variantes correctas, que se ejecutan perfectamente, y variantes que no van a ejecutarse.

Cuando NO va a compilar el método main() en Java

Antes de seguir, ten en cuenta que el método main() no compila solo en dos casos:

Cuando contiene un error de sintaxis (no cerrar el paréntesis, por ejemplo).

Cuando la devolución no es void pero no hay un return dentro del metodo.

Este último tiene truco, ya que si tiene el return va a compilar, pero va a provocar un error de tiempo de ejecución ( Runtime error) en la línea 7.

​​​​​Cuándo NO se va a ejecutar el método main() en Java

Como puedes deducir de lo que has leído más arriba, el método main() no se ejecutará cuando no respete las reglas que te he enunciado. Si ves que el método es private en lugar de public, si le falta ser static, si se llama Main, si el parámetro es String en lugar de String[]... Asegúrate de que el método main() sigue las reglas.

Cuando SÍ se va a ejecutar el método main() en Java

Aparte de la forma predeterminada en la que suele aparecer y que te he mostrado al inicio de este artículo, hay varias "variantes" del método main() que son totalmente válidas y que pueden aparecer en el examen de certificación.

Las palabras clave public y static son intercambiables, de manera que pueden aparecer en cualquier orden.

El método main() puede ser final y, junto con public y static, puede aparecer en cualquier orden.

El parámetro de main() no tiene que ser necesariamente una matriz String[], también puede ser String...

Recuerda, también, que una matriz se puede declarar tanto así:

Esto también se aplica al parámetro de main().

El parámetro puede recibir cualquier nombre

El parámetro se llama args de manera predeterminada, pero el método main() se va a ejecutar sin problema independientemente del nombre del parámetro. Tú en tu código llámalo siempre args, pero en el examen espera encontrarte cualquier cosa.

Ejercicios

Crea una aplicación sencilla que imprima la matriz args y ejecútala primero con los parámetros: "hola me" "llamo", luego con los parámetros "hola, me" "llamo" y, por último, con los parámetros hola, me" "llamo". ¿Qué diferencia hay en el resultado? ¿Por qué?

¿Qué pasa si ejecutas la aplicación anterior sin parámetros? ¿Tiene args valor null?

# data[].attributes.attachment_link.title
Cómo funciona el método main() en Java - OCAJ8P

# data[].attributes.attachment_link.description
El método main() es el punto en el que comienza la ejecución de una aplicación Java. Aprende cómo funciona el método main() en Java y sus variantes válidas.

# data[].attributes.body
Las instancias son la materialización de una clase, es decir, son objetos concretos que tienen su propio estado (los valores de sus atributos) y su propio comportamiento (los métodos que pueden ejecutar).

# data[].attributes.attachment_link.title
Qué es una instancia de clase en Java y cómo crearla

# data[].attributes.attachment_link.description
Descubre qué es una instancia de clase en Java en el contexto de la programación orientada a objetos.

# data[].attributes.body
Un constructor sirve para inicializar el objeto y establecer sus propiedades y valores predeterminados. Tiene el mismo nombre que la clase y no cuenta con ningún valor de retorno, ya que su función principal es inicializar el objeto y no devolver ningún valor.

Además, un constructor puede aceptar argumentos, lo que permite configurar el objeto con valores específicos al momento de su creación.

Antes de definir un constructor en la programación orientada a objetos, es necesario definir la clase que contiene el constructor. La clase es el «molde» a partir del cual se crearán los objetos, y es en la definición de la clase donde se establecen las propiedades y los métodos que los objetos podrán utilizar.

Una vez que se ha definido la clase, se puede determinar el constructor. Debe tener el mismo nombre que la clase y se define dentro de la clase. El constructor puede tener parámetros si se desea que los objetos tengan valores iniciales específicos al ser creados.

Un constructor en Java tiene el mismo nombre que la clase a la que pertenece, y no posee un tipo de retorno explícito, lo que significa que no se utiliza la palabra clave void ni ningún otro tipo de datos para especificar el valor de retorno del constructor.

Un constructor puede tener parámetros, mismos que se utilizan para proporcionar valores iniciales a los campos de datos de la clase. Estos parámetros se especifican en la definición del constructor, entre los paréntesis.

El constructor predeterminado lo proporciona automáticamente Java en caso de que no se defina ningún constructor explícitamente en la clase. Este constructor no toma ningún parámetro y su cuerpo está vacío.

Simplemente inicializa los miembros de datos de la clase con sus valores predeterminados. Si un programador desea proporcionar una implementación personalizada para el constructor predeterminado, debe definir un constructor explícito en la clase y proporcionar el cuerpo del constructor.

El constructor parametrizado toma uno o más parámetros y se utiliza para inicializar los miembros de datos de la clase con valores específicos proporcionados por el usuario. Un constructor parametrizado debe definirse explícitamente en la clase y se utiliza para crear objetos con diferentes estados y comportamientos, en función de los valores proporcionados en los parámetros.

# data[].attributes.attachment_link.readable_text
Ya hemos visto las ventajas que tiene Java como un lenguaje de programación orientado a objetos, donde uno de los conceptos fundamentales son los constructores.

Por ello, aquí exploraremos todo lo básico acerca de qué es un constructor en Java, cómo puedes implementarlo y sus tipos. ¡Comencemos!

Qué es un constructor en Java

En la programación orientada a objetos (y en Java), un constructor es un método especial que se utiliza para inicializar un objeto recién creado y asignarle valores iniciales a sus variables de instancia.

En otras palabras, un constructor es una función que se ejecuta automáticamente cuando se crea un objeto de una clase específica.

Para qué sirve un constructor en Java

Un constructor sirve para inicializar el objeto y establecer sus propiedades y valores predeterminados. Tiene el mismo nombre que la clase y no cuenta con ningún valor de retorno, ya que su función principal es inicializar el objeto y no devolver ningún valor.

Además, un constructor puede aceptar argumentos, lo que permite configurar el objeto con valores específicos al momento de su creación.

Antes de definir un constructor en la programación orientada a objetos, es necesario definir la clase que contiene el constructor. La clase es el "molde" a partir del cual se crearán los objetos, y es en la definición de la clase donde se establecen las propiedades y los métodos que los objetos podrán utilizar.

Una vez que se ha definido la clase, se puede determinar el constructor. Debe tener el mismo nombre que la clase y se define dentro de la clase. El constructor puede tener parámetros si se desea que los objetos tengan valores iniciales específicos al ser creados.

Cómo se implementan los constructores en Java

Un constructor en Java tiene el mismo nombre que la clase a la que pertenece, y no posee un tipo de retorno explícito, lo que significa que no se utiliza la palabra clave void ni ningún otro tipo de datos para especificar el valor de retorno del constructor.

Un constructor puede tener parámetros, mismos que se utilizan para proporcionar valores iniciales a los campos de datos de la clase. Estos parámetros se especifican en la definición del constructor, entre los paréntesis.

Por ejemplo, supongamos que tenemos una clase Persona con los campos nombre y edad. Podemos definir un constructor para la clase Persona:

En este ejemplo, el constructor Persona toma dos parámetros (nombre y edad) y utiliza la palabra clave "this" para referirse a los campos nombre y edad de la clase.

Cuando creamos un objeto de la clase Persona, podemos proporcionar los valores iniciales para los campos nombre y edad utilizando el constructor:

En este ejemplo, estamos creando un nuevo objeto Persona llamado "persona1", y estamos pasando los valores "Juan" y "25" al constructor para inicializar los campos nombre y edad del objeto.

Tipos de constructores en Java

En Java hay dos diferentes tipos de constructores que pueden utilizarse dependiendo de las necesidades de la clase y de los objetos que se van a crear.

Constructor predeterminado (default constructor)

El constructor predeterminado lo proporciona automáticamente Java en caso de que no se defina ningún constructor explícitamente en la clase. Este constructor no toma ningún parámetro y su cuerpo está vacío.

Simplemente inicializa los miembros de datos de la clase con sus valores predeterminados. Si un programador desea proporcionar una implementación personalizada para el constructor predeterminado, debe definir un constructor explícito en la clase y proporcionar el cuerpo del constructor.

Constructor parametrizado (parameterized constructor)

El constructor parametrizado toma uno o más parámetros y se utiliza para inicializar los miembros de datos de la clase con valores específicos proporcionados por el usuario. Un constructor parametrizado debe definirse explícitamente en la clase y se utiliza para crear objetos con diferentes estados y comportamientos, en función de los valores proporcionados en los parámetros.

Cómo crear un constructor en Java

1. Define la clase en la que deseas crear el constructor

Es importante primero establecer una clase, ya que los constructores son parte de las clases.

2. Define los atributos de la clase

Por ejemplo:

3. Define el constructor en sí

Para hacer esto, escribe el nombre de la clase seguido de paréntesis. Dentro de los paréntesis, escribe los parámetros que deseas pasar al constructor.

4. Asigna los valores de los parámetros

Dentro del cuerpo del constructor, asigna los valores de los parámetros a los atributos correspondientes de la clase.

public Coche(String marca, double kilometraje, String color, String diseño, int anoFabricacion, double precio, String modelo)

{

this.marca = marca;

this.kilometraje = kilometraje;

this.color = color;

this.diseño = diseño;

this.anoFabricacion = anoFabricacion;

this.precio = precio;

this.modelo = modelo;

}

5. Utiliza la clase para construir los objetos

Por ejemplo:

¡Y listo! Ahora que ya exploraste los constructores en este lenguaje, te invitamos a saber más acerca de cómo programar con Java.

# data[].attributes.attachment_link.title
Qué es un constructor en Java, sus tipos y cómo implementarlo

# data[].attributes.attachment_link.description
Conoce qué es un constructor en Java, el proceso para implementarlo y sus tipos, reforzados con ejemplos.

# data[].attributes.body
La abstracción describe el proceso mediante el cual se da forma a una entidad de la realidad tangible para ponerla en un código que maneje pautas basadas en estas características junto con funciones que representen este tipo de clases, la abstracción en concreto es representada dentro del lenguaje de programación Java por medio de atributos, métodos y clases, a través de los cuales se va a dar forma a un código determinado. El modelado de códigos orientados a objetos establece notables características para que a fin de cuentas se haga un código final que logre abstraer un objeto correctamente y eso debe hacerse al ponerlo en perspectiva, es decir teniendo una visión externa del objeto donde se estudia su comportamiento desde fuera para luego poder aplicarlo en un código que lo modele en un objeto.
Llevar a cabo una idea abstracta con el fin de que sea aplicada en un código determinado es importante en el mundo de la Programación Orientada a Objetos.
Entender estas ideas o pensamientos para que luego sean concretadas en algo material, que va a ejercer una función específica y se puede tocar, es la base de todo el asunto de abstracción en Java.
Ésta puede tener distintas caras, porque depende de quién aborda el proyecto y como lo aborda es que se crea un espécimen tangible
La abstracción va ligada a la herencia de forma especial porque juntas van a crear las conexiones necesarias para que se pueda implementar el código, destacando los atributos, las características, la forma, el espacio, las acciones que se van a realizar.

# data[].attributes.attachment_link.readable_text
Abstraccion en Java es obtener las caracteristicas principales

Java es por mucho el lenguaje de programación más popular que tienen a su disposición los programadores de todo el mundo y no es una casualidad que sea el favorito a la hora de programar objetos, sin embargo posee retos a los que los desarrolladores deben hacer frente sobre todo al principio cuando deben aprender conceptos que forman parte de la base con la que se llevan a cabo las numerosas aplicaciones de este lenguaje de programación. Java como código de programación posee una característica llamada la abstraccion en java que es una de las bases no sólo a la hora de programar sino de entenderlo en la mente de quien es el encargado de armar todo el proyecto, por lo que captar la abstraccion en java como concepto establece una pauta en cómo se pueden representar los objetos dentro del código, para entender este código te dejamos este curso de java 100% práctico y presencial.

Proceso Abstracto

La abstracción describe el proceso mediante el cual se da forma a una entidad de la realidad tangible para ponerla en un código que maneje pautas basadas en estas características junto con funciones que representen este tipo de clases, la abstracción en concreto es representada dentro del lenguaje de programación Java por medio de atributos, métodos y clases, a través de los cuales se va a dar forma a un código determinado. El modelado de códigos orientados a objetos establece notables características para que a fin de cuentas se haga un código final que logre abstraer un objeto correctamente y eso debe hacerse al ponerlo en perspectiva, es decir teniendo una visión externa del objeto donde se estudia su comportamiento desde fuera para luego poder aplicarlo en un código que lo modele en un objeto.

Características de la abstracción

Llevar a cabo una idea abstracta con el fin de que sea aplicada en un código determinado es importante en el mundo de la Programación Orientada a Objetos, entender estas ideas o pensamientos para que luego sean concretadas en algo material, que va a ejercer una función específica y se puede tocar, es la base de todo el asunto de abstracción en Java, esta puede tener distintas caras, porque depende de quién aborda el proyecto y como lo aborda es que se crea un espécimen tangible, la abstracción va ligada a la herencia de forma especial porque juntas van a crear las conexiones necesarias para que se pueda implementar el código, destacando los atributos, las características, la forma, el espacio, las acciones que se van a realizar. En Java se puede realizar la abstracción de entidades para representar un modelo de forma útil sobre un ente determinado, las acciones que a su vez desempeñan otras acciones son posibles bajo este concepto y son conocidas como abstracción de acciones, se puede realizar la agrupación de operaciones en máquinas virtuales que van a ser utilizadas en un nivel superior para controlar operaciones, cuando se almacenan un conjunto de operaciones que no se relacionan entre sí se da el caso de la abstracción de conciencia y establece una forma bastante particular a la hora de programar objetos, por lo que se puede decir que Java reconoce notables fuentes de inspiración para lograr códigos funcionales y útiles, para entender y realizar este tipo de códigos te dejamos este curso de java donde te enseñaran paso a paso.

Articulos Relacionados a la tecnología Java

# data[].attributes.attachment_link.description
La abstraccion en Java es un tema complicado de entender, la abstracción es obtener las caracteristicas principales de cualquier objeto real.

# data[].attributes.body
Permite que diferentes objetos respondan de manera diferente a un mismo mensaje. El polimorfismo da la posibilidad de que los objetos puedan ser tratados como si fueran de una clase más general, lo que hace que el código sea más flexible y escalable.

# data[].attributes.attachment_link.title
Qué es una instancia de clase en Java y cómo crearla

# data[].attributes.attachment_link.description
Descubre qué es una instancia de clase en Java en el contexto de la programación orientada a objetos.

# data[].attributes.body
La herencia es una forma de estructurar el software. Mediante la herencia podemos indicar que una clase hereda de otra. Es decir la clase extiende las capacidades (propiedades y métodos) que tenga y añade nuevas propiedades y acciones.

Digamos que las nuevas clases especializan más aquellas clases de las que heredan al añadir nueva funcionalidad. Aunque también pueden reescribir el funcionamiento de dichos elementos.

# data[].attributes.attachment_link.readable_text
Si estás empezando con el lenguaje Java hay una serie de conceptos básicos Java de la orientación a objetos que debes de manejar para poder desarrollar con este lenguaje.

Aquí los vamos a ver por encima y dedicaremos un capítulo entero a ellos entrando en detalle sobre todas sus características

Objeto

Es un elemento de software que intenta representar un objeto del mundo real. De esta forma un objeto tendrá sus propiedades y acciones a realizar con el objeto. Estas propiedades y acciones están encapsuladas dentro del objeto, cumpliendo así los principios de encapsulamiento.

El paradigma de la orientación a objetos aparece como contraste a la programación estructurada que se venía utilizando desde los años 60.

Un objeto tiene su estado (o estados) y su comportamiento. Esto se modela mediante propiedades (o variables) y métodos. Incluso un objeto puede contener a su vez a otro tipo de objeto.

Encapsulación de datos

Las interacciones con los objetos se hacen mediante los métodos. Es decir, si queremos conocer información del estado del objeto deberemos de llamar a uno de sus métodos y no directamente a las propiedades.

Esta encapsulación nos permitiría el cambiar las propiedades del objeto sin que los consumidores se vean afectados siempre y cuando les sigamos retornando el mismo resultado.

Si bien hay objetos que tienen propiedades públicas, por lo cual podremos acceder directamente a dichas propiedades sin necesidad de utilizar un método.

El uso de objetos nos proporciona los siguientes beneficios:

1. Modularidad, el objeto y sus propiedades puede ser pasado por diferentes estructuras del código fuente, pero el objeto es el mismo.

2. Encapsular Datos, ocultamos la implementación de propiedades del objeto ya que accederemos a través de los métodos del objeto.

3. Reutilización de Código, podemos tener diferentes instancias de un objeto de tal manera que esas diferentes instancias están compartiendo el mismo código.

4. Reemplazo, podemos reemplazar un objeto por otro siempre y cuando estos objetos tengan el mismo comportamiento.

Ejemplos de objetos

Cualquier concepto del mundo real se puede modelar como un objeto con su estado y comportamiento. Por ejemplo un televisor es un objeto**, cuyos estados pueden ser: *encendida, apagada, en el canal1, en el canal2, grabando,... y sus acciones serán "encender televisor", "apagar televisor", "cambiar de canal", "iniciar la grabación",...

Por ejemplo imaginemos una figura geométrica como podría ser un triángulo. Un triángulo podemos definirlo por varias propiedades como pueden ser: base, altura, el lado y las coordenadas x,y del centro del triángulo. Como métodos de un triángulo podemos "calcular el área del triángulo", "calcular el perímetro del triángulo".

Clase

Las clases representan los prototipos de los objetos que tenemos en el mundo real. Es decir, es una generalización de un conjunto de objetos. A su vez los objetos serán instancias de una determinada clase.

Si volvemos al ejemplo del televisor, existen múltiples tipos de televisores y cada uno con sus características. Si bien existe un esquema o prototipo que define el televisor. Este prototipo es lo que conocemos la clase.

En la clase es dónde realmente definimos las propiedades y métodos que podrán contener cada una de las instancias de los objetos.

Por ejemplo, para nuestro caso de las figuras geométricas podríamos definir un triángulo de la siguiente forma:

De momento no te preocupes por entender el código del todo, pero verás que hemos definido una clase triángulo la cual tiene dos propiedades base y altura. Estas propiedades las hemos definido como "private" lo cual hace que no puedan ser visibles desde fuera.

Luego tenemos lo que se conoce como un método constructor. Es el método que tiene el mismo nombre que la clase: Triangulo () y que nos sirve para inicializar las propiedades desde el exterior.

Además hemos creado un método que nos calcula el área de un triángulo (base x altura / 2). Este método ya es público y podrá ser invocado de forma externa.

Vemos cómo creamos diferentes objetos del tipo Triángulo. A estos objetos los pasamos diferentes valores.

Y por último hemos invocado al método que nos devuelve el área del triángulo del objeto en concreto.

Interface

Un interface es una forma de establecer un contrato entre dos elementos. Un interface indica qué acciones son las que una determinada clase nos va a ofrecer cuando vayamos a utilizarla.

Cuando implementemos un interface (cuando lo usemos) deberemos de implementar todas las acciones (métodos) que este contenga.

Por ejemplo podríamos definir un interface Figura el cual indique qué métodos son obligatorios cuando vayamos a definir una figura. El interface se define mediante la palabra interface.

Dentro del interface definimos los métodos que serán obligatorios. Por ejemplo, que de una figura se pueda calcular su área y calcular su perímetro.

Cuando queramos que una clase implemente un determinado interface deberemos de utilizar el operador implements indicando el nombre del interface a implementar.

Así, si un triángulo queremos que implemente el interface Figura lo definiremos de la siguiente forma:

En este momento la clase Triangulo deberá de implementar los métodos calcular área y calcular perímetro.

Paquete

Un paquete es una forma de organizar elementos de software mediante un espacio de nombres. Así podremos afrontar desarrollos grandes de software facilitando la forma de encontrar o referirnos a un elemento.

Podríamos entender el sistema de paquetes como si fuese un sistema de carpetas. De tal manera que colocaremos cada una de las clases (o ficheros) en un paquete (o directorio).

Los paquetes se definen mediante el modficiador package seguido del nombre del paquete. El paquete lo definiremos en la primera línea de cada una de las clases.

Una definición de paquete podría ser:

El lenguaje Java nos proporciona un conjunto de paquetes por defecto (conocido como API Java) en los que se pueden encontrar múltiples utilidades del lenguaje. Por ejemplo, la clase Java que nos ayuda a manipular las cadenas de texto es la clase String. La clase String la podemos encontrar en el paquete java.lang.

Herencia

La herencia es una forma de estructurar el software. Mediante la herencia podemos indicar que una clase hereda de otra. Es decir la clase extiende las capacidades (propiedades y métodos) que tenga y añade nuevas propiedades y acciones.

Digamos que las nuevas clases especializan más aquellas clases de las que heredan al añadir nueva funcionalidad. Aunque también pueden reescribir el funcionamiento de dichos elementos.

En nuestro ejemplo del triángulo, este podría heredar de una clase polígono.

De igual manera de esta clase general Poligono podrían heredar otras clases que representasen un polígono, por ejemplo las clases Cuadrado, Pentagono,...

La herencia entre clases se indica mediante el operador extends.

La clase superior de la que heredan las figuras puede definir una serie de propiedades y métodos que heredarán las clases hijas y que por ende podrán utilizar.

Por ejemplo, la clase Poligono puede tener una propiedad que sean las longitudes de los lados del polígono y que utilice esas longitudes para calcular el perímetro del polígono.

Cuando ahora indiquemos que la clase Triangulo hereda de la clase Poligono.

Veremos que los objetos instanciados como triángulos tendrán acceso a los métodos del polígono.

En este caso accedemos al método perímetro que heredamos de la clase Polígono.

Una de las cosas que tienes que saber en la herencia es que en el constructor de la clase que hereda (o clase hija) se deberá de llamar al constructor de la clase padre. Para ello se utiliza el método especial super();

# data[].attributes.attachment_link.description
Si estás empezando con el lenguaje Java hay una serie de conceptos básicos Java de la orientación a objetos que debes de manejar para poder desarrollar con este lenguaje.

# data[].attributes.body
Permite ocultar la complejidad interna de un objeto y exponer solo las operaciones necesarias para su uso. Los atributos y métodos de un objeto están protegidos y solo se puede acceder a ellos desde su propia clase.

# data[].attributes.attachment_link.title
Qué es una instancia de clase en Java y cómo crearla

# data[].attributes.attachment_link.description
Descubre qué es una instancia de clase en Java en el contexto de la programación orientada a objetos.