Autor: Juan Pablo Fuentes

package com.trifulcas.oop;

public class Cliente {
	private String nombre;
	private String email;
	private String direccion;
	private String password;
	private double sueldo;

	public Cliente(String nombre, String email, String direccion) {
		this.nombre = nombre;
		this.email = email;
		this.direccion = direccion;
	}

	/**
	 * @return the nombre
	 */
	public String getNombre() {
		return "Don "+nombre;
	}

	/**
	 * @param nombre the nombre to set
	 */
	public void setNombre(String nombre) {
		if (nombre.length() > 2) {
			this.nombre = nombre;
		}
	}

	/**
	 * @return the email
	 */
	public String getEmail() {
		return email;
	}


	/**
	 * @return the direccion
	 */
	public String getDireccion() {
		return direccion;
	}

	/**
	 * @param direccion the direccion to set
	 */
	public void setDireccion(String direccion) {
		this.direccion = direccion;
	}

	/**
	 * @param password the password to set
	 */
	public void setPassword(String password) {
		this.password = password;
	}

	/**
	 * @return the direccion
	 */
	public double getSueldoBruto() {
		return sueldo*.85;
	}

	/**
	 * @param direccion the direccion to set
	 */
	public void setSueldoBruto(double sueldo) {
		this.sueldo = sueldo/.85;
	}
	@Override
	public String toString() {
		return "Cliente [nombre=" + nombre + ", email=" + email + ", direccion=" + direccion + "]";
	}

}

Cliente pepe=new Cliente("José Pérez","pepe@pepe.com","Agla 6");
		
		System.out.println(pepe);
		
		System.out.println(pepe.getNombre());
		pepe.setNombre("J");
		System.out.println(pepe);
		System.out.println(pepe.getEmail());
		// No puedo pepe.setMail
		// Mail es de solo lectura
		// password es de solo escritura
		pepe.setPassword("1234");
		// No puedo System.out.println(pepe.getPassword());

public class Coche {
	public String marca;
	private int velocidad=0;
	private int velocidadMaxima=150;
	
	public Coche(String marca) {
		this.marca = marca;
	}
	public void acelerar() {
		System.out.println("brum brum");
		
		velocidad+=10;
		if (velocidad>velocidadMaxima) {
			velocidad=velocidadMaxima;
		}
	}
	public void frenar() {
		System.out.println("Ñññic");
		
		velocidad-=10;
		if (velocidad<0) {
			velocidad=0;
		}
	}
	@Override
	public String toString() {
		return "Coche [marca=" + marca + ", velocidad=" + velocidad + "]";
	}
	
}

Coche seat=new Coche("Seat Panda");
		System.out.println(seat);
		seat.frenar();
		System.out.println(seat);
		for(int i=0;i<20;i++) {
			seat.acelerar();
			System.out.println(seat);
		}

// base y altura que son de tipo double
// Lo vamos a poder crear: Poniendo la base y la altura
// Poniendo la base solamente, la altura valdrá 1
// No poniendo nada, base y altura valdrán 1
public class Rectangulo {
	double base;
	double altura;
	
	Rectangulo(double base, double altura){
		this.base=base;
		this.altura=altura;
	}
	Rectangulo(double base){
		this(base,1);
	}
	Rectangulo(){
		this(1);
	}
}

public class TestClases {

	public static void main(String[] args) {
		Rectangulo r1=new Rectangulo(3,4);
		Rectangulo r2=new Rectangulo(3);
		Rectangulo r3=new Rectangulo();
	}

}

public class Asignatura {
    String nombre;
    int  creditos;
    double precioCredito;


    double precioTotal(){
        return creditos*precioCredito;
    }
}

public class Empleado {
    String nombre;
    double salario;
    public Empleado(String nombre, double salario) {
        this.nombre = nombre;
        this.salario = salario;
    }

}

public class Mascota {
    String nombre;
    String tipo;
    public Mascota(String nombre) {
        this.nombre = nombre;
    }
}
public class Producto {
    String nombre;
    double precio;
    int stock;

    Producto(String nombre){
        this.nombre=nombre;
        precio=0;
        stock=0;
    }

    double PVP() {
        return precio*1.21;
    }
    void comprar(int cantidad) {
        stock+=cantidad;
    }

    void vender(int cantidad) {
        stock-=cantidad;
    }
}

package com.trifulcas.oop;

public class Empleado2 {
	String nombre;
	double sueldo;
	double irpf;

