Algoritmos JAVa

package semana_01;
//atributos públicos: codigo (int), nombre

//(String), horas trabajadas (int) y tarifa horaria (double). Implemente además:
public class Trabajador {
public int codigo,horas;
public String nombre;
public double tarifa;
//Un método que retorne el sueldo bruto (horas*tarifa)

public double sBruto(){
return horas*tarifa;
}
//Un método que retorne el descuento de acuerdo a la siguiente tabla:
//Sueldo bruto Descuento
//< 3500 1 1 % del sueldo bruto
//≥ 3500 y < 4500 1 3% del sueldo bruto
//≥ 4500 15% del sueldo bruto
public double descuento(){
if (sBruto()<3500) return sBruto()*11/100;
else if (sBruto()<4500) return sBruto()*13/100;
else return sBruto()*15/100;
}
// Un método que retorne el sueldo neto (sueldo bruto - descuento).
public double sNeto(){
return sBruto()-descuento();
}
//las variables no llevan parentesis
//los metodos si llevan parentesis
}
GUI
protected void actionPerformedBtnProcesar(ActionEvent arg0) {
//Declare y cree un objeto de tipo Trabajador.
Trabajador t1=new Trabajador(); // hemos creado un objeto del tipo
trabajador
//Ingrese datos fijos

t1.codigo=1;
t1.nombre="Juan Rodriguez";
t1.horas=48;
t1.tarifa=30;
//Visualice todos sus datos

imprimir("codigo: "+t1.codigo);
imprimir("nombre: "+t1.nombre);
imprimir("horas: "+t1.horas);
imprimir("tarifa: "+t1.tarifa);
imprimir("sueldo bruto: "+t1.sBruto());
imprimir("descuento: "+t1.descuento());
imprimir("sueldo neto: "+t1.sNeto());
imprimir("♥♥♥♥♥♥♥♥♥♥♥♥♥♥♥♥♥♥♥♥♥");
package semana_01;
public class Docente {

//Diseñe la clase Docente en el paquete semana_01 con los atributos públicos:
codigo (int), nombre
//(String), horas trabajadas (int) y tarifa por hora (double). Implemente
además:
public double tph;
//Un método público que retorne el sueldo (horas*tarifa)

public double sueldo(){
return horas*tph;
}
GUI
//Declare y cree un objeto de tipo Docente.
Docente d1=new Docente();
//Ingrese datos fijos.

d1.codigo=1;
d1.horas=9;
d1.nombre="Elmer Huertas";
d1.tph=35.5;
//Visualice todos sus datos.

imprimir("Nombre del docente: "+d1.nombre);
imprimir("codigo: "+d1.codigo);
imprimir("horas trabajadas: "+d1.horas);
imprimir("tarifa por horas: "+d1.tph);
imprimir("El sueldo del docente es : "+d1.sueldo());
package semana_01;
//Diseñe la clase Persona en el paquete semana_01 con los atributos públicos:
nombre (String),
//apellido (String), edad (int), estatura (double) y peso (double)
public class Persona {
public String nombre,apellido;
public int edad;
public double peso,estatura;
//Un método que retorne el estado de la persona entre: “menor de edad” o
“mayor de edad”
public String ePersona(){
if (edad<18 ) return "Menor de edad";
else return "Mayor de edad";
}
//Un método que retorne el índice de masa corporal de la persona

(peso/estatura²).
public double mCorporal(){
return peso/(estatura*estatura);
}
}
GUI
//Declare y cree un objeto de tipo Persona.
Persona p1=new Persona();
//Ingrese datos fijos.

p1.nombre="Alfredo";
p1.apellido="Mendiola";
p1.edad=17;
p1.peso=76;
p1.estatura=189;
//Visualice todos sus datos.

imprimir("nombre: "+p1.nombre);
imprimir("apellido: "+p1.apellido);
imprimir("edad: "+p1.edad);
imprimir("peso: "+p1.peso);
imprimir("estatura: "+p1.estatura);
imprimir("estado de persona : "+p1.ePersona());
imprimir("indice de masa corporal: "+p1.mCorporal());
package semana_02;
//DiseÃ±e la Clase Celular en el paquete semana_02 con los atributos privados:
nÃºmero (int), usuario
//(String), segundos consumidos (int) y precio por segundo (double).
public class Celular {
private int numero,segundos;
private String usuario;
private double precio;
//Un Constructor que inicialice los atributos

public Celular(int numero, int segundos, String usuario, double precio) {
//creando constructor
//constructor es igual q la clase, tiene parametros
//es un metodo pero no es un metodo con retorno no es vacio, es un
mentodo
//que sirve para construir y para inicializar las clases
//get es para q la clase me devuelva la clase d ese atributo
//set es para modificar datos a la clase
this.numero = numero;
this.segundos = segundos;
this.usuario = usuario;
this.precio = precio;
}
//Metodos de acceso publico set/get para todos los atributos privados.
public int getNumero() {
return numero;
}
public void setNumero(int numero) {
}
public int getSegundos() {
return segundos;
}
public void setSegundos(int segundos) {
}
public String getUsuario() {
return usuario;
}
public void setUsuario(String usuario) {
}
public double getPrecio() {
return precio;
}
public void setPrecio(double precio) {
}
//Un metodo que retorne el costo por consumo (segundos*precio).
public double costoporconsumo(){
return precio * segundos;
}
//Un metodo que retorne el impuesto por IGV (18% del costo por consumo).
public double impuesto(){
return costoporconsumo()*18/100;
}
//Un metodo que retorne el total a pagar (costo por consumo + impuesto
por IGV).
public double totalapagar(){
return costoporconsumo()+impuesto();
}
}
GUI

//Declare, cree e inicialice un objeto de tipo Celular (con datos
fijos).
Celular c = new Celular(999888777, 250, "Maria", 0.25);
listar(c);
//Aumente en 20 el número de segundos consumidos, disminuya en 5%
el precio por segundo
//y visualice nuevamente la información completa.
c.setSegundos(c.getSegundos()+20);
c.setPrecio(c.getPrecio()*0.95);
c.setUsuario("CL -"+c.getUsuario());
imprimir("Nuevos segundos: "+c.getSegundos());
imprimir("-----------------");
//listar(c);
}
//Implemente un método listado que reciba la referencia a un objeto de

