{"id":2308,"date":"2026-05-29T21:47:53","date_gmt":"2026-05-29T21:47:53","guid":{"rendered":"https:\/\/vkrastev1blog.com\/?p=2308"},"modified":"2026-11-03T19:35:02","modified_gmt":"2026-11-03T22:35:02","slug":"questions-and-informations-prepairing-for-java-developer-job-interview","status":"publish","type":"post","link":"https:\/\/vkrastev1blog.com\/2026\/05\/29\/questions-and-informations-prepairing-for-java-developer-job-interview\/","title":{"rendered":"Preguntas e informaci\u00f3n sobre la preparaci\u00f3n para la entrevista de trabajo de desarrollador de Java"},"content":{"rendered":"\n

Preguntas e informaci\u00f3n sobre la preparaci\u00f3n de la entrevista para desarrolladores de Java<\/h2>\n\n\n\n
\"\"<\/a><\/figure>\n\n\n\n
\n\n\n\n

\u00bfCu\u00e1les son los principios S\u00d3LIDOS?<\/h2>\n\n\n\n

\u00bfQu\u00e9 es el Principio de Responsabilidad \u00danica (SRP)?<\/h2>\n\n\n\n

Una clase debe tener solo una responsabilidad y una sola raz\u00f3n para cambiar.
Los beneficios incluyen pruebas m\u00e1s sencillas, menor acoplamiento y mejor organizaci\u00f3n.
Ejemplo:<\/p>\n\n\n

\n\t
\n\t\t
\n\t\t\t\n
\n
public class Book {<\/div>
private String name;<\/div>
private String author;<\/div>
private String text;<\/div>
\/\/ constructor, getters, and setters<\/div>
}<\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n
\n\n\n\n
\u00bfQu\u00e9 es el principio abierto-cerrado (OCP)?<\/h2>\n\n\n\n
Los componentes de software (clases, m\u00f3dulos, funciones) deben estar abiertos a la extensi\u00f3n pero cerrados a la modificaci\u00f3n.
Esto se logra mediante el uso de interfaces, clases abstractas y herencia.
Ejemplo:<\/p>\n\n\n
\n\t
\n\t\t
\n\t\t\t\n
\n
interface Shape {<\/div>
double area();<\/div>
}<\/div>
class Circle implements Shape <\/div>
{ \/* implementation \/ } <\/div>
class Rectangle implements Shape <\/div>
{ \/ implementation *\/ }<\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n
\n\n\n\n
\u00bfQu\u00e9 es el principio de sustituci\u00f3n de Liskov (LSP)?<\/h2>\n\n\n\n
Los subtipos deben poder reemplazar sus tipos base sin cambiar la correcci\u00f3n del programa. Esto sigue la relaci\u00f3n “es-un”.
Ejemplo:<\/p>\n\n\n
\n\t
\n\t\t
\n\t\t\t\n
\n
class Bird <\/div>
{ \/* common bird behavior \/ } <\/div>
class Sparrow extends Bird <\/div>
{ \/ specific sparrow behavior *\/ }<\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n
\n\n\n\n
\u00bfQu\u00e9 es el principio de segregaci\u00f3n de interfaces (ISP)?<\/h2>\n\n\n\n
No se debe obligar a los clientes a depender de interfaces que no utilizan. Divida las interfaces grandes en otras m\u00e1s peque\u00f1as y espec\u00edficas.
Ejemplo:<\/p>\n\n\n
\n\t
\n\t\t
\n\t\t\t\n
\n
interface Worker {<\/div>
void work();<\/div>
}<\/div>
interface Eater {<\/div>
void eat();<\/div>
}<\/div>
class Robot implements Worker <\/div>
{ \/* implementation *\/ }<\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n
\n\n\n\n
\u00bfQu\u00e9 es el principio de inversi\u00f3n de dependencia (DIP)?<\/h2>\n\n\n\n
Los m\u00f3dulos de nivel superior no deben depender de m\u00f3dulos de nivel inferior; ambos tipos deben depender de abstracciones. Las abstracciones no deber\u00edan depender de detalles; los detalles deben depender de abstracciones.<\/p>\n\n\n
\n\t
\n\t\t
\n\t\t\t\n
\n
\/\/ Abstraction<\/div>
interface MessageSender {<\/div>
void sendMessage(String message);<\/div>
}<\/div>
<\/div>
\/\/ High-level module<\/div>
class NotificationService {<\/div>
private MessageSender messageSender;<\/div>
<\/div>
public NotificationService(MessageSender messageSender) {<\/div>
this.messageSender = messageSender;<\/div>
  }<\/div>
<\/div>
public void send(String message) {<\/div>
messageSender.sendMessage(message);<\/div>
  }<\/div>
}<\/div>
<\/div>
\/\/ Low-level module<\/div>
class EmailSender implements MessageSender {<\/div>
@Override<\/div>
public void sendMessage(String message) {<\/div>
System.out.println("Sending Email: " + message);<\/div>
  }<\/div>
}<\/div>
<\/div>
\/\/ Another Low-level module<\/div>
class SmsSender implements MessageSender {<\/div>
@Override<\/div>
public void sendMessage(String message) {<\/div>
System.out.println("Sending SMS: " + message);<\/div>
  }<\/div>
}<\/div>
<\/div>
\/\/ Use SmsSender<\/div>
MessageSender smsSender = new SmsSender();<\/div>
NotificationService notificationService2 = <\/div>
              new NotificationService(smsSender);<\/div>
notificationService2.send("Hello via SMS!");<\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n
La interfaz MessageSender sirve como abstracci\u00f3n. El m\u00f3dulo de nivel superior NotificationService depende de esta abstracci\u00f3n en lugar de implementaciones concretas.
Los m\u00f3dulos de nivel inferior como EmailSender y SmsSender tambi\u00e9n dependen de la abstracci\u00f3n al implementar la interfaz MessageSender.<\/p>\n\n\n\n
\n\n\n\n
\u00bfQu\u00e9 es la normalizaci\u00f3n en SQL?<\/h2>\n\n\n\n
\u00bfQu\u00e9 es la normalizaci\u00f3n?
La normalizaci\u00f3n implica estructurar los datos en una base de datos relacional para eliminar anomal\u00edas como la redundancia. Divide tablas grandes y complejas en otras m\u00e1s peque\u00f1as preservando al mismo tiempo las relaciones entre los datos.<\/p>\n\n\n\n
\u00bfPor qu\u00e9 es importante la normalizaci\u00f3n?
Reduce la redundancia: Al dividir los datos en tablas m\u00e1s peque\u00f1as, evitamos almacenar la misma informaci\u00f3n varias veces.
Mejora el rendimiento de las consultas: las tablas normalizadas m\u00e1s peque\u00f1as conducen a una ejecuci\u00f3n m\u00e1s r\u00e1pida de las consultas.
Minimiza anomal\u00edas de actualizaci\u00f3n: Se pueden realizar cambios sin afectar otros registros.
Mejora la integridad de los datos: garantiza datos consistentes y precisos.<\/p>\n\n\n\n
Escenarios para aplicar la Normalizaci\u00f3n
Integridad de los datos: evita inconsistencias al actualizar los datos (por ejemplo, cuando cambia la edad de un cliente).
Consultas eficientes: simplifica las consultas complejas al desglosar los datos.
Optimizaci\u00f3n del almacenamiento: elimina el exceso de redundancia para ahorrar espacio.<\/p>\n\n\n\n
\n\n\n\n
\u00bfQu\u00e9 es un monolito de microservicios?<\/h2>\n\n\n\n
\u00bfQu\u00e9 es un monolito?<\/p>\n\n\n\n
La aplicaci\u00f3n monol\u00edtica est\u00e1 construida como un m\u00f3dulo \u00fanico y completo. Conecta estrechamente todos los componentes (como la interfaz de usuario del lado del cliente, la base de datos y la aplicaci\u00f3n del lado del servidor) en una base de c\u00f3digo com\u00fan.<\/p>\n\n\n\n
Ventajas:
Implementaci\u00f3n sencilla: dado que se trata de un \u00fanico archivo o directorio ejecutable, la implementaci\u00f3n es sencilla y directa.
Velocidad de desarrollo: En las primeras etapas de la vida de un proyecto, monolith permite un r\u00e1pido desarrollo gracias a su simplicidad.
Rendimiento: una base de c\u00f3digo centralizada puede manejar varias funciones de manera eficiente.<\/p>\n\n\n\n
\n\n\n\n
\u00bfQu\u00e9 son los microservicios?<\/h2>\n\n\n\n
Los microservicios dividen la aplicaci\u00f3n en servicios m\u00e1s peque\u00f1os que se pueden implementar de forma independiente. Cada servicio se centra en un dominio empresarial espec\u00edfico.<\/p>\n\n\n\n
Ventajas:
Escalabilidad: los microservicios permiten escalar componentes individuales independientemente unos de otros.
Flexibilidad: los desarrolladores pueden elegir diferentes tecnolog\u00edas para cada servicio.
Aislamiento: los errores en un servicio no afectan a los dem\u00e1s.<\/p>\n\n\n\n
Desaf\u00edos:
Complejidad: la gesti\u00f3n de m\u00faltiples servicios requiere una orquestaci\u00f3n confiable.
Gastos generales de red: la comunicaci\u00f3n entre servicios introduce latencia.
Complejidad de la implementaci\u00f3n: coordinar actualizaciones entre m\u00faltiples servicios puede ser un desaf\u00edo.<\/p>\n\n\n\n
\n\n\n\n
\u00bfQu\u00e9 es el polimorfismo?<\/h2>\n\n\n\n
Anulaci\u00f3n de m\u00e9todo:
Cuando una subclase proporciona una implementaci\u00f3n espec\u00edfica para un m\u00e9todo ya definido en su superclase.<\/p>\n\n\n\n
Sobrecarga de m\u00e9todos:
Cuando una clase tiene m\u00faltiples m\u00e9todos con el mismo nombre, pero con diferentes par\u00e1metros (diferente n\u00famero o tipos de argumentos).<\/p>\n\n\n\n
\n\n\n\n
\u00bfCu\u00e1l es el objetivo de los constructores privados?<\/h2>\n\n\n\n
Los constructores privados se utilizan en clases de utilidad o clases constantes.
Estas clases contienen s\u00f3lo m\u00e9todos o miembros est\u00e1ticos.<\/p>\n\n\n\n
Evitar la herencia (evitar la subclasificaci\u00f3n)<\/p>\n\n\n\n
Delegaci\u00f3n de Constructores:
Los constructores privados permiten la delegaci\u00f3n de constructores, donde constructores espec\u00edficos llaman a un constructor privado com\u00fan.<\/p>\n\n\n\n
Patr\u00f3n singleton<\/p>\n\n\n\n
\n\n\n\n
Para la JVM<\/h2>\n\n\n\n
Compilaci\u00f3n:
Cuando compila un archivo .java, el compilador de Java genera archivos .class que contienen c\u00f3digo de bytes (representaci\u00f3n intermedia).
Bytecode es independiente de la plataforma y se puede ejecutar en cualquier sistema con una JVM compatible.<\/p>\n\n\n\n
Subsistema de carga de clases:
Responsable de cargar clases en la memoria.
Lee los archivos .class, genera datos binarios y los almacena en el \u00e1rea de m\u00e9todos.
Crea un objeto Class que representa la clase cargada en la memoria del mont\u00f3n.<\/p>\n\n\n
\n\t
\n\t\t
\n\t\t\t\n
\n
Example: <\/div>
Student s1 = new Student(); <\/div>
Class c1 = s1.getClass();<\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n
Campo de golf:
Consta de tres pasos:
Verificaci\u00f3n: Comprueba la exactitud del archivo .class.
Preparaci\u00f3n: Para la memoria lateral de las variables de clase y las inicializa.
Resoluci\u00f3n (opcional): resuelve referencias simb\u00f3licas a otras clases o m\u00e9todos.<\/p>\n\n\n\n
Inicializaci\u00f3n:
Ejecuta inicializadores est\u00e1ticos (por ejemplo, bloques est\u00e1ticos) e inicializa variables est\u00e1ticas.
Las variables de instancia se inicializan cuando se crea el objeto.<\/p>\n\n\n\n
Motor de ejecuci\u00f3n:
Convierte c\u00f3digo de bytes a c\u00f3digo de m\u00e1quina.
Incluye compilaci\u00f3n Just-In-Time (JIT) para optimizar el rendimiento.<\/p>\n\n\n\n
En resumen, la JVM permite que los programas Java se ejecuten en cualquier lugar interpretando el c\u00f3digo de bytes y administrando la memoria.<\/p>\n\n\n\n
\n\n\n\n
\u00bfQu\u00e9 es un m\u00e9todo abstracto privado?<\/h2>\n\n\n\n
Casos de uso para m\u00e9todos privados en clases abstractas:<\/p>\n\n\n\n
Aunque los m\u00e9todos abstractos no pueden ser privados, puedes utilizar m\u00e9todos privados en una clase abstracta para varios prop\u00f3sitos:<\/p>\n\n\n\n
M\u00e9todos auxiliares: implemente una funcionalidad com\u00fan que comparten otros m\u00e9todos.
Encapsulaci\u00f3n: oculta los detalles de implementaci\u00f3n de las subclases.
Clases tipo estructura: cree clases peque\u00f1as con m\u00e9todos privados que sirvan como contenedores de datos<\/p>\n\n\n\n
\n\n\n\n
\u00bfQu\u00e9 es el recolector de basura?<\/h2>\n\n\n\n
Memoria del mont\u00f3n:
Los objetos Java se crean en la memoria din\u00e1mica, un \u00e1rea de memoria especialmente asignada.
Algunos objetos dejan de estar disponibles (el programa ya no hace referencia a ellos).<\/p>\n\n\n\n
Recolector de basura (GC):
GC identifica y elimina objetos no utilizados para liberar memoria.
Funciona autom\u00e1ticamente en segundo plano.
Dos tipos:
GC menor: elimina objetos no disponibles en la generaci\u00f3n joven.
Major GC (GC completo): borra objetos de la generaci\u00f3n anterior.<\/p>\n\n\n\n
Beneficios:
Los desarrolladores no necesitan eliminar objetos manualmente.
GC garantiza la disponibilidad de la memoria y evita OutOfMemoryErrors.<\/p>\n\n\n\n
\n\n\n\n
\u00bfQu\u00e9 es la programaci\u00f3n orientada a objetos?<\/h2>\n\n\n\n
Cuatro principios de la programaci\u00f3n orientada a objetos:<\/p>\n\n\n\n
Encapsulaci\u00f3n: agrupar datos (atributos) y m\u00e9todos (funciones) en una clase para ocultar detalles de implementaci\u00f3n y proporcionar una interfaz limpia.<\/p>\n\n\n\n
Herencia: Crear nuevas clases basadas en las existentes, heredando sus atributos y comportamiento. Esto fomenta la reutilizaci\u00f3n del c\u00f3digo.<\/p>\n\n\n\n
Polimorfismo: permite tratar objetos de diferentes clases de la misma manera a trav\u00e9s de una interfaz com\u00fan. Esto proporciona flexibilidad y hace que el sistema sea m\u00e1s f\u00e1cil de expandir (extensibilidad).<\/p>\n\n\n\n
Abstracci\u00f3n: centrarse en caracter\u00edsticas importantes ocultando complejidades innecesarias. La abstracci\u00f3n simplifica el dise\u00f1o y lo hace m\u00e1s f\u00e1cil de mantener y gestionar.<\/p>\n\n\n\n
\n\n\n\n
Las propiedades ACID desempe\u00f1an un papel clave para garantizar la confiabilidad y coherencia de las transacciones.<\/h2>\n\n\n\n
Atomicidad:
Las transacciones se ejecutan por completo o no se ejecutan en absoluto.
No hay confirmaci\u00f3n parcial: si una transacci\u00f3n falla en el medio, todos los cambios realizados en la base de datos se revierten.
Ejemplo: Considere una transferencia de $100 de la cuenta X a la cuenta Y. Si la transacci\u00f3n falla despu\u00e9s de retirar el monto de X pero antes de agregarlo a Y, la base de datos permanece consistente.<\/p>\n\n\n\n
Consistencia:
La base de datos debe mantener sus restricciones de integridad antes y despu\u00e9s de una transacci\u00f3n.
Ejemplo: Si el total antes de la transacci\u00f3n es $700 (X: $500, Y: $200), debe permanecer igual despu\u00e9s de la transacci\u00f3n (X: $400, Y: $300).<\/p>\n\n\n\n
Aislamiento:
Se pueden ejecutar varias transacciones simult\u00e1neamente sin afectarse entre s\u00ed.
Los cambios realizados por una transacci\u00f3n no son visibles para otras hasta que se confirman.
Se garantiza un resultado equivalente al que se obtendr\u00eda si las transacciones se ejecutaran en serie.
Ejemplo: el aislamiento de transacciones evita estados inconsistentes causados \u200b\u200bpor operaciones entrelazadas.<\/p>\n\n\n\n
Durabilidad:
Una vez que se confirma una transacci\u00f3n, sus cambios se vuelven permanentes.
Los cambios sobreviven a fallos o ca\u00eddas del sistema.
Se garantiza el almacenamiento de datos a largo plazo.
Ejemplo: incluso despu\u00e9s de reiniciar el sistema, los cambios confirmados permanecen guardados.
Recuerde, las propiedades ACID proporcionan la base para operaciones de bases de datos confiables y consistentes.<\/p>\n\n\n\n
\n\n\n\n
\u00bfQu\u00e9 es la plantilla de estrategia?<\/h2>\n\n\n\n

Descripci\u00f3n: Define una familia de algoritmos, encapsula cada uno de ellos y los hace intercambiables. Esto permite que un algoritmo cambie independientemente de los clientes que lo utilicen.
Ejemplo:<\/p>\n\n\n
\n\t
\n\t\t
\n\t\t\t\n
\n
\/\/ Interface for eat behavior<\/div>
interface EatBehavior {<\/div>
void eat();<\/div>
}<\/div>
<\/div>
\/\/ Concrete implementations of eat behavior<\/div>
class NormalDiet implements EatBehavior {<\/div>
@Override<\/div>
public void eat() {<\/div>
\/\/ Normal food<\/div>
  }<\/div>
}<\/div>
<\/div>
class LosingWeightDiet implements EatBehavior {<\/div>
@Override<\/div>
public void eat() {<\/div>
\/\/ Healthy food<\/div>
  }<\/div>
}<\/div>
<\/div>
\/\/ Cat class with eat behavior<\/div>
abstract class Cat {<\/div>
EatBehavior eatBehavior;<\/div>
public void eat() {<\/div>
    eatBehavior.eat();<\/div>
  }<\/div>
<\/div>
public void setEatBehavior(EatBehavior eatBehavior) {<\/div>
 this.eatBehavior = eatBehavior;<\/div>
  }<\/div>
}<\/div>
<\/div>
\/\/ Usage<\/div>
Cat cat = new Cat();<\/div>
cat.setEatBehavior(new LosingWeightDiet());<\/div>
cat.eat(); \/\/ Cat eats with a healthier diet<\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n
\n\n\n\n
Patrones creacionales<\/h2>\n\n\n\n
Estas plantillas se centran en la creaci\u00f3n de instancias de clases.
Los ejemplos incluyen<\/p>\n\n\n\n
m\u00e9todo de f\u00e1brica,
Planteamiento del problema: supongamos que queremos crear diferentes tipos de productos (por ejemplo, autom\u00f3viles, bicicletas) sin vincular estrechamente nuestro c\u00f3digo a implementaciones espec\u00edficas.
Componentes clave:
Producto: una clase o interfaz abstracta que define las operaciones generales para los objetos que crear\u00e1 la f\u00e1brica.
Productos concretos: clases reales que implementan la interfaz Producto y representan tipos de objetos concretos.
Creador: una clase o interfaz abstracta que declara el m\u00e9todo de f\u00e1brica. Es responsable de crear objetos Producto, pero delega la creaci\u00f3n real de subclases.
Creadores Concretos: Subclases de Creator que implementan el m\u00e9todo de f\u00e1brica. Ellos deciden qu\u00e9 producto de hormig\u00f3n en particular crear en funci\u00f3n de los par\u00e1metros de entrada o la configuraci\u00f3n.
M\u00e9todo de f\u00e1brica: un m\u00e9todo definido en la clase Creator que crea objetos Producto. Por lo general, se declara abstracto en Creator y se implementa en Concrete Creators.
Ejemplo en Java: Digamos que tenemos una F\u00e1brica que produce diferentes tipos de veh\u00edculos. Aqu\u00ed hay un ejemplo simplificado:<\/p>\n\n\n
\n\t
\n\t\t
\n\t\t\t\n
\n
\/\/<\/span> Abstract<\/span> Product<\/span><\/div>
interface<\/span> Product<\/span> {<\/span><\/div>
void<\/span> display<\/span>()<\/span>;<\/span><\/div>
}<\/span><\/div>
<\/div>
\/\/<\/span> Concrete<\/span> Products<\/span><\/div>
class<\/span> Car<\/span> implements<\/span> Product<\/span> {<\/span><\/div>
public<\/span> void<\/span> display<\/span>()<\/span> {<\/span><\/div>
System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>"Car created"<\/span>)<\/span>;<\/span><\/div>
  }<\/span><\/div>
}<\/span><\/div>
<\/div>
class<\/span> Bike<\/span> implements<\/span> Product<\/span> {<\/span><\/div>
public<\/span> void<\/span> display<\/span>()<\/span> {<\/span><\/div>
System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>"Bike created"<\/span>)<\/span>;<\/span><\/div>
  }<\/span><\/div>
}<\/span><\/div>
<\/div>
\/\/<\/span> Creator<\/span> (<\/span>Factory<\/span>)<\/span><\/div>
interface<\/span> Factory<\/span> {<\/span><\/div>
Product<\/span> factoryMethod<\/span>()<\/span>;<\/span><\/div>
}<\/span><\/div>
<\/div>
\/\/<\/span> Concrete<\/span> Creators<\/span><\/div>
class<\/span> ConcreteFactoryA<\/span> implements<\/span> Factory<\/span> {<\/span><\/div>
public<\/span> Product<\/span> factoryMethod<\/span>()<\/span> {<\/span><\/div>
return<\/span> new<\/span> Car<\/span>()<\/span>;<\/span><\/div>
  }<\/span><\/div>
}<\/span><\/div>
<\/div>
class<\/span> ConcreteFactoryB<\/span> implements<\/span> Factory<\/span> {<\/span><\/div>
public<\/span> Product<\/span> factoryMethod<\/span>()<\/span> {<\/span><\/div>
return<\/span> new<\/span> Bike<\/span>()<\/span>;<\/span><\/div>
  }<\/span><\/div>
}<\/span><\/div>
<\/div>
public<\/span> class<\/span> FactoryMethodExample<\/span> {<\/span><\/div>
public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[]<\/span> args<\/span>)<\/span> {<\/span><\/div>
Factory<\/span> factoryA<\/span> =<\/span> new<\/span> ConcreteFactoryA<\/span>()<\/span>;<\/span><\/div>
Product<\/span> productA<\/span> =<\/span> factoryA<\/span>.<\/span>factoryMethod<\/span>()<\/span>;<\/span><\/div>
productA<\/span>.<\/span>display<\/span>()<\/span>;<\/span><\/div>
Factory<\/span> factoryB<\/span> =<\/span> new<\/span> ConcreteFactoryB<\/span>()<\/span>;<\/span><\/div>
    Product<\/span> productB<\/span> =<\/span> factoryB<\/span>.<\/span>factoryMethod<\/span>()<\/span>;<\/span><\/div>
    productB<\/span>.<\/span>display<\/span>()<\/span>;<\/span><\/div>
}<\/span><\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n
\n\n\n\n
Constructor<\/h2>\n\n\n\n
El patr\u00f3n Builder es un patr\u00f3n de dise\u00f1o creativo que le permite construir objetos complejos paso a paso,
separando su construcci\u00f3n de su representaci\u00f3n. Aqu\u00ed hay un ejemplo simple en Java:<\/p>\n\n\n
\n\t
\n\t\t
\n\t\t\t\n
\n
\/\/<\/span> Define<\/span> the<\/span> class<\/span> you<\/span> want<\/span> to<\/span> build<\/span><\/div>
class<\/span> Post<\/span> {<\/span><\/div>
private<\/span> final<\/span> String<\/span> title<\/span>;<\/span><\/div>
private<\/span> final<\/span> String<\/span> text<\/span>;<\/span><\/div>
private<\/span> final<\/span> String<\/span> category<\/span>;<\/span><\/div>
<\/div>
Post<\/span>(<\/span>Builder<\/span> builder<\/span>)<\/span> {<\/span><\/div>
    this<\/span>.<\/span>title<\/span> =<\/span> builder<\/span>.<\/span>title<\/span>;<\/span><\/div>
    this<\/span>.<\/span>text<\/span> =<\/span> builder<\/span>.<\/span>text<\/span>;<\/span><\/div>
    this<\/span>.<\/span>category<\/span> =<\/span> builder<\/span>.<\/span>category<\/span>;<\/span><\/div>
}<\/span><\/div>
<\/div>
\/\/<\/span> Getters<\/span> for<\/span> properties<\/span><\/div>
public<\/span> String<\/span> getTitle<\/span>()<\/span> {<\/span><\/div>
    return<\/span> title<\/span>;<\/span><\/div>
}<\/span><\/div>
<\/div>
public<\/span> String<\/span> getText<\/span>()<\/span> {<\/span><\/div>
    return<\/span> text<\/span>;<\/span><\/div>
}<\/span><\/div>
<\/div>
public<\/span> String<\/span> getCategory<\/span>()<\/span> {<\/span><\/div>
    return<\/span> category<\/span>;<\/span><\/div>
}<\/span><\/div>
<\/div>
\/\/<\/span> Builder<\/span> class<\/span><\/div>
public<\/span> static<\/span> class<\/span> Builder<\/span> {<\/span><\/div>
    private<\/span> String<\/span> title<\/span>;<\/span><\/div>
    private<\/span> String<\/span> text<\/span>;<\/span><\/div>
    private<\/span> String<\/span> category<\/span>;<\/span><\/div>
<\/div>
    public<\/span> Builder<\/span> title<\/span>(<\/span>String<\/span> title<\/span>)<\/span> {<\/span><\/div>
        this<\/span>.<\/span>title<\/span> =<\/span> title<\/span>;<\/span><\/div>
        return<\/span> this<\/span>;<\/span><\/div>
    }<\/span><\/div>
<\/div>
    public<\/span> Builder<\/span> text<\/span>(<\/span>String<\/span> text<\/span>)<\/span> {<\/span><\/div>
        this<\/span>.<\/span>text<\/span> =<\/span> text<\/span>;<\/span><\/div>
        return<\/span> this<\/span>;<\/span><\/div>
    }<\/span><\/div>
<\/div>
    public<\/span> Builder<\/span> category<\/span>(<\/span>String<\/span> category<\/span>)<\/span> {<\/span><\/div>
        this<\/span>.<\/span>category<\/span> =<\/span> category<\/span>;<\/span><\/div>
        return<\/span> this<\/span>;<\/span><\/div>
    }<\/span><\/div>
<\/div>
    public<\/span> Post<\/span> build<\/span>()<\/span> {<\/span><\/div>
        return<\/span> new<\/span> Post<\/span>(<\/span>this<\/span>)<\/span>;<\/span><\/div>
    }<\/span><\/div>
}<\/span><\/div>
<\/div>
\/\/<\/span> Usage<\/span><\/div>
public<\/span> class<\/span> Main<\/span> {<\/span><\/div>
public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[]<\/span> args<\/span>)<\/span> {<\/span><\/div>
Post<\/span> post<\/span> =<\/span> new<\/span> Post<\/span>.<\/span>Builder<\/span>()<\/span><\/div>
.<\/span>title<\/span>(<\/span>"Java Builder Pattern"<\/span>)<\/span><\/div>
.<\/span>text<\/span>(<\/span>"Explaining how to implement the Builder Pattern in Java"<\/span>)<\/span><\/div>
.<\/span>category<\/span>(<\/span>"Design Patterns"<\/span>)<\/span><\/div>
.<\/span>build<\/span>()<\/span>;<\/span><\/div>
<\/div>
System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>"Title: "<\/span> +<\/span> post<\/span>.<\/span>getTitle<\/span>())<\/span>;<\/span><\/div>
    System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>"Text: "<\/span> +<\/span> post<\/span>.<\/span>getText<\/span>())<\/span>;<\/span><\/div>
    System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>"Category: "<\/span> +<\/span> post<\/span>.<\/span>getCategory<\/span>())<\/span>;<\/span><\/div>
  }<\/span><\/div>
}<\/span><\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n
\n\n\n\n
Prototipo<\/h2>\n\n\n\n
Prototipo<\/strong>

El patr\u00f3n prototipo es un patr\u00f3n de dise\u00f1o creativo que le permite crear nuevos objetos copiando un objeto existente.
En lugar de crear nuevas instancias desde cero, se clona un prototipo existente, que puede ser m\u00e1s eficiente y flexible. Veamos un ejemplo en Java:
Definir la interfaz del prototipo<\/strong>: Primero creamos una clase o interfaz abstracta llamada Tree<\/code>, con un m\u00e9todo abstracto copy()<\/code>:<\/p>\n\n\n
\n\t
\n\t\t
\n\t\t\t\n
\n
public abstract class Tree {<\/div>
public abstract Tree copy();<\/div>
}<\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n
Prototipos de hormig\u00f3n<\/strong>: A continuaci\u00f3n, implementamos dos clases concretas que extienden Tree<\/code>: PlasticTree<\/code> y PineTree<\/code>. Estas clases representan tipos espec\u00edficos de \u00e1rboles y proporcionan su propia implementaci\u00f3n de m\u00e9todos. copy()<\/code>:<\/p>\n\n\n
\n\t
\n\t\t
\n\t\t\t\n
\n
public class PlasticTree extends Tree {<\/div>
@Override<\/div>
public Tree copy() {<\/div>
PlasticTree plasticTreeClone = new PlasticTree(this.getMass(), <\/div>
this.getHeight());<\/div>
plasticTreeClone.setPosition(this.getPosition());<\/div>
return plasticTreeClone;<\/div>
  }<\/div>
}<\/div>
<\/div>
public class PineTree extends Tree {<\/div>
@Override<\/div>
public Tree copy() {<\/div>
PineTree pineTreeClone = new PineTree(this.getMass(), <\/div>
this.getHeight());<\/div>
pineTreeClone.setPosition(this.getPosition());<\/div>
return pineTreeClone;<\/div>
  }<\/div>
}<\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n

En estas clases personalizamos el proceso de clonaci\u00f3n seg\u00fan el tipo de \u00e1rbol espec\u00edfico. Por ejemplo, copiamos masa<\/em>, altura<\/em> y posici\u00f3n<\/em> del \u00e1rbol original.
Uso<\/strong>: Ahora creemos una instancia de nuestros prototipos concretos:
Java<\/p>\n\n\n\n
<\/p>\n\n\n
\n\t
\n\t\t
\n\t\t\t\n
\n
public<\/span> class<\/span> Main<\/span> {<\/span><\/div>
public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[]<\/span> args<\/span>)<\/span> {<\/span><\/div>
Tree<\/span> originalPlasticTree<\/span> =<\/span> new<\/span> PlasticTree<\/span>(<\/span>10<\/span>,<\/span> 5<\/span>)<\/span>;<\/span><\/div>
Tree<\/span> clonedPlasticTree<\/span> =<\/span> originalPlasticTree<\/span>.<\/span>copy<\/span>()<\/span>;<\/span><\/div>
    Tree<\/span> originalPineTree<\/span> =<\/span> new<\/span> PineTree<\/span>(<\/span>15<\/span>,<\/span> 8<\/span>)<\/span>;<\/span><\/div>
    Tree<\/span> clonedPineTree<\/span> =<\/span> originalPineTree<\/span>.<\/span>copy<\/span>()<\/span>;<\/span><\/div>
<\/div>
    \/\/<\/span> Use<\/span> the<\/span> cloned<\/span> trees<\/span> as<\/span> needed<\/span><\/div>
    \/\/<\/span> ...<\/span><\/div>
  }<\/span><\/div>
}<\/span><\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n
\n\n\n\n
\u00bfQu\u00e9 son los patrones estructurales?<\/h2>\n\n\n\n
Estas plantillas se refieren a la estructura y composici\u00f3n de una clase.<\/p>\n\n\n\n
Patr\u00f3n de adaptador<\/h2>\n\n\n\n
El patr\u00f3n de adaptador es un patr\u00f3n de dise\u00f1o estructural que permite que dos interfaces incompatibles funcionen juntas.
Act\u00faa como un puente entre estas interfaces, permiti\u00e9ndoles cooperar sin cambiar su c\u00f3digo fuente.<\/p>\n\n\n\n
Adaptador de objetos:
En este enfoque, utilizamos la composici\u00f3n para delegar la l\u00f3gica al adaptador.
El Adaptador contiene un Adaptee y delega el m\u00e9todo request() al m\u00e9todo espec\u00edficoRequest() en el Adaptee.
<\/p>\n\n\n
\n\t
\n\t\t
\n\t\t\t\n
\n
class Adaptee {<\/div>
void specificRequest() {<\/div>
System.out.println("Adaptee's specific request");<\/div>
  }<\/div>
}<\/div>
<\/div>
\/\/ Target interface<\/div>
interface Target {<\/div>
void request();<\/div>
}<\/div>
<\/div>
\/\/ Adapter (using composition)<\/div>
class Adapter implements Target {<\/div>
private final Adaptee adaptee;<\/div>
<\/div>
Adapter(Adaptee adaptee) {<\/div>
    this.adaptee = adaptee;<\/div>
}<\/div>
<\/div>
@Override<\/div>
public void request() {<\/div>
    adaptee.specificRequest();<\/div>
  }<\/div>
}<\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n
Adaptador de clase:
Requiere herencia m\u00faltiple (directamente imposible en Java).
Podemos lograr esto usando interfaces con m\u00e9todos predeterminados.
El Adaptador hereda de las clases Target y Adaptee.<\/p>\n\n\n
\n\t
\n\t\t
\n\t\t\t\n
\n
\/\/ Target interface<\/div>
interface Target {<\/div>
void request();<\/div>
}<\/div>
<\/div>
\/\/ Adaptee (existing class)<\/div>
class Adaptee {<\/div>
void specificRequest() {<\/div>
System.out.println("Adaptee's specific request");<\/div>
  }<\/div>
}<\/div>
<\/div>
\/\/ Adapter (using class inheritance)<\/div>
class Adapter extends Adaptee implements Target {<\/div>
@Override<\/div>
public void request() {<\/div>
specificRequest();<\/div>
  }<\/div>
}<\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n

Beneficios y compensaciones:
Class Adapter funciona bien para el mapeo uno a uno de m\u00e9todos.
Object Adapter proporciona m\u00e1s flexibilidad y evita la modificaci\u00f3n del c\u00f3digo fuente.<\/p>\n\n\n\n
\n\n\n\n
Patr\u00f3n decorador<\/h2>\n\n\n\n
El Patr\u00f3n Decorador es un patr\u00f3n de dise\u00f1o creativo que le permite agregar din\u00e1micamente funcionalidad y comportamiento a un objeto sin
para influir en el comportamiento de otros objetos existentes en la misma clase. Es especialmente \u00fatil cuando desea ampliar las capacidades de un objeto,
sin cambiar su estructura.<\/p>\n\n\n\n
Descripci\u00f3n general:
El Patr\u00f3n Decorador proporciona una interfaz extendida para el objeto original “envolvi\u00e9ndolo” con funcionalidad adicional.
Preferimos la composici\u00f3n a la herencia para reducir la sobrecarga de la subclasificaci\u00f3n.
Se pueden agregar decoradores en tiempo de ejecuci\u00f3n, lo que proporciona flexibilidad.
Escenario de ejemplo: Supongamos que tenemos un objeto \u00c1rbol de Navidad y queremos decorarlo con varios elementos como guirnaldas, oropel y luces de burbujas. Seguiremos las convenciones de dise\u00f1o originales de Gang of Four.
Implementaci\u00f3n:<\/p>\n\n\n
\n\t
\n\t\t
\n\t\t\t\n
\n
First<\/span>,<\/span> create<\/span> a<\/span> ChristmasTree<\/span> interface<\/span>:<\/span><\/div>
Java<\/span><\/div>
<\/div>
public<\/span> interface<\/span> ChristmasTree<\/span> {<\/span><\/div>
String<\/span> decorate<\/span>()<\/span>;<\/span><\/div>
}<\/span><\/div>
<\/div>
Implement<\/span> the<\/span> interface<\/span> with<\/span> a<\/span> basic<\/span> tree<\/span>:<\/span><\/div>
Java<\/span><\/div>
<\/div>
public<\/span> class<\/span> ChristmasTreeImpl<\/span> implements<\/span> ChristmasTree<\/span> {<\/span><\/div>
@<\/span>Override<\/span><\/div>
public<\/span> String<\/span> decorate<\/span>()<\/span> {<\/span><\/div>
return<\/span> "Christmas tree"<\/span>;<\/span><\/div>
  }<\/span><\/div>
}<\/span><\/div>
<\/div>
Next<\/span>,<\/span> create<\/span> an<\/span> abstract<\/span> TreeDecorator<\/span> class<\/span> that<\/span> implements<\/span> <\/div>
ChristmasTree<\/span> and<\/span> holds<\/span> the<\/span> decorated<\/span> tree<\/span>:<\/span><\/div>
Java<\/span><\/div>
<\/div>
public<\/span> abstract<\/span> class<\/span> TreeDecorator<\/span> implements<\/span> ChristmasTree<\/span> {<\/span><\/div>
private<\/span> final<\/span> ChristmasTree<\/span> tree<\/span>;<\/span><\/div>
public<\/span> TreeDecorator<\/span>(<\/span>ChristmasTree<\/span> tree<\/span>)<\/span> {<\/span><\/div>
    this<\/span>.<\/span>tree<\/span> =<\/span> tree<\/span>;<\/span><\/div>
}<\/span><\/div>
<\/div>
@<\/span>Override<\/span><\/div>
public<\/span> String<\/span> decorate<\/span>()<\/span> {<\/span><\/div>
    return<\/span> tree<\/span>.<\/span>decorate<\/span>()<\/span>;<\/span><\/div>
  }<\/span><\/div>
}<\/span><\/div>
<\/div>
Now<\/span> create<\/span> specific<\/span> decorators<\/span>.<\/span> For<\/span> example<\/span>,<\/span> BubbleLights<\/span>:<\/span><\/div>
Java<\/span><\/div>
<\/div>
public<\/span> class<\/span> BubbleLights<\/span> extends<\/span> TreeDecorator<\/span> {<\/span><\/div>
public<\/span> BubbleLights<\/span>(<\/span>ChristmasTree<\/span> tree<\/span>)<\/span> {<\/span><\/div>
  super<\/span>(<\/span>tree<\/span>)<\/span>;<\/span><\/div>
  }<\/span><\/div>
<\/div>
@<\/span>Override<\/span><\/div>
public<\/span> String<\/span> decorate<\/span>()<\/span> {<\/span><\/div>
    return<\/span> super<\/span>.<\/span>decorate<\/span>()<\/span> +<\/span> " with Bubble Lights"<\/span>;<\/span><\/div>
  }<\/span><\/div>
}<\/span><\/div>
<\/div>
public<\/span> class<\/span> Garland<\/span> extends<\/span> TreeDecorator<\/span> {<\/span><\/div>
public<\/span> Garland<\/span>(<\/span>ChristmasTree<\/span> tree<\/span>)<\/span> {<\/span><\/div>
super<\/span>(<\/span>tree<\/span>)<\/span>;<\/span><\/div>
}<\/span><\/div>
<\/div>
@<\/span>Override<\/span><\/div>
public<\/span> String<\/span> decorate<\/span>()<\/span> {<\/span><\/div>
    return<\/span> super<\/span>.<\/span>decorate<\/span>()<\/span> +<\/span> " with Garland"<\/span>;<\/span><\/div>
}<\/span><\/div>
<\/div>
}<\/span><\/div>
Usage<\/span>:<\/span><\/div>
Create<\/span> decorated<\/span> trees<\/span>:<\/span><\/div>
<\/div>
public<\/span> class<\/span> DecoratorPatternDemo<\/span> {<\/span><\/div>
public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[]<\/span> args<\/span>)<\/span> {<\/span><\/div>
ChristmasTree<\/span> tree1<\/span> =<\/span> new<\/span> Garland<\/span>(<\/span>new<\/span> ChristmasTreeImpl<\/span>())<\/span>;<\/span><\/div>
System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>tree1<\/span>.<\/span>decorate<\/span>())<\/span>;<\/span> <\/div>
\/\/<\/span> Output: "Christmas tree with Garland"<\/span><\/div>
ChristmasTree<\/span> tree2<\/span> =<\/span> new<\/span> BubbleLights<\/span>(<\/span><\/div>
new<\/span> Garland<\/span>(<\/span>new<\/span> Garland<\/span>(<\/span>new<\/span> ChristmasTreeImpl<\/span>())))<\/span>;<\/span><\/div>
    System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>tree2<\/span>.<\/span>decorate<\/span>())<\/span>;<\/span> <\/div>
    \/\/<\/span> Output: "Christmas tree with Garland with Garland <\/span><\/div>
    \/\/<\/span> with<\/span> Bubble<\/span> Lights<\/span>"<\/span><\/div>
  }<\/span><\/div>
}<\/span><\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n

Pattern permite agregar decoradores en tiempo de ejecuci\u00f3n, brindando flexibilidad para decorar seg\u00fan sea necesario.
Recuerde, el Patr\u00f3n Decorador se usa ampliamente en situaciones en las que desea ampliar el comportamiento de un objeto sin modificar su estructura b\u00e1sica.<\/p>\n\n\n\n
\n\n\n\n
Patr\u00f3n de fachada<\/h2>\n\n\n\n
El patr\u00f3n de fachada es un patr\u00f3n de dise\u00f1o estructural que simplifica la interacci\u00f3n con un subsistema complejo al proporcionar una interfaz unificada.
Act\u00faa como una “puerta de entrada” para ocultar la complejidad interna y hacer que el sistema sea m\u00e1s f\u00e1cil de usar para los clientes.<\/p>\n\n\n\n
Compuesto<\/h2>\n\n\n\n
El patr\u00f3n compuesto es un patr\u00f3n de dise\u00f1o estructural que le permite componer objetos en estructuras de \u00e1rbol para representar jerarqu\u00edas de parte y todo.
La idea principal detr\u00e1s del patr\u00f3n compuesto es construir una estructura de \u00e1rbol de objetos, donde los objetos individuales (hoja) y los objetos compuestos comparten una interfaz com\u00fan.<\/p>\n\n\n\n
Componente base (Departamento): Definiremos una interfaz de Departamento simple como nuestro componente base:<\/p>\n\n\n
\n\t
\n\t\t
\n\t\t\t\n
\n
public interface Department {<\/div>
void printDepartmentName();<\/div>
}<\/div>
<\/div>
Leaf Components (FinancialDepartment and SalesDepartment): <\/div>
Let\u2019s create classes for financial and sales departments, <\/div>
both implementing the Department interface:<\/div>
<\/div>
public class FinancialDepartment implements Department {<\/div>
  \/\/ Implementation details (e.g., id, name)<\/div>
  public void printDepartmentName() {<\/div>
  System.out.println(getClass().getSimpleName());<\/div>
  }<\/div>
}<\/div>
<\/div>
public class SalesDepartment implements Department {<\/div>
  \/\/ Implementation details (e.g., id, name)<\/div>
  public void printDepartmentName() {<\/div>
  System.out.println(getClass().getSimpleName());<\/div>
  }<\/div>
}<\/div>
<\/div>
These leaf classes implement the printDepartmentName() <\/div>
method and don\u2019t contain references to other Department objects.<\/div>
Composite Element (HeadDepartment): As a composite class, <\/div>
let\u2019s create a HeadDepartment that holds a collection of <\/div>
Department components:<\/div>
<\/div>
import java.util.ArrayList;<\/div>
import java.util.List;<\/div>
<\/div>
public class HeadDepartment implements Department {<\/div>
  private Integer id;<\/div>
  private String name;<\/div>
  private List childDepartments;<\/div>
<\/div>
  public HeadDepartment(Integer id, String name) {<\/div>
    this.id = id;<\/div>
    this.name = name;<\/div>
    this.childDepartments = new ArrayList<>();<\/div>
  }<\/div>
<\/div>
  public void printDepartmentName() {<\/div>
    childDepartments.forEach(Department::printDepartmentName);<\/div>
  }<\/div>
<\/div>
  public void addDepartment(Department department) {<\/div>
    childDepartments.add(department);<\/div>
  }<\/div>
<\/div>
  public void removeDepartment(Department department) {<\/div>
    childDepartments.remove(department);<\/div>
  }<\/div>
}<\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n
La clase HeadDepartment implementa el m\u00e9todo printDepartmentName() y proporciona m\u00e9todos para agregar y eliminar departamentos secundarios.
Uso: Puede crear instancias de departamentos hoja (por ejemplo, Departamento Financiero, Departamento de Ventas) y departamentos compuestos (por ejemplo, Departamento Principal). Agregue departamentos de hoja al compuesto e imprima sus nombres.<\/p>\n\n\n\n
<\/p>\n\n\n
\n\t
\n\t\t
\n\t\t\t\n
\n
public<\/span> class<\/span> Main<\/span> {<\/span><\/div>
public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[]<\/span> args<\/span>)<\/span> {<\/span><\/div>
    Department<\/span> finance<\/span> =<\/span> new<\/span> FinancialDepartment<\/span>()<\/span>;<\/span><\/div>
    Department<\/span> sales<\/span> =<\/span> new<\/span> SalesDepartment<\/span>()<\/span>;<\/span><\/div>
    HeadDepartment<\/span> headDepartment<\/span> =<\/span> new<\/span> HeadDepartment<\/span>(<\/span>1<\/span>,<\/span> <\/div>
    "Company Departments"<\/span>)<\/span>;<\/span><\/div>
    headDepartment<\/span>.<\/span>addDepartment<\/span>(<\/span>finance<\/span>)<\/span>;<\/span><\/div>
    headDepartment<\/span>.<\/span>addDepartment<\/span>(<\/span>sales<\/span>)<\/span>;<\/span><\/div>
    headDepartment<\/span>.<\/span>printDepartmentName<\/span>()<\/span>;<\/span><\/div>
  }<\/span><\/div>
}<\/span><\/div>
<\/div>
Output<\/span>:<\/span><\/div>
FinancialDepartment<\/span><\/div>
SalesDepartment<\/span><\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n
El patr\u00f3n compuesto le permite crear estructuras de \u00e1rbol flexibles donde
Los objetos individuales y las composiciones (composites) se pueden tratar de manera uniforme.<\/p>\n\n\n\n
\n\n\n\n
\u00bfQu\u00e9 es la funci\u00f3n HASH?<\/h2>\n\n\n\n
Una funci\u00f3n hash es una funci\u00f3n matem\u00e1tica que toma una entrada (o “mensaje”) y devuelve una cadena de caracteres de longitud fija,
que suele ser una secuencia de n\u00fameros y letras. Esta salida se denomina “valor hash” o simplemente “hash”. 
Las funciones hash se utilizan ampliamente en inform\u00e1tica y criptograf\u00eda y tienen varias propiedades importantes:<\/p>\n\n\n\n
\u00bfC\u00f3mo se utiliza una funci\u00f3n hash y c\u00f3mo funciona?<\/h2>\n\n\n\n
Determinista: la misma entrada siempre generar\u00e1 el mismo hash.<\/p>\n\n\n\n
R\u00e1pido: la funci\u00f3n puede calcular r\u00e1pidamente el valor hash para cualquier entrada.
\u00danico (casi): dos entradas diferentes deber\u00edan generar valores hash diferentes (tratamos de minimizar las “colisiones”).
Irreversible (unidireccional): dado un hash, deber\u00eda ser computacionalmente inviable recuperar la entrada original.
Uniforme: los valores hash se distribuyen uniformemente en el espacio de origen.<\/p>\n\n\n\n
Las funciones hash se utilizan ampliamente en diversas aplicaciones, como por ejemplo:<\/p>\n\n\n\n
Integridad de los datos: para garantizar que los datos no hayan sido alterados o alterados mediante la comparaci\u00f3n de valores hash.
Almacenamiento de contrase\u00f1as: para el almacenamiento seguro de contrase\u00f1as hash en lugar de contrase\u00f1as reales.
Criptograf\u00eda: Utilizada en firmas digitales y otros algoritmos criptogr\u00e1ficos.
Tablas hash: para una recuperaci\u00f3n eficiente de datos en programaci\u00f3n.<\/p>\n\n\n\n
Dame un ejemplo de un mapa hash: \u00bfc\u00f3mo lo implementar\u00edas?<\/h2>\n\n\n\n
SHA (algoritmo hash seguro):
Incluye variantes como SHA-1, SHA-256, SHA-384 y SHA-512.
SHA-256 y SHA-512 se utilizan ampliamente en criptograf\u00eda y tecnolog\u00edas blockchain (por ejemplo, Bitcoin).<\/p>\n\n\n\n
<\/p>\n\n\n
\n\t
\n\t\t
\n\t\t\t\n
\n
import<\/span> java<\/span>.<\/span>security<\/span>.<\/span>MessageDigest<\/span>;<\/span><\/div>
import<\/span> java<\/span>.<\/span>security<\/span>.<\/span>NoSuchAlgorithmException<\/span>;<\/span><\/div>
<\/div>
public<\/span> class<\/span> HashExample<\/span> {<\/span><\/div>
public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[]<\/span> args<\/span>)<\/span> {<\/span><\/div>
try<\/span> {<\/span><\/div>
\/\/<\/span> The<\/span> input<\/span> string<\/span> to<\/span> be<\/span> hashed<\/span><\/div>
String<\/span> input<\/span> =<\/span> "Hello, world!"<\/span>;<\/span><\/div>
        \/\/<\/span> Create<\/span> a<\/span> MessageDigest<\/span> instance<\/span> for<\/span> SHA<\/span>-<\/span>256<\/span><\/div>
        MessageDigest<\/span> digest<\/span> =<\/span> <\/div>
        MessageDigest<\/span>.<\/span>getInstance<\/span>(<\/span>"SHA-256"<\/span>)<\/span>;<\/span><\/div>
<\/div>
        \/\/<\/span> Compute<\/span> the<\/span> hash<\/span><\/div>
        byte<\/span>[]<\/span> hash<\/span> =<\/span> digest<\/span>.<\/span>digest<\/span>(<\/span>input<\/span>.<\/span>getBytes<\/span>())<\/span>;<\/span><\/div>
<\/div>
        \/\/<\/span> Convert<\/span> the<\/span> hash<\/span> bytes<\/span> to<\/span> a<\/span> hexadecimal<\/span> string<\/span><\/div>
        StringBuilder<\/span> hexString<\/span> =<\/span> new<\/span> StringBuilder<\/span>()<\/span>;<\/span><\/div>
        for<\/span> (<\/span>byte<\/span> b : hash) {<\/span><\/div>
            String<\/span> hex<\/span> =<\/span> String<\/span>.<\/span>format<\/span>(<\/span>"%02x"<\/span>,<\/span> b<\/span>)<\/span>;<\/span><\/div>
            hexString<\/span>.<\/span>append<\/span>(<\/span>hex<\/span>)<\/span>;<\/span><\/div>
        }<\/span><\/div>
<\/div>
        \/\/<\/span> Print<\/span> the<\/span> resulting<\/span> hash<\/span><\/div>
        System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>"SHA-256 Hash: "<\/span> +<\/span> <\/div>
        hexString<\/span>.<\/span>toString<\/span>())<\/span>;<\/span><\/div>
    }<\/span> catch<\/span> (<\/span>NoSuchAlgorithmException<\/span> e<\/span>)<\/span> {<\/span><\/div>
        System<\/span>.<\/span>err<\/span>.<\/span>println<\/span>(<\/span>"Error: "<\/span> +<\/span> e<\/span>.<\/span>getMessage<\/span>())<\/span>;<\/span><\/div>
    }<\/span><\/div>
  }<\/span><\/div>
}<\/span><\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n
Datos de entrada: la variable de entrada contiene los datos que queremos aplicar hash.
Inicializaci\u00f3n de MessageDigest: la instancia de MessageDigest se crea utilizando getInstance(“SHA-256”), que especifica el algoritmo hash SHA-256.
Hashing: el m\u00e9todo de resumen calcula el valor hash de los datos de entrada.
Conversi\u00f3n hexadecimal: dado que el valor hash est\u00e1 en formato binario, usamos un bucle para convertirlo a una cadena hexadecimal m\u00e1s legible.<\/p>\n\n\n\n
\n\n\n\n
\u00bfPoner y parchear? \u00bfCu\u00e1ndo debemos usarlos?<\/h2>\n\n\n\n
PUT y PATCH son m\u00e9todos HTTP que se utilizan para actualizar recursos en el servidor, pero difieren en c\u00f3mo aplican los cambios:<\/p>\n\n\n\n
PONER:
Actualizaci\u00f3n completa:
PUT se utiliza para reemplazar completamente un recurso existente.
Se debe presentar el recurso completo en la solicitud, incluso si solo se cambia una parte.<\/p>\n\n\n\n
Si el recurso no existe, PUT suele crearlo (aunque este comportamiento puede variar).<\/p>\n\n\n\n
Idempotente:<\/p>\n\n\n\n
Las solicitudes PUT repetidas con los mismos datos siempre dan como resultado el mismo estado del recurso.
Ejemplo: actualizar perfil de usuario:<\/p>\n\n\n
\n\t
\n\t\t
\n\t\t\t\n
\n
json<\/div>
PUT \/users\/123<\/div>
{<\/div>
"name": "Velislav",<\/div>
"email": "velislav@example.com",<\/div>
"age": 30<\/div>
}<\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n

Si solo cambia el nombre, pero el correo electr\u00f3nico y la edad siguen siendo los mismos, a\u00fan deben estar presentes en la solicitud.<\/p>\n\n\n\n
PARCHES:
Actualizaci\u00f3n parcial:<\/p>\n\n\n\n
PATCH se utiliza para actualizar parcialmente un recurso existente.
S\u00f3lo los campos que cambian se env\u00edan en la solicitud.<\/p>\n\n\n\n
Idempotente (principalmente):<\/p>\n\n\n\n
Al igual que PUT, las solicitudes PATCH repetidas con los mismos datos generalmente dan como resultado el mismo estado de recurso.
Sin embargo, el comportamiento puede depender de la implementaci\u00f3n del servidor.<\/p>\n\n\n\n
Ejemplo: actualizar solo nombre de usuario:<\/p>\n\n\n
\n\t
\n\t\t
\n\t\t\t\n
\n
json<\/div>
PATCH \/users\/123<\/div>
{<\/div>
"name": "Velislav"<\/div>
}<\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n

Aqu\u00ed, solo se actualiza el campo de nombre y los dem\u00e1s campos permanecen sin cambios.<\/p>\n\n\n\n
Diferencia principal:
PUT reemplaza todo el recurso, mientras que PATCH cambia solo los campos especificados del recurso.<\/p>\n\n\n\n
\n\n\n\n
M\u00e9todos HTTP con una breve descripci\u00f3n.<\/strong><\/h2>\n\n\n\n
GET: Se utiliza para recuperar datos del servidor sin modificarlos. A menudo se utiliza para buscar recursos o informaci\u00f3n.
POST: Se utiliza para enviar datos al servidor, generalmente para crear un nuevo recurso. Por ejemplo, al enviar un formulario o cargar un archivo.
PUT: Se utiliza para actualizar o reemplazar completamente un recurso existente en el servidor. Si el recurso no existe, se puede crear.
PATCH: Se utiliza para una actualizaci\u00f3n parcial de un recurso existente, modificando solo los campos especificados.
ELIMINAR: Se utiliza para eliminar un recurso del servidor.
HEAD: Similar a GET, se utiliza para recuperar solo los encabezados sin el cuerpo del recurso.
OPCIONES: Muestra qu\u00e9 m\u00e9todos HTTP est\u00e1n permitidos.
TRACE: Se utiliza principalmente con fines de diagn\u00f3stico al hacer eco de la solicitud al cliente.
CONNECT: Establece un t\u00fanel hacia el servidor, a menudo utilizado para conexiones SSL\/TLS.<\/p>\n\n\n\n
\n\n\n\n
Interfaz funcional<\/h2>\n\n\n\n
Una interfaz funcional en Java es una interfaz que contiene exactamente un m\u00e9todo abstracto. Estas interfaces se utilizan principalmente con expresiones lambda y referencias de m\u00e9todos, lo que permite un estilo de programaci\u00f3n funcional m\u00e1s breve y legible.<\/p>\n\n\n\n
Caracter\u00edsticas principales:<\/h3>\n\n\n\n
    \n
  1. M\u00e9todo abstracto \u00fanico<\/strong>: La interfaz funcional tiene un solo m\u00e9todo abstracto. \u00c9sta es la esencia de su funcionalidad.<\/li>\n\n\n\n
  2. M\u00e9todos predeterminados y est\u00e1ticos<\/strong>: Las interfaces funcionales pueden contener m\u00e9todos predeterminados y est\u00e1ticos, pero no cuentan como el \u00fanico m\u00e9todo abstracto.<\/li>\n\n\n\n
  3. Anotaci\u00f3n @FunctionalInterface<\/strong>: Si bien esta anotaci\u00f3n es opcional, ayuda a indicar que la interfaz proporcionada est\u00e1 destinada a ser funcional. Si se agregan m\u00e9todos abstractos adicionales a la interfaz, el compilador arroja un error.<\/li>\n<\/ol>\n\n\n\n
    Ejemplo:<\/h3>\n\n\n
    \n\t
    \n\t\t
    \n\t\t\t\n
    \n
    @<\/span>FunctionalInterface<\/span><\/div>
    interface<\/span> Calculator<\/span> {<\/span><\/div>
        int<\/span> calculate<\/span>(<\/span>int<\/span> a<\/span>,<\/span> int<\/span> b<\/span>)<\/span>;<\/span><\/div>
    }<\/span><\/div>
    <\/div>
    \/\/<\/span> Using<\/span> lambda<\/span> expression<\/span><\/div>
    public<\/span> class<\/span> Main<\/span> {<\/span><\/div>
        public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[]<\/span> args<\/span>)<\/span> {<\/span><\/div>
            \/\/<\/span> Implementing<\/span> the<\/span> calculate<\/span> method<\/span> using<\/span> a<\/span> lambda<\/span><\/div>
            Calculator<\/span> addition<\/span> =<\/span> (<\/span>a<\/span>,<\/span> b<\/span>)<\/span> -><\/span> a<\/span> +<\/span> b<\/span>;<\/span><\/div>
            Calculator<\/span> multiplication<\/span> =<\/span> (<\/span>a<\/span>,<\/span> b<\/span>)<\/span> -><\/span> a<\/span> *<\/span> b<\/span>;<\/span><\/div>
    <\/div>
            System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>"Addition: "<\/span> +<\/span> <\/div>
            addition<\/span>.<\/span>calculate<\/span>(<\/span>5<\/span>,<\/span> 3<\/span>))<\/span>;<\/span>  \/\/<\/span> Output: 8<\/span><\/div>
            System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>"Multiplication: "<\/span> +<\/span> <\/div>
            multiplication<\/span>.<\/span>calculate<\/span>(<\/span>5<\/span>,<\/span> 3<\/span>))<\/span>;<\/span>  \/\/<\/span> Output: 15<\/span><\/div>
        }<\/span><\/div>
    }<\/span><\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n
    Caso de uso:<\/h3>\n\n\n\n
    la interfaz Calculator<\/code> en el ejemplo solo hay un m\u00e9todo abstracto calculate<\/code>, lo que la convierte en una interfaz funcional.
    Esto nos permite utilizar expresiones lambda para una implementaci\u00f3n m\u00e1s corta y elegante.<\/p>\n\n\n\n
    Interfaces funcionales com\u00fanmente utilizadas en Java:<\/h3>\n\n\n\n
    Java proporciona varias interfaces funcionales integradas en el paquete. java.util.function<\/code>, como:<\/p>\n\n\n\n
      \n
    • Predicado<\/strong>: Acepta una entrada y devuelve un valor booleano.<\/li>\n\n\n\n
    • Funci\u00f3n<\/strong>: toma una entrada y devuelve un resultado de tipo R.<\/li>\n\n\n\n
    • Proveedor<\/strong>: proporciona un valor sin entrada.<\/li>\n\n\n\n
    • Consumidor<\/strong>: Toma un valor y realiza una acci\u00f3n.<\/li>\n<\/ul>\n\n\n\n
      Las interfaces funcionales facilitan el trabajo, especialmente en escenarios como trabajar con colecciones, transmisiones o tareas asincr\u00f3nicas.<\/p>\n\n\n\n
      Permiten que Java adopte paradigmas de programaci\u00f3n funcional manteniendo su car\u00e1cter orientado a objetos.<\/h2>\n\n\n\n
      \n\n\n\n
      \u00bfQu\u00e9 es una funci\u00f3n de orden superior?<\/h2>\n\n\n\n
      Una funci\u00f3n de orden superior es una funci\u00f3n que acepta otras funciones como argumentos o devuelve una funci\u00f3n como resultado. En otras palabras, opera con funciones, trat\u00e1ndolas como “ciudadanos de primera”. Esta es una caracter\u00edstica poderosa en los paradigmas de programaci\u00f3n funcional que permite la abstracci\u00f3n, la reutilizaci\u00f3n y la composici\u00f3n del c\u00f3digo.<\/p>\n\n\n\n
      Ejemplo de funci\u00f3n de orden superior en Java:<\/h3>\n\n\n
      \n\t
      \n\t\t
      \n\t\t\t\n
      \n
      import java.util.function.Function;<\/div>
      <\/div>
      public class Main {<\/div>
          public static void main(String[] args) {<\/div>
              \/\/ Higher-order function: applies a function to a value<\/div>
              Function<<\/span>Integer<\/span>,<\/span> Integer<\/span>><\/span> squareFunction = x -> x * x;<\/div>
              int result = applyFunction(5, squareFunction);<\/div>
              System.out.println("Square of 5: " + result);  <\/div>
                \/\/ Output: 25<\/div>
          }<\/div>
      <\/div>
          public static int applyFunction(int value, <\/div>
          Function<<\/span>Integer<\/span>,<\/span> Integer<\/span>><\/span> function) {<\/div>
              return function.apply(value);<\/div>
          }<\/div>
      }<\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n
      En el ejemplo anterior:<\/p>\n\n\n\n
        \n
      • el metodo applyFunction<\/code> es una funci\u00f3n de orden superior porque acepta otra funci\u00f3n (Function<Integer, Integer><\/code>) como par\u00e1metro.<\/li>\n<\/ul>\n\n\n\n
        Caracter\u00edsticas:<\/h3>\n\n\n\n
          \n
        1. Acepta funciones como argumentos<\/strong>: Las funciones de orden superior pueden tomar otras funciones como entrada para realizar operaciones espec\u00edficas.<\/li>\n\n\n\n
        2. Funciones de devoluciones<\/strong>: Pueden generar y devolver din\u00e1micamente nuevas funciones.<\/li>\n\n\n\n
        3. Fomenta la reutilizaci\u00f3n del c\u00f3digo<\/strong>: Promueve el c\u00f3digo modular y reutilizable, ya que las funciones se pueden pasar y combinar entre s\u00ed.<\/li>\n<\/ol>\n\n\n\n
          Caso de uso:<\/h3>\n\n\n\n
          En Java, las funciones de orden superior se utilizan a menudo en la programaci\u00f3n funcional con secuencias, lambdas y referencias de m\u00e9todos. Por ejemplo:<\/p>\n\n\n
          \n\t
          \n\t\t
          \n\t\t\t\n
          \n
          List<<\/span>String<\/span>><\/span> names = Arrays.asList("John", "Jane", "Jake");<\/div>
          names.stream()<\/div>
               .filter(name -> name.startsWith("J"))  <\/div>
               \/\/ Takes a lambda function as argument<\/div>
               .forEach(System.out::println);         <\/div>
            \/\/ Takes a method reference as argument<\/div><\/code><\/pre>\n\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n
          Las funciones de orden superior a\u00f1aden flexibilidad y potencia a los programas Java, permitiendo a los desarrolladores escribir c\u00f3digo limpio, conciso y expresivo.<\/h2>\n\n\n\n
          \n\n\n\n
          Algunos ejemplos reales con respuestas de entrevistas.<\/h2>\n\n\n\n
            \n
          • Comprende los conceptos b\u00e1sicos como polimorfismo, m\u00e9todos est\u00e1ticos y grupo de cadenas.<\/li>\n\n\n\n
          • Familiarizado con las colecciones (por ejemplo, HashSet, TreeSet) y sus casos de uso.<\/li>\n\n\n\n
          • Identificar correctamente los alcances de los beans (singleton, prototipo)<\/li>\n\n\n\n
          • Entiende qu\u00e9 es la inyecci\u00f3n de dependencia y su finalidad.<\/li>\n\n\n\n
          • Sabe c\u00f3mo implementar relaciones de muchos a muchos utilizando tablas de uni\u00f3n.<\/li>\n\n\n\n
          • Entiende el prop\u00f3sito de los \u00edndices (aunque superficialmente)<\/li>\n\n\n\n
          • Puede distinguir entre arquitecturas monol\u00edticas y de microservicios.<\/li>\n\n\n\n
          • Entiende las compensaciones b\u00e1sicas (escalabilidad, mantenibilidad)<\/li>\n\n\n\n
          • No comprende adecuadamente el principio de sustituci\u00f3n de Liskov y la inversi\u00f3n de dependencia.<\/li>\n\n\n\n
          • Es dif\u00edcil dar ejemplos concretos del principio abierto\/cerrado.<\/li>\n\n\n\n
          • No hay conocimientos profundos sobre la gesti\u00f3n del ciclo de vida de los beans.<\/li>\n\n\n\n
          • No comprende la inyecci\u00f3n avanzada de dependencia.<\/li>\n\n\n\n
          • Tiene un conocimiento superficial de los \u00edndices (\u00edndices compuestos, optimizaci\u00f3n de consultas).<\/li>\n\n\n\n
          • No estoy familiarizado con los niveles de aislamiento y el bloqueo optimista\/pesimista.<\/li>\n<\/ul>\n\n\n\n
            Ventajas:<\/p>\n\n\n\n
              \n
            • Trabaj\u00e9 con c\u00f3digo heredado en un sistema grande y complejo.<\/li>\n\n\n\n
            • Est\u00e1 familiarizado con SOLID.<\/li>\n\n\n\n
            • Tiene conocimiento de arroyos.<\/li>\n\n\n\n
            • Explicar \u00edndices y ACID.<\/li>\n\n\n\n
            • Buen nivel de ingles
              Contras:<\/li>\n\n\n\n
            • No hay responsabilidad por el despliegue o la infraestructura, participaci\u00f3n en el dise\u00f1o de la arquitectura.<\/li>\n\n\n\n
            • Tiene cierto conocimiento de los principios de la programaci\u00f3n orientada a objetos, pero ha tenido serias dificultades para explicarlos y ha confundido algunos conceptos.<\/li>\n\n\n\n
            • Conocimiento general de colecciones, pero con lagunas y bastante incierto.<\/li>\n\n\n\n
            • No comprende la diferencia entre concurrencia y paralelismo, no tiene un conocimiento particularmente s\u00f3lido de concurrencia.<\/li>\n\n\n\n
            • No ha analizado en detalle la arquitectura de microservicios.<\/li>\n\n\n\n
            • Ambig\u00fcedad en algunos conceptos de bases de datos (la discusi\u00f3n sobre \u00edndices fue superficial).<\/li>\n\n\n\n
            • No se pudo explicar el bloqueo en vivo.<\/li>\n\n\n\n
            • Hay lagunas en la comprensi\u00f3n del bloque final.<\/li>\n\n\n\n
            • Conocimiento limitado de los detalles del manejo de excepciones.<\/li>\n\n\n\n
            • Confundido con modificadores de acceso (protegido versus paquete privado)
              La opini\u00f3n general es que
              no es adecuado para el puesto de desarrollador Mid-Java debido a las lagunas en sus conocimientos t\u00e9cnicos.<\/li>\n\n\n\n
            • Bien explicado S\u00d3LIDO.<\/li>\n\n\n\n
            • Explic\u00f3 bien la programaci\u00f3n orientada a objetos.<\/li>\n\n\n\n
            • Composici\u00f3n explicada (pero al principio fue un poco dif\u00edcil).<\/li>\n\n\n\n
            • Excelente conocimiento de las colecciones.<\/li>\n\n\n\n
            • Explica la diferencia entre listas y conjuntos.<\/li>\n\n\n\n
            • Discuta HashSet.<\/li>\n\n\n\n
            • Discuta HashMap.<\/li>\n\n\n\n
            • Analice ConcurrentHashMap.<\/li>\n\n\n\n
            • Buen conocimiento de las estructuras de datos: pilas, colas, \u00e1rboles.<\/li>\n\n\n\n
            • Buen conocimiento de la arquitectura JVM.<\/li>\n\n\n\n
            • Explic\u00f3 bien la concurrencia frente al paralelismo y demostr\u00f3 un buen conocimiento de las aplicaciones multiproceso.<\/li>\n\n\n\n
            • Buen conocimiento de REST.<\/li>\n\n\n\n
            • \u00cdndices de base de datos bien explicados.<\/li>\n\n\n\n
            • Explicar los diferentes tipos de uniones.<\/li>\n<\/ul>\n\n\n\n
              <\/p>\n","protected":false},"excerpt":{"rendered":"
              Preguntas e informaci\u00f3n sobre la preparaci\u00f3n de la entrevista para desarrolladores de Java \u00bfQuales son los principios S\u00d3LIDOS? \u00bfQu\u00e9 es el Principio de Responsabilidad \u00danica (PRS)? Una clase debe tener solo una responsabilidad y una sola raz\u00f3n para cambiar. Los beneficios incluyen pruebas m\u00e1s sincillas, menor acopliamiento y mejor organizaci\u00f3n. Ejemplo: \u00bfQu\u00e9 es el principio abierto-cerrado (OCP)? […]<\/p>\n","protected":false},"author":65283547,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_coblocks_attr":"","_coblocks_dimensions":"","_coblocks_responsive_height":"","_coblocks_accordion_ie_support":"","_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_wpcom_ai_launchpad_first_post":false,"_jetpack_hide_featured_image":false,"_jetpack_featured_image_duplicate_dismissed":0,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[1017],"tags":[11788,789678139,2549795,196,789678143],"class_list":["post-2308","post","type-post","status-publish","format-standard","hentry","category-java","tag-interview","tag-interview-java-developer","tag-java-2","tag-programming","tag-questions-java-developer"],"jetpack_publicize_connections":[],"jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p4CoHV-Be","jetpack-related-posts":[{"id":2350,"url":"https:\/\/vkrastev1blog.com\/2026\/09\/01\/%d0%b2-youtube-%d0%bc%d0%be%d0%b6%d0%b5%d1%82%d0%b5-%d0%b4%d0%b0-%d0%bd%d0%b0%d0%bc%d0%b5%d1%80%d0%b8%d1%82%d0%b5-%d0%b2%d0%b5%d1%87%d0%b5-%d0%bc%d0%be%d0%b8-%d1%85%d1%80%d0%b8%d1%81%d1%82%d0%b8%d1%8f\/","url_meta":{"origin":2308,"position":0},"title":"Ya puedes encontrar mis canciones cristianas en YouTube","author":"vkrastev2014","date":"01.09.2026","format":false,"excerpt":"\u0412 YouTube \u043c\u043e\u0436\u0435\u0442\u0435 \u0434\u0430 \u043d\u0430\u043c\u0435\u0440\u0438\u0442\u0435 \u0432\u0435\u0447\u0435 \u043c\u043e\u0438 \u0425\u0440\u0438\u0441\u0442\u0438\u044f\u043d\u0441\u043a\u0438 \u043f\u0435\u0441\u043d\u0438 \u0438 \u0438\u043d\u0441\u0442\u0443\u043c\u0435\u043d\u0442\u0430\u043b\u0438 \u0438 \u0432\u0438\u0434\u0435\u043e\u0442\u0430 \u043d\u0430 \u043f\u0435\u0441\u043d\u0438\u0442\u0435 \u0417\u0434\u0440\u0430\u0432\u0435\u0439\u0442\u0435, \u043f\u0440\u043e\u0434\u0443\u0446\u0438\u0440\u0430\u043c \u0425\u0440\u0438\u0441\u0442\u0438\u044f\u043d\u0441\u043a\u0438 \u043f\u0435\u0441\u043d\u0438. \u0421\u044a\u0437\u0434\u0430\u0432\u0430\u043c \u0433\u0438 \u0441 \u043f\u043e\u043c\u043e\u0449\u0430 \u043d\u0430 \u0438\u0437\u043a\u0443\u0441\u0442\u0432\u0435\u043d \u0438\u043d\u0442\u0435\u043b\u0435\u043a\u0442 \u0438 \u0438\u043c\u0430\u043c \u0437\u0430\u043f\u0430\u0437\u0435\u043d\u0438 \u0430\u0432\u0442\u043e\u0440\u0441\u043a\u0438 \u043f\u0440\u0430\u0432\u0430. \u0422\u0435\u043a\u0441\u0442\u043e\u0432\u0435\u0442\u0435 \u0441\u0430 \u043c\u043e\u0435 \u0434\u0435\u043b\u043e. \u0421\u0442\u0438\u043b\u0430 \u043d\u0430 \u043c\u0443\u0437\u0438\u043a\u0430\u0442\u0430 \u0441\u0435 \u043e\u043f\u0440\u0435\u0434\u0435\u043b\u044f \u0441\u044a\u0449\u043e \u043e\u0442 \u043c\u0435\u043d\u0435. \u0429\u0435 \u0441\u0435 \u0440\u0430\u0434\u0432\u0430\u043c \u043d\u0430 \u0432\u0430\u0448\u0438\u0442\u0435 \u043e\u0442\u0437\u0438\u0432\u0438 \u0438\u2026","rel":"","context":"In "Art\u00edculos dedicados a la Biblia y sobre el esp\u00edritu y el cuerpo."","block_context":{"text":"Art\u00edculos dedicados a la Biblia y sobre el esp\u00edritu y el cuerpo.","link":"https:\/\/vkrastev1blog.com\/category\/%d1%81%d1%82%d0%b0%d1%82%d0%b8%d0%b8-%d0%bf%d0%be%d1%81%d0%b2%d0%b5%d1%82%d0%b5%d0%bd%d0%b8-%d0%bd%d0%b0-%d0%b1%d0%b8%d0%b1%d0%bb%d0%b8%d1%8f%d1%82%d0%b0-%d0%b8-%d0%b7%d0%b0-%d0%b4%d1%83%d1%85%d0%b0\/"},"img":{"alt_text":"","src":"https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2026\/09\/image.png?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2026\/09\/image.png?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2026\/09\/image.png?resize=525%2C300&ssl=1 1.5x, https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2026\/09\/image.png?resize=700%2C400&ssl=1 2x, https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2026\/09\/image.png?resize=1050%2C600&ssl=1 3x, https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2026\/09\/image.png?resize=1400%2C800&ssl=1 4x"},"classes":[]},{"id":1655,"url":"https:\/\/vkrastev1blog.com\/2025\/01\/22\/%d1%81%d1%83%d0%b3%d0%b5%d1%81%d1%82%d0%be%d0%bf%d0%b5%d0%b4%d0%b8%d1%8f-%d0%bc%d0%b5%d1%82%d0%be%d0%b4-%d0%b7%d0%b0-%d1%81%d0%ba%d0%be%d1%80%d0%be%d1%81%d1%82%d0%bd%d0%be-%d1%83%d1%87%d0%b5%d0%bd\/","url_meta":{"origin":2308,"position":1},"title":"Sugestopedia: M\u00e9todo para el aprendizaje r\u00e1pido de lenguas extranjeras, desarrollado por Georgi Lozanov.","author":"vkrastev2014","date":"22.01.2025","format":false,"excerpt":"\u0421\u0443\u0433\u0435\u0441\u0442\u043e\u043f\u0435\u0434\u0438\u044f: \u041c\u0435\u0442\u043e\u0434 \u0437\u0430 \u0441\u043a\u043e\u0440\u043e\u0441\u0442\u043d\u043e \u0443\u0447\u0435\u043d\u0435 \u043d\u0430 \u0447\u0443\u0436\u0434\u0438 \u0435\u0437\u0438\u0446\u0438, \u0440\u0430\u0437\u0440\u0430\u0431\u043e\u0442\u0435\u043d \u043e\u0442 \u0413\u0435\u043e\u0440\u0433\u0438 \u041b\u043e\u0437\u0430\u043d\u043e\u0432 \u041d\u0430\u0443\u0447\u043d\u043e-\u043f\u043e\u043f\u0443\u043b\u044f\u0440\u043d\u0430 \u0438 \u043e\u0431\u0440\u0430\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u043d\u0430 \u0441\u0442\u0430\u0442\u0438\u044f | \u0411\u044a\u043b\u0433\u0430\u0440\u0441\u043a\u0438 \u043d\u0430\u0443\u0447\u0435\u043d \u043f\u0440\u0438\u043d\u043e\u0441 \u043a\u044a\u043c \u0441\u0432\u0435\u0442\u043e\u0432\u043d\u0430\u0442\u0430 \u043f\u0435\u0434\u0430\u0433\u043e\u0433\u0438\u043a\u0430 \u0412\u044a\u0432\u0435\u0434\u0435\u043d\u0438\u0435 \u0412\u044a\u0437\u043c\u043e\u0436\u043d\u043e \u043b\u0438 \u0435 \u0447\u043e\u0432\u0435\u043a \u0434\u0430 \u043d\u0430\u0443\u0447\u0438 \u0447\u0443\u0436\u0434 \u0435\u0437\u0438\u043a \u0437\u043d\u0430\u0447\u0438\u0442\u0435\u043b\u043d\u043e \u043f\u043e-\u0431\u044a\u0440\u0437\u043e, \u0431\u0435\u0437 \u0434\u0430 \u0438\u0437\u043f\u0438\u0442\u0432\u0430 \u043e\u0431\u0438\u0447\u0430\u0439\u043d\u043e\u0442\u043e \u043d\u0430\u043f\u0440\u0435\u0436\u0435\u043d\u0438\u0435, \u0443\u043c\u043e\u0440\u0430 \u0438 \u0441\u0442\u0440\u0430\u0445 \u043e\u0442 \u0434\u043e\u043f\u0443\u0441\u043a\u0430\u043d\u0435 \u043d\u0430 \u0433\u0440\u0435\u0448\u043a\u0438? \u0412\u044a\u0437\u043c\u043e\u0436\u043d\u043e \u043b\u0438 \u0435 \u043e\u0431\u0443\u0447\u0435\u043d\u0438\u0435\u0442\u043e\u2026","rel":"","context":"In "Art\u00edculos dedicados a la Biblia y sobre el esp\u00edritu y el cuerpo."","block_context":{"text":"Art\u00edculos dedicados a la Biblia y sobre el esp\u00edritu y el cuerpo.","link":"https:\/\/vkrastev1blog.com\/category\/%d1%81%d1%82%d0%b0%d1%82%d0%b8%d0%b8-%d0%bf%d0%be%d1%81%d0%b2%d0%b5%d1%82%d0%b5%d0%bd%d0%b8-%d0%bd%d0%b0-%d0%b1%d0%b8%d0%b1%d0%bb%d0%b8%d1%8f%d1%82%d0%b0-%d0%b8-%d0%b7%d0%b0-%d0%b4%d1%83%d1%85%d0%b0\/"},"img":{"alt_text":"","src":"https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2025\/01\/%D0%9F%D1%80%D0%BE%D1%84.-%D0%93%D0%B5%D0%BE%D1%80%D0%B3%D0%B8-%D0%9B%D0%BE%D0%B7%D0%B0%D0%BD%D0%BE%D0%B2_-%D0%98%D0%B7%D0%BA%D1%83%D1%81%D1%82%D0%B2%D0%BE-%D0%B8-%D1%83%D1%87%D0%B5%D0%BD%D0%B5.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2025\/01\/%D0%9F%D1%80%D0%BE%D1%84.-%D0%93%D0%B5%D0%BE%D1%80%D0%B3%D0%B8-%D0%9B%D0%BE%D0%B7%D0%B0%D0%BD%D0%BE%D0%B2_-%D0%98%D0%B7%D0%BA%D1%83%D1%81%D1%82%D0%B2%D0%BE-%D0%B8-%D1%83%D1%87%D0%B5%D0%BD%D0%B5.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2025\/01\/%D0%9F%D1%80%D0%BE%D1%84.-%D0%93%D0%B5%D0%BE%D1%80%D0%B3%D0%B8-%D0%9B%D0%BE%D0%B7%D0%B0%D0%BD%D0%BE%D0%B2_-%D0%98%D0%B7%D0%BA%D1%83%D1%81%D1%82%D0%B2%D0%BE-%D0%B8-%D1%83%D1%87%D0%B5%D0%BD%D0%B5.jpg?resize=525%2C300&ssl=1 1.5x, https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2025\/01\/%D0%9F%D1%80%D0%BE%D1%84.-%D0%93%D0%B5%D0%BE%D1%80%D0%B3%D0%B8-%D0%9B%D0%BE%D0%B7%D0%B0%D0%BD%D0%BE%D0%B2_-%D0%98%D0%B7%D0%BA%D1%83%D1%81%D1%82%D0%B2%D0%BE-%D0%B8-%D1%83%D1%87%D0%B5%D0%BD%D0%B5.jpg?resize=700%2C400&ssl=1 2x, https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2025\/01\/%D0%9F%D1%80%D0%BE%D1%84.-%D0%93%D0%B5%D0%BE%D1%80%D0%B3%D0%B8-%D0%9B%D0%BE%D0%B7%D0%B0%D0%BD%D0%BE%D0%B2_-%D0%98%D0%B7%D0%BA%D1%83%D1%81%D1%82%D0%B2%D0%BE-%D0%B8-%D1%83%D1%87%D0%B5%D0%BD%D0%B5.jpg?resize=1050%2C600&ssl=1 3x, https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2025\/01\/%D0%9F%D1%80%D0%BE%D1%84.-%D0%93%D0%B5%D0%BE%D1%80%D0%B3%D0%B8-%D0%9B%D0%BE%D0%B7%D0%B0%D0%BD%D0%BE%D0%B2_-%D0%98%D0%B7%D0%BA%D1%83%D1%81%D1%82%D0%B2%D0%BE-%D0%B8-%D1%83%D1%87%D0%B5%D0%BD%D0%B5.jpg?resize=1400%2C800&ssl=1 4x"},"classes":[]},{"id":2537,"url":"https:\/\/vkrastev1blog.com\/2026\/10\/02\/%d1%82%d1%80%d0%b5%d1%82%d0%b8%d1%8f%d1%82-%d0%b2%d1%81%d0%b5%d0%bb%d0%b5%d0%bd%d1%81%d0%ba%d0%b8-%d1%81%d1%8a%d0%b1%d0%be%d1%80-%d0%b2-%d0%b5%d1%84%d0%b5%d1%81-431-%d0%b3-%d1%85%d1%80%d0%b8%d1%81\/","url_meta":{"origin":2308,"position":2},"title":"El Tercer Concilio Ecum\u00e9nico de \u00c9feso (431): la disputa cristol\u00f3gica entre Cirilo de Alejandr\u00eda y Nestorio y la afirmaci\u00f3n de la doctrina de la Madre de Dios","author":"vkrastev2014","date":"02.10.2026","format":false,"excerpt":"\u0422\u0440\u0435\u0442\u0438\u044f\u0442 \u0432\u0441\u0435\u043b\u0435\u043d\u0441\u043a\u0438 \u0441\u044a\u0431\u043e\u0440 \u0432 \u0415\u0444\u0435\u0441 (431 \u0433.): \u0445\u0440\u0438\u0441\u0442\u043e\u043b\u043e\u0433\u0438\u0447\u043d\u0438\u044f\u0442 \u0441\u043f\u043e\u0440 \u043c\u0435\u0436\u0434\u0443 \u041a\u0438\u0440\u0438\u043b \u0410\u043b\u0435\u043a\u0441\u0430\u043d\u0434\u0440\u0438\u0439\u0441\u043a\u0438 \u0438 \u041d\u0435\u0441\u0442\u043e\u0440\u0438\u0439 \u0438 \u0443\u0442\u0432\u044a\u0440\u0436\u0434\u0430\u0432\u0430\u043d\u0435\u0442\u043e \u043d\u0430 \u0443\u0447\u0435\u043d\u0438\u0435\u0442\u043e \u0437\u0430 \u0411\u043e\u0433\u043e\u0440\u043e\u0434\u0438\u0446\u0430 \u041d\u0430\u0443\u0447\u043d\u043e-\u0438\u0441\u0442\u043e\u0440\u0438\u0447\u0435\u0441\u043a\u043e \u0438 \u0431\u043e\u0433\u043e\u0441\u043b\u043e\u0432\u0441\u043a\u043e \u0438\u0437\u0441\u043b\u0435\u0434\u0432\u0430\u043d\u0435 \u0410\u0432\u0442\u043e\u0440: \u0412\u0435\u043b\u0438\u0441\u043b\u0430\u0432 \u041a\u0440\u044a\u0441\u0442\u0435\u0432\u0422\u0435\u043c\u0430: \u0418\u0441\u0442\u043e\u0440\u0438\u044f \u043d\u0430 \u0440\u0430\u043d\u043d\u0430\u0442\u0430 \u0426\u044a\u0440\u043a\u0432\u0430 \u0438 \u0440\u0430\u0437\u0432\u0438\u0442\u0438\u0435 \u043d\u0430 \u0445\u0440\u0438\u0441\u0442\u043e\u043b\u043e\u0433\u0438\u0447\u043d\u0430\u0442\u0430 \u0434\u043e\u0433\u043c\u0430\u0442\u0438\u043a\u0430\u041f\u0435\u0440\u0438\u043e\u0434: 428\u2013451 \u0433.\u041e\u0441\u043d\u043e\u0432\u043d\u043e \u0441\u044a\u0431\u0438\u0442\u0438\u0435: \u0422\u0440\u0435\u0442\u0438\u044f\u0442 \u0432\u0441\u0435\u043b\u0435\u043d\u0441\u043a\u0438 \u0441\u044a\u0431\u043e\u0440, \u0415\u0444\u0435\u0441, 431 \u0433. \u0420\u0435\u0437\u044e\u043c\u0435 \u0422\u0440\u0435\u0442\u0438\u044f\u0442 \u0432\u0441\u0435\u043b\u0435\u043d\u0441\u043a\u0438 \u0441\u044a\u0431\u043e\u0440, \u043f\u0440\u043e\u0432\u0435\u0434\u0435\u043d\u2026","rel":"","context":"In "Art\u00edculos dedicados a la Biblia y sobre el esp\u00edritu y el cuerpo."","block_context":{"text":"Art\u00edculos dedicados a la Biblia y sobre el esp\u00edritu y el cuerpo.","link":"https:\/\/vkrastev1blog.com\/category\/%d1%81%d1%82%d0%b0%d1%82%d0%b8%d0%b8-%d0%bf%d0%be%d1%81%d0%b2%d0%b5%d1%82%d0%b5%d0%bd%d0%b8-%d0%bd%d0%b0-%d0%b1%d0%b8%d0%b1%d0%bb%d0%b8%d1%8f%d1%82%d0%b0-%d0%b8-%d0%b7%d0%b0-%d0%b4%d1%83%d1%85%d0%b0\/"},"img":{"alt_text":"","src":"https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2026\/10\/chatgpt-image-oct-2-2026-08_12_12-pm.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2026\/10\/chatgpt-image-oct-2-2026-08_12_12-pm.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2026\/10\/chatgpt-image-oct-2-2026-08_12_12-pm.jpg?resize=525%2C300&ssl=1 1.5x, https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2026\/10\/chatgpt-image-oct-2-2026-08_12_12-pm.jpg?resize=700%2C400&ssl=1 2x, https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2026\/10\/chatgpt-image-oct-2-2026-08_12_12-pm.jpg?resize=1050%2C600&ssl=1 3x, https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2026\/10\/chatgpt-image-oct-2-2026-08_12_12-pm.jpg?resize=1400%2C800&ssl=1 4x"},"classes":[]},{"id":901,"url":"https:\/\/vkrastev1blog.com\/2024\/11\/17\/%d0%ba%d0%be%d0%bb%d0%ba%d0%be-%d0%bf%d1%80%d0%be%d1%82%d0%b5%d0%b8%d0%bd%d0%b8-%d0%b4%d0%b0-%d0%bf%d1%80%d0%b8%d0%b5%d0%bc%d0%b0%d0%bc%d0%b5-%d0%bd%d0%b0-%d0%b4%d0%b5%d0%bd\/","url_meta":{"origin":2308,"position":3},"title":"Cu\u00e1nta prote\u00edna comer al d\u00eda y los efectos de la falta de prote\u00ednas","author":"vkrastev2014","date":"17.11.2024","format":false,"excerpt":"\u041a\u043e\u043b\u043a\u043e \u043f\u0440\u043e\u0442\u0435\u0438\u043d\u0438 \u0434\u0430 \u043f\u0440\u0438\u0435\u043c\u0430\u043c\u0435 \u043d\u0430 \u0434\u0435\u043d \u0438 \u043f\u043e\u0441\u043b\u0435\u0434\u0438\u0446\u0438\u0442\u0435 \u043e\u0442 \u043f\u0440\u043e\u0442\u0435\u0438\u043d\u043e\u0432 \u0433\u043b\u0430\u0434 \u041f\u0440\u0438\u0435\u043c\u044a\u0442 \u043d\u0430 \u0434\u043e\u0441\u0442\u0430\u0442\u044a\u0447\u043d\u043e \u043f\u0440\u043e\u0442\u0435\u0438\u043d\u0438 \u043d\u0430 \u0434\u0435\u043d \u0435 \u043e\u0442 \u0441\u044a\u0449\u0435\u0441\u0442\u0432\u0435\u043d\u043e \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u0435 \u0437\u0430 \u043e\u0440\u0433\u0430\u043d\u0438\u0437\u043c\u0430 \u043f\u043e\u0440\u0430\u0434\u0438 \u043d\u044f\u043a\u043e\u043b\u043a\u043e \u043f\u0440\u0438\u0447\u0438\u043d\u0438: \u0418\u0437\u0433\u0440\u0430\u0436\u0434\u0430\u043d\u0435 \u0438 \u0432\u044a\u0437\u0441\u0442\u0430\u043d\u043e\u0432\u044f\u0432\u0430\u043d\u0435 \u043d\u0430 \u0442\u044a\u043a\u0430\u043d\u0438: \u041f\u0440\u043e\u0442\u0435\u0438\u043d\u0438\u0442\u0435 \u0441\u0430 \u043e\u0441\u043d\u043e\u0432\u043d\u0438\u0442\u0435 \u0433\u0440\u0430\u0434\u0438\u0432\u043d\u0438 \u0435\u043b\u0435\u043c\u0435\u043d\u0442\u0438 \u043d\u0430 \u043c\u0443\u0441\u043a\u0443\u043b\u0438\u0442\u0435, \u043a\u043e\u0436\u0430\u0442\u0430, \u043a\u043e\u0441\u0430\u0442\u0430 \u0438 \u043d\u043e\u043a\u0442\u0438\u0442\u0435. \u0422\u0435 \u0441\u0430 \u043d\u0435\u043e\u0431\u0445\u043e\u0434\u0438\u043c\u0438 \u0437\u0430 \u0432\u044a\u0437\u0441\u0442\u0430\u043d\u043e\u0432\u044f\u0432\u0430\u043d\u0435 \u043d\u0430 \u0442\u044a\u043a\u0430\u043d\u0438\u0442\u0435 \u0441\u043b\u0435\u0434\u2026","rel":"","context":"In "Art\u00edculos dedicados a la Biblia y sobre el esp\u00edritu y el cuerpo."","block_context":{"text":"Art\u00edculos dedicados a la Biblia y sobre el esp\u00edritu y el cuerpo.","link":"https:\/\/vkrastev1blog.com\/category\/%d1%81%d1%82%d0%b0%d1%82%d0%b8%d0%b8-%d0%bf%d0%be%d1%81%d0%b2%d0%b5%d1%82%d0%b5%d0%bd%d0%b8-%d0%bd%d0%b0-%d0%b1%d0%b8%d0%b1%d0%bb%d0%b8%d1%8f%d1%82%d0%b0-%d0%b8-%d0%b7%d0%b0-%d0%b4%d1%83%d1%85%d0%b0\/"},"img":{"alt_text":"","src":"https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2024\/11\/image-17.png?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2024\/11\/image-17.png?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2024\/11\/image-17.png?resize=525%2C300&ssl=1 1.5x, https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2024\/11\/image-17.png?resize=700%2C400&ssl=1 2x"},"classes":[]},{"id":2222,"url":"https:\/\/vkrastev1blog.com\/2025\/04\/19\/%d1%8f%d0%bc%d0%b0-%d0%bd%d0%b8%d1%8f%d0%bc%d0%b0-%d0%b5%d1%82%d0%b8%d1%87%d0%b5%d0%bd-%d0%ba%d0%be%d0%b4%d0%b5%d0%ba%d1%81-%d0%b7%d0%b0-%d0%b6%d0%b8%d0%b2%d0%be%d1%82-%d0%b2-%d0%b9%d0%be%d0%b3\/","url_meta":{"origin":2308,"position":4},"title":"Yama, Niyama: un c\u00f3digo de \u00e9tica para la vida del yoga","author":"vkrastev2014","date":"19.04.2025","format":false,"excerpt":"\u0419\u041e\u0413\u0410 \u0424\u0418\u041b\u041e\u0421\u041e\u0424\u0418\u042f\u0422\u0410 \u0418 \u0411\u0418\u0411\u041b\u0418\u042f\u0422\u0410 \u2013 \u0421\u042a\u0412\u041f\u0410\u0414\u0415\u041d\u0418\u042f, \u0420\u0410\u0417\u041b\u0418\u0427\u0418\u042f \u0418 \u0412\u042a\u0417\u041c\u041e\u0416\u041d\u041e \u041b\u0418 \u0415 \u0415\u0414\u041d\u0410\u0422\u0410 \u0414\u0410 \u0415 \u0412\u0417\u0410\u0418\u041c\u0421\u0422\u0412\u0410\u041b\u0410 \u041e\u0422 \u0414\u0420\u0423\u0413\u0410\u0422\u0410 \u0412\u044a\u0432\u0435\u0434\u0435\u043d\u0438\u0435 \u2013 \u0415\u0434\u043d\u0430 \u043c\u043e\u0440\u0430\u043b\u043d\u0430 \u0438\u0441\u0442\u0438\u043d\u0430, \u043d\u043e \u0435\u0434\u0438\u043d \u0438 \u0441\u044a\u0449 \u0434\u0443\u0445\u043e\u0432\u0435\u043d \u0438\u0437\u0442\u043e\u0447\u043d\u0438\u043a \u043b\u0438 \u0441\u0442\u043e\u0438 \u0437\u0430\u0434 \u043d\u0435\u044f? \u041a\u043e\u0433\u0430\u0442\u043e \u0441\u0440\u0430\u0432\u043d\u0438\u043c \u0435\u0442\u0438\u0447\u0435\u0441\u043a\u0438\u0442\u0435 \u043f\u0440\u0438\u043d\u0446\u0438\u043f\u0438 \u043d\u0430 \u0439\u043e\u0433\u0430 \u0444\u0438\u043b\u043e\u0441\u043e\u0444\u0438\u044f\u0442\u0430 \u0441 \u0443\u0447\u0435\u043d\u0438\u0435\u0442\u043e \u043d\u0430 \u0411\u0438\u0431\u043b\u0438\u044f\u0442\u0430, \u043e\u0442\u043a\u0440\u0438\u0432\u0430\u043c\u0435 \u0438\u0437\u043d\u0435\u043d\u0430\u0434\u0432\u0430\u0449\u043e \u043c\u043d\u043e\u0433\u043e \u0441\u0445\u043e\u0434\u0441\u0442\u0432\u0430. \u041d\u0435\u043d\u0430\u0441\u0438\u043b\u0438\u0435\u0442\u043e, \u0438\u0441\u0442\u0438\u043d\u043d\u043e\u0441\u0442\u0442\u0430, \u043e\u0442\u043a\u0430\u0437\u044a\u0442\u2026","rel":"","context":"In "Art\u00edculos dedicados a la Biblia y sobre el esp\u00edritu y el cuerpo."","block_context":{"text":"Art\u00edculos dedicados a la Biblia y sobre el esp\u00edritu y el cuerpo.","link":"https:\/\/vkrastev1blog.com\/category\/%d1%81%d1%82%d0%b0%d1%82%d0%b8%d0%b8-%d0%bf%d0%be%d1%81%d0%b2%d0%b5%d1%82%d0%b5%d0%bd%d0%b8-%d0%bd%d0%b0-%d0%b1%d0%b8%d0%b1%d0%bb%d0%b8%d1%8f%d1%82%d0%b0-%d0%b8-%d0%b7%d0%b0-%d0%b4%d1%83%d1%85%d0%b0\/"},"img":{"alt_text":"","src":"https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2025\/04\/viber_image_2025-04-19_23-13-17-352.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2025\/04\/viber_image_2025-04-19_23-13-17-352.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2025\/04\/viber_image_2025-04-19_23-13-17-352.jpg?resize=525%2C300&ssl=1 1.5x, https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2025\/04\/viber_image_2025-04-19_23-13-17-352.jpg?resize=700%2C400&ssl=1 2x, https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2025\/04\/viber_image_2025-04-19_23-13-17-352.jpg?resize=1050%2C600&ssl=1 3x"},"classes":[]},{"id":2586,"url":"https:\/\/vkrastev1blog.com\/2026\/10\/02\/%d0%b2%d0%b5%d0%bb%d0%b8%d0%ba%d0%b0%d1%82%d0%b0-%d1%81%d1%85%d0%b8%d0%b7%d0%bc%d0%b0-%d0%be%d1%82-1054-%d0%b3-%d0%b8%d1%81%d1%82%d0%be%d1%80%d0%b8%d1%87%d0%b5%d1%81%d0%ba%d0%b8%d1%82%d0%b5\/","url_meta":{"origin":2308,"position":5},"title":"El Gran Cisma de 1054: las razones hist\u00f3ricas de la divisi\u00f3n entre las Iglesias ortodoxa y cat\u00f3lica romana","author":"vkrastev2014","date":"02.10.2026","format":false,"excerpt":"\u0412\u0435\u043b\u0438\u043a\u0430\u0442\u0430 \u0441\u0445\u0438\u0437\u043c\u0430 \u043e\u0442 1054 \u0433. \u2014 \u0438\u0441\u0442\u043e\u0440\u0438\u0447\u0435\u0441\u043a\u0438\u0442\u0435 \u043f\u0440\u0438\u0447\u0438\u043d\u0438 \u0437\u0430 \u0440\u0430\u0437\u0434\u0435\u043b\u0435\u043d\u0438\u0435\u0442\u043e \u043c\u0435\u0436\u0434\u0443 \u041f\u0440\u0430\u0432\u043e\u0441\u043b\u0430\u0432\u043d\u0430\u0442\u0430 \u0438 \u0420\u0438\u043c\u043e\u043a\u0430\u0442\u043e\u043b\u0438\u0447\u0435\u0441\u043a\u0430\u0442\u0430 \u0446\u044a\u0440\u043a\u0432\u0430 \u0420\u0435\u0437\u044e\u043c\u0435 \u0412\u0435\u043b\u0438\u043a\u0430\u0442\u0430 \u0441\u0445\u0438\u0437\u043c\u0430 \u043e\u0442 1054 \u0433. \u0435 \u0435\u0434\u043d\u043e \u043e\u0442 \u043d\u0430\u0439-\u0437\u043d\u0430\u0447\u0438\u043c\u0438\u0442\u0435 \u0441\u044a\u0431\u0438\u0442\u0438\u044f \u0432 \u0438\u0441\u0442\u043e\u0440\u0438\u044f\u0442\u0430 \u043d\u0430 \u0445\u0440\u0438\u0441\u0442\u0438\u044f\u043d\u0441\u0442\u0432\u043e\u0442\u043e. \u0422\u044f \u0442\u0440\u0430\u0434\u0438\u0446\u0438\u043e\u043d\u043d\u043e \u0441\u0435 \u0441\u0432\u044a\u0440\u0437\u0432\u0430 \u0441 \u043f\u0440\u0435\u043a\u044a\u0441\u0432\u0430\u043d\u0435\u0442\u043e \u043d\u0430 \u0446\u044a\u0440\u043a\u043e\u0432\u043d\u043e\u0442\u043e \u043e\u0431\u0449\u0435\u043d\u0438\u0435 \u043c\u0435\u0436\u0434\u0443 \u0420\u0438\u043c\u0441\u043a\u0430\u0442\u0430 \u0446\u044a\u0440\u043a\u0432\u0430 \u043d\u0430 \u0417\u0430\u043f\u0430\u0434 \u0438 \u041a\u043e\u043d\u0441\u0442\u0430\u043d\u0442\u0438\u043d\u043e\u043f\u043e\u043b\u0441\u043a\u0430\u0442\u0430 \u0446\u044a\u0440\u043a\u0432\u0430 \u043d\u0430 \u0418\u0437\u0442\u043e\u043a. \u0421\u044a\u0431\u0438\u0442\u0438\u044f\u0442\u0430\u2026","rel":"","context":"In "Art\u00edculos dedicados a la Biblia y sobre el esp\u00edritu y el cuerpo."","block_context":{"text":"Art\u00edculos dedicados a la Biblia y sobre el esp\u00edritu y el cuerpo.","link":"https:\/\/vkrastev1blog.com\/category\/%d1%81%d1%82%d0%b0%d1%82%d0%b8%d0%b8-%d0%bf%d0%be%d1%81%d0%b2%d0%b5%d1%82%d0%b5%d0%bd%d0%b8-%d0%bd%d0%b0-%d0%b1%d0%b8%d0%b1%d0%bb%d0%b8%d1%8f%d1%82%d0%b0-%d0%b8-%d0%b7%d0%b0-%d0%b4%d1%83%d1%85%d0%b0\/"},"img":{"alt_text":"","src":"https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2026\/10\/qw2qge1gpm-imcejrbliuv09vw-lm2pdjcnyrstfpg4msbjvq5ayy300dumb4g0dqgb04qse4r49kf4hgozsmknaycx-6ls4n1_6et7huoj0n4ovamyps8jiqzamtvq9qa1jdrc-ci-cw5e8oylvd1jxmveqgxdxbfu8ds4uwz8.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2026\/10\/qw2qge1gpm-imcejrbliuv09vw-lm2pdjcnyrstfpg4msbjvq5ayy300dumb4g0dqgb04qse4r49kf4hgozsmknaycx-6ls4n1_6et7huoj0n4ovamyps8jiqzamtvq9qa1jdrc-ci-cw5e8oylvd1jxmveqgxdxbfu8ds4uwz8.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2026\/10\/qw2qge1gpm-imcejrbliuv09vw-lm2pdjcnyrstfpg4msbjvq5ayy300dumb4g0dqgb04qse4r49kf4hgozsmknaycx-6ls4n1_6et7huoj0n4ovamyps8jiqzamtvq9qa1jdrc-ci-cw5e8oylvd1jxmveqgxdxbfu8ds4uwz8.jpg?resize=525%2C300&ssl=1 1.5x, https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2026\/10\/qw2qge1gpm-imcejrbliuv09vw-lm2pdjcnyrstfpg4msbjvq5ayy300dumb4g0dqgb04qse4r49kf4hgozsmknaycx-6ls4n1_6et7huoj0n4ovamyps8jiqzamtvq9qa1jdrc-ci-cw5e8oylvd1jxmveqgxdxbfu8ds4uwz8.jpg?resize=700%2C400&ssl=1 2x, https:\/\/i0.wp.com\/vkrastev1blog.com\/wp-content\/uploads\/2026\/10\/qw2qge1gpm-imcejrbliuv09vw-lm2pdjcnyrstfpg4msbjvq5ayy300dumb4g0dqgb04qse4r49kf4hgozsmknaycx-6ls4n1_6et7huoj0n4ovamyps8jiqzamtvq9qa1jdrc-ci-cw5e8oylvd1jxmveqgxdxbfu8ds4uwz8.jpg?resize=1050%2C600&ssl=1 3x"},"classes":[]}],"jetpack_likes_enabled":true,"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/vkrastev1blog.com\/wp-json\/wp\/v2\/posts\/2308","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/vkrastev1blog.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/vkrastev1blog.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/vkrastev1blog.com\/wp-json\/wp\/v2\/users\/65283547"}],"replies":[{"embeddable":true,"href":"https:\/\/vkrastev1blog.com\/wp-json\/wp\/v2\/comments?post=2308"}],"version-history":[{"count":94,"href":"https:\/\/vkrastev1blog.com\/wp-json\/wp\/v2\/posts\/2308\/revisions"}],"predecessor-version":[{"id":3259,"href":"https:\/\/vkrastev1blog.com\/wp-json\/wp\/v2\/posts\/2308\/revisions\/3259"}],"wp:attachment":[{"href":"https:\/\/vkrastev1blog.com\/wp-json\/wp\/v2\/media?parent=2308"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/vkrastev1blog.com\/wp-json\/wp\/v2\/categories?post=2308"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/vkrastev1blog.com\/wp-json\/wp\/v2\/tags?post=2308"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}