	// COnstructor con dos parámetros
	public Empleado2(String nombre, double sueldo) {

		this.nombre = nombre;
		this.sueldo = sueldo;
		if (sueldo<3000) {
			irpf=0.1;
		}else {
			irpf=0.12;
		}
	}

	// Constructor con un parámetro
	public Empleado2(String nombre) {
		this.nombre = nombre;
		this.sueldo = 1600;
		irpf=0.1;
	}
	// Constructor sin parámetros
	public Empleado2() {
		this.nombre = "Anónimo";
		this.sueldo = 1600;
		irpf=0.1;
	}
}

package com.trifulcas.oop;

public class Empleado {
	String nombre;
	double sueldo;
	double irpf;

	// COnstructor con dos parámetros
	public Empleado(String nombre, double sueldo) {

		this.nombre = nombre;
		this.sueldo = sueldo;
		if (sueldo<3000) {
			irpf=0.1;
		}else {
			irpf=0.12;
		}
	}

	// Constructor con un parámetro
	public Empleado(String nombre) {
		this(nombre,1600);
	}
	// Constructor sin parámetros
	public Empleado() {
		this("Anónimo");
	}
}

// Voy a crear una clase para almacenar productos
// EL producto tiene un nombre, un precio y un stock
// Cuando creo el producto obligatoriamente le tengo que dar un nombre
// El stock y el precio por defecto valen 0
// Voy a crear una función PVP que me devuelve el precio  más el iva
// Voy a crear una función comprar que me añade una cantidad al stock
public class Producto {
	String nombre;
	double precio;
	int stock;
	
	Producto(String nombre){
		this.nombre=nombre;
		precio=0;
		stock=0;
	}
	
	double PVP() {
		return precio*1.21;
	}
	void comprar(int cantidad) {
		stock+=cantidad;
	}

}

public static void main(String[] args) {
		Producto tuerca=new Producto("Tuerca");
		tuerca.precio=20;
		System.out.println(tuerca.PVP());
		tuerca.comprar(30);
		System.out.println(tuerca.stock);
		tuerca.comprar(30);
		System.out.println(tuerca.stock);
		
		Producto misterio;
		misterio=tuerca;
		
		System.out.println(misterio.stock); // ¿? 0 60 error 
		
		misterio.comprar(40);
		
		System.out.println(tuerca.stock); // 0 20 no existe 60 100 10000
		System.out.println(misterio==tuerca);
	}

package com.trifulcas.oop;

// La sintaxis de una clase es muy sencilla 'class'
public class Alumno {
	// Propiedades
	String nombre;
	// 2) Para obligar a dar valor a alguna propiedad
	// El constructor de alumno requiere de un parámetro
	// de tipo String. Esto quiere decir que cuando 
	// cree un objeto alumno le tendré que pasar un nombre
	Alumno(String nombre){
		// ¿Qué es this? This hace referencia al propio objeto
		// Por qué aquí hace falta y en saludo no?
		// Lo uso para diferenciar entre el parámetro y la propiedad
		this.nombre=nombre;
	}
	// Funciones
	void saludo() {
		System.out.println(this.getSaludo() + this.nombre);
		// Sin this también funciona ¿Por qué?
		// Porque Java por defecto busca funciones y propiedades en this
		System.out.println(getSaludo() + nombre);
	}
	String getSaludo() {
		return "Hola que tal ";
	}
}

public class Coche {
	String marca;
	int velocidad=0;
	
	public Coche(String marca) {
		super();
		this.marca = marca;
	}
	void acelerar() {
		System.out.println("brum brum");
		// Lo interesante de las clases es que sus funciones
		// Pueden acceder y modificar las propiedades
		velocidad+=10;
	}
	void frenar() {
		System.out.println("Ñññic");
		
		velocidad-=10;
		if (velocidad<0) {
			velocidad=0;
		}
	}
}

public class Cuadrado {
	// Cada objeto cuadrado tendrá su lado
	double lado;

	// COnstructor: es una función especial que se llama
	// Cuando creamos (instanciamos) el objeto
	// se llama igual que la clase
	// ¿Para qué se usa?
	// 1) Para inicializar valores de mis propiedades
	// 2) Para obligar a dar valor a alguna propiedad
	Cuadrado() {
		lado=1;
	}

	// Todas las funciones devuelven el valor en función
	// de la propiedad de la clase, no como un parámetro
	double area() {
		return lado * lado;
	}

	double perimetro() {
		return lado * 4;
	}

	double diagonal() {
		return Math.sqrt(lado * lado * 2);
	}
}

