| 1 |
¿Qué es una clase? |
Una clase es una plantilla para crear objetos que define un conjunto de atributos y métodos que esos objetos pueden tener. |
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
|
class Person:
def __init__(self, name: str, age: int):
self.name = name
self.age = age
def get_name(self):
return self.name
def get_age(self):
return self.age
|
public class Person
{
private string Name;
private int Age;
public Person(string name, int age)
{
Name = name;
Age = age;
}
public string GetName()
{
return Name;
}
public int GetAge()
{
return Age;
}
}
|
class Person {
constructor(private name: string, private age: number) {}
public getName(): string {
return this.name;
}
public getAge(): number {
return this.age;
}
}
|
| 2 |
¿Qué es un objeto? |
Un objeto es una instancia de una clase que contiene valores específicos para los atributos definidos por la clase y puede usar los métodos de la clase. |
Person person = new Person("John", 30);
System.out.println(person.getName()); // John
|
person = Person("John", 30)
print(person.get_name()) # John
|
Person person = new Person("John", 30);
Console.WriteLine(person.GetName()); // John
|
let person = new Person("John", 30);
console.log(person.getName()); // John
|
| 3 |
¿Qué es la herencia? |
La herencia es un mecanismo que permite a una clase heredar atributos y métodos de otra clase. |
public class Student extends Person {
private String studentId;
public Student(String name, int age, String studentId) {
super(name, age);
this.studentId = studentId;
}
public String getStudentId() {
return studentId;
}
}
|
class Student(Person):
def __init__(self, name: str, age: int, student_id: str):
super().__init__(name, age)
self.student_id = student_id
def get_student_id(self):
return self.student_id
|
public class Student : Person
{
private string StudentId;
public Student(string name, int age, string studentId) : base(name, age)
{
StudentId = studentId;
}
public string GetStudentId()
{
return StudentId;
}
}
|
class Student extends Person {
constructor(name: string, age: number, private studentId: string) {
super(name, age);
}
public getStudentId(): string {
return this.studentId;
}
}
|
| 4 |
¿Qué es el polimorfismo? |
El polimorfismo permite que diferentes clases implementen el mismo método de diferentes maneras. |
public class Animal {
public void makeSound() {
System.out.println("Some sound");
}
}
public class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("Bark");
}
}
|
class Animal:
def make_sound(self):
print("Some sound")
class Dog(Animal):
def make_sound(self):
print("Bark")
|
public class Animal
{
public virtual void MakeSound()
{
Console.WriteLine("Some sound");
}
}
public class Dog : Animal
{
public override void MakeSound()
{
Console.WriteLine("Bark");
}
}
|
class Animal {
public makeSound(): void {
console.log("Some sound");
}
}
class Dog extends Animal {
public makeSound(): void {
console.log("Bark");
}
}
|
| 5 |
¿Qué es la encapsulación? |
La encapsulación es el concepto de ocultar los detalles internos de una clase y exponer solo lo necesario a través de métodos públicos. |
public class Person {
private String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
|
class Person:
def __init__(self, name: str):
self.__name = name
def set_name(self, name: str):
self.__name = name
def get_name(self) -> str:
return self.__name
|
public class Person
{
private string Name;
public void SetName(string name)
{
Name = name;
}
public string GetName()
{
return Name;
}
}
|
class Person {
private name: string;
constructor(name: string) {
this.name = name;
}
public setName(name: string): void {
this.name = name;
}
public getName(): string {
return this.name;
}
}
|
| 6 |
¿Qué es una interfaz? |
Una interfaz define un contrato que otras clases deben implementar, especificando métodos sin proporcionar su implementación. |
public interface Animal {
void makeSound();
}
public class Dog implements Animal {
@Override
public void makeSound() {
System.out.println("Bark");
}
}
|
class Animal:
def make_sound(self):
pass
class Dog(Animal):
def make_sound(self):
print("Bark")
|
public interface IAnimal
{
void MakeSound();
}
public class Dog : IAnimal
{
public void MakeSound()
{
Console.WriteLine("Bark");
}
}
|
interface Animal {
makeSound(): void;
}
class Dog implements Animal {
public makeSound(): void {
console.log("Bark");
}
}
|
| 7 |
¿Qué es la composición? |
La composición es un tipo de relación en la que una clase contiene referencias a otras clases y utiliza sus funcionalidades. |
public class Engine {
// Engine properties and methods
}
public class Car {
private Engine engine;
public Car() {
this.engine = new Engine();
}
}
|
class Engine:
# Engine properties and methods
pass
class Car:
def __init__(self):
self.engine = Engine()
|
public class Engine
{
// Engine properties and methods
}
public class Car
{
private Engine _engine;
public Car()
{
_engine = new Engine();
}
}
|
class Engine {
// Engine properties and methods
}
class Car {
private engine: Engine;
constructor() {
this.engine = new Engine();
}
}
|
| 8 |
¿Qué es la agregación? |
La agregación es una relación en la que una clase contiene referencias a otras clases, pero esas clases pueden existir independientemente. |
public class Department {
private List employees;
public Department() {
this.employees = new ArrayList<>();
}
public void addEmployee(Employee employee) {
employees.add(employee);
}
}
|
class Employee:
# Employee properties and methods
pass
class Department:
def __init__(self):
self.employees = []
def add_employee(self, employee: Employee):
self.employees.append(employee)
|
public class Department
{
private List Employees;
public Department()
{
Employees = new List();
}
public void AddEmployee(Employee employee)
{
Employees.Add(employee);
}
}
|
class Department {
private employees: Employee[] = [];
public addEmployee(employee: Employee): void {
this.employees.push(employee);
}
}
|
| 9 |
¿Qué es un constructor? |
Un constructor es un método especial de una clase que se llama automáticamente cuando se crea una instancia de la clase, utilizado para inicializar los objetos. |
public class Person {
private String name;
public Person(String name) {
this.name = name;
}
}
|
class Person:
def __init__(self, name: str):
self.name = name
|
public class Person
{
private string Name;
public Person(string name)
{
Name = name;
}
}
|
class Person {
constructor(private name: string) {}
}
|
| 10 |
¿Qué es un método estático? |
Un método estático pertenece a la clase en lugar de a una instancia específica de la clase y puede ser llamado sin crear una instancia de la clase. |
public class MathUtils {
public static int add(int a, int b) {
return a + b;
}
}
|
class MathUtils:
@staticmethod
def add(a: int, b: int) -> int:
return a + b
|
public class MathUtils
{
public static int Add(int a, int b)
{
return a + b;
}
}
|
class MathUtils {
public static add(a: number, b: number): number {
return a + b;
}
}
|
| 11 |
¿Qué es la sobrecarga de métodos? |
La sobrecarga de métodos permite tener varios métodos con el mismo nombre pero con diferentes parámetros. |
public class Printer {
public void print(int value) {
System.out.println(value);
}
public void print(String value) {
System.out.println(value);
}
}
|
class Printer:
def print(self, value):
if isinstance(value, int):
print(f"Integer: {value}")
elif isinstance(value, str):
print(f"String: {value}")
|
public class Printer
{
public void Print(int value)
{
Console.WriteLine(value);
}
public void Print(string value)
{
Console.WriteLine(value);
}
}
|
class Printer {
public print(value: number | string): void {
if (typeof value === 'number') {
console.log(`Number: ${value}`);
} else {
console.log(`String: ${value}`);
}
}
}
|
| 12 |
¿Qué es la sobreescritura de métodos? |
La sobreescritura de métodos permite que una subclase proporcione una implementación específica para un método que ya está definido en su superclase. |
public class Animal {
public void makeSound() {
System.out.println("Some sound");
}
}
public class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("Bark");
}
}
|
class Animal:
def make_sound(self):
print("Some sound")
class Dog(Animal):
def make_sound(self):
print("Bark")
|
public class Animal
{
public virtual void MakeSound()
{
Console.WriteLine("Some sound");
}
}
public class Dog : Animal
{
public override void MakeSound()
{
Console.WriteLine("Bark");
}
}
|
class Animal {
public makeSound(): void {
console.log("Some sound");
}
}
class Dog extends Animal {
public makeSound(): void {
console.log("Bark");
}
}
|
| 13 |
¿Qué es la herencia múltiple? |
La herencia múltiple permite que una clase herede de más de una clase base. Sin embargo, muchos lenguajes de programación no lo soportan directamente. |
// Java does not support multiple inheritance directly, but interfaces can be used
|
# Python supports multiple inheritance
class A:
def method_a(self):
pass
class B:
def method_b(self):
pass
class C(A, B):
pass
|
// C# does not support multiple inheritance directly, but interfaces can be used
|
// TypeScript supports multiple inheritance via interfaces
interface A {
methodA(): void;
}
interface B {
methodB(): void;
}
class C implements A, B {
methodA(): void {}
methodB(): void {}
}
|
| 14 |
¿Qué es un patrón de diseño? |
Un patrón de diseño es una solución reutilizable a un problema común en el diseño de software. |
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
|
class Singleton:
_instance = None
def __new__(cls):
if cls._instance is None:
cls._instance = super(Singleton, cls).__new__(cls)
return cls._instance
|
public class Singleton
{
private static Singleton _instance;
private Singleton() {}
public static Singleton GetInstance()
{
if (_instance == null)
{
_instance = new Singleton();
}
return _instance;
}
}
|
class Singleton {
private static instance: Singleton;
private constructor() {}
public static getInstance(): Singleton {
if (!this.instance) {
this.instance = new Singleton();
}
return this.instance;
}
}
|