tipo Celular y visualice
//sus datos completos
void listar(Celular x){//puede ponerse cualquier letra

imprimir("Numero de celular :"+x.getNumero());
imprimir("Numero de segundos consumido :"+x.getSegundos());
imprimir("Nombre de usuario :"+x.getUsuario());
imprimir("Precio por segundo :"+x.getPrecio());
imprimir("costo por consumo :"+x.costoporconsumo());
imprimir("Impuesto IGV :"+x.impuesto());
imprimir("Total a pagar :"+x.totalapagar());
imprimir("---------------");
}
package semana_02;
//Diseñe la clase Computadora en el paquete semana_02 con los atributos
privados: codigo (int),
//marca (String), color (String) y precio en dólares (double).
public class Computadora {
private int codigo;

private String marca, color;
private double dolares;
//Un Constructor que inicialice los atributos.

public Computadora(int codigo, String marca, String color, double
dolares) {
this.codigo = codigo;
this.marca = marca;
this.color = color;
this.dolares = dolares;
}
//Métodos de acceso público set/get para todos los atributos privados.

public int getCodigo() {
return codigo;
}
public void setCodigo(int codigo) {
}
public String getMarca() {
return marca;
}
public void setMarca(String marca) {
this.marca = marca;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getDolares() {
return dolares;
}
public void setDolares(double dolares) {
this.dolares = dolares;
}
//Un método que retorne el precio de la computadora en soles (1 dólar =
3.28 soles).
public double precioasoles(){
return dolares*3.28;
}
//Un método que retorne el precio de la computadora en euros (1 euro =
1.11 dólares).
public double precioaeuros(){
return dolares/1.11;
}
GUI

//Declare, cree e inicialice un objeto de tipo Computadora (con
datos fijos).
Computadora c = new Computadora(25,"toshiba", "verde", 95);
listar (c);
c.setDolares(c.getDolares()*0.90);
// Disminuya en 10% el precio en dÃ³lares de la computadora y
visualice nuevamente la
//informaciÃ³n completa.
imprimir("Nuevo precio en dolares: "+c.getDolares());
imprimir("-----------------");
}
//Implemente un mï¿½todo listado que reciba la referencia a un objeto de
tipo Computadora y
//visualice sus datos completos.
void listar(Computadora x){
imprimir("codigo :"+x.getCodigo());
imprimir("marca :"+x.getMarca());
imprimir("color :"+x.getColor());
imprimir("precio en dolares :"+x.getDolares());
imprimir("precio en soles :"+x.precioasoles());
imprimir("precio en euros :"+x.precioaeuros());
package semana_02;
/*Diseñe la clase Edificio en el paquete semana_02 con los atributos privados:
código (int), número de
departamentos (int), número de contrato (int) y costo en dólares de un
departamento (double)
*/
public class Edificio {
private int codigo,numDepa,numContra;
private double costoDolares;

public Edificio(int codigo, int numDepa, int numContra, double
costoDolares) {
this.numDepa = numDepa;
this.numContra = numContra;
this.costoDolares = costoDolares;
}

return codigo;
}
}
public int getNumDepa() {
return numDepa;
}
public void setNumDepa(int numDepa) {
this.numDepa = numDepa;
}
public int getNumContra() {
return numContra;
}
public void setNumContra(int numContra) {
this.numContra = numContra;
}
public double getCostoDolares() {
return costoDolares;
}
public void setCostoDolares(double costoDolares) {
}
//Un método que retorne el precio en dólares del edificio (#dptos. *

costo unitario)
public double precioEdificioDolares(){
return numDepa*costoDolares;
}
GUI
protected void actionPerformedBtnProcesar(ActionEvent arg0)

//Declare, cree e inicialice un objeto de tipo Edificio (con datos
leídos por GUI).
Edificio e=new Edificio(leerCodigo(), leerNumDptos(),
leerNumContrato(), leerCostoDpto());
listar(e);
//Incremente en 20% el costo de un departamento y visualice
nuevamente la información
//completa.
e.setCostoDolares(e.getCostoDolares()*1.2);
listar(e);
limpieza();
}
tipo Edificio y visualice
void listar(Edificio x){
imprimir("Codigo :"+x.getCodigo());
imprimir("Num. de Dptos :"+x.getNumDepa());
imprimir("Num. de Contratos :"+x.getNumContra());
imprimir("Costo de Departamento :"+x.getCostoDolares());
imprimir("Precio de Edificio :"+x.precioEdificioDolares());
/*Diseñe la Clase Video en el paquete semana_02 con los atributos privados:
codigo (int), nombre del video (String), duración (double), precio en soles
(double) y tipo de cambio (double).
package semana_02;
public class Video {

private int codigo;
private String nombre;
private double duracion ,precio, tipodecambio;

public Video(int codigo, String nombre, double duracion, double precio, double
tipodecambio) {
this.nombre = nombre;
this.duracion = duracion;
this.tipodecambio = tipodecambio;
}

return codigo;
}
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
}
public double getDuracion() {
return duracion;
}
public void setDuracion(double duracion) {
this.duracion = duracion;
}
return precio;
}
}
public double getTipodecambio() {
return tipodecambio;
}
public void setTipodecambio(double tipodecambio) {
this.tipodecambio = tipodecambio;
}
//Un método que retorne el precio del video en dólares.
public double precioendolares(){
return precio * tipodecambio;
gui
//Declare, cree e inicialice un objeto de tipo Video (con datos fijos).
Video v = new Video(1, "MATADOR", 120,3.50,3.28);
listar(v);
//Aumente en 5.50 el precio del video y visualice nuevamente la
información completa.
v.setPrecio(v.getPrecio()+5.50);
imprimir("Nuevo precio :"+v.getPrecio());
imprimir("*********************");
}
tipo Video y visualice
void listar(Video x){
imprimir("codigo de pelicula :"+x.getCodigo());
imprimir("Nombre de pelicula :"+x.getNombre());
imprimir("duracion de pelicula :"+x.getDuracion());
imprimir("precio de pelicula :"+x.getPrecio());
imprimir("tipo de cambio del dolar :"+x.getTipodecambio());
imprimir("precio en dolares :"+x.precioendolares());
imprimir("*********************");
//Diseñe la clase Persona en el paquete semana_02 con los atributos privados:
nombre (String),
//apellido (String), edad (int), talla (double) y peso (double).Implemente
además:
package semana_02;
public class Persona {
public int edad;
public String nombre,apellido;
public double talla, peso;

public Persona(int edad, String nombre, String apellido, double talla, double
peso) {
this.edad = edad;
this.apellido = apellido;
this.talla = talla;
this.peso = peso;
}
public int getEdad() {
return edad;
}
public void setEdad(int edad) {
this.edad = edad;
}
return nombre;
}
}
public String getApellido() {
return apellido;
}
public void setApellido(String apellido) {
this.apellido = apellido;
}
public double getTalla() {
return talla;
}
public void setTalla(double talla) {
this.talla = talla;
}
public double getPeso() {
return peso;
}
public void setPeso(double peso) {
this.peso = peso;
}
//Un método que retorne el texto: “menor de edad” o “mayor de edad”.
public String detalle_edad(){
if (edad<18) return "MENOR DE EDAD";
else return "MAYOR DE EDAD";
}
}
Gui

//Declare, cree e inicialice un objeto de tipo Persona (con datos
fijos).
Persona p=new Persona(18,"Alfredo","Mendiola",183,70) ;
listar (p);
//Modifique la edad de la persona y visualice nuevamente la
información completa.
p.setEdad(p.getEdad()+4);
imprimir("nueva edad: "+p.getEdad());
imprimir("-----------------");
}
tipo Persona y visualice
//sus datos completos.
void listar(Persona x){
imprimir("Edad :"+x.getEdad());
imprimir("Nombre :"+x.getNombre());
imprimir("Apellido :"+x.getApellido());
imprimir("Talla :"+x.getTalla());
imprimir("Peso :"+x.getPeso());
}
package semana_02;
//Diseñe la Clase Empleado en el paquete semana_02 con los atributos privados:
//(String), número de celular (int) y sueldo en soles (double)
public class Empleado {
private int codigo;
private double sueldo,celular;

public Empleado(int codigo, String nombre, double celular, double sueldo)
{
this.celular = celular;
this.sueldo = sueldo;
}
return codigo;
}
}
public double getCelular() {
return celular;
}
public void setCelular(double celular) {
this.celular = celular;
}
return nombre;
}
}
public double getSueldo() {
return sueldo;
}
public void setSueldo(double sueldo) {
this.sueldo = sueldo;
}
/* Un método que retorne un texto indicando

si el sueldo es “mayor a 3500”, “menor a 3500”
o “igual a 3500”.*/
public String calculandosueldo(){
if (sueldo>3500) return "MAYOR A 3500";
if (sueldo<3500) return "MENOR A 3500";
else return "IGUAL a 3500";
}
Gui
//Declare, cree e inicialice un objeto de tipo Empleado (con datos leídos por
GUI).
Empleado e = new Empleado
(leerCodigo(),leerNombre(),leerCelular(),leerSueldo());
listar (e);
//Cambie el número de celular por otro aleatorio, aumente el sueldo en
200 soles y visualice
//nuevamente la información completa.
e.setSueldo(e.getSueldo()+200);
e.setCelular( (Math.random()*(900000000-(999999999+1))+999999999));
listar(e);
limpieza();
}
tipo Empleado y
void listar(Empleado x){
imprimir("Nombre del empleado :"+x.getNombre());
imprimir("Num. de celular :"+x.getCelular());
imprimir("sueldo :"+x.getSueldo());
imprimir ("el sueldo es :"+x.calculandosueldo());
imprimir ("////////////////////////");
}
//Diseñe la Clase Trabajador en el paquete semana_02 con los atributos privados:
codigo (int),
//nombre (String), horas trabajadas (int) y tarifa por hora (double)
package semana_02;
public class Trabajador {
public double txh;

public Trabajador(int codigo, int horas, String nombre, double txh) {
this.horas = horas;
this.txh = txh;
}
return codigo;
}
}
public int getHoras() {
return horas;
}
public void setHoras(int horas) {
this.horas = horas;
}
return nombre;
}
}
public double getTxh() {
return txh;
}
public void setTxh(double txh) {
this.txh = txh;
}
//Un método que retorne el sueldo bruto (horas*tarifa).
public double sueldobruto(){
return horas*txh;
}
//Un método que retorne el descuento (15% del sueldo bruto).
return sueldobruto() * 0.15;
}
//Un método que retorne el sueldo neto (sueldo bruto - descuento)
public double sueldoneto(){
return sueldobruto() - descuento();
}
}
Gui
//Declare, cree e inicialice un objeto de tipo Trabajador (con
datos fijos)
Trabajador t=new Trabajador(1,8,"Manuel Ortega",58);
listar (t);
//Aumente en 10 el nï¿½mero de horas, disminuya en 15% la tarifa y
visualice nuevamente la
//informaciï¿½n completa.
t.setHoras(t.getHoras()+10);
t.setTxh(t.getTxh()*0.85);
imprimir("Nuevas horas trabajadas : "+t.getHoras());
imprimir("Nueva tarifa por Horas : "+t.getTxh());
}
//Implemente un mï¿½todo listado que reciba la referencia a un
objeto de tipo Trabajador y
void listar(Trabajador x){
imprimir("horas trabajadas :"+x.getHoras());
imprimir("Nombre :"+x.getNombre());
imprimir("tarifa por hora :"+x.getTxh());
imprimir(" sueldo bruto :"+x.sueldobruto());
imprimir("el descuento es de :"+x.descuento()+" soles.");
imprimir("sueldo neto :"+x.sueldoneto());
imprimir("****************");
}
package semana_03;
//Diseñe la clase Profesor en el paquete semana_03 con los atributos privados:
código (int), nombre
//(String), horas trabajadas (int) y tarifa por hora (double
public class Profesor {
private int codigo,horas;
private double tarifa;
//Metodo estatico ,variable privada de clase -- es con la palabra static
//Una variable privada de clase que cuente la cantidad de objetos tipo Profesor
creados.
private static int cantidad;
//Una variable privada de clase que acumule la suma de los sueldos.
private static double sumaSueldos;
//Un Constructor que inicialice los atributos, cuente la cantidad de

objetos creados y sume los sueldos.
//Haga uso de la referencia this.
public Profesor(int codigo, int horas, String nombre, double tarifa) {
this.horas = horas;
this.tarifa = tarifa;
//poniendo contador y acumulador

//cuenta y acumula el sueldo
cantidad ++;
sumaSueldos+=sueldo();
}
//Métodos de acceso set para todos los atributos privados. Haga uso de la
referencia this.
//Métodos de acceso get para todos los atributos privados.
return codigo;
}
}
return horas;
}
this.horas = horas;
}
return nombre;
}
}
public double getTarifa() {
return tarifa;
}
public void setTarifa(double tarifa) {
}
//obejtos staticos
//Métodos de clase set/get para las variables privadas de clase.

public static int getCantidad() {
return cantidad;
}
public static void setCantidad(int cantidad) {
Profesor.cantidad = cantidad;
}
public static void setSumaSueldos(double sumaSueldos) {
Profesor.sumaSueldos = sumaSueldos;
}
public static double getSumaSueldos() {
return sumaSueldos;
}
//Un método que retorne el sueldo del docente (horas * tarifa).

public double sueldo(){
}
Gui

//impedir q siga imprimiendo
txtS.setText("");
//Declare, cree e inicialice tres objetos de tipo Profesor (con datos fijos).
Profesor p=new Profesor(1, 20, "Manuel Rodriguez", 80);
listar (p);
Profesor q=new Profesor(2, 30, "Rosa Alvarez", 25);
listar (q);
Profesor r=new Profesor(3, 40, "Alfredo Benitez", 55);
listar (r);
// Muestre la cantidad de objetos creados y la suma de los sueldos.

imprimir("///////////////////////");
imprimir("reporte :");
imprimir("cantidad de profesores :"+Profesor.getCantidad());
imprimir("Suma total de sueldos :"+Profesor.getSumaSueldos());
//para q no siga contando cantidad d profesores ni cantidad d la suma de los
sueldos
Profesor.setCantidad(0);
Profesor.setSumaSueldos(0);
}
//x es el objeto para lllamar
//Implemente un método listado que reciba la referencia a un objeto de tipo

Profesor y visualice
void listar(Profesor x){
imprimir ("codigo : " +x.getCodigo());
imprimir ("Nombre : " +x.getNombre());
imprimir ("Horas Laboradas : " +x.getHoras());
imprimir ("Tarifa por horas : " +x.getTarifa());
imprimir ("Sueldo : " +x.sueldo());
imprimir("///////////////////////");
package semana_03;
//Diseñe la Clase Asistente en el paquete semana_03 con los atributos privados:
//(String), dni (int) y sueldo en soles (double).
public class Asistente {
private int codigo,dni;
private double sueldosoles;
//Una variable privada de clase que cuente la cantidad de objetos tipo Asistente
creados.
private static int asistentes;
//Una variable privada de clase que acumule los sueldos.
private static double sumaSueldos;
//Un Constructor que inicialice los atributos. Haga uso de la referencia this.
public Asistente(int codigo, int dni, String nombre, double sueldosoles) {
this.dni = dni;
this.sueldosoles = sueldosoles;
asistentes ++;
//acumulando sueldo q se va a ingresar
sumaSueldos+=sueldosoles;
}
referencia this.
// Métodos de acceso get para todos los atributos privados.
return codigo;
}
}
public int getDni() {
return dni;
}
public void setDni(int dni) {
this.dni = dni;
}
return nombre;
}
}
public double getSueldosoles() {
return sueldosoles;
}
public void setSueldosoles(double sueldosoles) {
this.sueldosoles = sueldosoles;
}

public static int getAsistentes() {
return asistentes;
}
public static void setAsistentes(int asistentes) {
Asistente.asistentes = asistentes;
}
public static double getSumaSueldos() {
return sumaSueldos;
}
public static void setSumaSueldos(double sumaSueldos) {
Asistente.sumaSueldos = sumaSueldos;
}
//Un método que retorne un texto indicando si el sueldo es “mayor a 1 500”,
“menor a 1500” o
//“igual a 1 500”.
public String mensaje(){
if(sueldosoles>1500)return "sueldo Mayor a 1500";
else if (sueldosoles==1500)return "Sueldo Igual a 1500";
else return "Sueldo menor a 1500";
}
Gui
//Declare, cree e inicialice un objeto de tipo Asistente (con datos
leídos por GUI).
Asistente a=new Asistente(leerCodigo(), leerDNI(), leerNombre(), leerSueldo()) ;
listar(a);
//Muestre la cantidad de objetos creados y la suma de los sueldos.

imprimir("REPORTE :");
imprimir("CANTIDAD DE ASISTENTES CREADOS :"+Asistente.getAsistentes());
imprimir("TOTAL DE SUELDOS :"+Asistente.getSumaSueldos());
imprimir("================");
limpieza();
}
tipo Asistente y
void listar (Asistente x){
imprimir("Codigo : "+x.getCodigo());
imprimir("DNI :"+x.getDni());
imprimir("Nombre : "+x.getNombre());
imprimir("Sueldo :"+x.getSueldosoles());
imprimir ("Mensaje :"+x.mensaje());
package semana_03;
//Diseñe la Clase Pelota en el paquete semana_03 con los atributos privados:
marca (String), peso en
//gramos (double), presión en libras (double), diámetro en centímetros (double)
y precio (double)
public class Pelota {
public String marca;
public double pesogramos,pesolibras,diametro,precio;
//Una variable privada de clase que cuente la cantidad de objetos tipo

Pelota creados.
private static int cantpelota;
//Una variable privada de clase que acumule el importe a pagar.
private static double importe;
//Un Constructor que inicialice los atributos. Haga uso de la referencia

this.
public Pelota(String marca, double pesogramos, double pesolibras,
double diametro, double precio) {
this.marca = marca;
this.pesogramos = pesogramos;
this.pesolibras = pesolibras;
this.diametro = diametro;
cantpelota ++;
importe+=importepagar();
referencia this.
return marca;
}
this.marca = marca;
}
public double getPesogramos() {
return pesogramos;
}
public void setPesogramos(double pesogramos) {
}
public double getPesolibras() {
return pesolibras;
}
public void setPesolibras(double pesolibras) {
this.pesolibras = pesolibras;
}
public double getDiametro() {
return diametro;
}
public void setDiametro(double diametro) {
this.diametro = diametro;
}
return precio;
}
}

public static int getCantpelota() {
return cantpelota;
}
public static void setCantpelota(int cantpelota) {
Pelota.cantpelota = cantpelota;
}
public static double getImporte() {
return importe;
}
public static void setImporte(double importe) {
Pelota.importe = importe;
}
//Un método que retorne el radio (diámetro / 2).
public double radio(){
return diametro/2;
}
//Un método que retorne el volumen del balón (4 * 3.1416 * radio*

radio * radio / 3).
public double volumenbalon(){
return (4*3.1516*radio()*radio()*radio()/3);
}
//Un método que retorne el descuento (10% del precio).

return precio*0.10;
}
//Un método que retorne el importe a pagar (precio - descuento)

public double importepagar(){
return (precio-descuento());
GUI

//Declare, cree e inicialice tres objetos de tipo Pelota (con datos
fijos).
Pelota p =new Pelota("Viniball",500,600,80,30);
listar(p);
//Declare, cree e inicialice tres objetos de tipo Pelota (con datos fijos).
Pelota q=new Pelota("MIBALON",700,450,30,80);
listar(q);
//Declare, cree e inicialice tres objetos de tipo Pelota (con datos fijos).
Pelota r=new Pelota("UMBRO",1000,690,25,90);
listar(r);
//Muestre la cantidad de objetos creados y el importe a pagar acumulado.

imprimir("Cantidad de objetos creados : "+Pelota.getCantpelota());
imprimir("Importe a pagar acumulado : "+Pelota.getImporte());
imprimir("///////////////////////");
//dejar q cuente
Pelota.setCantpelota(0);
Pelota.setImporte(0);
}
Pelota y visualice
void listar (Pelota x){
imprimir("Marca : "+x.getMarca());
imprimir("Peso en gramos : "+x.getPesogramos());
imprimir("Presion en libras : "+x.getPesolibras());
imprimir("Diametro : "+x.getDiametro());
imprimir("Precio : "+x.getPrecio());
imprimir("Radio : "+x.radio());
imprimir("Volumen del balon : "+x.volumenbalon());
imprimir("Descuento : "+x.descuento());
imprimir("Importe a pagar : "+x.importepagar());
imprimir("///////////////////////");
}
package semana_03;
//Diseñe la Clase Ejecutivo en el paquete semana_03 con los atributos privados:
//(String), horas trabajadas (int) y tarifa por hora (double).
public class Ejecutivo {
private int codigo,horas;
private double tarifa;
//Una variable privada de clase que cuente la cantidad de objetos tipo Ejecutivo
creados.
//Una variable privada de clase que acumule los sueldos netos.
private static double sumasueldo;
//Un Constructor que inicialice los atributos. Haga uso de la referencia

this.
public Ejecutivo(int codigo, int horas, double tarifa, String nombre) {
this.horas = horas;
cantidad ++;
sumasueldo+=sueldoneto();
}
referencia this.
// Métodos de acceso get para todos los atributos privados.
return codigo;
}
}
return horas;
}
this.horas = horas;
}
public double getTarifa() {
return tarifa;
}
public void setTarifa(double tarifa) {
}
return nombre;
}
}
return cantidad;
}
public static void setCantidad(int cantidad) {
Ejecutivo.cantidad = cantidad;
}
//Métodos de clase get para las variables de clase privadas.

public static double getSumasueldo() {
return sumasueldo;
}
public static void setSumasueldo(double sumasueldo) {
Ejecutivo.sumasueldo = sumasueldo;
}
//Un método que retorne el sueldo bruto (horas*tarifa).

public double sueldobruto(){
}
//Un método que retorne el descuento (15% del sueldo bruto).

return sueldobruto()*0.15;
}
//Un método que retorne el sueldo neto (sueldo bruto - descuento)

public double sueldoneto(){
return sueldobruto() - descuento();
}
GUI

//Declare, cree e inicialice tres objetos de tipo Asistente (con
datos fijos).
Ejecutivo p=new Ejecutivo(3,25,8,"MARCO GALLARDO");
listar (p);
//Declare, cree e inicialice tres objetos de tipo Asistente (con datos fijos).
Ejecutivo q=new Ejecutivo(4,180,7,"FELIPE NEGREDO");
listar (q);
//Declare, cree e inicialice tres objetos de tipo Asistente (con datos fijos).
Ejecutivo r=new Ejecutivo(5,70,15,"CARLOS MINA");
listar (r);
//Muestre la cantidad de objetos creados y la suma de los sueldos netos.

imprimir("NUMERO DE EJECUTIVOS : "+Ejecutivo.getCantidad());
imprimir("Suma de sueldos netos : "+Ejecutivo.getSumasueldo());
imprimir("///////////////////////");
//para q no siga contando cantidad d profesores ni cantidad d la suma de los
sueldos
Ejecutivo.setCantidad(0);
Ejecutivo.setSumasueldo(0);
}

tipo Aistente y visualice
void listar(Ejecutivo x){
imprimir("Codigo : "+x.getCodigo());
imprimir("nombre : "+x.getNombre());
imprimir("Horas trabajadas : "+x.getHoras());
imprimir("tarifa por hora : "+x.getTarifa());
imprimir("sueldo bruto : "+x.sueldobruto());
imprimir("descuento : "+ x.descuento());
imprimir("sueldo neto: "+x.sueldoneto());
imprimir("///////////////////////");
package semana_03;
//Diseñe la clase Edificio en el paquete semana_03 con los atributos privados:
//departamentos (int), número de contrato (int) y costo en dólares de un
public int numero,segundos;
public String usuario;
public double precio;
//Una variable privada de clase que cuente la cantidad de objetos tipo Celular
creados.
//Una variable privada de clase que acumule el total a pagar.
private static double totalPagar;
//Un Constructor que inicialice los atributos, cuente la cantidad de objetos
creados y acumule el
//total a pagar.
public Celular(int numero, int segundos, String usuario, double precio) {
cantidad++;
totalPagar+=sumTotalPagar();
}
referencia this.

return numero;
}
}
return segundos;
}
}
return usuario;
}
}
return precio;
}
}
return cantidad;
}
public static double getTotalPagar() {
return totalPagar;
}
//Un método que retorne el costo de consumo (segundos*precio).

public double costoConsumo(){
return segundos*precio;
}
//Un método que retorne el impuesto por IGV (18% del costo de consumo).
public double IGV(){
return costoConsumo()*0.18;
}
//Un método que retorne el total a pagar (costo de consumo + impuesto por IGV).
public double sumTotalPagar(){
return costoConsumo()+IGV();}
}
GUI

//Declare, cree e inicialice tres objetos de tipo Celular (con datos
fijos)
Celular c=new Celular(985788125, 1500, "Roberto Benitez", 0.020);
listar (c);
//Declare, cree e inicialice tres objetos de tipo Celular (con datos fijos)
Celular d=new Celular(999888777, 1400, "Alfreda Guitierrez", 0.025);
listar(d);
//Declare, cree e inicialice tres objetos de tipo Celular (con datos fijos)
Celular e=new Celular(988555222, 120, "Martin Ramirez", 0.168);
listar (e);
//Muestre la cantidad de objetos creados y el total a pagar acumulado.

imprimir("Cantidad de Usuarios creados : "+Celular.getCantidad());
imprimir("Total a Pagar Acumulado : "+Celular.getTotalPagar());
imprimir("========================");

Celular y visualice
void listar (Celular x){
imprimir("Nombre de usuario : "+x.getUsuario());
imprimir("Numero de usuario : "+x.getNumero());
imprimir("Segundos consumidos : "+x.getSegundos());
imprimir("Precio por segundo : "+x.getPrecio());
imprimir("Costo por consumo : "+x.costoConsumo());
imprimir("IGV: "+x.IGV());
imprimir("Total a pagar : "+x.sumTotalPagar());
imprimir("=================");
}
package semana_03;
//Diseñe la clase Edificio en el paquete semana_03 con los atributos privados:
//departamentos (int), número de contrato (int) y costo en dólares de un
public class Edificio {
private int codigo,numDep,numCont;
private double costoDolares;
private static int contador;

private static double acumulado;

public Edificio(int codigo, int numDep, int numCont, double costoDolares) {
super();
this.numDep = numDep;
this.numCont = numCont;
contador++;
acumulado+=costoDepartamento();
}

return codigo;
}
}
public int getNumDep() {
return numDep;
}
public void setNumDep(int numDep) {
this.numDep = numDep;
}
public int getNumCont() {
return numCont;
}
public void setNumCont(int numCont) {
this.numCont = numCont;
}
public double getCostoDolares() {
return costoDolares;
}
public void setCostoDolares(double costoDolares) {
}
public static int getContador() {

return contador;
}
public static double getAcumulado() {
return acumulado;
}
//Un método que retorne el precio en dólares del edificio (#dptos. * costo
unitario)
public double costoDepartamento(){
return costoDolares * numDep;
}
GUI
//Declare, cree e inicialice un objeto de tipo Edificio (con datos
leídos por GUI)
Edificio e=new Edificio(leerCodigo(),leerNumDptos(), leerNumContrato(),
leerCostoDpto());
listar (e);
//Incremente en 20% el costo de un departamento y visualice nuevamente la

información
//completa
e.setCostoDolares(e.getCostoDolares()*1.20);
//Muestre la cantidad de objetos creados y el acumulado en dólares de los
edificios.
imprimir("-===REPORTE===-");
imprimir("Numero de Datos Ingresados : "+Edificio.getContador());
imprimir("Total de dolares del edificio : "+Edificio.getAcumulado());
imprimir("Nuevos precio de departamento: "+e.getCostoDolares());
limpieza();
}
tipo Edificio y visualice
void listar(Edificio x){
imprimir("Numero de Codigo : "+ x.getCodigo());
imprimir("Numero de Departamentos : "+ x.getNumDep());
imprimir("Numero de Contrato : "+ x.getNumCont());
imprimir("Costo de departamentos en Dolares : "+ x.getCostoDolares());
package semana_04;
//Diseñe la Clase Celular en el paquete semana_05 con los atributos privados:
//número (int), usuario (String), segundos consumidos (int) y precio por segundo
(double),
//si la inicializacion de la variables es 0 no es necesario ponerle; por
defecto es 0
//asumiendo
//por defecto los valores de inicialización:
// numero
//
private int numero=88888888,segundos;
private double precio;
private String usuario="NINGUNO";
//variables d clase ... solo se quedan ahi
//Una variable privada de Clase que cuente la cantidad de objetos tipo Celular
creados.
//Una variable privada de Clase que acumule el total a pagar.

private static double sumaTotalPagar;
//Un Constructor que inicialice todos los atributos, cuente la cantidad de

objetos creados y
//acumule el total a pagar. Haga uso de la referencia this.
public Celular(int numero, int segundos, double precio, String usuario) {
//Un Constructor que inicialice todos los atributos,
//cuente la cantidad de objetos creados y
//acumule el total a pagar. Haga uso de la referencia this.
cantidad++;
sumaTotalPagar+=totalPagar();
}
/*Un Constructor con dos parámetros que inicialice sólo los
* atributos número y usuario, cuente la cantidad de objetos
* creados y acumule el total
* a pagar. Haga uso de la referencia this.
*/
public Celular(int numero, String usuario) {
cantidad++;
}
/*Un Constructor sin parámetros que cuente la cantidad de objetos

creados y acumule el total a pagar.
*/
public Celular(){
cantidad++;
}
/*Métodos de acceso set para todos los atributos privados. Haga uso de la
referencia this.
- Métodos de acceso get para todos los atributos privados.
- Métodos de Clase get para todas las variables de Clase privadas.
*/
return numero;
}
}
return segundos;
}
}
return precio;
}
}
return usuario;
}
}
return cantidad;
}
public static double getSumaTotalPagar() {
return sumaTotalPagar;
}
//Un método que retorne el costo de consumo (segundos*precio).
public double costoConsumo(){
return segundos*precio;
}
//Un método que retorne el impuesto por IGV (18% del costo de consumo).
public double impuesto(){
return costoConsumo()*18/100;
}
//Un método que retorne el total a pagar (costo de consumo + impuesto por IGV).
public double totalPagar(){
return costoConsumo()+impuesto();
}
GUI
/*Declare, cree e inicialice tres objetos de tipo Celular, haciendo

uso de los tres
* constructores (con datos fijos, según sea el caso) a la
* pulsación del botón Procesar.
*/
Celular c=new Celular(999888777, 250, 0.25, "MANUEL PERALEZ");
listar (c);
Celular d=new Celular(999777333, "ROSA FLOREZ");

listar(d);
Celular e=new Celular();
listar (e);
imprimir();
//Muestre la cantidad de objetos creados y el total a pagar
acumulado.
imprimir("Canitdad de celulares : "+Celular.getCantidad());
imprimir("Suma de Importes Pagados :
"+Celular.getSumaTotalPagar());
}
//Implemente un método listado que reciba la referencia de cada objeto
tipo Celular y visualice
void listar(Celular x){
imprimir("Numero Celular : "+x.getNumero());
imprimir("Numero de Segundos : "+x.getSegundos());
imprimir("Precio por Segundo : "+x.getPrecio());
imprimir("Nombre de usuario : "+x.getUsuario());
imprimir("COSTO DE CONSUMO : "+x.costoConsumo());
imprimir("IGV : "+x.impuesto());
imprimir("TOTAL A PAGAR : "+x.totalPagar());
imprimir("_________________________________ ");
//imprimiendo cantidad de letras del usuario
imprimir("NUMERO DE LETRAS DEL USUARIO : "+x.getUsuario().length());
//impirmiendo el primer caracter
imprimir("primer Caracter : "+x.getUsuario().charAt(0));
//imprimiendo ultimo caracter
imprimir("Ultimo caracter : "+x.getUsuario().charAt(x.getUsuario().length()-1));
}
package semana_04;
/*Diseñe la Clase Pelota en el paquete semana_05 con los atributos
* privados: marca
(String), peso en gramos (double), presión en libras (double),
diámetro en centímetros (double) y precio (double)
marca =”ninguno”
peso en gramos = 0.0
presión en libras = 0.0
diámetro en cms. =0.0
precio = 0.0
*/
public class Pelota {
private String marca="ninguno";
private double pesogramos=0.0,presionlibras=0.0,diamecent=0.0,precio=0.0;
//Una variable privada de Clase que cuente la cantidad de objetos tipo Pelota
creados
//Una variable privada de Clase que acumule el importe a pagar

private static double sumaImporte;
//Un Constructor que inicialice todos los atributos, cuente la cantidad de

objetos creados y
//acumule el importe a pagar. Haga uso de la referencia this.
public Pelota(String marca, double pesogramos, double presionlibras,
double diamecent, double precio) {
this.marca = marca;
this.presionlibras = presionlibras;
this.diamecent = diamecent;
cantidad++;
sumaImporte+=totalPagar();
}
//Un Constructor con tres parámetros que inicialice sólo los atributos marca,
peso en gramos y
//presión en libras, cuente la cantidad de objetos creados y acumule el importe
a pagar. Haga
//uso de la referencia this.
public Pelota(String marca, double pesogramos, double presionlibras) {
this.marca = marca;
cantidad++;
}
//Un Constructor sin parámetros que cuente la cantidad de objetos creados y

acumule el
//importe a pagar
public Pelota() {
cantidad++;
}
//Métodos de acceso set para todos los atributos privados. HHaga uso de la
referencia this.

return marca;
}

return cantidad;
}
public static double getSumaImporte() {

return sumaImporte;
}

this.marca = marca;
}
public double getPesogramos() {

return pesogramos;
}
public void setPesogramos(double pesogramos) {
}
public double getPresionlibras() {

return presionlibras;
}
public void setPresionlibras(double presionlibras) {

}
public double getDiamecent() {

return diamecent;
}
public void setDiamecent(double diamecent) {

this.diamecent = diamecent;
}

return precio;
}

}
//Un método que retorne el radio (diámetro / 2).

public double radio(){
return diamecent/2;
}
//Un método que retorne el volumen del balón (3.1416 * radio* radio).
public double volumenBalon(){
return 3.1416*radio()*radio();
}
//Un método que retorne el descuento (10% del precio).

return precio*0.10;
}
//Un método que retorne el importe a pagar (precio - descuento).

public double totalPagar(){
return precio-descuento();
}
Gui
//Declare, cree e inicialice tres objetos de tipo Pelota, haciendo
uso de los
//tres constructores (con datos fijos, según sea el caso) a la
pulsación del botón Procesar.
Pelota p=new Pelota("VINIBALL", 400, 1500, 40, 90);
listar(p);
Pelota q =new Pelota("MIBALON", 550, 1200);

listar(q);
Pelota r=new Pelota();

listar(r);
imprimir();
//Muestre la cantidad de objetos creados y el importe a pagar
acumulado.
imprimir("CANTIDAD DE OBJETOS CREADOS : "+Pelota.getCantidad());
imprimir("IMPORTE A PAGAR ACUMULADO : "+Pelota.getSumaImporte());
}
//Implemente un método listado que reciba la referencia de cada

//objeto tipo Pelota y visualice
void listar(Pelota x){

imprimir("Marca de pelota : "+x.getMarca());
imprimir("Peso en gramos : "+x.getPesogramos());
imprimir("Presion en libras : "+x.getPresionlibras());
imprimir("Diametros en CM : "+x.getDiamecent());
imprimir("Precio: "+x.getPrecio());
imprimir("Radio del balon : "+x.radio());
imprimir("Volumen del balon : "+x.volumenBalon());
imprimir("Descuento : "+x.descuento());
imprimir("Importe a pagar : "+x.totalPagar());
imprimir();
}

Algoritmos JAVa

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Algoritmos JAVa

Caricato da

Copyright:

Formati disponibili

package semana_01;

//atributos públicos: codigo (int), nombre

//Un método que retorne el sueldo bruto (horas*tarifa)

//Ingrese datos fijos

//Visualice todos sus datos

public class Docente {

//Un método público que retorne el sueldo (horas*tarifa)

//Ingrese datos fijos.

//Visualice todos sus datos.

//Un método que retorne el índice de masa corporal de la persona

//Ingrese datos fijos.

//Visualice todos sus datos.

//Un Constructor que inicialice los atributos

protected void actionPerformedBtnProcesar(ActionEvent arg0) {

//Implemente un método listado que reciba la referencia a un objeto de

void listar(Celular x){//puede ponerse cualquier letra

private int codigo;

//Un Constructor que inicialice los atributos.

//Métodos de acceso público set/get para todos los atributos privados.

protected void actionPerformedBtnProcesar(ActionEvent arg0) {

//Un Constructor que inicialice los atributos

//Métodos de acceso público set/get para todos los atributos privados.

//Un método que retorne el precio en dólares del edificio (#dptos. *

protected void actionPerformedBtnProcesar(ActionEvent arg0)

public class Video {

//Un Constructor que inicialice los atributos.

//Métodos de acceso público set/get para todos los atributos privados.

//Un Constructor que inicialice los atributos.

protected void actionPerformedBtnProcesar(ActionEvent arg0) {

//Un Constructor que inicialice los atributos

/* Un método que retorne un texto indicando

//Un Constructor que inicialice los atributos.

//Metodo estatico ,variable privada de clase -- es con la palabra static

//Un Constructor que inicialice los atributos, cuente la cantidad de

//poniendo contador y acumulador

//Métodos de clase set/get para las variables privadas de clase.

//Un método que retorne el sueldo del docente (horas * tarifa).

protected void actionPerformedBtnProcesar(ActionEvent arg0) {

// Muestre la cantidad de objetos creados y la suma de los sueldos.

//Implemente un método listado que reciba la referencia a un objeto de tipo

//Métodos de clase set/get para las variables privadas de clase.

//Muestre la cantidad de objetos creados y la suma de los sueldos.

//Una variable privada de clase que cuente la cantidad de objetos tipo

//Un Constructor que inicialice los atributos. Haga uso de la referencia

//Métodos de clase set/get para las variables privadas de clase.

//Un método que retorne el volumen del balón (4 * 3.1416 * radio*

//Un método que retorne el descuento (10% del precio).

//Un método que retorne el importe a pagar (precio - descuento)

protected void actionPerformedBtnProcesar(ActionEvent arg0) {

//Muestre la cantidad de objetos creados y el importe a pagar acumulado.

//Un Constructor que inicialice los atributos. Haga uso de la referencia

//Métodos de clase get para las variables de clase privadas.

//Un método que retorne el sueldo bruto (horas*tarifa).

//Un método que retorne el descuento (15% del sueldo bruto).

//Un método que retorne el sueldo neto (sueldo bruto - descuento)

protected void actionPerformedBtnProcesar(ActionEvent arg0) {

//Muestre la cantidad de objetos creados y la suma de los sueldos netos.

//Implemente un método listado que reciba la referencia a un objeto de

public int getNumero() {

//Un método que retorne el costo de consumo (segundos*precio).

protected void actionPerformedBtnProcesar(ActionEvent arg0) {

//Muestre la cantidad de objetos creados y el total a pagar acumulado.

//Implemente un método listado que reciba la referencia a un objeto de tipo

private static int contador;