public static void main(String[] args) {
		// String es la plantilla y cadena es un objeto
		// Cada cadena es una instancia de la clase String
		String cadena = "Hola que tal";
		String otracadena = "Hola que tal";
		String yotracadena = "Hola que tal";
		// Como cada objeto es instancia de la clase String
		// Todos comparten las mismas propiedades y funciones
		System.out.println(cadena.length());
		System.out.println(otracadena.length());
		System.out.println(yotracadena.length());

		// Yo tengo la clase Alumno
		// La clase alumno es una plantilla para crear alumnos
		// La palabra clave new es la que me crea el objeto
		Alumno ana = new Alumno("Ana Pi");
	
		ana.saludo();
		Alumno eva = new Alumno("Eva Pérez");
		
		eva.saludo();
		// juan está declarado pero no he creado ningún objeto
		// Es como si no existiera. No puedo poner juan.nombre="sss"
		Alumno juan;

		Coche seat = new Coche("Seat Panda");
		
		seat.acelerar();
		seat.acelerar();
		System.out.println(seat.velocidad);
		seat.frenar();
		seat.frenar();
		seat.frenar();
		seat.frenar();
		System.out.println(seat.velocidad);
		// Otro coche nuevo
		Coche citroen = new Coche("Citroen");
		
		for (int i = 0; i < 10; i++) {
			citroen.acelerar();
		}
		System.out.println(citroen.velocidad);

		// Esto no tiene sentido:
		// Coche.marca="Seat";
		// Las propiedades se ponen en los objetos, no en la clase
		// Porque la clase es la plantilla
		// Nosotros no usamos el plano de una casa para colgar un cuadro

		// Cada objeto que creamos de la clase cuadrado
		// Encapsula las funciones que nos dan información de su propia
		// clase. No tenemos que pasar esos valores como parámetro
		Cuadrado c1 = new Cuadrado();
		c1.lado = 2;
		System.out.println(c1.area());
		System.out.println(c1.perimetro());
		System.out.println(c1.diagonal());

		System.out.println(cadena.toUpperCase());
		
		// Yo puedo crear un ArrayList con la clase Cuadrado
		// Igual que lo hacía de string o de cualquier otra cosa
		ArrayList<Cuadrado> lista =new ArrayList<>();
		for(int i=1;i<=10;i++) {
			// Creo un objeto
			Cuadrado c=new Cuadrado();
			c.lado=i;
			// Añado a la lista
			lista.add(c);
		}
		// Recorrer esa lista
		for(Cuadrado c:lista) {
			// Imprimir el área
			System.out.println(c.area());
		}
		
		Cuadrado a=new Cuadrado();
		Cuadrado b=new Cuadrado();
		a.lado=1;
		b.lado=1;
		System.out.println(a==b); // false porque no son el mismo objeto
		
		System.out.println("Cuadrado nuevo con constructor");
		Cuadrado nuevo=new Cuadrado();
		System.out.println(nuevo.lado);
	}

// La sintaxis de una clase es muy sencilla 'class'
public class Alumno {
	// Propiedades
	String nombre;

	// Funciones
	void saludo() {
		System.out.println("Hola " + nombre);
	}
}

public class Coche {
	String marca;
	int velocidad=0;
	
	void acelerar() {
		System.out.println("brum brum");
		// Lo interesante de las clases es que sus funciones
		// Pueden acceder y modificar las propiedades
		velocidad+=10;
	}
	void frenar() {
		System.out.println("Ñññic");
		velocidad-=10;
	}
}

package com.trifulcas.oop;

public class Cuadrado {
	// Cada objeto cuadrado tendrá su lado
	double lado;
	
	// Todas las funciones devuelven el valor en función
	// de la propiedad de la clase, no como un parámetro
	double area() {
		return lado*lado;
	}
	double perimetro() {
		return lado*4;
	}
	double diagonal() {
		return Math.sqrt(lado*lado*2);
	}
}

public class Introduccion {

