Ejemplo Programación Orientado a Objetos por JCT
Enunciado del problema Implementar la privacidad con la criptografía
Se quiere crear una aplicación para controlar los gastos telefónicos de una empresa. La empresa cuenta con tres
líneas telefónicas a través de las cuales se pueden realizar llamadas locales, de larga distancia y a celulares La
empresa cuenta con planes telefónicos que establecen las siguientes tarifas:
Minuto Llamada Local: $ 100 pesos por Minuto
Llamada Larga Distancia: $200 pesos Minuto
Llamada Celular: $500 pesos
1. Agregar una llamada a alguna de las líneas telefónicas de la empresa.
2. Visualizar la información de cada linea. Esta información incluye el número total de llamadas realizadas, la
duración total de las llamadas en minutos (aleatoria) y el costo total de las llamadas en pesos.
3. Visualizar la información consolidada de todas las lineas telefónicas de la empresa Esta información incluye el
costo total en pesos de las tres lineas, el número total de llamadas realizadas, la duración total de llamadas en
minutos y el cálculo del costo promedio por minuto según el costo total y el total de minutos.
4. Reiniciar la información de las lineas telefónicas de la empresa.
Interfaz por consola
Solución con
POO
1. Análisis
Conceptual
Conocimiento previo de las líneas
telefónicas
Una “línea telefónica” o “circuito telefónico” es un circuito
eléctrico de un sistema de telecomunicaciones por teléfono.
Típicamente, se refiere a un cable físico u otro medio de
transmisión de señales que conecte el aparato telefónico del
usuario a la red de telecomunicaciones, y normalmente
Ejemplo Programación Orientado a Objetos por JCT
supone también un único número de teléfono asociado a dicho usuario para poder facturarle el
servicio prestado.
En 1876 las primeras líneas eran simples conductores metálicos directamente conectados de
un teléfono a otro con la Tierra como toma de tierra. Más tarde, en 1878, la compañía de
teléfonos Bell Telephone Company llevó líneas, conocidas como bucle local, desde el teléfono
de cada usuario a la centralita o central telefónica, que llevaba a cabo todos los intercambios
eléctricos necesarios para permitir que las señales de voz fueran transmitidas a teléfonos.
Cuando se realiza una llamada local, la centralita conecta el bucle local al bucle de abonado
del número marcado.
Los cables eran normalmente de cobre, aunque también se usó aluminio, y se llevaban de dos
en dos, separados aproximadamente 25 centímetros, sobre postes, y más tarde como cable
de par trenzado de 2 hilos.
Las líneas modernas pueden ir bajo tierra a un conversor analógico-digital que convierte
la señal analógica a digital para transmitirla por fibra óptica.
La mayoría de los hogares están conectados mediante conductores de cobre y conectores RJ-
11.
2. Análisis desde Programación Orientada Objetos
2.1 Análisis del documento de requerimientos
2.2 Identificar los aspectos que forman parte de un problema.
Cliente Compañia
Usuario Operadores
1. Agregar una llamada a alguna de las líneas telefónicas de la empresa.
Requerimiento 2. Visualizar la información de cada linea. Esta información incluye el
funcional número total de llamadas realizadas, la duración total de las llamadas en
minutos (aleatoria) y el costo total de las llamadas en pesos.
3. Visualizar la información consolidada de todas las lineas telefónicas de la
empresa Esta información incluye el costo total en pesos de las tres lineas,
el número total de llamadas realizadas, la duración total de llamadas en
minutos y el cálculo del costo promedio por minuto según el costo total y el
total de minutos.
4. Reiniciar la información de las lineas telefónicas de la empresa.
Mundo del La telefonía es un sistema de comunicación para la
problema transmisión de sonidos a larga distancia mediante medios
eléctricos o electromagnéticos.
Requerimiento No hay
no funcional
2.3 Requerimientos Funcionales
Ejemplo Programación Orientado a Objetos por JCT
Requerimiento Funcional 1
Nombre: 1. Agregar una llamada a alguna de las líneas telefónicas de la empresa.
Resumen: Seleccionar que línea se usara para el servicio.
Entradas
Int LINEA;
Resultado
Requerimiento Funcional 2
Nombre: 2. Visualizar la información de cada linea. Esta información incluye el número total de
llamadas realizadas, la duración total de las llamadas en minutos (aleatoria) y el costo
total de las llamadas en pesos.
Resumen: Ver en pantalla información referente a una canal
Entradas:
Int eleccion;
Resultado
Nombre: 3. Visualizar la información consolidada de todas las lineas telefónicas de la empresa
Esta información incluye el costo total en pesos de las tres lineas, el número total de
llamadas realizadas, la duración total de llamadas en minutos y el cálculo del costo
promedio por minuto según el costo total y el total de minutos.
Resumen: Ver en pantalla información referente a todos los canales.
Ejemplo Programación Orientado a Objetos por JCT
Entradas:
Int eleccion;
Resultado
Nombre: 4. Reiniciar la información de las lineas telefónicas de la empresa.
Resumen: Borrar los datos en cada línea.
Entradas:
Int eleccion;
Resultado
Ejemplo Programación Orientado a Objetos por JCT
2.4. El Modelo del Mundo del Problema
Entidad Descripción
La Telefonía es la técnica de telecomunicación utilizada para la
TELEFONI instalación y mantenimiento de los sistemas técnicos
A necesarios para la transmisión de voz y datos por medios
eléctricos, electromagnéticos e inalámbricos.
2.4 Los Requerimientos no Funcionales
Ninguno
2.5. Identificar las clases.
… sustantivos/clases
… Verbos/Atributos
Se quiere crear una aplicación para controlar los gastos telefónicos de una empresa. La empresa cuenta con tres
líneas telefónicas a través de las cuales se pueden realzar llamadas locales, de larga distancia y a celulares La
empresa cuenta con planes telefónicos que establecen las siguientes tarifas:
Minuto Llamada Local: $ 100 pesos por Minuto
Llamada Larga Distancia: $200 pesos Minuto
Llamada Celular: $500 pesos
1. Agregar una llamada a alguna de las líneas telefónicas de la empresa.
2. Visualizar la información de cada linea. Esta información incluye el número total de llamadas realizadas, la
duración total de las llamadas en minutos (aleatoria) y el costo total de las llamadas en pesos.
3. Visualizar la información consolidada de todas las lineas telefónicas de la empresa Esta información incluye el
costo total en pesos de las tres lineas, el número total de llamadas realizadas, la duración total de llamadas en
minutos y el cálculo del costo promedio por minuto según el costo total y el total de minutos.
4. Reiniciar la información de las lineas telefónicas de la empresa.
Sustantivos y frases nominales en el documento de requerimientos del
Programa
Aplicacion Control
Linea Llamada
Lineas
Tarifas
Fig. 1.5 Diagrama Sustantivos y frases nominales
Se crean clases sólo para los sustantivos y frases nominales que tengan
importancia en el sistema.
Ejemplo Programación Orientado a Objetos por JCT
programa por LT Representa el modelo o mundo
consola
Aplicacion Aplicativo
Linea Linea individual
Lineas Canales manejados
Tarifas Menu del aplicativo
Control Interfaz
Llamada Eleccion del usuario
La clase Main la clase principal y en este caso la controladora. Los demás
sustantivos o frases nominales no son relevantes.
2.6 Identificación de los atributos de las clases
programa por Cifrado Representa el modelo o mundo
consola
Crear No relevante
Agregar No relevante
Visualizar Ver por pantalla el menú o datos finales.
Reiniciar Vaciar datos referentes a los canales
Incluir Anexar Información constantemente
Contar Numero de entradas en el aplicativo
a) Definir campos de entradas
Atributo Tipo de Atributo Posibles valores
ELECP Int, Mayor o igual a 0 (1- 5)
Tipo int, Mayor o igual a 0 (1- 3)
Linea Int Mayor o igual a 0 (1- 3)
Fig. 1.8 Diagrama campos de entrada
b) Definir variables de salidas
Atributo Tipo de Posibles valores
Atributo
INDICEE int Mayor o igual a 0
REGIS[0] float Mayor o igual a 0
Fig. 1.9 Diagrama campos de salida
Ejemplo Programación Orientado a Objetos por JCT
2.7 Identificación de las operaciones o comportamientos de las clases
Verbos y frases verbales en el documento de requerimientos del FISICA
Crear
Agregar
Visualizar
Reiniciar
Incluir
Contar
Figura 1.16 modelado de posibles métodos
3.6 métodos de las clases
Crear Main()
Agregar Menu()
Visualizar Vista()
Reiniciar Main()
Incluir Lamada()
Contar LiNE()
2.8 Definir signatura de los métodos
Nombre: Main
Descripción: No retorna nada, es el main.
Parámetros: ELECP
Retorno: ninguno
Cuerpo del /*
método
*
Ejemplo Programación Orientado a Objetos por JCT
* Autor:Julian Moreno
*
*/
package EJECU;
import [Link];
import [Link];
import [Link];
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner([Link]);
LINE lineas = new LINE();
Menu menu = new Menu();
Vista a;
a= new Vista();
int ELECP=0;
do {
[Link]();
[Link]();
try {
ELECP = [Link]();
} catch(InputMismatchException e) {
[Link]("POR FAVOR
INGRESE DE NUEVO EL NUMERO");
input=new Scanner([Link]);
continue;
}
Ejemplo Programación Orientado a Objetos por JCT
switch(ELECP) {
case 1:
menu.AÑADIR(lineas);
break;
case 2:
[Link](lineas);
break;
case 3:
[Link](lineas);
break;
case 4:
lineas.REINICIO2();
[Link]("LINEAS
REINICIADAS..\n");
break;
case 5:
[Link]();
[Link]("FINALIZACION
COMPLETA");
break;
default:
[Link]("opcion errada,
porfavor digite una opcion dentro de los estandares");
break;
}
} while (ELECP != 5);
}
Figura 1.17 Signatura calcularAltura ()
Ejemplo Programación Orientado a Objetos por JCT
Nombre: Menu()
Descripción Controla las elecciones internas del main
:
Parámetros: Duración, tipo tarifa, canal
Retorno: ninguno
Cuerpo del package EJECU;
método
import [Link];
import [Link];
import [Link];
import [Link];
public class Menu {
Scanner input = new Scanner([Link]);
public void AÑADIR(LINE lineas) {
int CANAL = SCANAL();
int Duration=0,Tiposs=4;
double Fijo=0;
if(CANAL!=-1) {
Lineap linea = [Link](CANAL);
Duration = (int) ([Link]()*6 + 1) ;
do {
[Link]();
[Link]("Seleccione el tipo
de llamada:");
[Link]("1. Llamada
local");
[Link]("2. Llamada larga
Ejemplo Programación Orientado a Objetos por JCT
distancia");
[Link]("3. Llamada
celular");
try {
Tiposs = [Link]();
} catch(InputMismatchException e) {
[Link]("Intente por
favor ingresar de nuevo el numero");
input=new Scanner([Link]);
continue;
}
switch(Tiposs) {
case 1:
Fijo = 0.5;
break;
case 2:
Fijo = 1;
break;
case 3:
Fijo = 2;
break;
default:
[Link]("Opcion
errada, intente de nuevo");
break;
}
} while(Tiposs>3);
linea.añadir(Duration, Fijo);
[Link]("Llamada añadida,
Ejemplo Programación Orientado a Objetos por JCT
correctamente c:");
[Link]();
Julian();
}
private int SCANAL() {
int LINEA=4;
do {
[Link]("Seleccione el canal o linea a
usar:");
[Link]("1. CANAL
PRINCIPAL");
[Link]("2. CANAL
SEGUNDARIO");
[Link]("3. CANAL
TERCIARIO");
try {
[Link]();
[Link]("Para seleccionar
la linea ingres un numero dentro del rango (1-3)");
LINEA = [Link]()-1;
} catch(InputMismatchException e) {
[Link]("Numero errado,
intente de nuevo");
input=new Scanner([Link]);
continue;
}
}while(LINEA>2);
return LINEA;
Ejemplo Programación Orientado a Objetos por JCT
}
public void getRINDI(LINE lineas) {
int INDICEEE = SCANAL();
if(INDICEEE!=-1) {
Lineap x = [Link](INDICEEE);
double[] REGIS = x.REGISTRO1();
[Link]();
[Link]("INDICE INDIVIDUAL:");
[Link]("Información de la linea
"+(INDICEEE+1));
[Link]("Numero de llamadas:
%.0f%n",REGIS[0]);
[Link]("Duración total: %.0f
%n",REGIS[1]);
[Link]("Costo total: %.2f
%n",REGIS[2]);
}
[Link]();
Julian();
public void getRTOTAL(LINE lineas) {
double[] REGIS = [Link]();
[Link]();
[Link]("CONSOLIDACIÓN:");
[Link]("Numero de llamadas: %.0f
%n",REGIS[0]);
[Link]("Duración total: %.0f
Ejemplo Programación Orientado a Objetos por JCT
%n",REGIS[1]);
[Link]("Costo total: %.0f
%n",REGIS[2]);
[Link]("Costo promedio por minuto:
%.2f%n",REGIS[3]);
Julian();
private void Julian() {
[Link]();
[Link]("Presione cualquier tecla para
regresar al Menu");
[Link]();
}
}
Figura 1.18 Signatura calcularAltura ()
Nombre: Lineap()
Descripción Maneja las lineas ingresadas por teclado y asigna valores al
: arreglo
Parámetros: Rgt,calluwu
Retorno: Valores de registro
Cuerpo del //* @author Julian
método
package JULIAN;
import [Link];
import [Link];
Ejemplo Programación Orientado a Objetos por JCT
public class Lineap {
private ArrayList <Calluwu> llamadas;
public Lineap () {
llamadas = new ArrayList<Calluwu>();
}
public double[] REGISTRO1() {
double[] RGT = {0, 0, 0};
if(![Link]()) {
RGT[0] = [Link]();
RGT[1] = duracionLlamadas();
RGT[2] = costoLlamadas();
}
return RGT;
}
public void añadir(int duracion, double tarifa) {
Calluwu llamada = new Calluwu(duracion, tarifa);
[Link](llamada);
}
private int duracionLlamadas() {
Iterator<Calluwu> current = [Link]();
int duracion = 0;
while([Link]()) {
duracion = duracion +
[Link]().getDuracion();
}
Ejemplo Programación Orientado a Objetos por JCT
return duracion;
}
public void REINICIOP() {
llamadas = new ArrayList<Calluwu>();
}
private double costoLlamadas() {
Iterator<Calluwu> current = [Link]();
double valoruwu = 0;
while([Link]()) {
valoruwu = valoruwu +
[Link]().getCosto();
}
return valoruwu;
}
Nombre: Calluwu()
Descripción Retorna los valores obtenidos por llamada
:
Parámetros: ninguno
Retorno: Duración,costo
Cuerpo del //* @author Julian
método
package JULIAN;
Ejemplo Programación Orientado a Objetos por JCT
public class Calluwu {
int duracion;
double costo;
public Calluwu(int duracion, double tarifa) {
[Link] = duracion;
costo = duracion * tarifa;
}
public int getDuracion() {
return duracion;
}
public double getCosto() {
return costo;
}
Nombre: LINE()
Descripción Maneja el arreglo
:
Parámetros: Rgs,Registroc, reinicio2
Retorno: REFGISTRO
Cuerpo del package JULIAN;
método
import [Link];
import [Link];
public class LINE {
Ejemplo Programación Orientado a Objetos por JCT
private ArrayList<Lineap> lineas = new
ArrayList<Lineap>();
public Lineap getLinea(int index) {
Lineap linea = [Link](index);
return linea;
}
public LINE() {
for(int i = 0; i < 3; i++) {
[Link](new Lineap());
}
}
public double[] REGISTROTOTAL() {
Iterator<Lineap> current = [Link]();
double[] rgs = {0, 0, 0, 0};
double[] REGUISTROC;
while([Link]()) {
REGUISTROC =
[Link]().REGISTRO1();
rgs[0] = rgs[0] + REGUISTROC[0];
rgs[1] = rgs[1] + REGUISTROC[1];
rgs[2] = rgs[2] + REGUISTROC[2];
}
if(rgs[0]!=0) {
rgs[3] = rgs[2]/rgs[1];
}
return rgs;
Ejemplo Programación Orientado a Objetos por JCT
public void REINICIO2() {
Iterator<Lineap> current = [Link]();
while([Link]()) {
[Link]().REINICIOP();
}
}
}
Diseño del programa UML
3.1 Diagramas de caso-uso Ahora se presenta el primero de varios
diagramas de UML en el caso de estudio. Se crea un diagrama de caso-uso
para modelar las interacciones entre los clientes de un sistema
Ejemplo Programación Orientado a Objetos por JCT
Fig. 1.4 Diagrama de caso-uso para el sistema Física, desde la perspectiva del
usuario
La figura 1.4 muestra el diagrama de caso-uso para nuestro sistema Física La
figura humana representa a un actor, el cual define los roles que desempeña una
entidad externa (como una persona u otro sistema) cuando interactúa con el
sistema. Para nuestro sistema Física, el actor es un Usuario que puede ver la
altura, y la velocidad del Programa de Fisica.
3.2 Diagramas de clases
Fig. 1.6 Representación de una clase main en UML mediante un diagrama
de clases.
Ejemplo Programación Orientado a Objetos por JCT
Fig. 1.7 Representación de una clase Vista en UML mediante un diagrama
de clases.
Fig. 1.7 Representación de una clase Menu en UML mediante un diagrama
de clases.
Fig. 1.8 Representación de una clase LINE en UML mediante un diagrama
de clases.
Fig. 1.9 Representación de una clase Lineap en UML mediante un
diagrama de clases.
Ejemplo Programación Orientado a Objetos por JCT
Fig. 2.0 Representación de una clase Calluwu en UML mediante un
diagrama de clases.
3.3 Diagrama de Relaciones entre clases.
Ejemplo Programación Orientado a Objetos por JCT
Fig. 1.9 Representación la relación entre las clases Menu, Vista y Calculo
UML mediante un diagrama de clases.
4. Implementación
6.1Implementación en lenguaje Java
Bajo el modelo MVC, en el mismo paquete. se usa tres clases, el Modelo es la
clase Calculo, la vista es la clase Vista, y la clase principal es Main. (Exceptuando
las clase Calculobr, Menubr) ya que corresponden al mismo sistema pero en
versión inglesa.
Ejemplo Programación Orientado a Objetos por JCT
Implementación
//Clase main
/*
*
* @author Julian
*
*/
package EJECU;
import [Link];
import [Link];
import [Link];
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner([Link]);
LINE lineas = new LINE();
Menu menu = new Menu();
Vista a;
a= new Vista();
int ELECP=0;
do {
[Link]();
[Link]();
try {
ELECP = [Link]();
} catch(InputMismatchException e) {
[Link]("POR FAVOR INGRESE DE NUEVO EL
NUMERO");
input=new Scanner([Link]);
continue;
}
switch(ELECP) {
case 1:
Ejemplo Programación Orientado a Objetos por JCT
menu.AÑADIR(lineas);
break;
case 2:
[Link](lineas);
break;
case 3:
[Link](lineas);
break;
case 4:
lineas.REINICIO2();
[Link]("LINEAS REINICIADAS..\n");
break;
case 5:
[Link]();
[Link]("FINALIZACION COMPLETA");
break;
default:
[Link]("opcion errada, porfavor digite una opcion
dentro de los estandares");
break;
}
} while (ELECP != 5);
}
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package EJECU;
/**
*
* @author Julian
*/
public class Vista {
public void Vista(){
[Link]("************************************************************************");
[Link]("* *");
[Link]("* UNIVERSIDAD FRANCISCO JOSE DE CALDAS
*");
[Link]("* PROGRAMA CURRICULAR: INGENIERIA ELECTRONICA
*");
[Link]("* CABINAS DE TELEFONOS *");
[Link]("* Julian Santiago Moreno Cucaita *");
[Link]("*************************************************************************");
}
public void Menu(){
[Link]("*************************************************************************");
[Link]("MENU CABINA DE TELEFONOS: ");
Ejemplo Programación Orientado a Objetos por JCT
[Link]("1. Registrar una llamada");
[Link]("2. Información de una línea");
[Link]("3. Información de todas las lineas");
[Link]("4. Reiniciar líneas telefonicas");
[Link]("5. Finalizar ejecucion");
[Link]("*************************************************************************");
CLase calluwu
//* @author Julian
package JULIAN;
public class Calluwu {
int DURATION;
double VALOR;
public Calluwu(int duracion, double tarifa) {
[Link] = duracion;
VALOR = duracion * tarifa;
}
public int getDURATION() {
return DURATION;
}
public double getVALOR() {
return VALOR;
}
//Clase LINE
package JULIAN;
import [Link];
import [Link];
public class LINE {
private ArrayList<Lineap> lineas = new ArrayList<Lineap>();
public Lineap getLinea(int index) {
Lineap linea = [Link](index);
Ejemplo Programación Orientado a Objetos por JCT
return linea;
}
public LINE() {
for(int i = 0; i < 3; i++) {
[Link](new Lineap());
}
}
public double[] REGISTROTOTAL() {
Iterator<Lineap> current = [Link]();
double[] rgs = {0, 0, 0, 0};
double[] REGUISTROC;
while([Link]()) {
REGUISTROC = [Link]().REGISTRO1();
rgs[0] = rgs[0] + REGUISTROC[0];
rgs[1] = rgs[1] + REGUISTROC[1];
rgs[2] = rgs[2] + REGUISTROC[2];
}
if(rgs[0]!=0) {
rgs[3] = rgs[2]/rgs[1];
}
return rgs;
}
public void REINICIO2() {
Iterator<Lineap> current = [Link]();
while([Link]()) {
[Link]().REINICIOP();
}
}
}}//fin de la clase
Clase lineap/
//* @author Julian
package JULIAN;
import [Link];
import [Link];
public class Lineap {
private ArrayList <Calluwu> llamadas;
public Lineap () {
llamadas = new ArrayList<Calluwu>();
}
public double[] REGISTRO1() {
double[] RGT = {0, 0, 0};
Ejemplo Programación Orientado a Objetos por JCT
if(![Link]()) {
RGT[0] = [Link]();
RGT[1] = DURATIONLLAMA();
RGT[2] = COSTOLLAMA();
}
return RGT;
}
public void ANEXAR(int duracion, double tarifa) {
Calluwu llamada = new Calluwu(duracion, tarifa);
[Link](llamada);
}
private int DURATIONLLAMA() {
Iterator<Calluwu> current = [Link]();
int DURATION = 0;
while([Link]()) {
DURATION = DURATION + [Link]().getDURATION();
}
return DURATION;
}
public void REINICIOP() {
llamadas = new ArrayList<Calluwu>();
}
private double COSTOLLAMA() {
Iterator<Calluwu> current = [Link]();
double valoruwu = 0;
while([Link]()) {
valoruwu = valoruwu + [Link]().getVALOR();
}
return valoruwu;
}
//* @author Julian
package EJECU;
import [Link];
import [Link];
import [Link];
import [Link];
Ejemplo Programación Orientado a Objetos por JCT
public class Menu {
Scanner input = new Scanner([Link]);
public void AÑADIR(LINE lineas) {
int CANAL = SCANAL();
int Duration=0,Tiposs=4;
double Fijo=0;
if(CANAL!=-1) {
Lineap linea = [Link](CANAL);
Duration = (int) ([Link]()*6 + 1) ;
do {
[Link]();
[Link]("Seleccione el tipo de llamada:");
[Link]("1. Llamada local");
[Link]("2. Llamada larga distancia");
[Link]("3. Llamada celular");
try {
Tiposs = [Link]();
} catch(InputMismatchException e) {
[Link]("Intente por favor ingresar
de nuevo el numero");
input=new Scanner([Link]);
continue;
}
switch(Tiposs) {
case 1:
Fijo = 0.5;
break;
case 2:
Fijo = 1;
break;
case 3:
Fijo = 2;
break;
default:
[Link]("Opcion errada, intente de
nuevo");
break;
}
} while(Tiposs>3);
[Link](Duration, Fijo);
Ejemplo Programación Orientado a Objetos por JCT
[Link]("Llamada añadida, correctamente c:");
[Link]();
Julian();
}
private int SCANAL() {
int LINEA=4;
do {
[Link]("Seleccione el canal o linea a usar:");
[Link]("1. CANAL PRINCIPAL");
[Link]("2. CANAL SEGUNDARIO");
[Link]("3. CANAL TERCIARIO");
try {
[Link]();
[Link]("Para seleccionar la linea ingres
un numero dentro del rango (1-3)");
LINEA = [Link]()-1;
} catch(InputMismatchException e) {
[Link]("Numero errado, intente de
nuevo");
input=new Scanner([Link]);
continue;
}
}while(LINEA>2);
return LINEA;
}
public void getRINDI(LINE lineas) {
int INDICEEE = SCANAL();
if(INDICEEE!=-1) {
Lineap x = [Link](INDICEEE);
double[] REGIS = x.REGISTRO1();
[Link]();
[Link]("INDICE INDIVIDUAL:");
[Link]("Información de la linea "+
(INDICEEE+1));
[Link]("Numero de llamadas: %.0f
%n",REGIS[0]);
[Link]("Duración total: %.0f%n",REGIS[1]);
[Link]("Costo total: %.2f%n",REGIS[2]);
}
Ejemplo Programación Orientado a Objetos por JCT
[Link]();
Julian();
public void getRTOTAL(LINE lineas) {
double[] REGIS = [Link]();
[Link]();
[Link]("CONSOLIDACIÓN:");
[Link]("Numero de llamadas: %.0f%n",REGIS[0]);
[Link]("Duración total: %.0f%n",REGIS[1]);
[Link]("Costo total: %.0f%n",REGIS[2]);
[Link]("Costo promedio por minuto: %.2f
%n",REGIS[3]);
Julian();
private void Julian() {
[Link]();
[Link]("Presione cualquier tecla para regresar al
Menu");
[Link]();
}
}
Ejemplo Programación Orientado a Objetos por JCT
4. Testeo