package com.trifulcas.clases;
//Herencia
class Producto {
public String nombre;
public double precio;
}
class Intangible extends Producto {
public String url;
}
class Tangible extends Producto {
public int stock;
}
class Reposteria extends Tangible {
public String caracteristicas;
}
//Agregación
class Almacen {
public Reposteria pasteles;
public Reposteria magdalenas;
public Intangible cupon;
}
[/Java]
package com.trifulcas.clases;
public class Profesor {
private String name;
private String email;
private double sueldo;
private double dietas;
private String password;
private String direccion;
// getters y setters: Poner y obtener valores
// Getter: obtiene el valor
public String getNombre() {
return name;
}
//Setter: pone el valor
public void setNombre(String nombre) {
this.name=nombre;
}
public String getEmail() {
return email;
}
public void setEmail(String valor) {
email = valor;
}
/**
*
* @return
*/
public double getSueldo() {
return sueldo+dietas;
}
/**
*
* @param sueldo
*/
public void setSueldo(double sueldo) {
this.sueldo = sueldo*.9;
this.dietas= sueldo*.1;
}
// Como password sólo tiene un setter y no tiene getter
// Es una propiedad de solo escritura. Podemos poner un valor
// Pero no recuperarlo
public void setPassword(String password) {
this.password=password;
}
// Como dietas sólo tiene getter podemos obtener el valor
// Pero no podemos modificarlo. Es una propiedad de sólo lectura
public double getDietas() {
return dietas;
}
/**
* @return la dirección del profesor
*/
public String getDireccion() {
return direccion;
}
/**
* Esta función es un setter
* @param direccion Es la dirección del profesor (calle y número)
*/
public void setDireccion(String direccion) {
this.direccion = direccion;
}
}
public static void main(String[] args) {
Profesor juan=new Profesor();
juan.setNombre("Juan");
juan.setSueldo(1000);
juan.setPassword("12345");
System.out.println(juan.getNombre());
System.out.println(juan.getSueldo());
System.out.println(juan.getDietas());
}
Vamos a crear una clase ’empleado’ con las siguientes propiedades:
nombre de tipo String y sueldo de tipo double
Vamos a añadir una función sueldoNeto que nos devuelve:
1.- El sueldo multiplicado por 0.9 si el sueldo es menor de 2000
1.- El sueldo multiplicado por 0.85 si el sueldo es mayor o igual que 2000.
Vamos a crear una clase ‘cesta’ con las siguientes propiedades:
Cliente de tipo String, importe de tipo double, cantidad de tipo int.
Crearemos también las funciones total que nos devuelve el importe por la cantidad
Y totalConIva que nos devuelve el importe con la cantidad multiplicado por 21%
A esta clase le añadimos una propiedad IVA de tipo double y un constructor.
El constructor nos pide el nombre del cliente como parámetro y nos pone .21 en el IVA
Vamos a crear la clase Alumno. Tiene de propiedades:
Nombre, nota, curso y actitud
nota es de tipo double, curso de tipo String, actitud de tipo int.
En el constructor pedimos el nombre y ponemos actitud=5
Creamos una función puntuar a la que le pasamos un valor y nos lo guarda en nota.
Tenemos una función castigo que resta 1 a la actitud
Tenemos una función recompensa que suma 1 a la actitud
Tenemos una función aprobado que nos devuelve un booleano que es true si la nota y la actitud son mayores o iguales a 5.
public class Alumno {
public String nombre;
public double nota;
public String curso;
public int actitud;
public Alumno(String nombre) {
this.nombre = nombre;
actitud = 5;
}
public void puntuar(double nota) {
this.nota = nota;
}
public void castigo() {
actitud--;
}
public void recompensa() {
actitud++;
}
public boolean aprobado() {
return nota >= 5 && actitud >= 5;
}
}
public static void main(String[] args) {
Alumno eva=new Alumno("Eva García");
eva.puntuar(8);
eva.recompensa();
System.out.println(eva.nota);
System.out.println(eva.actitud);
System.out.println(eva.aprobado());
}
OOP
La programación orientada a objetos se basa en definir clases
que después se instancian en objetos
La clase es la definición de las propiedades y métodos
que tendrá un objeto. Pero no es un objeto.
El objeto es la instancia de la clase y es con lo que se
trabaja.
Ejemplo: Clase: fruta Objeto: Pera
Clase: Plano de una casa Objeto: La casa
Yo no puedo vivir en el plano de una casa pero la casa
no se puede construir si no tenemos un plano.
Para definir una clase usamos la palabra reservada ‘class’
public class MiClase{
}
Buena práctica: Las clases empiezan con mayúsculas
Para instanciar un objeto usamos la palabra reservada ‘new’
MiClase miobjeto=new MiClase()
¿Qué puede tener una clase?
Propiedades y funciones
Las propiedades son valores de mi clase y las funciones procedimientos que tengo ahí para calcular cosas
Que pueden utilizar los valores de la clase. Para ello usamos la palabra reservada ‘this’
public class Alumno{
public String nombre;
public void saludo(){
System.out.println(“Hola me llamo “+this.nombre);
}
}
Las clases tienen también un constructor que se lo que primero se ejecuta cuando instanciamos la clase.
El constructor no tiene una indicación de parámetro a devolver y se llama igual que la clase.
public class Alumno{
public String nombre;
public void saludo(){
System.out.println(“Hola me llamo “+this.nombre);
}
public Alumno(){
}
}
Los constructores pueden tener parámetros en cuyo caso al instanciarlos debemos indicarlos.
public class Alumno{
public String nombre;
public void saludo(){
System.out.println(“Hola me llamo “+this.nombre);
}
public Alumno(String nombre){
this.nombre=nombre;
}
}
—
Alumno Ana=new Alumno(“Ana Pi”);
https://www.javatpoint.com/java-oops-concepts
https://asociacionaepi.es/programacion-orientada-a-objetos-en-java/
package com.trifulcas.clases;
public class Producto {
public String referencia;
public double precio;
public double iva;
public double descuento;
public double PVP() {
// La palabra clave this hace referencia al valor
// de la propiedad del objeto en el que estamos
return this.precio*(1+this.iva);
}
// Función descuento que nos devuelva el precio menos un 10%
public double descuento() {
return this.PVP()*(1-this.descuento);
}
// Toda clase puede tener un constructor
// Se llama cuando instanciamos la clase, al hacer new
// Si pongo un parámetro en elconstructor
// Obligo a que cuando se instancie pongan ese valor
public Producto(String referencia) {
// ¿Qué ponemos dentro de un constructor?
// Todas aquellas inicializaciones que necesite nuestra clase
// Si nuestra clase necesita algunos valores por defecto
// También los ponemos aquí
this.referencia=referencia;
this.iva=.21;
this.descuento=.1;
}
}
package com.trifulcas.clases;
public class ProbarClases {
public static void main(String[] args) {
// Al tener un constructor con parámetro
// Se lo tengo que pasar al instanciarlo
Producto tarta=new Producto("Tarta chupiguay");
Producto cupcake=new Producto("Magdalena con ínfulas");
// Esto ahora da error porque es obligatorio pasar la referencia
//Producto foo=new Producto();
tarta.precio=100;
cupcake.precio=10;
System.out.println(tarta.referencia);
System.out.println(tarta.PVP());
System.out.println(tarta.descuento());
System.out.println(PVP(tarta.precio));
System.out.println(cupcake.PVP());
}
public static double PVP(double precio) {
return precio*1.21;
}
}
package com.trifulcas.saludo;
public class EjemplosClases {
public static void main(String[] args) {
// Para instanciar una clase creo una variable de ese tipo
// Y con la palabra clave new INSTANCIO la clase
Alumno ana=new Alumno();
ana.nombre="Ana Pi";
Alumno pep=new Alumno();
pep.nombre="Pepe Bou";
Alumno[] alumnos=new Alumno[4];
alumnos[0]=new Alumno();
alumnos[0].nombre="Eva";
for(int i=0;i<4;i++) {
alumnos[i]=new Alumno();
alumnos[i].nombre="Alumno "+i;
}
// Esto no lo puedo hacer porque Alumno es una CLASE
// Es decir, una definición, no un objeto
// Alumno.nombre="Juan";
Empleado eva=new Empleado();
eva.nombre="Eva Pou";
}
// Definiendo las propiedades y funciones de la clase Alumno
public static class Alumno{
public String nombre;
}
}
package com.trifulcas.saludo;
public class Empleado {
public String nombre;
}
package com.trifulcas.saludo;
public class Recursividad {
public static void main(String[] args) {
System.out.println(factorial(5));
System.out.println(fibonacci(5));
System.out.println(fibonacci(8));
}
// Una función recursiva es una función que se llama a sí misma
// Factorial: multiplicación desde el 1 hasta el número
// Factorial: N! -> N*(N-1)! 1!->1
// factorial(5)-->5*factorial(4)
// factorial(4)-->4*factorial(3)
// factorial(3)-->3*factorial(2)
// factorial(2)-->2*factorial(1)
// factorial(1)-->1
public static int factorial(int num) {
if (num <= 1) {
return 1;
} else {
return num * factorial(num - 1);
}
}
/*
* Las reglas para definir una función recursiva son dos
* a) Tener un caso base, es decir habrá un momento en el que la función
* devuelve un valor fijo.
* b) Descomponer el problema en la misma función pero de valores más pequeños
*/
/*
* Sucesión de fibonacci. Empezamos con 1,1 y cada número es la suma de los dos anteriores
* 1,1,2,3,5,8,13,21,34,....
* Obtener el elemento N de la sucesión de fibonacci
* Si N es 1 o 2 --> 1
* El elemento N es igual a suma de fib(N-1) + fib(N-2)
*/
public static int fibonacci(int posicion) {
if(posicion<=2) {
return 1;
} else {
return fibonacci(posicion-1)+fibonacci(posicion-2);
}
}
}
https://www.w3schools.com/java/java_scope.asp
package com.trifulcas.saludo;
public class Ambito {
public static void main(String[] args) {
// x está definida para todo el bloque, incluyendo subbloques
int x=0;
for(int i=0;i<10;i++) {
// i y nombre sólo están definidas dentro de este bloque
String nombre="Juan";
System.out.println(i);
System.out.println(nombre);
System.out.println(x);
}
// x existe
System.out.println(x);
// Pero i y nombre no porque se ha cerrado el bloque en el que
// estaban definidas
System.out.println(i);
System.out.println(nombre);
}
}
Cread un programa que nos pida 5 números, los almacene en un array y después nos pida un número y nos diga cuantos valores del array son mayores o iguales a ese número.
Cread un programa que nos pida seis nombres de alumnos y los guarde en un array. Después nos pedirá un nombre y nos dirá si ese nombre está en el array o no.
Cread un programa que cree un array bidimensional de 3×3 y que nos ponga el valor 1 en la diagonal principal:
1 0 0
0 1 0
0 0 1
Con el programa que ya hay en trifulcas de las notas y los alumnos que nos pida los datos y luego nos diga cual es la nota máxima de todos los alumnos y qué alumno lo tiene.
package com.trifulcas.saludo;
import java.util.Scanner;
public class Ejercicio4 {
public static void main(String[] args) {
int[] numeros = new int[5];
Scanner in = new Scanner(System.in);
for (int i = 0; i < 5; i++) {
System.out.println("Introduce el número " + (i + 1));
numeros[i]=in.nextInt();
}
System.out.println("Introduce el número a comprobar");
int numero=in.nextInt();
int cont=0;
for(int i=0;i<numeros.length;i++) {
if(numeros[i]>=numero) {
cont++;
}
}
System.out.println("Hay "+cont+" numeros mayores o iguales que "+numero);
System.out.println("Hay "+mayores(numeros,numero)+" numeros mayores o iguales que "+numero);
in.close();
}
public static int mayores(int[] numeros, int numero) {
int cont=0;
for(int n:numeros) {
if (n>=numero) {
cont++;
}
}
return cont;
}
}
package com.trifulcas.saludo;
import java.util.Scanner;
public class Ejercicio4b {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int[] numeros=pedirNumeros(5,in);
int numero=pedirNumero(in);
System.out.println("Hay "+mayores(numeros,numero)+" mayores que "+numero);
in.close();
}
public static int[] pedirNumeros(int tam,Scanner in) {
int[] numeros=new int[tam];
for (int i = 0; i < 5; i++) {
System.out.println("Introduce el número " + (i + 1));
numeros[i]=in.nextInt();
}
return numeros;
}
public static int pedirNumero(Scanner in) {
System.out.println("Introduce el número ");
int numero=in.nextInt();
return numero;
}
public static int mayores(int[] numeros, int numero) {
int cont=0;
for(int n:numeros) {
if (n>=numero) {
cont++;
}
}
return cont;
}
}
package com.trifulcas.saludo;
import java.util.Scanner;
public class Ejercicio5 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String[] alumnos = new String[6];
for (int i = 0; i < 6; i++) {
System.out.println("Introduce el alumno " + (i + 1));
alumnos[i] = in.nextLine();
}
System.out.println("Introduce el alumno a buscar");
String alumno = in.nextLine();
boolean esta = false;
for (String el : alumnos) {
// Para comparar dos strings
if (alumno.equals(el)) {
esta = true;
}
}
System.out.println("El alumno "+alumno+(esta?"":" no ")+" está en la lista");
in.close();
}
}
package com.trifulcas.saludo;
public class Ejercicio6 {
public static void main(String[] args) {
int[][] tabla = new int[3][3];
// Recorrer todo el array bidimensional
// Y cuando se cumpla la condición poner un 1
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i == j) {
tabla[i][j] = 1;
}
}
}
for (int i = 0; i < 3; i++) {
tabla[i][i] = 1;
}
int[][] otra=diagonal(5);
mostrar(otra);
}
public static int[][] diagonal(int tam){
int[][] tabla=new int[tam][tam];
for (int i = 0; i < tam; i++) {
tabla[i][i] = 1;
}
return tabla;
}
static void mostrar(int[][] tabla) {
// Es otro bucle anidado porque tengo dos dimensiones
for (int i = 0; i < tabla.length; i++) {
for (int j = 0; j < tabla[i].length; j++) {
System.out.print(tabla[i][j] + " | ");
}
System.out.println();
}
}
}
package com.trifulcas.saludo;
import java.util.Scanner;
public class Ejercicio7 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// Pido el número de alumnos (alto de mi tabla multidimensional)
System.out.println("Introduce el número de alumnos");
int alumnos = in.nextInt();
// Pido el número de notas (ancho de mi tabla multidimensional)
System.out.println("Introduce el número de notas por alumno");
int numero = in.nextInt();
// Creo un array multidimensional con los datos que me han dado
int[][] notas = new int[alumnos][numero];
// Para pedir los datos tengo que usar un bucle anidado
// El primero (i) es de los alumnos
// El segundo (j) es de las notas
// La combinación (i,j) son las coordenadas de mi array bidimensional
for (int i = 0; i < alumnos; i++) {
System.out.println("Introduce las notas del alumno " + (i + 1));
for (int j = 0; j < numero; j++) {
System.out.println("Introduce la nota " + (j + 1));
// Guardo la nota en la coordenada adecuada
notas[i][j] = in.nextInt();
}
}
mostrar(notas);
int mayor = notas[0][0]; // Esto es una triquiñuela para evitar coger mínimos como el '0'
int alumno = 0;
for (int i = 0; i < alumnos; i++) {
for (int j = 0; j < numero; j++) {
if (mayor < notas[i][j]) {
mayor = notas[i][j];
alumno=i;
}
}
}
System.out.println("La nota más alta es " + mayor+" y es del alumno "+(alumno+1));
}
static void mostrar(int[][] tabla) {
// Es otro bucle anidado porque tengo dos dimensiones
for (int i = 0; i < tabla.length; i++) {
for (int j = 0; j < tabla[i].length; j++) {
System.out.print(tabla[i][j] + " | ");
}
System.out.println();
}
}
}
https://books.trinket.io/thinkjava2/chapter7.html#sec89
package com.trifulcas.saludo;
public class Referencia {
public static void main(String[] args) {
int[] num= {1,2,3,4};
mostrar(num);
int[] doble=doble(num);
mostrar(doble);
mostrar(num);
doble[0]=27;
mostrar(num);
int[] otroDoble=dobleOk(num);
mostrar(num);
mostrar(otroDoble);
}
static int[] doble(int[] tabla) {
for(int i=0;i<tabla.length;i++) {
tabla[i]*=2;
}
return tabla;
}
static int[] dobleOk(int[] tabla) {
int[] copia=new int[tabla.length];
for(int i=0;i<tabla.length;i++) {
copia[i]=tabla[i]*2;
}
return copia;
}
static void mostrar(int[] tabla) {
for(int elemento:tabla) {
System.out.println(elemento);
}
}
}