### Good Practices

## Clean Code
7 Principio

1. Los nombres son importantes

Debe ser preciso y dar una idea de lo que hace.
No importan los nombres grandes mientras cumpla con el punto anterior
2. Regla del Boy Scout
Se debe dejar el código mas limpio de lo que se encontraba
3. Debes ser el verdadero autor del código
Las funciones deben ser claras y pequeñas
4. DRY (Don't Repeat Yourself)
No deben existir ambigûedades o mas de una función que realice la misma acción.
5. Comentar solamente lo necesario
6. Tratamiento de Errores
7. test Limpios
Fast, Independent, Repeatable, Self-Validation y Timely

## S.T.U.P.I.D.
- Singleton - No se debe abusar del platón singleton, es mejor utilizar otras opciones
- Tight Coupling (Acoplamiento Apretado) - No es tolerante a Cambios
- Untestability (No Testeable) - se debe tener código que sea testeable
- Premature Optimization - Altos costos y problemas inecesarios
- Indescriptive Naming - Nombrar correctamente variables y Funciones
- Duplication - Falta de principio DRY

## S.O.L.I.D.
- Single Responsability Principle ( Principio de Responsabilidad Única y compuesto de
colaboradores como
faces comunes)
- Open/Close Principe ( Abiertas a Extensión y cerradas a modificación )
- Liskov Sustitution Principle - Si S es un subtipo de T, instancias de T deberían poderse
sustituir por instancias de S sin alterar las propiedades del programa ( cambiar de autos en
aplicaciones de armado para el dia de mañana )
se suele resolver utilizando polimorfismo.
- Interface segregation Principle - El principio de segregación de interfaces, nos dice que
ninguna clase debe ser forzada a depender de métodos que no utiliza. (varias
implementaciones o interfaces como en tipos de pajaros)
- Dependency Inversion Principle (DIP) - Los módulos de alto nivel no deberían depender de
los módulos de bajo nivel.
Ambos deben de depender de Abstracciones / bajo acoplamiento similar a Spring

## Patrones de Arquitectura

- Modelo vista Controlador

Arquitectura para aplicaciones World Wide Web en los principales lenguajes de
programación.

- Cliente Servidor
un servidor y múltiples clientes
Aplicaciones en línea como correo electrónico, uso compartido de documentos y banca.

- Patron de Capas
Capa de presentación (también conocida como capa UI )
Capa de aplicación (también conocida como capa de servicio )
Capa de lógica de negocios (también conocida como capa de dominio )
Capa de acceso a datos (también conocida como capa de persistencia )

- Patrones Maestro esclavo

En la replicación de la base de datos, la base de datos maestra se considera como la fuente
autorizada y las bases de datos esclavas se sincronizan con ella.
Periféricos conectados a un bus en un sistema informático (unidades maestra y esclava).

- Patrón Filtro de Tubería

- Patrón del Agente
- Patrón de igual a igual
- Patrón de bus de evento
- Patrón de Pizarra
- Patrón de Interprete

## Patrones de Diseño

# Patrones Creacionales
- Factory Method
Se invocan desde el metodo Fabrica y se selecciona el objeto a utilizar

Se define boton y dialogo

Se configura y el dialogo inicia el button de acuerdo a la configuración e inicio del dialogo

Principio de responsabilidad única. Codigo mas facil de mantener

Principio de abierto/cerrado. Nuevos productos

App de configuración

- Abstract Method
Fabrica Abstracta con los metodos de creación de todos los objetos
Clase abstracta para el objeto boton
Clase abstracta para lasfabricas.

Principio de responsabilidad única. Codigo mas facil de mantener

Principio de abierto/cerrado. Nuevos productos
Los productos de Fabricas son compatibles
Apps de configuracion

- Builder
El uso del patrón Builder sólo tiene sentido cuando tus productos son bastante complejos
Descripcion interna, externa, compras/proveedor, pedidos, dcm -> Entra clase constructora

Uso Arbol de productos en pedidos.com

- Singleton
Garantizar que una clase tenga una única instancia.
Proporcionar un punto de acceso global a dicha instancia.

Bases de datos ??

Obtienes un punto de acceso global a dicha instancia.

# Patrones Estructurales
- Adapter

# Patrones de Comportamiento
- Strategy
- ? State

## Programación Orientada a Objetos

# La clase es un modelo o prototipo que define las varibales y métodos comunes a todos los
objetos de cierta clase.
# Los objetos de Software al igual que los objetos del mundo real, tambien tienen varianles
de clase y metodos
El objeto mantiene sus caracteristicas con una o mas vaibles e implementa su
comportamiento con métodos.

# Encapsulación
Evita que al instanciar un objeto se pueda acceder a las variables por seguridad.
Para esto utilizamos métodos Getters and Setters

# Herencia
Una clase puede heredar las variables y su comportamiento a otra clase (La clase
que hereda es llamada superclase o clase padre).
Se crea una Jerarquia de Herencia.

# Polimorfismo

- Polimorfismo de Asignación - Se usa una clase para heredar. Se puede decir que el tipo
estatico de la variable j es Vehiculo y su tipo dinamico es coche. Vehiculo j = new Coche();
- Polimorfismo Puro - Funciones Polimorficas Se espera un objeto que instancia de una
interfaz o clase Padre
- Sobrecarga - En el polimorfismo de sobrecarga, dos o más funciones comparten el mismo
identificador, pero distinta lista de argumentos.
- Polimorfismo de Inclusión - La habilidad para redefinir por completo el método de una
superclase en una subclase es lo que se conoce como polimorfismo de inclusión (o
redefinición) @Override

## Programación Funcional

Estilo o forma de Programación

Paradigma Funcional con Lambdas JAVA8

La funcion sobre la estructura, uso de java8 para recibir y regresar funciones

### JAVA

## Collections

# Conjuntos - Los Elementos no tienen un orden y no existen duplicados ( Interfaz Set<E> )

- Hashset<E> Impleméntación con tabla hash
- LinkedHashSet<E> Implementación Tabla Hash + Doble Lista Enlazada
- TreeSet<E> Implementación con Árbol

# Colecciones - Estructura Secuencial, donde cada elemento tiene un índice o posición (

Interfaz List<E> )
- ArrayList<E> Acceso Rápido
- LinkedList<E> Inserciones / Borrado Rápidas
- Stack<E> Pila
- Vector<E> Obsoleto

