La herencia, como todos hemos escuchado, es una de las características más importantes de los lenguajes de programación orientados a objetos, ya sea Java, C++ o cualquier otro lenguaje OOP. Pero, ¿cuál es la necesidad de herencia? ¿Por qué es un concepto tan importante?
La herencia se puede definir como un mecanismo por el cual un objeto puede adquirir todas las propiedades (es decir, miembros de datos) y comportamiento (es decir, funciones o métodos de miembros) de un objeto principal.
La idea básica de la herencia es crear la nueva clase (llamada clase secundaria, derivada o subclase) a partir de una clase existente (llamada clase padre, Base o Superclase). Es decir, la clase secundaria hereda las propiedades (métodos y campos) de la clase principal.
Pensar en lograr algo sin Herencia será malgastar tiempo y recursos ya que tenemos que escribir el mismo código una y otra vez.
Tomemos un ejemplo, tres clases Persona, Empleado y Estudiante tienen algunos atributos, algunos comunes y otros diferentes. Vea el código a continuación.
Java
// Java program without inheritance
import java.io.*;
import java.math.BigDecimal;
// class person
class Person {
private String name;
private int age;
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
public String toString()
{
return String.format(
"Person :- name : %s , age : %d", name, age);
}
}
//class student
class Student {
private String name;
private int age;
private int rollno;
private String school;
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
public int getRollno() { return rollno; }
public void setRollno(int rollno)
{
this.rollno = rollno;
}
public String getSchool() { return school; }
public void setSchool(String school)
{
this.school = school;
}
public String toString()
{
return String.format(
"Student :- name : %s , age : %d , roll : %d , school : %s",
name, age, rollno, school);
}
}
//class Employee
class Employee {
private String name;
private int age;
private double salary;
private String organisation;
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
public double getSalary() { return salary; }
public void setSalary(double salary)
{
this.salary = salary;
}
public String getOrganisation() { return organisation; }
public void setOrganisation(String organisation)
{
this.organisation = organisation;
}
public String toString()
{
return String.format(
"Employee :- name : %s , age : %d , organisation : %s , salary : %f",
name, age, organisation, salary);
}
}
// class PersonRunner
public class PersonRunner {
public static void main(String[] args)
{
Person person = new Person();
Student student = new Student();
Employee employee = new Employee();
person.setName("Saurabh");
person.setAge(20);
student.setName("Prateek");
student.setAge(21);
student.setRollno(101);
student.setSchool("New Era HS");
employee.setName("Sushant");
employee.setAge(25);
employee.setOrganisation("GeeksforGeeks");
employee.setSalary(50000.00);
System.out.println(person);
System.out.println(student);
System.out.println(employee);
}
}
Person :- name : Saurabh , age : 20 Student :- name : Prateek , age : 21 , roll : 101 , school : New Era HS Employee :- name : Sushant , age : 25 , organisation : GeeksforGeeks , salary : 50000.000000
Tenga en cuenta que tenemos que escribir el mismo código que ya está escrito en la clase Persona nuevamente en la clase Estudiante y en la clase Empleado. Esto requiere tiempo y memoria.
Ahora lea cuidadosamente el código a continuación donde estamos usando Herencia.
Java
// Java program with inheritance
import java.io.*;
class Person {
private String name;
private int age;
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
public String toString()
{
return String.format(
"Person :- name : %s , age : %d", getName(),
getAge());
}
}
// Student class is inheriting the properties of Person
// class( through extend keyword) Therefore, we don't need to
// declare name and age (and their related methods which are
// covered in Person) again.
class Student extends Person {
private int rollno;
private String school;
public int getRollno() { return rollno; }
public void setRollno(int rollno)
{
this.rollno = rollno;
}
public String getSchool() { return school; }
public void setSchool(String school)
{
this.school = school;
}
public String toString()
{
return String.format(
"Student :- name : %s , age : %d , roll : %d , school : %s",
getName(), getAge(), getRollno(), getSchool());
}
}
// Employee class is inheriting the properties of Person
// class( through extend keyword) Therefore, we don't need to
// declare name and age (and their related methods which are
// covered in Person) again.
class Employee extends Person {
private double salary;
private String organisation;
public double getSalary() { return salary; }
public void setSalary(double salary)
{
this.salary = salary;
}
public String getOrganisation() { return organisation; }
public void setOrganisation(String organisation)
{
this.organisation = organisation;
}
public String toString()
{
return String.format(
"Employee :- name : %s , age : %d , organisation : %s , salary : %f",
getName(), getAge(), getOrganisation(),
getSalary());
}
}
public class PersonRunner {
public static void main(String[] args)
{
Person person = new Person();
Student student = new Student();
Employee employee = new Employee();
person.setName("Saurabh");
person.setAge(20);
student.setName("Prateek");
student.setAge(21);
student.setRollno(101);
student.setSchool("New Era HS");
employee.setName("Sushant");
employee.setAge(25);
employee.setOrganisation("GeeksforGeeks");
employee.setSalary(50000.00);
System.out.println(person);
System.out.println(student);
System.out.println(employee);
}
}
Person :- name : Saurabh , age : 20 Student :- name : Prateek , age : 21 , roll : 101 , school : New Era HS Employee :- name : Sushant , age : 25 , organisation : GeeksforGeeks , salary : 50000.000000
Tenga en cuenta que hemos escrito menos código en el ejemplo anterior cuando se usa Herencia en comparación con el primer ejemplo donde no se usó Herencia y, por lo tanto, tuvimos que definir el nombre, la edad y sus métodos relacionados una y otra vez.
Es decir, hemos utilizado el concepto de reutilización del mismo modo que hemos reutilizado el código escrito en la clase Person una y otra vez.
Además, el ejemplo anterior muestra la anulación de métodos (ya que la función toString de la clase Person se anula tanto en la clase Student como en la clase Employee, que también es una característica importante de la herencia).
Por lo tanto, concluye que el objetivo principal de la herencia es implementar el concepto de reutilización, ahorrando tiempo y recursos y también creando mejores conexiones entre diferentes clases y logrando la anulación de métodos.
Publicación traducida automáticamente
Artículo escrito por ankitsinghrajput y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA