PROGRAMACIÓN ORIENTADA A OBJETOS

Práctica de fracciones

PARTE 1.

 Se pide construir una clase denominada Fracción.

 La Fracción se caracteriza por tener un numerador y un denominador, ambos

valores enteros.

 La Fracción se podrá inicializar de las siguientes formas:

o Sin argumentos, en cuyo caso lo hará con valores unidad para los dos
atributos.

o Con un argumento, que representará el valor del numerador. El

denominador valdrá la unidad.

o Con dos argumentos, que representarán el valor del numerador y del

denominador, respectivamente.

o A partir de los datos de otra fracción.

 Se ofrecerán métodos Get y Set seguros para cada uno de los dos atributos de la
clase.

 El comportamiento de la fracción atenderá a la siguiente especificación:

o La fracción se podrá sumar con otra que entre como argumento. El

método devolverá la suma de las dos fracciones, dejando las fracciones
originales inalteradas.

o La fracción se podrá restar con otra que entre como argumento. El

método devolverá la resta de las dos fracciones, dejando las fracciones
originales inalteradas.

o La fracción se podrá multiplicar por otra que entre como argumento. El

método devolverá el producto de las dos fracciones, dejando las
fracciones originales inalteradas.

o La fracción se podrá dividir por otra que entre como argumento. El

método devolverá la división de las dos fracciones, dejando las
fracciones originales inalteradas.
 o Se podrá mostrar la fracción por consola, mostrando claramente el
numerador, el denominador y la barra de fracción.

o La fracción se podrá reducir a un número entero. El método devolverá

dicho número.

o La fracción se podrá reducir a un número real. El método devolverá

dicho número.

o Se podrá comprobar si la fracción es o no irreducible.

o La fracción se podrá simplificar. El método no devolverá nada, se

limitará a simplificar la fracción (en caso de que la fracción sea
irreducible, el método no hará nada).

NOTA. Para programar los dos últimos métodos se recomienda que se

programe un método privado mcd, con la siguiente cabecera:

private int mcd(int a, int b)

El método, al ser privado, no será accesible desde fuera de la clase

Fracción, pero sí podrá ser utilizado por los métodos de la misma.

o Se deberá poder comprobar si la fracción es equivalente a otra.

o Se escribirá un método que realice una copia de la fracción.

PARTE 2.

 Se pide construir una clase principal que pruebe todos los métodos programados
en la clase fracción: debe crear varias fracciones con sus diferentes
constructores, realizar todas las operaciones aritméticas, mostrar las fracciones,
simplificarlas, calcular el entero y el real reducido asociado, comprobar si son
irreducibles o no y comprobar si dos fracciones son equivalentes o no. También
debe recuperar sus atributos, modificarlos a través de los métodos Get y Set y
realizar una copia de la fracción.
public class Fraccion {

private int numerador, denominador;

public Fraccion() {

numerador = denominador = 1; }

public Fraccion(int num) {

numerador = num;

denominador = 1; }

public Fraccion(int num, int den) {

if (den != 0) {

numerador = num;

denominador = den;

} else {

numerador = denominador = 1;

//System.out.println("El denominador debe ser distinto de 0,

//Fracción Unidad generada"); (mejor en documentación)

public Fraccion(Fraccion f){

numerador = f.getNumerador();

denominador = f.getDenominador();}

public int getDenominador() {

return denominador;}

public int getNumerador() {

return numerador;}
public void setNumerador(int num) {

numerador = num; }

public void setDenominador(int den) {

if (den != 0) {

denominador = den;

} //else {

//System.out.println("El denominador debe ser distinto de cero");

//mantiene el valor que tuviera anteriormente.

// }

public Fraccion suma(Fraccion f) {

int num = this.getNumerador() * f.getDenominador() +

this.getDenominador() * f.getNumerador();

int den = this.getDenominador() * f.getDenominador();

Fraccion res = new Fraccion(num, den);

return res;}

public Fraccion resta(Fraccion f) {

int num = this.getNumerador() * f.getDenominador() –

this.getDenominador() * f.getNumerador();

int den = this.getDenominador() * f.getDenominador();

Fraccion res = new Fraccion(num, den);

return res;}

public Fraccion multiplica(Fraccion f) {

int num = this.getNumerador() * f.getNumerador();

int den = this.getDenominador() * f.getDenominador();

Fraccion res = new Fraccion(num, den);

return res;}
public Fraccion divide(Fraccion f) {

int num = this.getNumerador() * f.getDenominador();

int den = this.getDenominador() * f.getNumerador();

Fraccion res = new Fraccion(num, den);

return res;}

public void mostrar() {

System.out.println(getNumerador() + "/" + getDenominador());}

public int entero() {

int res = getNumerador() / getDenominador();

return res; }

public double real() {

double res = (double) getNumerador() / (double) getDenominador();

return res; }

public boolean equivalente(Fraccion f){

return (this.numerador*f.getDenominador() ==

this.denominador*f.getNumerador()); }

public void simplifica() {

int mcd = mcd(getNumerador(), getDenominador());

this.setNumerador(numerador / mcd);

this.setDenominador(denominador / mcd);}

public boolean irreducible() {

if (mcd(getNumerador(), getDenominador()) == 1)

return true;

return false; }
 public Fraccion copia () {

return new Fraccion (numerador, denominador)

/*método privado, lo pueden usar los métodos públicos que lo necesiten, pero
es inaccesible desde fuera de la clase */

private int mcd(int a, int b) {

int resultado;

if (b == 0) {

resultado = a;

} else {

resultado = mcd(b, a % b);

return resultado;

} //Fracción
public class Test {

public static void main(String[] args) {

Fraccion f = new Fraccion(1, 2);

Fraccion f2 = new Fraccion(4);

Fraccion f3 = new Fraccion();

Fraccion f4;

f4 = f.suma(f2);

f4.mostrar();

f4 = f.resta(f2);

f4.mostrar();

f4 = f.multiplica(f2);

f4.mostrar();

f4 = f.divide(f2);

f4.mostrar();

int n = f4.entero();

System.out.println(n);

double d = f4.real();

System.out.println(d);

Fraccion f5 = new Fraccion(12, 48);

f5.simplifica();

f5.mostrar();

Fraccion f6 = new Fraccion(12, 0);

f6.setNumerador(0);

f6.setDenominador(2);

f5.divide(f6).mostrar();

System.out.println (f4.getNumerador());

System.out.println (f4.getDenominador());

Fraccion f7 = new Fraccion(2, 4);

Fraccion f8 = new Fraccion(f7);

f8 = f7.copia();
if (f7.irreducible()) {

System.out.print("La fracción: ");

f7.mostrar();

System.out.println("es irreducible");

} else {

System.out.print("La fracción: ");

f7.mostrar();

System.out.println("es simplificable");

if (f7.equivalente(f8)) {

System.out.print("La fracción:");

f7.mostrar();

System.out.print(" es equivalente a: ");

f8.mostrar();

} else {

System.out.print("La fracción:");

f7.mostrar();

System.out.print(" NO es equivalente a: ");

f8.mostrar();

if (f5.equivalente(f8)) {

System.out.print("La fracción:");

f5.mostrar();

System.out.print(" es equivalente a: ");

f8.mostrar();

} else {

System.out.print("La fracción:");

f5.mostrar();

System.out.print(" NO es equivalente a: ");

f8.mostrar(); }

Fraccion f9 = new Fraccion (f8);

f9.mostrar();}}