# Diccionario o Matriz Asosiativa - Cada elemento tiene asociado una clave que se usa para
recuperarlo ( Interfaz Map<k,v> )
- HashMap<k,v>
- TreeMap<k,v>
- LinkedHashMap<k,v>

## Stream API (JAVA 8++)

# Funciones Lambda
Un lambda es un concepto relacionado con la programación funcional que se definió en
Java 8 para tratar de dotar a Java de un paradigma funcional que difiere del paradigma de
la programación imperativa.

En la versión 8 de Java se incluyó un API que facilitaba en gran medida el trabajo con
colecciones. Este nos permite realizar operaciones sobre la colección, como por ejemplo
buscar, filtrar, reordenar, reducir, etc.
- ForEach
- Stream
- Filter
- Count
- Collect
- Map

## Concurrency

Paralelo: Varias CPU manejan varias tareas al mismo tiempo

Simultaneidad: Una CPU procesa varias tareas y las ejecuta a su vez de acuerdo con el
intervalo de tiempo. Lógicamente, estas tareas se ejecutan al mismo tiempo.

## Testing

Test Unitarios

- Fast: Rápida ejecución.

- Isolated: Independiente de otros test.
- Repeatable: Se puede repetir en el tiempo.
- Self-Validating: Cada test debe poder validar si es correcto o no a sí mismo.
- Timely: ¿Cuándo se deben desarrollar los test? ¿Antes o después de que esté todo
implementado? Sabemos que cuesta hacer primero los test y después la implementación
(TDD: Test-driven development), pero es lo suyo para centrarnos en lo que realmente se
desea implementar.

- Sólo pruebas los métodos públicos de cada clase.

- Un test no debe implementar ninguna lógica de negocio (nada de if...else...for...etc)

Framework Java testing: JUnit 4

JUnit es un framework Java para implementar test en Java. Se basa en anotaciones:

- @Test: indica que el método que la contiene es un test: expected y timeout.

- @Before: ejecuta el método que la contiene justo antes de cada test.
- @After: ejecuta el método que la contiene justo después de cada test.
- @BeforeClass: ejecuta el método (estático) que la contiene justo antes del primer test.
-@AfterClass: ejecuta el método (estático) que la contiene justo después del último test.
- @Ignore: evita la ejecución del tests. No es muy recomendable su uso porque puede
ocultar test fallidos. Si dudamos si el test debe estar o no, quizás borrarlo es la mejor de las
decisiones.

