PROGRAMACIÓN ORIENTADA A OBJETOS POO
JAVA
Docente: Leydi Johana Polo
Una entidad financiera que presta dinero a sus clientes requiere calcular el valor mensual a pagar por uno de ellos teniendo en cuenta:
• El plazo máximo para los prestamos es de 5 años.
• El valor de la cuota mensual corresponde al valor resultante del monto total prestado entre el número de cuotas del crédito.
• Además del valor de la cuota mensual, se debe pagar los intereses corrientes mensuales que corresponden al 1.5% del valor de la cuota mensual.
• Además del valor de la cuota mensual y los intereses corrientes, se debe pagar un valor mensual correspondiente a un seguro, que equivale a un porcentaje del valor de la cuota mensual y depende de la edad del cliente. Si tiene hasta 30 años paga el 0.3%, entre 30 y 50 años el 0.5% y por más de 50 años el 0.8%.
• Se debe presentar el valor liquidado por cada concepto que conforma el valor final a pagar.
TALLER 1 PROBLEMÁTICA
Exigencias en la lógica del proyecto:
✓ Elaborar el diagrama de clases incluyendo atributos y métodos.
✓ Un método calcula el valor de la cuota mensual
✓ Un método calcula el valor de los intereses corrientes.
✓ Un método calcula el valor del seguro.
✓ Un método presenta el valor calculado para cada concepto y el valor final a pagar por el cliente.
Exigencias de POO del proyecto:
• Definir el diagrama de clases UML teniendo en cuenta que todos los métodos son de tipo “void”.
• Creación correcta de clases (atributos y métodos) y de objetos.
• El proyecto debe funcionar correctamente según las exigencias hechas
CREDITOS edad
plazo
montoprestamo vlrIntereses vlrCuotaMes vlrSeguro
calcularCouota() calcularIntereses() calcularSeguro() Presentar()
import javax.swing.JLabel;
public class Creditos {
String edad; // se maneja tipo string porque tenemos un radio buton int plazo;
double montoPrestamo, vlrIntereses, vlrCoutaMes, vlrSeguro;
public Creditos(String edad, int plazo, double montoPrestamo) { // constructor this.edad = edad;
this.plazo = plazo;
this.montoPrestamo = montoPrestamo;
}
Clase créditos
// se hace el primer método tipo void calcular cuota void calcularCuota () {
vlrCoutaMes = montoPrestamo/plazo;
}
// se hace el segundo metodo tipo void calcular intereses void calcularinteres (){
vlrIntereses = vlrCoutaMes * 0.015;
}
// se hace el tercer metodo tipo void calcular seguro void calcularSeguro() {
if (edad.equals("A")) {// se usa equals porque el atributo es un string vlrSeguro = vlrCoutaMes*0.003;
}
else { if (edad.equals("B")) {
vlrSeguro = vlrCoutaMes*0.005;
}
else {
vlrSeguro = vlrCoutaMes*0.008;
} } }
// se hace el metodo tipo void presentar
void presentar (JLabel lblCuotaMes, JLabel lblInteres, JLabel lblSeguro, JLabel lblValorPagar) {
lblCuotaMes.setText(""+vlrCoutaMes); // cuita mensual lblInteres.setText(""+vlrIntereses); // intereses
lblSeguro.setText(""+vlrSeguro); // seguro
lblValorPagar.setText(""+(vlrCoutaMes+vlrIntereses+vlrSeguro));
}
public class Formulario extends javax.swing.JFrame { public Formulario() {
initComponents();
buttonGroup1.add (rbtnMentreinta);
buttonGroup1.add (rbtnHastaCincu);
buttonGroup1.add (rbtnMayCincu); }
Clase formulario
private void btnCerrarActionPerformed(java.awt.event.ActionEvent evt) { // se agrega el cerrar
System.exit(0);
private void btnCalcularActionPerformed(java.awt.event.ActionEvent evt) { // se agregan las opciones para la edad del rango tipo "A"
String edad = "A"; // con esto me ahorro el condicional del primer radiobutton if (rbtnHastaCincu.isSelected()){edad= "B";}
if (rbtnMayCincu.isSelected()){edad= "C";}
int plazo = Integer.parseInt(cmbPlazo.getSelectedItem().toString())*12;
double montoPrestamo = Double.parseDouble(txtPrestamo.getText());
Creditos obj = new Creditos(edad, plazo, montoPrestamo); // se crea el objeto obj.calcularCuota();
obj.calcularinteres();
obj.calcularSeguro();
obj.presentar(lblCuotaMes, lblInteres, lblSeguro, lblValorPagar);// se ponen en el mismo orden del método presentar
}
1. void
nombre:_metodo ([parametros]) { }
2. nombre_clase ([parametros]) { }
3. metodos que retornan valor y se debe agregar un return
Int double float boolean string nombre_metodo ([parametros]){
}
TRES TIPOS DE MÉTODOS EN JAVA
De un servicio de taxi se requiere calcular el valor a cancelar teniendo en cuenta las siguientes observaciones:
✓Todo servicio tiene un número de kilómetros recorridos. Si el número de kilómetros no supera los tres kilómetros, el valor a pagar por los kilómetros recorridos es de $4500. Si el número de kilómetros es superior a tres kilómetros el valor apagar por los kilómetros recorridos es de $1500 por cada kilómetro.
✓El servicio se puede prestar en un día ordinario o en un día festivo, encaso de que el servicio se preste en un día festivo se paga el 70% del valor de los kilómetros recorridos .Si el tipo de día es ordinario este valor es cero.
✓El servicio puede ser diurno o nocturno. Esto depende de la hora en que se presta el servicio, entre las 18 y las 24 horas el servicio se considera nocturno y se debe pagar por valor de recargo nocturno el 50% del valor de los kilómetros recorridos.
EJERCICIO EN CLASE
Exigencias en la lógica del proyecto:
✓ Un método calcula el valor de los kilómetros recorridos.
✓ Un método calcula el valor del tipo de día dependiendo si es ordinario o festivo.
✓ Un método calcula el valor a pagar por recargo nocturno.
✓ Un método presenta el valor a pagar por cada concepto y el valor final a pagar.
Exigencias de POO del proyecto:
• Definir el diagrama de clases UML teniendo en cuenta que todos los métodos son de tipo “void”.
• Creación correcta de clases (atributos y métodos) y de objetos.
• El proyecto debe funcionar correctamente según las exigencias hechas
Exigencias en la lógica del proyecto
SERVICIO numKm
tipoDia
horaServicio
calcularVlrKmRec () calcularVlrDia ()
calcularRecargoNoc() Presentar ()
CASOS DE ESTUDIO
De un empleado se conoce su nombre, documento de identificación, el salario básico mensual, los días trabajados en un mes y las horas extras de trabajo en un mes.
✓Se requiere calcular lo que gana en el mes este empleado según los días de trabajo, a partir del salario básico mensual teniendo en cuenta que el salario básico mensual corresponde a 30 días de trabajo.
✓Además, se requiere calcular lo que gana en el mes este empleado por las horas extras trabajadas teniendo en cuenta que cada hora extra vale un 25% más de lo que vale una hora de trabajo ordinario. Es de tener en cuenta que un empleado normalmente trabaja 30 días con una intensidad diaria de 8horas.
✓Finalmente, se requiere calcular el total ganado por el empleado que equivale a la sumatoria de lo que gana por los días trabajados y lo que gana por las horas extras trabajadas.
Caso 1
Exigencias en la lógica del proyecto:
✓ Elaborar el diagrama de clases incluyendo atributos y métodos.
✓ Un método calcula el valor de los días trabajados.
✓ Un método calcula el valor de las horas extras trabajadas.
✓ Un método calcula el total que gana el empleado en un mes equivalente a la suma de lo que gana por los días trabajados y las horas extras trabajadas.
✓ Un método que presenta el total que gana en el mes el empleado por los días y las horas extras trabajadas.
Exigencias de POO del proyecto:
• Definir el diagrama de clases UML teniendo en cuenta que todos los métodos son del tipo que retornan valor.
• Creación correcta de clases (atributos y métodos) y de objetos.
• El proyecto debe funcionar correctamente según las exigencias hechas
NOMINA Nombre
Id
Dias_trab Horas salario
diasTrab() horasExt() auxTrans() segSocial() Presentar()
CASO 2
Se requiere calcular el valor de las comisiones de los vendedores de la empresa ABC Ltda, teniendo en cuenta los siguientes criterios:
➢ El valor de las comisiones que gana un vendedor corresponde a un porcentaje de su salario básico mensual y este porcentaje depende del número de puntos acumulados por las ventas realizadas (ver tabla anexa).
➢ Los puntos acumulables son validos de 10 en 10. El menor número de puntos acumulables es 10 y el mayor número de puntos acumulables es 100.
➢ El vendedor que obtenga por valor de comisiones lo correspondiente a su salario básico mensual, la empresa adicionalmente le obsequia un bono por el 50% de su salario básico mensual para hacerlo valido en la cadena de almacenes
HOMECENTRE.
Para los vendedores con más de 60 puntos pero que el valor de las comisiones no alcanza el valor de su salario básico mensual, la empresa les obsequia el bono por valor de $30.000 pesos.
➢ Para los vendedores que tienen valor de comisiones a partir de 80 puntos acumulados la empresa les realiza un aporte de ahorro al fondo de empleados correspondiente al 10% de su salario básico.
Exigencias en la lógica del proyecto:
✓ El método vlrcomision() calcula el valor de la comisión del vendedor.
✓ El método vlrahorro() calcula el valor del aporte de ahorro que realiza la empresa por el vendedor al fondo de empleados.
✓ El método vlrbono() calcula el valor del bono que obsequia la empresa a sus vendedores.
✓ El método presentar() presenta en detalle en etiquetas: el valor de las comisiones, el valor del bono y el valor del aporte al fondo de empleados.
Exigencias de POO en el proyecto entregable:
1. Creación correcta clases con sus atributos y métodos.
2. Definición correcta de objetos y métodos.
3. El proyecto debe funcionar utilizando de forma correcta los métodos y la
definición de la clase.
COMISION nombreVendedor salarioBasico
vlrcomision() vlrahorro() vlrbono() presentar()
EN LA CLASE COMISION SE DEFINEN ATRIBUTOS METODO CONSTRUCTOR
Atributos de la clase Nombre y salario
import java.text.DecimalFormat;
import javax.swing.JLabel;
public class Comision { String nombre;
double salario;
// constructor
public Comision(String nombre, double salario) { this.nombre = nombre;
this.salario = salario;
}
EN LA CLASE FORMULARIO SE DEFINE EL FOR PARA EL COMBO DE PUNTOS
for (int i=10; i<=100; i+=10) {cmbPuntos.addItem(""+i);
} }
Este es el nombre dado al combo que entrega los puntos este for se usa para
incrementar de a 10 en 10 el valor del combo puntos
double vlrAhorro (int puntos){
double aporte=0;
if (puntos >= 80) {
aporte = salario*10/100;
} else{
if(puntos < 80) aporte = 0;
}
return aporte;
}
Se instancian las variables: puntos
Se instancian: puntos Método vlrComision()
Método vlrAhorro()
- El If define la acción de aporte del 10% para los puntos >= 80 - Se debe definir un else para los casos que no cumplen la condición para no generar aporte
EN LA CLASE COMISION SE DEFINEN LOS METODOS
double vlrComision(int puntos) { double comis=0;
comis=salario*puntos/100;
return comis;
}
Definir return con lo que se espera
Nombre del
metodo vlrBono()
double vlrBono(int puntos){
double bono=0;
if (puntos == 100) { bono = salario/2;
}
if (puntos <100 && puntos >=60){
bono = 30000;
} else{
if(puntos < 60) bono = 0;
}return bono;
}
Instanciar los atributos propios del método:
puntos y bono
- El primer If define la acción para el caso de puntos = 100
- El segundo if para el rango de puntos >=
60 y <100
- Se debe definir un else para los casos que no cumplen ninguna condición
Se pone return con lo que se espera obtener
En el Método presentar() se deben instanciar las variables según su tipo o etiqueta:
JLabel lblVlrComision, JLabel lblVlrAhorro, JLabel lblVlrBono, double salario, double comis, double aporte, double bono
void presentar (JLabel lblVlrComision, JLabel lblVlrAhorro, JLabel lblVlrBono, double salario, double comis, double aporte, double bono){
DecimalFormat formato = new DecimalFormat("##,###,###.##");// este metodo format se usa para crear un objeto formato que se usa para definir el formato numerico del salario
lblVlrComision.setText(""+formato.format(comis));
lblVlrAhorro.setText(""+formato.format(aporte));
lblVlrBono.setText(""+formato.format(bono));
}
El método format se usa para crear un objeto formato que se usa para definir el formato numérico del salario.
Debe ser llamado al principio de la clase
se llaman los labels donde se va a presentar cada atributo de salida con la variable entregada por el método en el return según el caso
Debe ser llamado al principio de la clase
private void btnCalcularActionPerformed(java.awt.event.ActionEvent evt) { double salario = Double.parseDouble(txtSalario.getText());
int puntos = Integer.parseInt(cmbPuntos.getSelectedItem().toString());
Comision obj = new Comision(txtNombre.getText(), salario);
double comis = obj.vlrComision(puntos);
double aporte = obj.vlrAhorro(puntos);
double bono = obj.vlrBono(puntos);
obj.presentar(lblVlrComision, lblVlrAhorro, lblVlrBono, salario, comis, aporte, bono); }
SE INVOCAN LOS METODOS DE LA CLASE COMISION
EN LA CLASE FORMULARIO SE DEFINEN LAS ACCIONES DEL BOTÓN CALCULAR
Es importante realizar esta configuración con base a los métodos de la clase Comision.
Generalmente es mejor hacerlo despues
double es una clase y parseDouble es un método para volver double el string
Lo mismo en int y parseInt
se crea un objeto llamado obj de la clase Comision y se instancia teniendo en cuenta el orden del constructor de esa clase (Nombre y salario)
se invoca el método .presentar de la clase nomina, usando el objeto obj creado
Los atributos se deben poner en orden según como estén creados en el método presentar de la clase comisión:
void presentar (JLabel lblVlrComision, JLabel lblVlrAhorro, JLabel lblVlrBono, double salario, double comis, double aporte, double bono)
CASO 3
En una cabina telefónica se requiere una solución software que permita calcular el valor a pagar por un cliente por una llamada telefónica por minutos, teniendo en cuenta
✓ La llamada se puede realizar a destino celular, nacional o
internacional. El minuto a celular vale $200, a destino nacional
$300 y a destino internacional $500.
✓ La llamada a cualquier destino con duración a partir de 20 minutos, tiene un descuento del 10%.
✓ Toda llamada tiene iva. Las llamadas con destino a celular y
nacional el iva es del 16% y con destino intenacional el iva es del
19%.
Exigencias en la lógica del proyecto:
✓ El método valorLlamada() calcula el valor de los minutos de la llamada teniendo en cuenta el destino de la llamada.
✓ El método valorDcto() calcula el posible valor de descuento de la llamada.
✓ El método valorIva() calcula el valor del iva teniendo en cuenta el destino de la llamada.
✓ El método factura() calcula el total a pagar por el cliente y presenta en detalle: el valor de los minutos, el valor del descuento, el valor del iva y el valor final a pagar por el cliente que realiza la llamada. Nota: El total a
pagar por el cliente corresponde al valor de los minutos más el valor del iva menos el valor del descuento.
Exigencias de POO en el proyecto entregable:
1. Creación correcta clases con sus atributos y métodos.
2. Definición correcta de objetos y métodos.
3. El proyecto debe funcionar utilizando de forma correcta los métodos y la
definición de la clase.
LLAMADA telDestino
duracion
valorLLamada() valorDcto() valorIva() factura()
Clase Llamada
Se definen la clase llamada y los atributos de clase y el método constructor
Clase y atributos
Constructor
Se importan los métodos
DecimalFormat y JLabel
Se define el primer método valorLLamada() tipo double que retorna valor En este método mediante la estructura de control if se calcula el valor de los minutos según el tipo de destino:
celular vale $200 nacional $300 internacional $500
.equals() se usa para comparar el atributo telDestino con el string Celular, Nacional o Internacional según el caso
Se define el segundo método valorDcto() también tipo double igualmente usando la estructura de control if se calcula el valor del descuento a
partir de 20 minutos, tiene un descuento del 10%, para el caso de menos
de 20 min el valor se hace 0
El tercer método método valorIva() también es tipo doublé, usando la
estructura de control if se calcula el valor del iva comparando el destino de las
llamadas celular y nacional para calcular el iva del 16% y se usa un else if para
el destino intenacional para calcular el 19%.
El ultimo método llamado factura (), corresponde a un presentar. Este método
permite calcular el total a pagar y ademas presenta en detalle: el valor de los
minutos, el valor del descuento, el valor del iva y el valor final a pagar
import java.text.DecimalFormat;
import javax.swing.JLabel;
public class Llamada { String telDestino;
public Llamada(String telDestino) { this.telDestino = telDestino;
}
double valorLLamada(int duracion) { double valorDestin=0;
if (telDestino.equals("Celular")) { valorDestin = duracion*200;
}
if (telDestino.equals("Nacional")) { valorDestin = duracion*300;
}
if (telDestino.equals("Internacional")) { valorDestin = duracion*500;
} return (valorDestin);
}
double valorDcto(int duracion, double valorDestin){
double valorDescu =0;
if (duracion >= 20) {
valorDescu = valorDestin*10/100;
}
if (duracion < 20) { valorDescu = 0;
} return (valorDescu);
}
double valorIva(int duracion, double valorDestin){
double valorIva =0;
if (telDestino.equals("Celular")) { valorIva = valorDestin*16/100;
}
if (telDestino.equals("Nacional")) { valorIva = valorDestin*16/100;
}
else {if (telDestino.equals("Internacional")) { valorIva = valorDestin*19/100;
}
}return (valorIva);
}
void factura (JLabel lblValorDestin, JLabel lblValorDescu, JLabel lblValorIva,
JLabel lblValorTotal,
int duracion, double valorDestin, double valorDescu, double valorIva) {
DecimalFormat formato = new DecimalFormat("##,###,###.##");
lblValorDestin.setText(""+formato.format(valorDestin));
lblValorDescu.setText(""+formato.format(valorDescu));
lblValorIva.setText(""+formato.format(valorIva));
lblValorTotal.setText(""+(valorDestin - valorDescu + valorIva));
} }
Código clase Llamada
Clase Formulario
Inicialmente se definen los valores para los radiobuton
En el calcular se hacen 3 if para definir el atributo de entrada según el tipo de destino
Con el objeto se llaman los métodos Se crea el objeto por medio de la clase
public class Formulario extends javax.swing.JFrame { public Formulario() {
initComponents();
buttonGroup1.add (rbtnCel);
buttonGroup1.add (rbtnNal);
buttonGroup1.add (rbtnInter);
}
private void btnCalculActionPerformed(java.awt.event.ActionEvent evt) { String telDestino= "";
if (rbtnCel.isSelected()){telDestino= "Celular";}
if (rbtnNal.isSelected()){telDestino= "Nacional";}
if (rbtnInter.isSelected()){telDestino= "Internacional";}
int duracion = Integer.parseInt(txtMin.getText());
Llamada obj = new Llamada(telDestino);
double valorDestin = obj.valorLLamada(duracion);
double valorDescu = obj.valorDcto(duracion, valorDestin);
double valorIva = obj.valorIva(duracion, valorDestin);
obj.factura(lblValorDestin, lblValorDescu, lblValorIva, lblValorTotal, duracion, valorDestin, valorDescu, valorIva);
}
Código que se agrega a la clase Formulario
CASO 4
Un acueducto requiere una solución software que le permita calcular el valor que debe pagar un usuario a partir de los metros cúbicos de agua consumidos, teniendo en cuenta:
✓ El usuario puede ser de estrato Residencial, Comercial o Industrial. El valor del metro cubico de agua para el estrato Residencial es de $250, para el estrato
Comercial es de $380 y para el estrato Industrial es de $600.
✓ Para cualquier estrato, si el consumo de metros cúbicos de agua supera los 100, se debe pagar un incremento por exceso de consumo correspondiente al 15% del valor de los metros cúbicos de agua consumidos.
✓ Todo estrato debe pagar por mantenimiento del acueducto. Residencial y
Comercial el 5% del valor de los metros cúbicos de agua consumidos y el estrato Industrial el 10%.
Exigencias en la lógica del proyecto:
✓ El método valorMetros() calcula el valor de los metros cúbicos de agua consumidos teniendo en cuenta el estrato del usuario.
✓ El método valorInc() calcula el posible valor de incremento por exceso de consumo de agua.
✓ El método valorMto() calcula el valor por concepto de mantenimiento del acueducto.
✓ El método factura() calcula el total a pagar por el usuario y presenta en detalle: el valor de los metros cúbicos de agua consumidos, el valor del incremento por exceso de consumo, el valor por mantenimiento y el valor final a pagar por el usuario.
Nota: El total a pagar por el usuario corresponde al valor de los metros cúbicos de agua más el valor del incremento más el valor por mantenimiento.
Exigencias de POO en el proyecto entregable:
1. Creación correcta clases con sus atributos y métodos.
2. Definición correcta de objetos y métodos.
3. El proyecto debe funcionar utilizando de forma correcta los métodos y la definición de la clase.
ACUEDUCTO idUsuario
consumo estrato
valorMetros() valorInc() valorMto() factura()
Clase Acueducto
Se definen la clase Acueducto y los atributos de clase y el método constructor
Clase y atributos
Constructor
Se importan los métodos
DecimalFormat y JLabel
Se define el primer método valorMetros() tipo double que retorna valor
En este metodo mediante la estructura de control if calcula el valor del consumo según el estrato:
Residencial $250 Comercial $380 Industrial $600.
.equals() se usa para comparar el atributo estrato con el string Residencial,
Comercial, Industrial según el caso
Se define el segundo método valorInc() también tipo doublé, igualmente usando la estructura de control if se calcula el valor del descuento para todos los estratos si el consumo de metros cúbicos de agua supera los 100, se debe pagar un
incremento por exceso de consumo correspondiente al 15%, para el caso de menos de 100 el valor de incremento se hace 0
El tercer método método valorMto() también es tipo doublé, usando la estructura de control if se calcula el valor del mantenimiento comparando el estrato para los casos de Residencial y Comercial el 5% del valor de los metros cúbicos de agua consumidos y para el caso Industrial el 10%. En este caso se usa un else if para el estrato Industrial, ya que el valor de mantenimiento será diferente
El ultimo método llamado factura (), corresponde a un presentar. Este método permite calcular el total a pagar y además presenta en detalle: El valor de los metros cúbicos de agua consumidos, el valor del incremento por exceso de consumo, el valor por
mantenimiento y el total a pagar por el usuario que corresponde al valor de los metros cúbicos de agua más el valor del incremento más el valor por mantenimiento
import java.text.DecimalFormat;
import javax.swing.JLabel;
public class Acueducto { String idUsuario;
public Acueducto(String idUsuario) { this.idUsuario = idUsuario;
}
double valorMetros(int consumo, String estrato) { double valorConsumo=0;
if (estrato.equals("Residencial")) { valorConsumo = consumo*250;
}
if (estrato.equals("Comercial")) { valorConsumo = consumo*380;
}
if (estrato.equals("Industrial")) { valorConsumo = consumo*600;
} return (valorConsumo);
}
double valorInc(int consumo, double valorConsumo){
double valorIncremento=0;
if (consumo >= 100) {
valorIncremento = valorConsumo*15/100;
}
if (consumo < 100) { valorIncremento = 0;
} return (valorIncremento);
}
double valorMto(String estrato, double valorConsumo){
double valorManto=0;
if (estrato.equals("Residencial")) { valorManto = valorConsumo*5/100;
}
if (estrato.equals("Comercial")) { valorManto = valorConsumo*5/100;
}
else {if (estrato.equals("Industrial")) { valorManto = valorConsumo*10/100;
}
}return (valorManto);
}
void factura (JLabel lblConsumo, JLabel lblIncrem, JLabel lblValorManto,
JLabel lblTotalPag, int consumo, String estrato, double valorConsumo,
double valorIncremento, double valorManto) { DecimalFormat formato = new
DecimalFormat("##,###,###.##");
lblConsumo.setText(""+formato.format(valorConsumo));
lblIncrem.setText(""+formato.format(valorIncremento));
lblValorManto.setText(""+formato.format(valorManto));
lblTotalPag.setText(""+formato.format(valorConsumo + valorIncremento + valorManto));
} }
Código clase Acueducto
Clase Formulario
Inicialmente se definen los valores para los radiobuton
En el calcular se hacen 3 if para definir el atributo de entrada según el tipo de destino
Se crea el objeto por medio de la clase
Con el objeto se llaman los
métodos
public class Formulario extends javax.swing.JFrame { public Formulario() {
initComponents();
buttonGroup1.add (rbtnResiden);
buttonGroup1.add (rbtnComer);
buttonGroup1.add (rbtnIndustri);
}
private void btnCalcularActionPerformed(java.awt.event.ActionEvent evt) { String estrato= "";
if (rbtnResiden.isSelected()){estrato = "Residencial";}
if (rbtnComer.isSelected()){estrato = "Comercial";}
if (rbtnIndustri.isSelected()){estrato = "Industrial";}
int consumo = Integer.parseInt(txtmts.getText());
Acueducto obj = new Acueducto(estrato);
double valorConsumo = obj.valorMetros(consumo, estrato);
double valorIncremento = obj.valorInc(consumo, valorConsumo);
double valorManto = obj.valorMto(estrato, valorConsumo);
obj.factura(lblConsumo, lblIncrem, lblValorManto, lblTotalPag,
consumo, estrato, valorConsumo, valorIncremento, valorManto);
}