	public static void main(String[] args) {
		// String es la plantilla y cadena es un objeto
		// Cada cadena es una instancia de la clase String
		String cadena="Hola que tal";
		String otracadena="Hola que tal";
		String yotracadena="Hola que tal";
		// Como cada objeto es instancia de la clase String
		// Todos comparten las mismas propiedades y funciones
		System.out.println(cadena.length());
		System.out.println(otracadena.length());
		System.out.println(yotracadena.length());
		
		// Yo tengo la clase Alumno
		// La clase alumno es una plantilla para crear alumnos
		// La palabra clave new es la que me crea el objeto
		Alumno ana = new Alumno();
		ana.nombre="Ana Pi";
		ana.saludo();
		Alumno eva=new Alumno();
		eva.nombre="Eva Pérez";
		eva.saludo();
		// juan está declarado pero no he creado ningún objeto
		// Es como si no existiera. No puedo poner juan.nombre="sss"
		Alumno juan;
		
		Coche seat=new Coche();
		seat.marca="Seat Panda";
		seat.acelerar();
		seat.acelerar();
		System.out.println(seat.velocidad);
		seat.frenar();
		System.out.println(seat.velocidad);
		// Otro coche nuevo
		Coche citroen=new Coche();
		citroen.marca="Citroen";
		for(int i=0;i<10;i++) {
			citroen.acelerar();
		}
		System.out.println(citroen.velocidad);

		// Esto no tiene sentido:
		// Coche.marca="Seat";
		// Las propiedades se ponen en los objetos, no en la clase
		// Porque la clase es la plantilla
		// Nosotros no usamos el plano de una casa para colgar un cuadro

// Cada objeto que creamos de la clase cuadrado
		// Encapsula las funciones que nos dan información de su propia
		// clase. No tenemos que pasar esos valores como parámetro
		Cuadrado c1 = new Cuadrado();
		c1.lado = 2;
		System.out.println(c1.area());
		System.out.println(c1.perimetro());
		System.out.println(c1.diagonal());

		System.out.println(cadena.toUpperCase());

// Yo puedo crear un ArrayList con la clase Cuadrado
		// Igual que lo hacía de string o de cualquier otra cosa
		ArrayList<Cuadrado> lista =new ArrayList<>();
		for(int i=1;i<=10;i++) {
			// Creo un objeto
			Cuadrado c=new Cuadrado();
			c.lado=i;
			// Añado a la lista
			lista.add(c);
		}
		// Recorrer esa lista
		for(Cuadrado c:lista) {
			// Imprimir el área
			System.out.println(c.area());
		}

Cuadrado a=new Cuadrado();
		Cuadrado b=new Cuadrado();
		a.lado=1;
		b.lado=1;
		System.out.println(a==b); // false porque no son el mismo objeto
}

}

package com.trifulcas.colecciones;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;

public class SolucionesColecciones {

	public static void main(String[] args) {
		HashMap<String, Integer> notas = new HashMap<>();
		notas.put("JS", 5);
		notas.put("c#", 8);
		notas.put("Java", 9);
		System.out.println(calculaMedia(notas));
		System.out.println(100 / 3.0);
		HashMap<String, ArrayList<Integer>> productos = new HashMap<>();
		productos.put("Tuerca", new ArrayList<>());
		productos.get("Tuerca").add(1);
		productos.get("Tuerca").add(2);
		productos.get("Tuerca").add(3);
		productos.put("Tornillo", new ArrayList<>(Arrays.asList(2, 3, 4)));
		productos.put("Arandela", new ArrayList<>(Arrays.asList(4, 5, 6)));
		System.out.println(productos);
		System.out.println(precioMinimo(productos));
	}

	static double calculaMedia(HashMap<String, Integer> notas) {
		double suma = 0;
		// Recorro los valores que es lo que me hace falta
		for (int nota : notas.values()) {
			suma += nota;
		}
		// Redondear a dos decimales OJO cuando en java dividimos dos enteros nos hace
		// la división entera
		// Por lo tanto quita los decimales. Si queremos conservarlos ponemos .0
		return Math.round((suma / notas.size()) * 100) / 100.0;
	}

	// Ojo con los parámetros de entrada y salida
	static HashMap<String, Integer> precioMinimo(HashMap<String, ArrayList<Integer>> productos) {
		HashMap<String, Integer> res = new HashMap<String, Integer>();
		// Recorro el hashmap
		for (String producto : productos.keySet()) {
			// Añado la clave la misma y el valor aprovecho el min de collections
			res.put(producto, Collections.min(productos.get(producto)));
			// Si no me acuerdo del collections me creo yo la función
			res.put(producto, minimoValor(productos.get(producto)));
		}
		return res;
	}
	// No hace falta pero bueno...
	static int minimoValor(ArrayList<Integer> numeros) {
		int minimo = numeros.get(0);
		for (int numero : numeros) {
			if (numero < minimo) {
				minimo = numero;
			}
		}
		return minimo;
	}
}