Las condiciones de aceptación del test se implementa con los asserts. Los más comunes
son los siguientes:

- assertTrue/assertFalse (condición a testear): Comprueba que la condición es cierta o falsa.

- assertEquals/assertNotEquals (valor esperado, valor obtenido). Es importante el orden de
los valores esperado y obtenido.
- assertNull/assertNotNull (object): Comprueba que el objeto obtenido es nulo o no.
- assertSame/assertNotSame(object1, object2): Comprueba si dos objetos son iguales o no.
- fail(): Fuerza que el test termine con fallo. Se puede indicar un mensaje.

Mockito y los dobles

Mockito es una librería Java que permite simular el comportamiento de una clase de forma
dinámica. De esta forma nos aislamos de las dependencias con otras clases y sólo
testeamos la funcionalidad concreta que queremos.

La simulación del comportamiento de una clase se hace mediante los “dobles” que pueden
ser de distintos tipos:

- Dummy: Son objetos que se utilizan para realizar llamadas a otros métodos, pero no se
usan.
- Stub: es como un dummy ya que sus métodos no hacen nada, pero devuelven cierto valor
que necesitamos para ejecutar nuestro test con respecto a ciertas condiciones.
- Spy: Es un objeto real que permite verificar el uso que se hace del propio objeto, por
ejemplo el número de veces que se ejecuta un método o los argumentos que se le pasan.
- Mock: Es un stub en el que sus métodos sí implementan un comportamiento, pues
esperan recibir unos valores y en función de ellos devuelve una respuesta.
- Fake: Son objetos que tienen una implementación que funciona pero que no son
apropiados para usar en producción (por ejemplo, una implementación de HttpSession).

### Angular
Patrones de diseño
Conceptos orientados a objetos
Como es la estructura y los patrones
Consumo de apis
Estructura de paquetes
MAnejo de las dependencias

Conceptos basicos
Directivas
Uso de apis en Angular
Interfaces
Clases Unitarias

@Validacion de Request
@DTO
Validaciones Java
Inyeccion de dependencias
Invocaciones a Store Procedures JPA

Java
Polimorfismo
Primaria Si una interfas puede tener un metodo implementado.
### ------------------------------------------------->
### ------------------------------------------------->
### ------------------------------------------------->
### ------------------------------------------------->
### ------------------------------------------------->
### ------------------------------------------------->

### Object-Oriented Programming OOP - POO - JAVA

## Clase
Una clase en Java es un grupo de objetos con propiedades en común.
## Metodo
Un metodo en JAva es una colección de instruccones que plantea una tarea especifica

- Public: El Metodo o clase es accesible para todas las clases

- Protected: El Metodo o Clase es accesible por la misma clase, clases del mismo paquete o
subclases de otros paquetes.
- Default: El Metodo o Clase es accesible para la misma clase y clases del mismo paquete
- Private: Solo es accesible para la misma clase.

- Static: Crea miembros que pertenecen a la clase, y no a una instancia.

No es necesario crear un objeto de la clase para acceder a estos atributos o metodos
- Abstract: Indica que no se provee una implementación para un cierto método, sino que la
implementación se da por las clases que extiendad la clase actual.
Una clase que tenga un método abstract debe declararse de igual forma.
- Final: Indica que una variable, método o clase no se va a modificar, lo cuaĺ puede ser útil
para añadir mas semantica, por cuestiones de rendimiento y para detectar errores
final variable -> No se puede asignar nuevo valor
final metodo -> No se puede sobreescribir
final class -> No se puede extender

## Clase abstracta VS Interfaz

Cuando un clase hereda de una Clase Abstracta, estas pasando de una abstracción a una
concreción y una relación entre clases
Ideal para la reutilización de Código y la perspectiva de la evolución

Cuando implementas una interfaz estas definiendo como se comporta / Similar a definir un
contrato
Es ideal para la declaración de tipo

## INTERFAZ
Una interfaz puede extender EXTEND cualquier numero de interfaces pero no puede
implementar otra interfaz

## Herencia
En Java se maneja herencia simple, es decir que solo se puede heredar de una sola clase a
la vez.
Para decir que una clase hereda de otra, se utiliza la palabra reservada extends seguido de
la clase que se quiere heredar.
## Polimorfismo
En Java un método con el mismo nombre puede comportarse de forma diferente de acuerdo
al objeto recibido.

3 tipos de polimorfismo:
- Sobrecarga: El más conocido y se aplica cuando existen funciones con el mismo nombre
en clases que son completamente independientes una de la otra.
- Paramétrico: Existen funciones con el mismo nombre pero se usan diferentes parámetros
(nombre o tipo). Se selecciona el método dependiendo del tipo de datos que se envíe.
- Inclusión: Es cuando se puede llamar a un método sin tener que conocer su tipo, así no se
toma en cuenta los detalles de las clases especializadas, utilizando una interfaz común

## Abstracción
El concepto de abstracción trata la descomposición de sistemas complejos en partes
sencillas, las cuales se pueden describir fácilmente.
## Encaosulamiento
En Java lo tenemos en una clase, en la que se puede ocultar o restringir los datos
(variables) o el código (métodos) utilizando palabras reservadas del lenguaje.

#### Spring - JAVA

## Inversión de dependencias
Inversión de Control
En Spring se encarga de mantener en su 'Contexto' todas las instancias e inyectar esa
instancia a quien necesite / beans
La inversión de dependencias es un principio que describe un conjunto de técnicas
destinadas a disminuir el acoplamiento entre los componentes de una aplicación.

## Inyección de dependencias
La inyección de dependencias es una de las técnicas utilizadas para implementar el
principio de inversión de dependencias.

La inyección de dependencias es un patrón de diseño que tiene como objetivo tomar la

responsabilidad de crear las instancias de las clases que otro objeto necesita y
suministrárselo para que esta clase los pueda utilizar.

# Ventajas

- Reducción de acoplamiento y aumenta la cohesión

- Cada clase tiene un única responsabilidad
- Reutilización

# Tipos
- Constructor -> @Configuration @Bean
- Setter -> @Configuration @Bean
- Field -> @Autowired - Se asigna atraves de la Api de Reflexión
Por:
- XML
- JavaConfig
@Configuration: Para marcar que esta clase va inicializar beans
@ComponentScan: Para buscar beans con anotaciones Spring
@Bean: En métodos que inicializan bean

Como inyectar dependencias en Spring

- @Component : Indica que esta clase se gestiona por el contenedor de Spring
- Spring se da cuenta de esta dependencia porque nuestra clase es un componente
que a su vez tiene en su constructor a la ClassB .
- Será Spring el que cree la ClassB y luego al instanciar la ClassA le pase en el
parámetro del constructor esa dependencia

- @Congiguration : Es una clase de definición de beans

- / @Bean : Se crea un bean como Singleton Scope

- @Autowired

## Validation
@Valid
@RequestBody -> coincida con el cuerpo del DTO

@NotNull : Determina de que el valor no sea nulo

@Min : Determina que el numero debeser igual o mas grande que el valor especificado
@Max : Determina que el numero debe ser igual o menor que el valor especificado
@Size : Determina que el tamaño debe ser igual al valor especifiacdo
@Pattern : Determina que la secuencia siga la expresion regular especificada

## StoreProcedures
@Procedure
int GET_TOTAL_CARS_BY_MODEL(String model);

@Entity
@NamedStoredProcedureQuery(name = "Car.getTotalCardsbyModelEntity",
procedureName = "GET_TOTAL_CARS_BY_MODEL", parameters = {
@StoredProcedureParameter(mode = ParameterMode.IN, name = "model_in", type =
String.class),
@StoredProcedureParameter(mode = ParameterMode.OUT, name = "count_out", type =
Integer.class)})
public class Car {
// class definition
}
@Procedure(name = "Car.getTotalCardsbyModelEntity")
int getTotalCarsByModelEntiy(@Param("model_in") String model);

### Angular

Uso de superset TypeScript

Creado para hacer código JS mas escalable

## Interface
Definen variables y metodos que se usaran.
Define el contrato, la sitaxis que la clase debe seguir en la estructura. (Structural Subtyping)

## Type
Nos permite definir un tipo de dato personalizado.

## @Inyectable parala inyección de dependencias

Se usa en los serivcios y se usa con inyección de dependencias en el constructor

## HttpClient / HttpClientModule
HTTP cliente se usa para APIS -> Retorna un observable