daniel alberto zavaleta palacios ejercicio poo (bluej)
TRANSCRIPT
Instituto Tecnologico de Tuxtla Gutierrez
Programación Orientada a Objetos
Ejercicio Resueltos Capitulo 1 y 2
Daniel Alberto Zavaleta Palacios
Matricula: 11270328
Maestro: Raúl Paredes Trinidad
Turno: Matutino
Ingeniería en Sistemas Computacionales
Capitulo1 Ejercicio 1.1
Acá se pueden apreciar que se han creado dos objetos de la clase circulo y uno de la clase cuadrado Ejercicio 1.2 Lo que ocurre es que al llamar do veces el método mover abajo se mueve dos veces para abajo, y al darle dos veces a volver invisible, simplemente al darle la segunda vez sigue siendo invisible ya que se le digo la primera vez que fuera invisible y al volver a darle simplemente queda igua Ejercicio 1.3 Para poder mover a la izquierda se pone un signo menos (-) Ejercicio 1.4
Ejercicio 1.5 Al ingresar un color que no está permitido, simplemente el cirulo se colorea de color negro Ejercicio 1.6 Marcar un erro, diciendo que no se puede encontrar la variable, esto se debe a que como es una cadena esta se debe escribir entre comilla (Ejempló “blue”) Ejemplo 1.7
Acá se puede ver que antes de
llamar el método el circulo era
de color azul, después se llamo 2
veces a l método cambiar color y
como consecuencia quedo en
rojo y amarillo,
Acá se puede ver que se han creado varios objetos con diretes atributos, cada objeto tendrán los mismos métodos
Ejercicio 1.8
Acá se puede observar cómo va cambiando el estado de un objeto, pué debemos recordar que el estado de un objeto son sus características que posee en un determinado momento Ejercicio 1.9 Para dibujar la casa primero se crea el numero de objetos de cada clase necesarios para poder dibujar la casa, luego se les pone el tamaña adecuado a cada uno y por ultimo se ordenan con los diferentes métodos, para que as al final quede en forma de casa. La otra forma seria creando un objeto que se encargue de crear a los demás objetos y a la vez, les de su tamaña ubicación y color correspondiente
Ejercicio 1.10
Acá se puede apreciar se dibuja la casa prácticamente solita Ejercicio 1.11 Se crea un objeto llamado picture1: este objeto se encargara de crear a los otros objetos con sus respetivas medidas, ubicación, tamaño y color
Ejercicio1.12
Acá se puede ver que el código fuente de la clases Ejercicio 1.13
Se puede ver la modificación en el código, y por ende al ejecutar el método el sol en lugar de ser amarillo ahora será azul Ejercicio 1.14
Acá se agrega un nuevo campo de tipo circle y de nombre sun2, a continuación se pone las sentencias extras que se ponen en el método drow para que se pueda dibujar el sol2 sun2 = new Circle(); sun2.changeColor("yellow"); sun2.moveHorizontal(10);
sun2.moveVertical(-15); sun2.changeSize(60); sun2.makeVisible(); Ejercicio 1.15
Acá se puede apreciar la parte en amarilla es la que se agrego para hacer que el sol descienda después de que se creó el dibujo, para eso se creó un nuevo método llamado Sol_hola que básicamente lo que hace es bajar el sol lentamente de modo que parezca que está saliendo Ejercicio 1.16
Una vez más se puede ver que en la parte amarilla es la que sea agrego, se agrego un método nuevo para que el sol se puede ir después Ejercicio 1.17
Ejercicio1.18
Acá se puede ver que en la primera captura el objeto pide un dos parámetros para que este puede trabajar, luego en la segunda captura se muestra el objeto ya creado en el banco d objetos
En esta imagen nos damos cuenta que el método getName nos regrese el valor del nombre, este es un método de retorno pues no regresa un valor Ejercicio1.19
Acá se crea un nuevo objeto de tipo labclass en objeto al ser creado pide un parámetro de tipo entero, después de ponerlo el objeto queda creado y aparece en el banco de objetos Ejercicio1.20
Ejercicio 1.21
Ejercicio 1.22
Al llamar el método imprimir lista imprime el nombre de los alumnos inscritos, ese método usa los parámetros que anteriormente se le han pasado y los manda imprimir después, acá podemos ver como un parámetro fue pasado a un campo
Acá se han creado tres objetos de tipo estudiante y uno de clase de laboratorio, también observamos que hemos inscrito un estudiante, para eso llamamos a método inscribir estudiante y nos damos cuenta que nos pide un parámetro de tipo estudiante y por eso debemos poner que objeto será al que se inscribirá
Ejercicio 1.23
Acá una vez más se puede ver como se crean varios objetos estudiantes se inscriben y por último se llama el método imprimir lista para que nos regrese el nombre de los estudiantes ademsas de que nos diga la cantidad de estudiantes inscritos Ejercicio 1.24
Acá podeos ver por medio del inspector, los diferentes campos que tiene el objeto además de saber de que tipos son
Ejercicio 1.25
Acá se puede ver como se agregaron los demás campos de profesor, salón, hora, y salón. Y después se ve que al imprimir, se imprimen todos los detalles. Ejercicio 1.26 Algunos de los tipos de datos en java son los siguientes:
Ejercicio 1.27 Los datos son: boolena string Int
Boolean Int doublé Ejercicio 1.28 Se debe poner una nueva declaración de campo, y quedaría asi: Pritvate String nombre; Ejercicio 1.29 La declaración quedaría de la siguiente manera: public void Enviar(String abc) { } Ejercicio 1.30 public void promedio(int numa, int numb) { } Ejercicio 1.31 Puede ser objeto o clase, ya que depende del nivel de abstracción del diseñador, puede ser una clase pues la clase se llamaría libro y sus objetos podrían ser las hojas, pero también puede ser objeto ya que pude pertenecer a una clase libro Ejercicio 1.32 No, ya que solo un objeto puede pertenecer a una sola clase
Capitulo 2
Capitulo2
Ejercicio 2.1
Acá se puede ver que se crea un
objeto de la máquina de escribir,
y luego se mandan a llamar sus
métodos correspondientes.
En estas imágenes se llama al los
métodos conseguir precio,
insertar dinero e imprimir boleto
Ejercicio 2.2
Después de llamar el método imprimir boleto, el saldo de es cero, ya que después de
imprimir el boleto, el saldo siempre volverá a cero
Ejercicio 2.3
Esta máquina tiene muchas fallas, ya que no da cambio, acepta cantidades negativas e
imprime el boleto sin importar que falta o sobre dinero.
Ejercicio 2.4
Muy bien, en este momento quedo muy claramente cómo funciona la máquina de boletos,
mas sin embargo aun no nos metemos en el código, próximamente lo haremos
Ejercicio 2.5
Acá se puede apreciar que se han creado dos objetos de la clase maquina de boletos, ambos
con los mismo métodos, pero con diferentes atributos, ejemplo cada quien con diferentes
precios.
Ejercicio 2.6
public class Estudiante
{
}
public class CursoDeLaboratorio
{
}
Ejercicio 2.7
No se puede ya que la sintaxis no es la correcta, la sintaxis correcta es:
(public/prívate)+class+(NombreDeLaClase)
Ejemplo public class Mascota
En caso de que no se escribamos correctamente saldrá el siguiente erro.
<identifier> expected
Ejercicio 2.8
Si es posible ya que por defecto inicia las clases en públicas, pero sin embargo es bueno
colocarlas para poder saber que estamos haciendo
Ejercicio 2.9
Campos
private int price;
private int balance;
private int total;
private int estado;
Constructor
public TicketMachinere()
{
price = 1000;
balance = 0;
total = 0;
}
Métodos
public int getPrice()
{
return price;
}
public int getBalance()
{
return balance;
}
public void insertMoney(int amount)
{
balance = balance + amount;
}
public int Total()
{
return total;
}
public void Mensaje()
{
System.out.println("Por favor ingrese la cantidad de dinero correcta");
}
public void Mostrar_precio()
{
System.out.println("El precio del boleto es de " + price + " centavos");
}
public void Vaciar_total()
{
total=0;
}
public void Cambiar_precio(int campre)
{
price=campre;
}
public void printTicket()
{
// Simulate the printing of a ticket.
System.out.println("##################");
System.out.println("# The BlueJ Line");
System.out.println("# Ticket");
System.out.println("# " + price + " cents.");
System.out.println("##################");
System.out.println();
balance = 0;
}
}
En la parte de atrás mostramos cuales son los campos, constructor y métodos
Ejercicio 2.10
Los constructores no llevan valores de retorno, además de que el constructor siempre
llevara el mismo nombre de la clase
Ejercicio 2.11
1.- privada y entera
2.-privada y de tipo objeto
3.-Privada y de tipo objeto
Ejercicio 2.12
1.- vive
2.-tutor
3.- juego
Ejercicio 2.13
Si tiene una gran importancia ya que al escribir un campo primero se escribe prívate o
public luego el tipo de campo que es y por último el nombre del campo en caso de no
escribir bien la sintaxis puede salir un mensaje de error como el siguiente:
<identifier> expected
Ejercicio 2.14
Si es de carácter muy importante ya que si no se pone ; marca el siguiente error:
; expected
Es muy importante no olvidar ; si lo recordamos esto nos ahorrara muchos dolores de
cabeza
Ejercicio 2.15
La declaración queda de la siguiente forma
prívate int Estado;
Ejercicio 2.16
Pertenece a la clase Estudiante
Ejercicio 2.17
El constructor tiene dos parámetros, el primero es de tipo String(cadena) y el segundo es de
tipo int(entero)
Ejercicio 2.18
Muy posiblemente serán del tipo String int ,float y alomejor de tipo objeto
Ejercicio 2.19
nombre=nombreMascota;
A continuación se muestra la clase Mascota creada
Ejercicio 2.20
El error es que se puso int antes del precio, lo que se hizo fue declarar una variable local, y
eso hace es que ahí se declara una variable local con el mismo nombre de un campo no
podre usar el campo en ese constructor o método. El código correctamente debe quedar de
la siguiente manera
public TicketMachine(int ticketCost)
{
price = ticketCost;
balance = 0;
total = 0;
}
Como nos dimos cuenta se quito el int y así si se puede usar el campo con su parámetro
correspondiente
Ejercicio 2.21
La única diferencia es el nombre del método y campo al que retorna, una retorna al campo
saldo y el otro retorna al precio, fuera de ahí pues ambos regresan un entero.
Ejercicio 2.22
Se podría caracterizar con la pregunta ¿Cuál es el saldo?
Ejercicio 2.23
No, ya que solo se está cambiando el nombre del método, pero no se está modificando
ningún campo, ni se está haciendo un cambio en alguna sentencia del código
Ejercicio 2.24
public int Mostrar_Total()
{
return total;
}
Ejercicio 2.25
Marca un erro ya que falta una sentencia para saber que valor se retornara
missing return statement
Ejercicio 2.26
La diferencia principal es que en una el tipo de return es int y en otra el tipo de es void, esto
quiere decir que el método imprimir boleto no regresara ningún valor, pero si pude
imprimir mediante la sentencia System.out.println
Ejercicio 2.27
No tienen return ya que estos ambos son métodos de modificación, en el método ingresar
dinero modifica el campo de balance, mientras que el método imprimir boleto imprime el
boleto y además, modifica el total sumándole el balance y por ultimo restablece el balance
Ejercicio 2.28
Se crea un objeto de la clase
Maquina de boletos y se ve en e
banco de objetos
Después de haberlo creado, se
invoca el método getBalance y
con eso nos devuelve en valor de
saldo, como aun no hemos
metido dinero el saldo es igual a
0
Ejercicio 2.29
La palabra reservada void, void es un retorno que no regresa ningún valor.
Ejercicio 2.30
Public void PonerPrecio(int pre)
{
Precio=pre;
}
Ejercicio 2.31
public void incrementar(int puntos)
{
puntaje=puntaje+puntos;
}
Ejercicio 2.32
public void descuento(int cantidad)
{
precio=precio-cantidad;
}
Se ingresa el dinero, este método
pasara el parámetro al campo
balance
Se vuelve a invocar el método
getBalance ahora como ya
hemos ingresado dinero, el valor
ahora es de 100.
Ejercicio 2.33
public void Mensaje()
{
System.out.println("Por favor ingrese la cantidad de dinero correcta");
}
Ejercicio 2.34
public void Mostrar_precio()
{
System.out.println("El precio del boleto es de " + price + " centavos");
}
Ejercicio 2.35
Ejercicio 2.36
Se imprimirá la palabra precio en lugar del campo precio, esto se debe a que si queremos
imprimir algo lo escribimos entre comillas, y si queremos imprimir un campo no lleva
comillas
Ejercicio 2.37
Imprimirá el # precio cvos ya que está entre comillas, si queremos imprimir el campo
precio más la palabra centavos se tendría que escribir de la siguiente manera
(“El precio es de “+ precio + “centavos”);
Ejercicio 2.38
No ya que ambas tienen fallas al momento de imprimir el boleto, si se quisiera usa se
tendría que usar de la siguiente manera
public void Mostrar_precio()
{
System.out.println("El precio del boleto es de " + price + " centavos");
}
Ejercicio 2.39
La modificación del constructor hace que al crearse un objeto de máquina de boletos
siempre se iniciara el campo precio con 1000, el constructor queda de la siguiente manera
Acá se puede ver que se
han creado dos maquina
de boletos, y ambas
muestran diferente
valores cuando se llama
al método mostrar precio,
esto se debe a que cada
una de un objeto
independiente.
public TicketMachine()
{
price = 1000;
balance = 0;
total = 0;
}
Ejercicio 2.40 El método no necesita ningún parámetro ya que trabajara sin necesidad de información
extra, es un método de modificación ya que modifica el valor del campo total, el método
queda de la siguiente manera.
public void Vaciar_total()
{
total=0;
}
Ejercicio 2.41
El método es de modificación ya que modificara el campo del precio, el método queda de la
siguiente manera.
public void CambiarPrecio(int pre)
{
precio=pre;
}
Ejercicio 2.42
Acá se muestra los dos objetos creados, y después se muestran los dos códigos de los dos
constructores
public TicketMachine(int ticketCost)
{
price = ticketCost;
balance = 0;
total = 0;
}
public TicketMachine()
{
price = 100;
balance = 0;
total = 0;
}
Ejercicio 2.43
Acepta valores positivos negativos y ceros, por lo que podemos decir que tiene un error,
pues no debe pasar, se debe corregir todo esto para que el método trabaje correctamente
Ejercicio 2.44
Con esto corregimos un problema, pues ya no aceptara números negativos, ahora si
queremos aceptar números positivos y que empiece a partir de 1 quedaría asi
If(cantidad >=1)
Ejercicio 2.45
Usamos un boolen para hacerlo visible, está bien implementado ya que se quiere hacer
visible o invisible y las variables de tipo boolena nos dan esa opción.
Ejercicio 2.46
La diferencia es que en lugar de volver a cero el campo de saldo, solo le resta el saldo
menos el precio, para que asi quede en saldo algo de cambio, y sea disponible para usarlo
de nuevo al imprimir un nuevo boleto.
Ejercicio 2.47
No ya que mínimo habrá en el campo saldo la cantidad necesario para imprimir un boleto,
mínimo el campo saldo quedara en cero pero nunca un valor negativo.
Ejercicio 2.48
A continuación se muestran algunos tipo de operadores en java
Operadores Unarios: El mas (+) y el menos (-). Para cambiar el signo del operando.
Operador Instanceof: Nos permite saber si un objeto pertenece a una clase o no.
* NombreObjeto instanceof NombreClase
Operadores Incrementales: Son los operadores que nos permiten incrementar las variables
en una unidad. Se pueden usar delante y detrás de la variable dependiendo de lo que
queramos, es decir, si queremos que incremente o viceversa antes de utilizar o lo contrario.
* '++'
* '--'
Operadores Relacionales: Permiten comparar variables según relación de
igualdad/desigualdad o relacción mayor/menor. Devuelven siempre un valor boolean.
* '>': Mayor que
* '<': Menor que
* '==': Iguales
* '¡=': Distintos
* '>=': Mayor o igual que
* '<=': Menor o igual que
Operadores Lógicos: Nos permiten construir expresiones lógicas.
* '&&' : devuelve true si ambos operandos son true.
* '||' : devuelve true si alguno de los operandos son true.
* '!' : Niega el operando que se le pasa.
* '&' : devuelve true si ambos operandos son true, evaluándolos ambos.
* '|' : devuelve true uno de los operandos es true, evaluándolos ambos.
Operador de concatenación con cadena de caracteres '+':
* Por Ejemplo: System.out.println("El total es"+ result +"unidades");
Operadores que actúan a nivel de bits: Son mucho menos utilizados por eso los explicamos
mas por encima.
* '>>': desplazamiento a la derecha de los bits del operando
* '<<': desplazamiento a la izquierda de los bits de operando
* '&': operador and a nivel de bit.
* '|': operador or a nivel de bit
Ejercicio 2.49
ahorro=precio*descuento;
Ejercicio 2.50
promedio=total/cantidad;
Ejercicio 2.51
If(precio>presupuesto)
{
System.out.println(“El precio es muy caro”);
}
Else
{
System.out.println(“El precio es justo);
}
Ejercicio 2.52
If(precio>presupuesto)
{
System.out.println(“El precio es muy caro, su presupuesto es de “ + presupuesto );
}
Else
{
System.out.println(“El precio es justo);
}
Ejercicio 2.53
Por que regresa el valor de saldo, pero en la línea anterior saldo es igualado a cero, y por
eso al retornar a saldo este vale cero, en cambio en el anterior copia saldo a una variable
loca, luego el saldo lo iguala a cero y por ultimo retorna a la variable local en la que se
copio el valor de saldo
Ejercicio 2.54
Ya no iguala el saldo a cero ya que antes tiene un return a saldo, y siempre un return debe
ser la última sentencia que se debe ejecutar ya que después del return ya no se hará nada
más
Ejercicio 2.55
public int Vaciar_total()
{
int tomi;
tomi=total;
total=0;
return tomi;
}
Ejercicio 2.56
Ambos, ya que modifica un campo, y además muestra un campo
Ejercicio 2.57
public void printTicket_3(int op)
{
int cantidad;
int canreapa;
canreapa=0;
cantidad=0;
ahorro=price*des;
canreapa=price3-balance;
if(canreapa <= 0) {
// Simulate the printing of a ticket.
ahorro=price*des;
System.out.println("##################");
System.out.println("# The BlueJ Line");
System.out.println("# Ticket");
System.out.println("# " + price3 + " cents.");
System.out.println("##################");
System.out.println();
// Update the total collected with the price.
total = total + price3;
// Reduce the balance by the prince.
balance = balance - price3;
}
else {
System.out.println("Te faltan por pagar "+ canreapa + " centavos");
}
}
Ejercicio 2.58
No es necesario modificar tantos campos, en general solo habría que modificar algunos
métodos agregando variables locales, parámetros y usar un switch al imprimirlos boletos
para saber de que tipo de boleto se imprimira, quedaría de la siguiente manera.
public class Mi_maquina
{
private int total;
private int saldo;
private int precio1;
private int precio2;
private int precio3;
/**
* Ingrese el costo de los boletos
*/
public Mi_maquina(int costo1, int costo2, int costo3)
{
precio1=costo1;
precio2=costo2;
precio3=costo3;
total=0;
saldo=0;
}
public int Mostar_saldo()
{
return saldo;
}
public int Mostrar_total()
{
return total;
}
/**
* Restaurar el total y muestra el total existente hasta ese momento
*/
public int Restaurar_total()
{
int totem;
totem=total;
total=0;
return totem;
}
public void Mostar_precio_de_boletos()
{
System.out.println("El precio del boleto Numero 1 es de $"+ precio1);
System.out.println("El precio del boleto Numero 2 es de $"+ precio2);
System.out.println("El precio del boleto Numero 3 es de $"+ precio3);
}
public void Cambiar_precio_de_boletos(int costo1, int costo2, int costo3)
{
precio1=costo1;
precio2=costo2;
precio3=costo3;
}
/**
* Regresa el dinero sobrante (cambio) y restaura el saldo a cero
*/
public int Entregar_cambio()
{
int satem;
satem=saldo;
saldo=0;
return satem;
}
public void Insertar_dinero(int aumento)
{
if(aumento>0)
{
saldo=saldo+aumento;
}
else
{
System.out.println(+ aumento + " No es un valor permitido, por favor ingrese un valor
positivo");
}
}
/**
* Seleccione con numero el tipo de boleto que desee y la cantidad (1,2 o 3)
*/
public void Imprimir_boleto(int opc, int can)
{
int tem1;
int tem2;
int tem3;
tem1=0;
tem2=0;
tem3=0;
tem1=precio1;
tem2=precio2;
tem3=precio3;
switch ( opc )
{
case 1:
tem1=precio1*can;
if(saldo >= tem1)
{
saldo=saldo-tem1;
total=total+tem1;
System.out.println("*******************Mi Maquina***********************");
System.out.println(+ can + " boleto(s) de "+ precio1 + " Centavos");
System.out.println("Le queda de saldo "+ saldo + " Centavos");
System.out.println(" ");
saldo=0;
}
else
{
System.out.println("Su saldo actual es insuficiente, su saldo actual es de:"+ saldo +
",Ingrese mas dinero o elija otro tipo de boleto");
}
break;
case 2:
tem2=precio2*can;
if(saldo >=tem2)
{
saldo=saldo-tem2;
total=total+tem2;
System.out.println("*******************Mi Maquina***********************");
System.out.println(+ can + " boleto de "+ precio2 + " Centavos");
System.out.println("Le queda de saldo "+ saldo + " Centavos");
System.out.println(" ");
saldo=0;
}
else
{
System.out.println("Su saldo actual es insuficiente, su saldo actual es de:"+ saldo +
",Ingrese mas dinero o elija otro tipo de boleto");
}
break;
case 3:
tem3=precio3*can;
if(saldo >=tem3)
{
saldo=saldo-tem3;
total=total+tem3;
System.out.println("*******************Mi Maquina***********************");
System.out.println(+ can + " boleto de "+ precio3 + " Centavos");
System.out.println("Le queda de saldo "+ saldo + " Centavos");
System.out.println(" ");
saldo=0;
}
else
{
System.out.println("Su saldo actual es insuficiente, su saldo actual es de:"+ saldo +
",Ingrese mas dinero o elija otro tipo de boleto");
}
break;
default:
System.out.println("Error Ingrese el tipo de boleto correcto");
break;
}
}
}
Ejercicio 2.59
El nombre del método es getCodigo y es de tipo String
Ejercicio 2.60
El nombre del método es SetCredito, el nombre del parámetro es cantidadDeCredito y es de
tipo entero (int)
Ejercicio 2.61
public class Persona
{
}
Ejercicio 2.62
private String nombre;
private int edad;
private String código;
private int crédito;
Ejercicio 2.63
public Modulo(String CodigoDelModulo)
{
Código=CodigoDelModulo;
}
Ejercicio 2.64
Public Persona(String miNombre, int Miedad)
{
nombre=miNombre;
edad=Miedad;
}
Ejercicio 2.65 El error es que lleva un void y si se supone que retornara debe llevar el tipo de dato que
retorna corregido queda de la siguiente manera
Public int getEdad()
{
Return edad;
}
Ejercicio 2.66
public String getNombre()
{
return nombre;
}
Ejercicio 2.67
public void setEdad(int ed)
{
Edad=ed;
}
Ejercicio 2.68
public void Imprimir_detalles()
{
System.out.println(“El nombre de la persona es “ + nombre );
}
Ejercicio 2.69
Ejercicio 2.70
Retornara Henr557
Ejercicio 2.71
Marca un error, esto se debe a que la primera cadena es muy corta, pues debe ser mínimo
de 4 caracteres
Ejercicio 2.72
public Student(String fullName, String studentID)
{
if(fullName.length()<4)
{
System.out.println("\nError: El nombre completo es demasiado, debe ser mayor 4
letras");
}
if(studentID.length()<3)
{
System.out.println("\nError: El ID del estudiate es demasiado corto, debe ser mayor
a 3 letras");
}
name = fullName;
id = studentID;
credits = 0;
}
Ejercicio 2.73
public String getLoginName()
{
int tano;
int taid;
tano=name.length();
taid=id.length();
if(tano<4 && taid>=3)
{
return name.substring(0,tano) + id.substring(0,3);
}
if(tano>=4 && taid<3)
{
return name.substring(0,4) + id.substring(0,taid);
}
if(tano<4 && taid<3)
{
return name.substring(0,tano) + id.substring(0,taid);
}
else
{
return name.substring(0,4) + id.substring(0,3);
}
}
Ejercicio 2.74
A continuación se muestra las dos imágenes de los métodos de acceso muestra autor y
mostrar título y luego se muestra el código de esos dos métodos
public String Mostrar_autor()
{
return author;
}
public String Mostar_titulo()
{
return title;
}
Ejercicio 2.75 A continuación se muestra la impresión al llamar imprimir_mi_autor e imprimir_titulo y
luego se muestra el código de la impresión en los dos métodos.
public void Imprimir_mi_autor()
{
System.out.println("El autor es "+ author);
}
public void Imprimir_titulo()
{
System.out.println("El titulo del libro es " + title);
}
Ejercicio 2.76
Campo
private int paginas;
Constructor
public Book(String bookAuthor, String bookTitle, int nupa)
{
author = bookAuthor;
title = bookTitle;
paginas=nupa;
}
Método
public int Mostar_num_de_paginas()
{
return paginas;
}
Ejercicio 2.77
El código del método imprimir detalles queda de la siguiente manera
public void Imprimir_detalles()
{
System.out.println("\nTitulo:" + title);
System.out.println("Autor:" + author);
System.out.println("Num de paginas:" + paginas);
System.out.println("Num de referencia:" + NumeroDeReferencia);
System.out.println("Este libro se a prestado:"+ prestado + " Veces");
}
Ejercicio 2.78
Campo
private String NumeroDeReferencia;
Constructor
public Book(String bookAuthor, String bookTitle, int nupa)
{
author = bookAuthor;
title = bookTitle;
NumeroDeReferencia="";
paginas=nupa;
}
Método
public void Cambiar_numero_de_referencai(String numre)
{
NumeroDeReferencia=numre;
}
Ejercicio 2.79
Constructor
public Book(String bookAuthor, String bookTitle,String NReferencia)
{
author = bookAuthor;
title = bookTitle;
int num;
num=NReferencia.length();
if(num>=3)
{
NumeroDeReferencia=NReferencia;
}
}
Acá nos damos cuenta que no es necesario en el método de imprimir detalles poner la
sentencia condiciona ya que desde el constructor la evaluamos y si paso el constructor por
lógica si se imprime en caso de que no pasa la prueba en el constructor imprimirá cero en
número de referencia
Ejercicio 2.80
public void Cambiar_numero_de_referencai(String numre)
{
int num;
num=numre.length();
if(num>=3)
{
NumeroDeReferencia=numre;
}
else
{
System.out.println("Error: Ingrese un numero de referencia de almenos 3
caracteres");
}
}
Ejercicio 2.81
Campo
private int prestado;
Método Prestar
public void Prestarlibro()
{
prestado=prestado+1;
}
Método Imprimir Detalles
public void Imprimir_detalles()
{
System.out.println("\nTitulo:" + title);
System.out.println("Autor:" + author);
System.out.println("Num de paginas:" + paginas);
System.out.println("Num de referencia:" + NumeroDeReferencia);
System.out.println("Este libro se a prestado:"+ prestado + " Veces");
}
Ejercicio 2.82
A continuación mostraremos una captura, donde se muestra un objeto creado y luego se
muestra el código
public class calentador
{
private int temperatura;
public calentador()
{
temperatura=15;
}
public void Calentar_Aumentar_tem()
{
Temperatura=temperatura+5;
}
public void Enfriar_Disminuir_tem()
{
Temperautura=temperatura-5;
}
public int Mostar_tem_actual()
{
return temperatura;
}
}
Ejercicio 2.83
A continuación se muestra el código anterior pero modificado, este método hace cosas un
poca mas diferentes que al anterior, posee muchas ventajas con respecto al anterior pues
este lo podemos considerar que se puede implementar en la vida real
public class calentador
{
private int temperatura;
private int max;
private int min;
private int incremento;
/**
* Ingrese el minimo y el maximo de temperatura
*/
public calentador(int mi, int ma)
{
max=ma;
min=mi;
temperatura=15;
incremento=5;
}
public void Calentar_Aumentar_tem()
{
int tem1;
tem1=temperatura;
tem1=tem1+incremento;
if(tem1<=max)
{
temperatura=temperatura+incremento;
}
else
{
System.out.println("La temperatura actual es de "+ temperatura + ", no se permite calentar
mas la temperatura");
}
}
public void Enfriar_Disminuir_tem()
{
int tem1;
tem1=temperatura;
tem1=tem1-incremento;
if(tem1>=min)
{
temperatura=temperatura-incremento;
}
else
{
System.out.println("La temperatura actual es de "+ temperatura + ", no se permite enfriar
mas la temperatura");
}
}
public void Cambiar_incremento(int nui)
{
if(nui>0)
{
incremento=nui;
}
else
{
System.out.println("Se debe ingresar un valor positivo y que sea diferente de cero");
}
}
public int Mostar_min()
{
return min;
}
public int Mostar_max()
{
return max;
}
public int Mostar_tem_actual()
{
return temperatura;
}