El término Orientado a Objetos explica el concepto de organizar el software como una combinación de diferentes tipos de objetos que incorpora tanto datos como comportamiento. Por lo tanto, la programación orientada a objetos (OOP) es un modelo de programación que simplifica el desarrollo y el mantenimiento del software al proporcionar algunas reglas. Los programas se organizan en torno a objetos en lugar de acción y lógica. Aumenta la flexibilidad y la mantenibilidad del programa. Comprender el funcionamiento del programa se vuelve más fácil, ya que los OOP llevan los datos y su comportamiento (métodos) a una sola ubicación (objetos).
Los conceptos básicos de los OOP son:
- Objeto
- Clase
- Encapsulación
- Herencia
- Polimorfismo
- Abstracción
Este artículo trata sobre Objetos y Clases en Java.
Requerimientos de Clases y Objetos en Programación Orientada a Objetos
Clases: una clase es un plano o prototipo definido por el usuario a partir del cual se crean objetos. Representa el conjunto de propiedades o métodos que son comunes a todos los objetos de un tipo. Se requieren clases en OOP porque:
- Proporciona una plantilla para crear objetos, que pueden vincular código a datos.
- Tiene definiciones de métodos y datos.
- Admite la propiedad de herencia de la programación orientada a objetos y, por lo tanto, puede mantener la jerarquía de clases.
- Ayuda a mantener las especificaciones de acceso de las variables miembro.
Objetos: Es la unidad básica de la Programación Orientada a Objetos y representa las entidades de la vida real.
Las entidades de la vida real comparten dos características: todas tienen atributos y comportamiento.
Un objeto consta de:
- Estado: Está representado por los atributos de un objeto. También muestra las propiedades de un objeto.
- Comportamiento: Se representa mediante métodos de un objeto. Muestra la respuesta de un objeto con otros objetos.
- Identidad: Da un nombre único a un objeto. También otorga permiso a un objeto para interactuar con otros objetos.
Los objetos son necesarios en los OOP porque se pueden crear para llamar a una función no estática que no está presente dentro del método principal pero está presente dentro de la clase y también proporciona el nombre del espacio que se utiliza para almacenar los datos.
Ejemplo: para la suma de dos números, es necesario almacenar los dos números por separado, de modo que se puedan elegir y se puedan realizar las operaciones deseadas en ellos. Por lo tanto, crear dos objetos diferentes para almacenar los dos números será una solución ideal para este escenario.
Ejemplo para demostrar el uso de Objetos y clases en OOPs
Los objetos se relacionan con cosas que se encuentran en el mundo real. Por ejemplo, un programa de gráficos puede tener objetos como «círculo», «cuadrado», «menú». Un sistema de compras en línea puede tener objetos como «carrito de compras», «cliente» y «producto».
Declaración de objetos (también llamada instanciación de una clase)
Cuando se crea un objeto de una clase, se dice que la clase está instanciada . Todas las instancias comparten los atributos y el comportamiento de la clase. Pero los valores de esos atributos, es decir, el estado son únicos para cada objeto. Una sola clase puede tener cualquier número de instancias.
Ejemplo :
Como declaramos variables como (type name;). Esto notifica al compilador que usaremos nombre para referirnos a datos cuyo tipo es tipo. Con una variable primitiva, esta declaración también reserva la cantidad adecuada de memoria para la variable. Entonces, para la variable de referencia, el tipo debe ser estrictamente un nombre de clase concreto. En general, no podemos crear objetos de una clase abstracta o una interfaz.
Dog tuffy;
Si declaramos la variable de referencia (tuffy) de esta manera, su valor será indeterminado (nulo) hasta que se cree un objeto y se le asigne. Simplemente declarar una variable de referencia no crea un objeto.
Inicializar un objeto usando new
El operador new instancia una clase asignando memoria para un nuevo objeto y devolviendo una referencia a esa memoria. El operador new también invoca al constructor de clases.
Java
// Java program to illustrate the concept
// of classes and objects
// Class Declaration
public class Dog {
// Instance Variables
String name;
String breed;
int age;
String color;
// Constructor Declaration of Class
public Dog(String name, String breed,
int age, String color)
{
this.name = name;
this.breed = breed;
this.age = age;
this.color = color;
}
// method 1
public String getName()
{
return name;
}
// method 2
public String getBreed()
{
return breed;
}
// method 3
public int getAge()
{
return age;
}
// method 4
public String getColor()
{
return color;
}
@Override
public String toString()
{
return ("Hi my name is " + this.getName() +
".\nMy breed, age and color are " + this.getBreed()
+ ", " + this.getAge() + ", " + this.getColor());
}
public static void main(String[] args)
{
Dog tuffy = new Dog("tuffy", "papillon", 5, "white");
System.out.println(tuffy.toString());
}
}
Hi my name is tuffy. My breed, age and color are papillon, 5, white
- Esta clase contiene un único constructor . Podemos reconocer un constructor porque su declaración usa el mismo nombre que la clase y no tiene tipo de retorno. El compilador de Java diferencia los constructores según el número y el tipo de argumentos. El constructor de la clase Perro toma cuatro argumentos. La siguiente declaración proporciona «tuffy», «papillon», 5, «white» como valores para esos argumentos:
Dog tuffy = new Dog("tuffy", "papillon", 5, "white");
El resultado de ejecutar esta declaración se puede ilustrar como:
Nota: Todas las clases tienen al menos un constructor. Si una clase no declara explícitamente ninguna, el compilador de Java proporciona automáticamente un constructor sin argumentos, también llamado constructor predeterminado . Este constructor predeterminado llama al constructor sin argumentos del padre de la clase (ya que contiene solo una declaración, es decir, super();), o al constructor de la clase Object si la clase no tiene otro padre (ya que la clase Object es el padre de todas las clases, ya sea directa o indirectamente ). ).
Diferentes formas de crear Objetos
- Usar nueva palabra clave: es la forma más sencilla de crear un objeto. Al usar este método, se puede llamar al constructor deseado.
Sintaxis:
ClassName ReferenceVariable = new ClassName();
Java
// Java program to illustrate the
// creating and accessing objects
// using new keyword
// base class
class Dog {
// the class Dog has two fields
String dogName;
int dogAge;
// the class Dog has one constructor
Dog(String name, int age)
{
this.dogName = name;
this.dogAge = age;
}
}
// driver class
public class Test {
public static void main(String[] args)
{
// creating objects of the class Dog
Dog ob1 = new Dog("Bravo", 4);
Dog ob2 = new Dog("Oliver", 5);
// accessing the object data through reference
System.out.println(ob1.dogName + ", " + ob1.dogAge);
System.out.println(ob2.dogName + ", " + ob2.dogAge);
}
}
Bravo, 4 Oliver, 5
- Usando el método Class.newInstance(): se usa para crear una nueva clase dinámicamente. Puede invocar cualquier constructor sin argumentos. Este método devuelve la clase Objeto de clase en el que se llama al método newInstance(), que devolverá el objeto de esa clase que se pasa como argumento de línea de comando.
Motivo de las diferentes excepciones planteadas: –
ClassNotFoundException ocurrirá si la clase pasada no existe.
Se producirá una excepción de instancia si la clase pasada no contiene un constructor predeterminado, ya que el método newInstance() llama internamente al constructor predeterminado de esa clase en particular.
Se producirá IllegalAccessException si la clase de conducción no tiene acceso a la definición de la definición de clase especificada.
Sintaxis:
ClassName ReferenceVariable =
(ClassName) Class.forName("PackageName.ClassName").newInstance();
Java
// Java program to demonstrate
// object creation using newInstance() method
// Base class
class Example {
void message()
{
System.out.println("Hello Geeks !!");
}
}
// Driver class
class Test {
public static void main(String args[])
{
try {
Class c = Class.forName("Example");
Example s = (Example)c.newInstance();
s.message();
}
catch (Exception e) {
System.out.println(e);
}
}
}
Hello Geeks !!
- Usando el método newInstance() para la clase Constructor: es una forma reflexiva de crear objetos. Al usarlo, se puede llamar al constructor parametrizado y privado. Envuelve la excepción lanzada con una InvocaciónTargetException. Es utilizado por diferentes marcos: Spring, Hibernate, Struts, etc. Se prefiere el método Constructor.newInstance() sobre el método Class.newInstance().
Sintaxis:
Constructor constructor = ClassName.class.getConstructor(); ClassName ReferenceVariable = constructor.newInstance();
Ejemplo:
Java
// java program to demonstrate
// creation of object
// using Constructor.newInstance() method
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class ConstructorExample {
// different exception is thrown
public static void main(String[] args)
throws NoSuchMethodException,
SecurityException,
InstantiationException,
IllegalAccessException,
IllegalArgumentException,
InvocationTargetException
{
Constructor constructor = ExampleClass.class
.getConstructor(String.class);
ExampleClass exampleObject = (ExampleClass)constructor
.newInstance("GeeksForGeeks");
System.out.println(exampleObject.getemp_name());
}
}
class ExampleClass {
// private variable declared
private String emp_name;
public ExampleClass(String emp_name)
{
this.emp_name = emp_name;
}
// get method for emp_named to access
// private variable emp_name
public String getemp_name()
{
return emp_name;
}
// set method for emp_name to access
// private variable emp_name
public void setemp_name(String emp_name)
{
this.emp_name = emp_name;
}
}
GeeksForGeeks
- Usando el método clone(): Se usa para hacer clones de un objeto. Es la forma más fácil y eficiente de copiar un objeto. En código, la interfaz java.lang.Cloneable debe ser implementada por la clase cuyo clon de objeto se va a crear. Si no se implementa la interfaz Cloneable, el método clone() genera CloneNotSupportedException .
Sintaxis:
ClassName ReferenceVariable = (ClassName) ReferenceVariable.clone();
Ejemplo:
Java
// java program to demonstrate
// object creation using clone() method
// employee class whose objects are cloned
class Employee implements Cloneable {
int emp_id;
String emp_name;
// default constructor
Employee(String emp_name, int emp_id)
{
this.emp_id = emp_id;
this.emp_name = emp_name;
}
public Object clone() throws CloneNotSupportedException
{
return super.clone();
}
}
// driver class
public class Test {
public static void main(String args[])
{
try {
Employee ob1 = new Employee("Tom", 201);
// Creating a new reference variable ob2
// which is pointing to the same address as ob1
Employee ob2 = (Employee)ob1.clone();
System.out.println(ob1.emp_id + ", " + ob1.emp_name);
System.out.println(ob2.emp_id + ", " + ob2.emp_name);
}
catch (CloneNotSupportedException c) {
System.out.println("Exception: " + c);
}
}
}
201, Tom 201, Tom
- Uso de la deserialización: para deserializar un objeto, primero implemente una interfaz serializable en la clase. No se utiliza ningún constructor para crear un objeto en este método.
Sintaxis:
ObjectInputStream in = new ObjectInputStream(new FileInputStream(FileName)); ClassName ReferenceVariable = (ClassName) in.readObject();
Ejemplo:
Java
// Java code to demonstrate object
// creation by deserialization
import java.io.*;
// Base class
class Example implements java.io.Serializable {
public int emp_id;
public String emp_name;
// Default constructor
public Example(int emp_id, String emp_name)
{
this.emp_id = emp_id;
this.emp_name = emp_name;
}
}
// Driver class
class Test {
public static void main(String[] args)
{
Example object = new Example(1, "geeksforgeeks");
String filename = "file1.ser";
// Serialization
try {
// Saving of object in a file
FileOutputStream file1 = new FileOutputStream(filename);
ObjectOutputStream out = new ObjectOutputStream(file1);
// Method for serialization of object
out.writeObject(object);
out.close();
file1.close();
System.out.println("Object has been serialized");
}
catch (IOException ex) {
System.out.println("IOException is caught");
}
Example object1 = null;
// Deserialization
try {
// Reading object from a file
FileInputStream file1 = new FileInputStream(filename);
ObjectInputStream in = new ObjectInputStream(file1);
// Method for deserialization of object
object1 = (Example)in.readObject();
in.close();
file1.close();
System.out.println("Object has been deserialized");
System.out.println("Employee ID = " + object1.emp_id);
System.out.println("Employee Name = " + object1.emp_name);
}
catch (IOException ex) {
System.out.println("IOException is caught");
}
catch (ClassNotFoundException ex) {
System.out.println("ClassNotFoundException is caught");
}
}
}
Diferencias entre objetos y clases
Publicación traducida automáticamente
Artículo escrito por Astha_Singh y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA