Merge pull request mouredev#4716 from AmadorQuispe/aqh

#26 - JAVA

Author: Roswell468

Roadmap/08 - CLASES/go/AmadorQuispe.go

@@ -0,0 +1,149 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+)
+
+// En GO las clases son diferentes a los demás lenguajes, se usan structs
+type Student struct {
+	id   int
+	name string
+}
+
+// Constructor
+func NewStudent() Student {
+	return Student{}
+}
+
+// También es posible simular los métodos setter y getter
+func (s *Student) SetId(id int) {
+	s.id = id
+}
+func (s *Student) SetName(name string) {
+	s.name = name
+}
+
+func (s *Student) GetId() int {
+	return s.id
+}
+
+func (s *Student) GetName() string {
+	return s.name
+}
+
+func (s *Student) ToString() string {
+	return fmt.Sprintf("{Id: %d, Name: %s}", s.id, s.name)
+}
+
+// Pila LIFO último en entrar, primero en salir
+type Stack[T any] struct {
+	elements []T
+}
+
+func NewStack[T any]() Stack[T] {
+	return Stack[T]{}
+}
+
+func (s *Stack[T]) Empty() bool {
+	return len(s.elements) == 0
+}
+
+func (s *Stack[T]) Push(item T) T {
+	s.elements = append(s.elements, item)
+	return item
+}
+
+func (s *Stack[T]) Pop() (T, error) {
+	var zero T
+	if s.Empty() {
+		return zero, errors.New("stack is empty")
+	}
+	item := s.elements[len(s.elements)-1]
+	s.elements = s.elements[:len(s.elements)-1]
+	return item, nil
+}
+
+func (s *Stack[T]) Peek() (T, error) {
+	var zero T
+	if s.Empty() {
+		return zero, errors.New("stack is empty")
+	}
+	return s.elements[len(s.elements)-1], nil
+}
+
+func (s *Stack[T]) Size() int {
+	return len(s.elements)
+}
+
+func (s *Stack[T]) Print() {
+	fmt.Println(s.elements)
+}
+
+// Colas FIFO primero en entrar, primero en salir
+type Queue[T any] struct {
+	elements []T
+}
+
+func (q *Queue[T]) Empty() bool {
+	return len(q.elements) == 0
+}
+func NewQueue[T any]() Queue[T] {
+	return Queue[T]{}
+}
+
+func (q *Queue[T]) Add(item T) T {
+	q.elements = append(q.elements, item)
+	return item
+}
+
+func (q *Queue[T]) Poll() (T, error) {
+	var item T
+	if q.Empty() {
+		return item, errors.New("queue is empty")
+	}
+	item = q.elements[0]
+	q.elements = q.elements[1:]
+	return item, nil
+}
+
+func (q *Queue[T]) Size() int {
+	return len(q.elements)
+}
+
+func (q *Queue[T]) Print() {
+	fmt.Println(q.elements)
+}
+
+func main() {
+	//CLASES
+	student := Student{}
+	student.SetId(100)
+	student.SetName("Amador")
+	fmt.Println(student.ToString())
+	//PILAS
+	stack := NewStack[int]()
+	stack.Push(1)
+	stack.Push(2)
+	stack.Push(3)
+	stack.Push(4)
+	stack.Push(5)
+	fmt.Println(stack.Size())
+	stack.Print()
+	stack.Pop()
+	stack.Pop()
+	fmt.Println(stack.Size())
+	stack.Print()
+
+	//COLAS
+	queue := NewQueue[string]()
+	queue.Add("Amador")
+	queue.Add("Alex")
+	queue.Add("Pedro")
+	fmt.Println(queue.Size())
+	queue.Print()
+	queue.Poll()
+	fmt.Println(queue.Size())
+	queue.Print()
+
+}

Roadmap/09 - HERENCIA/go/AmadorQuispe.go

@@ -0,0 +1,111 @@
+package main
+
+import "fmt"
+
+//Go no cuenta con una palabra para declarar herencia en los structs, sin embargo sí tiene algo parecido.
+//Para que un struct en go posea todos los campos que declara otro struct, le pasamos este último como un campo anónimo
+
+type Animal struct {
+	code string
+	name string
+}
+
+type Cat struct {
+	Animal
+}
+
+type Dog struct {
+	Animal
+}
+
+type Sound interface {
+	MakeSound()
+}
+
+func (c *Cat) MakeSound() {
+	fmt.Printf("El gato %s hace miau miau \n", c.name)
+}
+
+func (d *Dog) MakeSound() {
+	fmt.Printf("El perro %s hace wau wau \n", d.name)
+}
+
+//Está función puede recibir cualquier struct que implemente la interfaz Sound
+func PrintAnimal(sound Sound) {
+	sound.MakeSound()
+}
+
+//=============================================================
+//======================= EXTRA ===============================
+//=============================================================
+type EmployeeManager interface {
+	AddEmployee(employee Employee)
+	PrintEmployees()
+}
+
+type Employee struct {
+	id        int
+	name      string
+	employees []Employee
+}
+
+func (e *Employee) AddEmployee(employee Employee) {
+	e.employees = append(e.employees, employee)
+}
+
+func (e *Employee) PrintEmployees() {
+	for _, employee := range e.employees {
+		fmt.Printf("id : %d, name:%s\n", employee.id, employee.name)
+	}
+}
+
+type Manager struct {
+	Employee
+}
+
+func (m *Manager) CoordinateProjects() {
+	fmt.Printf("%s está coordinando todos los proyectos de la empresa.\n", m.name)
+}
+
+type ProjectManager struct {
+	Employee
+	project string
+}
+
+func (pm *ProjectManager) CoordinateProject() {
+	fmt.Printf("%s está coordinando su proyecto %s \n", pm.name, pm.project)
+}
+
+type Programmer struct {
+	Employee
+	languages []string
+}
+
+func (e *Programmer) AddEmployee(employee Employee) {
+	fmt.Println("Un programador no puede tener empleados, no se ha agregado")
+}
+
+func (e *Programmer) Code() {
+	fmt.Printf("%s está programando en %v", e.name, e.languages)
+}
+
+func main() {
+	cat1 := Cat{Animal{code: "0001", name: "Thor"}}
+	PrintAnimal(&cat1)
+	dog1 := Dog{Animal{code: "0002", name: "Run Run"}}
+	PrintAnimal(&dog1)
+	//EXTRA
+	m := Manager{Employee{id: 100, name: "Amador"}}
+	m.AddEmployee(Employee{id: 200, name: "Alex"})
+	p := Programmer{languages: []string{"Java", "Go"}, Employee: Employee{id: 100, name: "Mia"}}
+	p.AddEmployee(Employee{id: 300, name: "Pedro"})
+
+	var employeeManagers []EmployeeManager
+	employeeManagers = append(employeeManagers, &m, &p)
+
+	for _, manager := range employeeManagers {
+		manager.AddEmployee(Employee{id: 500, name: "New Employee"})
+	}
+	m.CoordinateProjects()
+	m.PrintEmployees()
+}