═════════════════════

Programación Orientada a Objetos

LABORATORIO DE PROGRAMACIÓN JAVA
═════════════════════

Mg. PABLO EDWIN LÓPEZ VILLANUEVA

 Aspectos Básicos de Java

EJERCICIO
Ejemplo básico en JAVA usando println

​ ​ ​ ​
​ ​ ​ ​
EJERCICIO
Operaciones básicas Suma y Resta

​ ​ ​ ​
​ ​ ​ ​
EJERCICIO
Operaciones aritméticas fundamentales

​ ​ ​ ​
EJERCICIO
Operaciones aritméticas fundamentales

​ ​ ​ ​
EJERCICIO
Generacion de Numeros Aleatorios

​ ​ ​ ​
EJERCICIO

​ ​ ​ ​
SINTAXIS JAVA
Los 5 bucles hacen lo mismo

public class Demo {

public static void main(String args[]) {

int i;
​
for(int i=1;i<=10;i++) {
​ [Link](i);
​ }
​ [Link]("-----------------------");

​ i=1;
​ while(i<=10) {
​ [Link](i);
​ i++;
​ }
​ [Link]("-----------------------");

​ i=0;
​ while(i<10) {
​ i++;
​ [Link](i);
​ }
​ [Link]("-----------------------");
​
i=0;
​ do {
​ i++;
​ [Link](i);
​ } while(i<10);
​ [Link]("-----------------------");

i=1;
​ do {
​ [Link](i);
​ i++;
​ } while(i<=10);
​ [Link]("-----------------------");

}
}

​ ​ ​ ​
public class Demo {

public static void Bucles(int N) {

int i;

for(int i=1;i<=N;i++) {
​ [Link](i);
​ }
​ [Link]("-----------------------");

​ i=1;
​ while(i<=N) {
​ [Link](i);
​ i++;
​ }
​ [Link]("-----------------------");

​ i=0;
​ while(i<N) {
​ i++;
​ [Link](i);
​ }
​ [Link]("-----------------------");
​
i=0;
​ do {
​ i++;
​ [Link](i);
​ } while(i<N);
​ [Link]("-----------------------");

i=1;
​ do {
​ [Link](i);
​ i++;
​ } while(i<=N);
​ [Link]("-----------------------");

public static void main(String args[]) {

​ Bucles(10);
}
}

​ ​ ​ ​
Modo Consola

​ ​ ​ ​
​ ​ ​ ​
​ ​ ​ ​
​ ​ ​ ​
EJERCICIO
Generar una tabla de 20 números aleatorios A y B con
las operaciones básicas Suma, Resta y Producto

​ ​ ​ ​
 Modo Netbeans
Netbeans es un Entorno de Desarrollo Integrado (IDE: Integrated
Development Environment ) para desarrollar aplicaciones en Java

​ ​ ​ ​
​ ​ ​ ​
​ ​ ​ ​
​ ​ ​ ​
​ ​ ​ ​
​ ​ ​ ​
 Lista de Ejercicios
EJERCICIO

Escriba un programa que realize el encriptado y

desencriptado

import [Link].*;
import [Link].*;

public class Encriptacion_Desencriptacion {

//-------------------------------------------------------
//-------------------------------------------------------
public static String fff(String SS, int Mode) {
String CLAVE1 = "
!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~⌂";
String CLAVE2 = "Q_$Ef32ln9AcD/M&yj`x[J#r
Sz)FL0(q!k1w%+m\\,>R6BvYI*VN8K;=eH:4oG@}\"|as^XptCg7'{?]Pd⌂O5T<hW-ZU~bui.";
String TT;
int k,P,L;
char E;
L = [Link]();
TT = "";
for(int i=0;i<=L-1;i++) {
E = [Link](i);
//- - - - - - - - - - - - - - - - -
P = -1;
k = 0;
while((k<=(Mode==1?[Link]():[Link]()))&&(P==-1)) {

​ ​ ​ ​
 if((Mode==1?[Link](k):[Link](k))==E) {
P = k;
}
k++;
}
//- - - - - - - - - - - - - - - - -
if(P>=0) {
TT = TT + (Mode==1?[Link](P):[Link](P));
}
}
return TT;
}
//-------------------------------------------------------
public static void main(String[] args) {
String SS,C1,C2;
SS = "abcd1234";
C1 = fff(SS,1);
C2 = fff(C1,-1);
[Link](SS);
[Link](C1); //Cadena Encriptada
[Link](C2); //Cadena Desencriptada
}
//-------------------------------------------------------
}

EJERCICIO

Escriba un programa que pida 2 números de punto

flotante, y muestre cuál es el mayor (o si son iguales)

SOLUCIÓN

Se va a implementar diferentes versiones que generarán la

misma salida

​ ​ ​ ​
Versión 1

[Link]
import [Link];

public class EJERCICIO1 {

public static void main(String[] args) {

​ float A,B;
​ Scanner OBJ = new Scanner([Link]);
[Link]("Ingrese 1er Numero: ");
A = [Link]();
[Link]("Ingrese 2do Numero: ");
B = [Link]();
​ if(A==B) {
[Link](A + " es igual a " + B);
​ }
​ else {
​ ​ if(A<B) {
[Link](A + " es menor que " + B);
​ ​ }
​ ​ else {
[Link](A + " es mayor que " + B);
​ ​ }
​ }
}
}

Versión 2

[Link]
import [Link];

public class EJERCICIO2 {

public static void main(String[] args) {

​ float A,B;
​ Scanner OBJ = new Scanner([Link]);
[Link]("Ingrese 1er Numero: ");
A = [Link]();
[Link]("Ingrese 2do Numero: ");
B = [Link]();
​ if(A==B) {
[Link](A + " es igual a " + B);
​ }
​ else if(A<B) {
[Link](A + " es menor que " + B);
​ }

​ ​ ​ ​
​ else {
[Link](A + " es mayor que " + B);
​ }
}
}

Versión 3

[Link]
import [Link];

public class EJERCICIO3 {

public static void main(String[] args) {

float A,B;
String Cadena;
​ Scanner OBJ = new Scanner([Link]);
[Link]("Ingrese 1er Numero: ");
A = [Link]();
[Link]("Ingrese 2do Numero: ");
B = [Link]();
Cadena = (A==B?"es Igual a":(A<B?"es Menor que":"es Mayor que"));
[Link](A + " " + Cadena " " + B);
}
}

Versión 4

[Link]
import [Link];

public class EJERCICIO4 {

//---------------------------------------------------
private static float LeerNumeroReal(String Texto) {
Scanner OBJ = new Scanner([Link]);
float X;
[Link](Texto);
X = [Link]();
​ return X;
}
//---------------------------------------------------
private static String ResultadoComparacion(float A, float B) {

​ ​ ​ ​
 String Cadena;
if(A==B) {
Cadena = A + " es igual a " + B;
​ }
​ else if(A<B) {
Cadena = A + " es menor que " + B;
​ }
​ else {
Cadena = A + " es mayor que " + B;
​ }
​ return Cadena;
}
//---------------------------------------------------
public static void main(String[] args) {
​ float A,B;
A = LeerNumeroReal("Ingrese 1er Numero: ");
B = LeerNumeroReal("Ingrese 2do Numero: ");
[Link](ResultadoComparacion(A,B));
}
//---------------------------------------------------
}

Versión 5

Para crear una versión orientada a objetos se debe crear una

clase adicional que contenga la funcionalidad.

[Link]
public class EJERCICIO5 {

public static void main(String[] args) {

​ Clase5 LIB = new Clase5();
​ float A,B;
A = [Link]("Ingrese 1er Numero: ");
B = [Link]("Ingrese 2do Numero: ");
[Link]([Link](A,B));
}
}

​ ​ ​ ​
[Link]
import [Link];

public class Clase5 {

//---------------------------------------------------
// CONSTRUCTOR
//---------------------------------------------------
public Clase5() {
}
//---------------------------------------------------
public float LeerNumeroReal(String Texto) {
​ Scanner OBJ = new Scanner([Link]);
​ float X;
[Link](Texto);
X = [Link]();
​ ​ return X;
​ }
//---------------------------------------------------
public String ResultadoComparacion(float A, float B) {
​ String Cadena;
if(A==B) {
Cadena = A + " es igual a " + B;
​ ​ }
​ ​ else if(A<B) {
Cadena = A + " es menor que " + B;
​ ​ }
​ ​ else {
Cadena = A + " es mayor que " + B;
​ ​ }
​ ​ return Cadena;
}
//---------------------------------------------------
}

Los programas anteriores en todas sus versiones, generan los

mismos resultados.

Se va a utilizar la solución especificada como versión 4, es

decir el programa [Link]

​ ​ ​ ​
EJERCICIO

Dados dos números A y B, determinar si son iguales o

diferentes

SOLUCIÓN

La igualdad o no igualdad de dos valores numéricos

representa claramente una estructura lógica de dos niveles.

​ ​ ​ ​
Versión 1

[Link]
public class EJERCICIO1 {

public static void main(String args[]) {

int N = (int)([Link]()*100);
[Link]("=======================================");
[Link](" VERIFICAR SI UN ENTERO ES PAR O IMPAR ");
[Link]("=======================================");
[Link] ("\n" + N + " ==> ");
if(N%2==0) {
[Link]("PAR");
}
else {
[Link]("IMPAR");
}
} //main

} //class

El bloque if comprendido del código anterior puede

ser reemplazado por el operador condicional ( ? : )
tal como se especifica en el siguiente programa
[Link]
import [Link];

public class EJERCICIO2 {

public static void main(String args[]) {

Scanner SCN = new Scanner([Link]);
int A,B;
[Link]("===================================");
[Link](" COMPARACION DE 2 NUMEROS ENTEROS ");
[Link]("===================================");
[Link]("");
[Link] ("Ingrese Numero A: ");
A = [Link]();
[Link] ("Ingrese Numero B: ");
B = [Link]();
[Link]("");
[Link]("Valores " + (A==B?"Iguales":"Diferentes"));
}

​ ​ ​ ​
}

Ambos programas son equivalentes, ya que

proporcionan la misma salida en pantalla

===================================
COMPARACION DE 2 NUMEROS ENTEROS
===================================

Ingrese Numero A: 25
Ingrese Numero B: 25

Valores Iguales

===================================
COMPARACION DE 2 NUMEROS ENTEROS
===================================

Ingrese Numero A: 78
Ingrese Numero B: 123

Valores Diferentes

La estructura lógica de dos niveles puede

incrementarse a medida que aparecen nuevas
posibilidades de ocurrencia en los resultados.
El siguiente problema amplía a 3 posibilidades los
resultados del problema anterior

EJERCICIO

​ ​ ​ ​
Dados dos números A y B, determinar si A<B o A=B o
A>B

SOLUCIÓN

La solución del problema adopta ahora una estructura lógica

de tres niveles

[Link]
import [Link];

public class Ejercicio1{

public static void main(String args[]) {

Scanner SCN = new Scanner([Link]);
int A,B;
String S;
[Link]("===================================");
[Link](" COMPARACION DE 2 NUMEROS ENTEROS ");
[Link]("===================================");
[Link]("");
[Link] ("Ingrese el valor de A: ");
A = [Link]();
[Link] ("Ingrese el valor de B: ");
B = [Link]();
[Link]();
if(A==B) {
S = "igual a";
}
else {
if(A<B) {
S = "menor que";
}
else {
S = "mayor que";
}
}
[Link](A + " es " + S + " " + B);
}

​ ​ ​ ​
usando la estructura if…else if…else se tiene una nueva
versión modificada

[Link]
import [Link];

public class Ejercicio2 {

public static void main(String args[]) {

Scanner SCN = new Scanner([Link]);
int A,B;
String S;
[Link]("===================================");
[Link](" COMPARACION DE 2 NUMEROS ENTEROS ");
[Link]("===================================");
[Link]("");
[Link] ("Ingrese el valor de A: ");
A = [Link]();
[Link] ("Ingrese el valor de B: ");
B = [Link]();
[Link]();
if(A==B) {
S = "igual a";
}
else if(A<B) {
S = "menor que";
}
else {
S = "mayor que";
}
[Link](A + " es " + S + " " + B);
}

Finalmente, usando el operador condicional se tiene una

nueva versión de la solución del problema

[Link]
import [Link];

public class Ejercicio3 {

public static void main(String args[]) {

Scanner SCN = new Scanner([Link]);

​ ​ ​ ​
 int A,B;
String S;
[Link]("===================================");
[Link](" COMPARACION DE 2 NUMEROS ENTEROS ");
[Link]("===================================");
[Link]("");
[Link] ("Ingrese el valor de A: ");
A = [Link]();
[Link] ("Ingrese el valor de B: ");
B = [Link]();
[Link]();
S = (A==B?"igual a":(A<B?"menor que":"mayor que"));
[Link](A + " es " + S + " " + B);
}

Todos los programas anteriores en sus versiones son

equivalentes, ya que proporcionan la misma salida en pantalla

===================================
COMPARACION DE 2 NUMEROS ENTEROS
===================================

Ingrese el valor de A: 48
Ingrese el valor de B: 120

48 es es menor que 120

===================================
COMPARACION DE 2 NUMEROS ENTEROS
===================================

Ingrese el valor de A: 48
Ingrese el valor de B: 48

48 es es igual a 48

===================================
COMPARACION DE 2 NUMEROS ENTEROS
===================================

​ ​ ​ ​
 Ingrese el valor de A: 120
Ingrese el valor de B: 48

120 es es mayor que 48

EJERCICIO

Obtener los divisores de un número entero positivo y

calcular la suma y el promedio.

Una manera más elemental de la solución del problema es

colocar todo el código en el bloque principal main() y realizar
N iteraciones para la búsqueda de divisores.

​ ​ ​ ​
import [Link];

public class Divisores1 {

public static void main(String args[]) {

int N;
Scanner Keyboard = new Scanner([Link]);
[Link]("DIVISORES DE UN NUMERO");
[Link]("======================");
[Link]("Ingrese un entero positivo: ");
N=[Link]();
for(int k=1;k<=N;k++) {
if((N%k)==0) {
[Link](k);
}
}
} //main
} //class

El código anterior, puede ser escrito de manera equivalente

como

import [Link];

public class Divisores {

//------------------------------------------
public static int LeerNumero() {
Scanner Keyboard = new Scanner([Link]);
int T;
[Link]("DIVISORES DE UN NUMERO");
[Link]("======================");
[Link]("Ingrese un entero positivo: ");
T=[Link]();
return T;
}
//------------------------------------------
public static void CalcularDivisores(int N) {
for(int k=1;k<=N;k++) {
if((N%k)==0) {
[Link](k);
}
}
}
//------------------------------------------
public static void main(String args[]) {

​ ​ ​ ​
 int N;
N =LeerNumero();
CalcularDivisores(N);
}
//------------------------------------------
}

Generando la salida
DIVISORES DE UN NUMERO
======================
Ingrese un entero positivo: 120
1
2
3
4
5
6
8
10
12
15
20
24
30
40
60
120

Para determinar la suma y promedio de los divisores, el

siguiente código es una versión modificada del programa
anterior e incorpora nuevas instrucciones.
import [Link];

public class Divisores {

//------------------------------------------
public static int LeerNumero() {
Scanner Keyboard = new Scanner([Link]);
int T;
[Link]("DIVISORES DE UN NUMERO");
[Link]("======================");
[Link]("Ingrese un entero positivo: ");
T=[Link]();

​ ​ ​ ​
 return T;
}
//------------------------------------------
public static void CalcularDivisores(int N) {
int n;
long S;
double P;
n=0;
S=0;
for(int k=1;k<=N;k++) {
if((N%k)==0) {
n++;
S=S+k;
[Link](k);
}
}
P=1.0*S/n;
[Link]("El Total de Divisores es: " + n);
[Link]("La Suma de Divisores es: " + S);
[Link]("El Promedio es: " + P);
}
//------------------------------------------
public static void main(String args[]) {
int N;
N = LeerNumero();
CalcularDivisores(N);
}
//------------------------------------------
}

DIVISORES DE UN NUMERO
======================
Ingrese un entero positivo: 72
1
2
3
4
6
8
9
12
18
24
36
72
El Total de Divisores es: 12
La Suma de Divisores es: 195
El Promedio es: 16.25

​ ​ ​ ​
Al revisar el código de los 3 programas anteriores, se observa
que adoptan un criterio común en la lógica conducente a la
solución del problema.
La instrucción iterativa
for(int k=1;k<=N;k++) {
establece un recorrido de k: 1,2,3,....,N-2,N-1,N.
Por lo tanto, para un valor muy grande de N, tal como
N=100000000 (cien millones) se realizarán exactamente N
iteraciones incrementando de manera evidente el tiempo de
procesamiento computacional.
Una alternativa para minimizar el costo de procesamiento
sería tomar en consideración que
𝑁
Si k es divisor de N, entonces 𝑘
también es un divisor de N.

Sea 𝑇 = [ 𝑁] el valor entero de la raíz cuadrada de N.

Luego, una solución más óptima del problema consiste en

implementar un recorrido para k desde 1 hasta el valor T que
en Java es expresado mediante (int)[Link](N).
En este caso, para el valor N=100000000 (cien millones),
únicamente se realizarán T=10000 (diez mil) iteraciones,
logrando de este modo un mejor rendimiento.

​ ​ ​ ​
El siguiente programa genera los mismos resultados que las
versiones anteriores; no obstante, representa una solución
más optimizada.

import [Link];

public class Divisores {

//------------------------------------------
public static int LeerNumero() {
Scanner Keyboard = new Scanner([Link]);
int T;
[Link]("DIVISORES DE UN NUMERO");
[Link]("======================");
[Link]("Ingrese un entero positivo: ");
T=[Link]();
return T;
}
//------------------------------------------
public static void CalcularDivisores(int N) {
int n,T;
long S;
double P;
String R1="",R2="";
n = 0;
S = 0;
T = (int)[Link](N);
for(int k=1;k<=T;k++) {
if((N%k)==0) {
n=n+2;
S=S+k+(N/k);
R1 = R1 + k + "\n";
R2 = (N/k) + "\n" + R2;
}
}
P=1.0*S/n;
[Link](R1+R2);
[Link]("El Total de Divisores es: " + n);
[Link]("La Suma de Divisores es: " + S);
[Link]("El Promedio es: " + P);
}
//------------------------------------------
public static void main(String args[]) {
int N;
N = LeerNumero();
CalcularDivisores(N);
}
//------------------------------------------
}

​ ​ ​ ​
EJERCICIO
Dado un entero no negativo, generar el Triángulo
de Pascal.

​ ​ ​ ​
El triángulo de Pascal se forma a partir de los coeficientes de
la potencia del binomio (a+b)n
𝑛
(𝑎 + 𝑏)
los cuales representan una sucesión de n+1 números
combinatorios

{ }𝑛
𝐶𝑘
𝑛 𝑛 𝑛 𝑛
= 𝐶0 , 𝐶1 , 𝐶2 , 𝐶3 , . . . , 𝐶𝑛−2 , 𝐶𝑛−1 , 𝐶𝑛
𝑛 𝑛 𝑛

donde
𝑛 𝑛!
𝐶𝑘 = 𝑘!(𝑛−𝑘)!

Por ejemplo, cuando n=5, los coeficientes son

5 5 5 5 5 5
𝐶0 , 𝐶1 , 𝐶2 , 𝐶3 , 𝐶4 , 𝐶5

1 , 5 , 10 , 10 , 5 , 1
El siguiente programa genera el triángulo de Pascal a partir de
un entero no negativo

import [Link];

public class A {

public static void main(String args[]) {

Scanner SCN = new Scanner([Link]);
int N,C;
double F1,F2,F3;
[Link]("TRIANGULO DE PASCAL\n");
[Link]("===================\n");
[Link]("Ingrese un entero no negativo: ");
N = [Link]();

​ ​ ​ ​
 for(int n=0;n<=N;n++) {
F1 = 1;
for(int i=1;i<=n;i++) {
F1 = F1 * i;
}
for(int k=0;k<=n;k++) {
F2 = 1;
for(int i=1;i<=k;i++) {
F2 = F2 * i;
}
F3 = 1;
for(int i=1;i<=n-k;i++) {
F3 = F3 * i;
}
C = (int)(F1/(F2*F3));
[Link]("%5d",C);
}
[Link]("\n");
}
}//main

} //class

la cual es equivalente a la siguiente versión que está

estructurada en segmentos o módulos funcionales

import [Link];

public class A {
//----------------------------------------------
private static int LeerNumero() {
Scanner SCN = new Scanner([Link]);
int T;
[Link]("TRIANGULO DE PASCAL\n");
[Link]("===================\n");
[Link]("Ingrese un entero no negativo: ");
T = [Link]();
return T;
}
//----------------------------------------------
private static double Factorial(int N) {
double P;
P = 1;
for(int i=1;i<=N;i++) {
P = P * i;
}
return P;

​ ​ ​ ​
 }
//----------------------------------------------
private static void TrianguloPascal(int N) {
int C;
double F;
for(int n=0;n<=N;n++) {
F = Factorial(n);
for(int k=0;k<=n;k++) {
C = (int)(F/(Factorial(k)*Factorial(n-k)));
[Link]("%5d",C);
}
[Link]("\n");
}
}
//----------------------------------------------
// MODULO PRINCIPAL
//----------------------------------------------
public static void main(String args[]) {
int N;
N=LeerNumero();
TrianguloPascal(N);
}
//----------------------------------------------
}

Las dos versiones de programa anteriores son equivalentes.

No obstante, el proceso de obtención del triángulo involucra
el cálculo autónomo e independiente del factorial de los
números n, k y n-k generando procesos repetitivos e
innecesarios. Por ejemplo, si n=100 y k=40 el cálculo de los
factoriales
n = 100! = 1x2x3x4x5x ..... x38x39x40x ..... x58x59x60x ..... x97x98x99x100
k = 40! = 1x2x3x4x5x ..... x38x39x40
n-k = 60! = 1x2x3x4x5x ..... x38x39x40x ..... x58x59x60
genera claramente procesos repetitivos:
Los siguientes programas representan la versión optimizada
para la solución del problema

​ ​ ​ ​
import [Link];

public class A {

public static void main(String args[]) {

Scanner SCN = new Scanner([Link]);
int N,C;
[Link]("TRIANGULO DE PASCAL\n");
[Link]("===================\n");
[Link]("Ingrese un entero no negativo: ");
N = [Link]();
for(int i=0;i<=N;i++) {
C=1;
[Link]("%5d",C);
for(int k=1;k<=i;k++) {
C = C*(i-k+1)/k;
[Link]("%5d",C);
}
[Link]("\n");
}
}//main

} //class

Finalmente, se tiene la versión estructurada en segmentos o

módulos funcionales

import [Link];

public class A {
//----------------------------------------------
private static int LeerNumero() {
Scanner SCN = new Scanner([Link]);
int T;
[Link]("TRIANGULO DE PASCAL\n");
[Link]("===================\n");
[Link]("Ingrese un entero no negativo: ");
T = [Link]();
return T;
}
//----------------------------------------------
private static void TrianguloPascal(int N) {
int C;
for(int i=0;i<=N;i++) {
C=1;
[Link]("%5d",C);
for(int k=1;k<=i;k++) {
C = C*(i-k+1)/k;
[Link]("%5d",C);

​ ​ ​ ​
 }
[Link]("\n");
}
}
//----------------------------------------------
// MODULO PRINCIPAL
//----------------------------------------------
public static void main(String args[]) {
int N;
N=LeerNumero();
TrianguloPascal(N);
}
//----------------------------------------------
}

La ejecución es

TRIANGULO DE PASCAL
===================
Ingrese un entero no negativo: 12
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
1 10 45 120 210 252 210 120 45 10 1
1 11 55 165 330 462 462 330 165 55 11 1
1 12 66 220 495 792 924 792 495 220 66 12 1

EJERCICIO

Escriba un programa que genere el siguiente patrón

basado en un parámetro entero N>0

​ *
​ ​ ​ ​
 ​ * *
​ * * *
​ * * * *
​ * * * * *
* * * * * *
* * * * * * *
* * * * * * * *
* * * * * * * * *
SOLUCIÓN
Se observa que cada línea del triángulo contiene asteriscos separados
por un espacio.

Por tanto, la solución requiere generar un rectángulo de dimensiones

(Altura = N y Base= 2N-1)

En cada k-ésima línea (k=1 … N) se debe escribir/imprimir

(2𝑁−1)−(2𝑘−1)
2
=𝑁−𝐾

espacios en blanco a la izquierda y derecha de cada patrón de

impresión.

​ ​ ​ ​
El k-ésimo patrón de impresión contiene k-1 veces un * y un espacio en
blanco.

Por ejemplo, para k=5

[Link]
public class GeneraTriangulo {

public static void main(String[] args) {

Clase2 LIB = new Clase2();
int N;
N = [Link]("Ingrese un Numero: ");
[Link](N);
}
}

[Link]
import [Link];

public class Clase {

​ ​ ​ ​
 //---------------------------------------------------
public Clase() {
}
//---------------------------------------------------
public int LeerNumeroEntero(String Texto) {
​ Scanner OBJ = new Scanner([Link]);
​ int NUM;
[Link](Texto);
NUM = [Link]();
​ ​ return NUM;
​ }
//---------------------------------------------------
private String Replicate(String S, int T) {
String CAD;
​ ​ CAD = "";
​ ​ for(int i=1;i<=T;i++) {
​ ​ ​ CAD = CAD + S;
​ ​ }
​ ​ return CAD;
​ }
//---------------------------------------------------
public void DibujarTriangulo(int N) {
​ String LINEA;
​ int n;
for(int k=1;k<=N;k++) {
​ ​ ​ //- - - - - - - - - - - - - - - - -
​ ​ ​ LINEA = Replicate(" ",N-k) +
​ ​ ​ ​ Replicate("* ",k-1) + "*" +
​ ​ ​ ​ Replicate(" ",N-k);
​ ​ ​ [Link](LINEA);
​ ​ }
}
//---------------------------------------------------
}

​ ​ ​ ​
EJERCICIO

Escriba un programa que "tabule" la función

y = 1 + x - x2/3

en el rango [-2 , 2].

Pida el intervalo de tabulación y cree una clase que incluya un método

que calcula la función.

[Link]
public class EJERCICIO {

public static void main(String[] args) {

Clase LIB = new Clase();
double A,B,E,X,Y;
[Link]("INTERVALO [A,B]");
A = [Link]("Ingrese A: ");
B = [Link]("Ingrese B: ");
E = [Link]("Ingrese Incremento: ");
[Link]("------------------------------");
[Link]("X\tY");
[Link]("------------------------------");
X = A;

​ ​ ​ ​
 while(X<=B) {
Y = 1 + X - [Link](X,3);
[Link](X + "\t" + Y);
X = X + E;

}
[Link]("------------------------------");
}
}

[Link]
import [Link];

public class Clase {

//---------------------------------------------------
public Clase() {
}
//---------------------------------------------------
public double LeerNumeroReal(String Texto) {
​ Scanner OBJ = new Scanner([Link]);
​ double X;
[Link](Texto);
X = [Link]();
​ ​ return X;
​ }
//---------------------------------------------------
public int LeerNumeroEntero(String Texto) {
​ Scanner OBJ = new Scanner([Link]);
​ int NUM;
[Link](Texto);
NUM = [Link]();
​ ​ return NUM;
​ }
//---------------------------------------------------
private String Replicate(String S, int T) {
String CAD;
​ ​ CAD = "";
​ ​ for(int i=1;i<=T;i++) {
​ ​ ​ CAD = CAD + S;
​ ​ }
​ ​ return CAD;
​ }
//---------------------------------------------------
}

​ ​ ​ ​
​ ​ ​ ​
EJERCICIO

Generar N puntos aleatorios (x,y) en el sistema de coordenadas XY.

Los puntos deben ser aleatorios pertenecientes a un rango o region

determinada según se visualiza en la figura.

Determinar:

-​ La distancia de cada punto (x,y) generado al origen (0,0)

-​ El total de puntos por cuadrante

[Link]
public class PROGRAMA {

private static CLASE OBJ = new CLASE();

//---------------------------------------------
public static void main(String[] args) {
int X[];
int Y[];

​ ​ ​ ​
double DISTANCIA[];
int N,A,B,C,D;
[Link]("Puntos Aleatorios (x,y) en el Plano XY");
[Link]("--------------------------------");
[Link]("PUNTOS ALEATORIOS");
N = [Link](" - Ingrese Cantidad a Generar: ");
[Link]("EJE HORIZONTAL X DE ABSCISAS");
A = [Link](" - Ingrese Limite Inferior : ");
B = [Link](" - Ingrese Limite Superior : ");
[Link]("EJE VERTICAL Y DE ORDENADAS");
C = [Link](" - Ingrese Limite Inferior : ");
D = [Link](" - Ingrese Limite Superior : ");
[Link]();
X = [Link](N,A,B);
Y = [Link](N,C,D);
[Link](X,Y);
[Link](X,Y);
}
//---------------------------------------------
}

[Link]
import [Link];

public class CLASE {

//---------------------------------------------
public CLASE() {
}
//---------------------------------------------
public static int[] GenerarPuntos(int N, int MIN, int MAX) {
int[] V = new int[N];
for(int i=0;i<=N-1;i++) {
V[i] = MIN + (int)([Link]()*(MAX-MIN+1));
}
return V;
}
//---------------------------------------------
public static void DistanciasAlOrigen(int[] X, int[] Y) {
int N;
double SUM,DIST;
N = [Link];
[Link]("DISTANCIAS HACIA EL ORIGEN (0,0)");
[Link]("-----------------------------------------");
[Link]("Nro\tX\tY\tDISTANCIA");
[Link]("-----------------------------------------");
SUM = 0;
for(int i=0;i<=N-1;i++) {
DIST = [Link]([Link](X[i],2) + [Link](Y[i],2));
SUM = SUM + DIST;

​ ​ ​ ​
 [Link]( (i+1) + "\t" + X[i] + "\t" + Y[i] + "\t" +
DIST);
}
[Link]("-----------------------------------------");
[Link]("La Distncia Promedio es: " + SUM/N);
}
//---------------------------------------------
public static void DistribucionPorCuadrantes(int[] X, int[] Y) {
int N,n1,n2,n3,n4;
N = [Link];
n1 = 0;
n2 = 0;
n3 = 0;
n4 = 0;
for(int i=0;i<=N-1;i++) {
if(Y[i]>0) {
if(X[i]>0) {
n1 = n1 + 1;
}
else {
n2 = n2 + 1;
}
}
else {
if(X[i]>0) {
n4 = n4 + 1;
}
else {
n3 = n3 + 1;
}
}
}
[Link]();
[Link]("DISTRIBUCION DE PUNTOS");
[Link]("----------------------");
[Link](" CUADRANTE TOTAL ");
[Link]("----------------------");
[Link](" 1 " + n1);
[Link](" 2 " + n2);
[Link](" 3 " + n3);
[Link](" 4 " + n4);
[Link]("----------------------");
}
//---------------------------------------------
public int ReadInteger(String Texto) {
Scanner OBJ = new Scanner([Link]);
int N;
[Link](Texto);
N = [Link]();
return N;
}
//---------------------------------------------
}

​ ​ ​ ​
​ ​ ​ ​
​ ​ ​ ​
EJERCICIO

Generar N números aleatorios y luego determinar Minimo, Maximo,

Media, Mediana, Varianza, Moda.

[Link]
public class Global {
public static int N=100;
public static int A=0;
public static int B=9;
public static int X[];
//---------------------------------------------
public Global() {
}
//---------------------------------------------
}

[Link]
import [Link];
import [Link];

public class Herramientas {

//private Global GLB = new Global();
//---------------------------------------------
public Herramientas() {
}
//------------------------------------------------------------------
public void LecturaParametros() {
Scanner OBJ = new Scanner([Link]);
[Link]("=============================");
[Link]("MUESTRA DE NUMEROS ALEATORIOS");
[Link]("=============================");
[Link] ("Cantidad de Elementos: ");
Global.N = [Link]();
Global.X = new int[Global.N];
[Link] ("Limite Inferior: ");
Global.A = [Link]();
[Link] ("Limite Superior: ");

​ ​ ​ ​
 Global.B = [Link]();
}
//------------------------------------------------------------------
public void ImprimirDatos() {
for(int i=0;i<=Global.N-1;i++) {
[Link](Global.X[i] + "\t");
}
[Link]("\n");
}
//------------------------------------------------------------------
public void CargarDatos() {
for(int i=0;i<=Global.N-1;i++) {
Global.X[i] = Global.A +
(int)([Link]()*(Global.B-Global.A+1));
}

}
//------------------------------------------------------------------
}

[Link]
public class Estadistica {
//---------------------------------------------
public Estadistica() {
}
//---------------------------------------------
public int Minimo() {
int MIN;
MIN = Global.X[0];
for(int i=0;i<=Global.N-1;i++) {
if(Global.X[i]<MIN) {
MIN = Global.X[i];
}
}
return MIN;
}
//---------------------------------------------
public int Maximo() {
int MAX;
MAX = Global.X[0];
for(int i=0;i<=Global.N-1;i++) {
if(MAX<Global.X[i]) {
MAX = Global.X[i];
}
}
return MAX;
}
//---------------------------------------------
public double Media() {

​ ​ ​ ​
 double SUM;
SUM = 0;
for(int i=0;i<=Global.N-1;i++) {
SUM = SUM + Global.X[i];
}
return SUM/Global.N;
}
//---------------------------------------------
public double Varianza() {
double SUM,MEDIA;
MEDIA = Media();
SUM = 0;
for(int i=0;i<=Global.N-1;i++) {
SUM = SUM + [Link](Global.X[i]-MEDIA,2);
}
return SUM/Global.N;
}
//---------------------------------------------
public void Ordenar() {
int TMP;
for(int k=1;k<=Global.N-1;k++) {
for(int i=0;i<=Global.N-k-1;i++) {
if(Global.X[i]>Global.X[i+1]) {
TMP = Global.X[i];
Global.X[i] = Global.X[i+1];
Global.X[i+1] = TMP;
}
}
}
}
//---------------------------------------------
public int Mediana() {
int MEDIANA;
Ordenar();
if(Global.N%2==0) {
MEDIANA = (Global.X[(Global.N/2)-1] + Global.X[Global.N/2])/2;
}
else {
MEDIANA = Global.X[(Global.N-1)/2];
}
return MEDIANA;
}
//---------------------------------------------
}

[Link]
public class MuestraAleatoria {
//---------------------------------------------
public static void main(String[] args) {
Global GLB = new Global();
Herramientas TLS = new Herramientas();
Estadistica EST = new Estadistica();

​ ​ ​ ​
 [Link]();
[Link]();
[Link]();
[Link]("El Minimo es : " + [Link]());
[Link]("El Maximo es : " + [Link]());
[Link]("La Media es : " + [Link]());
[Link]("La Varianza es : " + [Link]());
[Link]("La Mediana es : " + [Link]());
[Link]("\n");
}
//---------------------------------------------
}

​ ​ ​ ​
EJERCICIO
Dado un conjunto de datos de N elementos aleatorios [Link],
elaborar un programa orientado a objetos que determine la frecuencia
máxima y mínima de elementos, agrupe los elementos en cuartiles
C1,C2,C3,C4 y determine los promedios correspondientes U1,U2,U3,U4.

VERSIÓN 1 - NO ORIENTADO A OBJETOS

import [Link];

public class Prueba_TMuestra {

//============================================
public static int N;
public static int n;
public static int V[];
public static int R[];
public static int ITEM[];
public static int FREQ[];

//============================================
public static void PrintVector() {
[Link]("ELEMENTOS DE LA MUESTRA");

​ ​ ​ ​
[Link]("-------------------------------------------------------
----------");
for(int k=0;k<=N-1;k++) {
[Link](V[k] + " ");
}
[Link]();

[Link]("-------------------------------------------------------
----------");
}
//============================================
public static void PrintFrecuencias() {
[Link]();
[Link]("FRECUENCIA DE ELEMENTOS");
[Link]("-----------------------");
[Link](" ITEM\t\tFREQ");
[Link]("-----------------------");
for(int k=0;k<=n-1;k++) {
[Link](" " + ITEM[k] + "\t\t" + FREQ[k]);
}
[Link]("-----------------------");
int PosMin = FrecuenciaMinima();
int PosMax = FrecuenciaMaxima();
[Link]("Frecuencia Minima:");
[Link](" ITEM: " + ITEM[PosMin]);
[Link](" FREQ: " + FREQ[PosMin]);
[Link]("Frecuencia Maxima:");
[Link](" ITEM: " + ITEM[PosMax]);
[Link](" FREQ: " + FREQ[PosMax]);
}
//============================================
public static void PrintCuartil(String TITLE, int A, int B) {
double M;
int T;
T = B-A+1;
M = 0;
[Link](TITLE);
[Link]("------------");
for(int k=A;k<=B; k++) {
[Link](V[k] + " ");
M = M + V[k]/T;
}
[Link]();
[Link]("Promedio: " + M);
[Link]();
}
//============================================
public static void GenerarCuartiles() {
int P1,P2,P3;
P1 = (int)(N/4)-1;
P2 = (int)(N/2)-1;
P3 = (int)(3*N/4)-1;
[Link]();
[Link]("CUARTILES DE LA MUESTRA");
PrintCuartil("CUARTIL 1",0,P1);
PrintCuartil("CUARTIL 2",P1+1,P2);

​ ​ ​ ​
 PrintCuartil("CUARTIL 3",P2+1,P3);
PrintCuartil("CUARTIL 4",P3+1,N-1);
}
//============================================
public static void SortVector() {
int TMP;
for(int k=1;k<=N-1;k++) {
for(int i=0;i<=N-k-1;i++) {
if(V[i]>V[i+1]) {
TMP = V[i];
V[i] = V[i+1];
V[i+1] = TMP;
}
}
}
}
//============================================
public static void LoadVector() {
int A,B;
Scanner TECLADO = new Scanner([Link]);
[Link]();
[Link]("LECTURA DE DATOS");
[Link](" - Cantidad de Datos: ");
N = [Link]();
[Link](" - Limite Inferior : ");
A = [Link]();
[Link](" - Limite Superior : ");
B = [Link]();
[Link]();
V = new int[N];
R = new int[N];
ITEM = new int[N];
FREQ = new int[N];
for(int k=0;k<=N-1;k++) {
V[k] = A + (int)([Link]()*(B-A+1));
R[k] = 0;
}
}
//============================================
public static int FrecuenciaMinima() {
int P;
P = 0;
for(int k=0;k<=n-1;k++) {
if(FREQ[k]<FREQ[P]) {
P = k;
}
}
return P;
}
//============================================
public static int FrecuenciaMaxima() {
int P;
P = 0;
for(int k=0;k<=n-1;k++) {
if(FREQ[P]<FREQ[k]) {
P = k;
}

​ ​ ​ ​
 }
return P;
}
//============================================
public static void CalcularFrecuencias() {
int C;
n = -1;
for(int k=0;k<=N-1;k++) {
if(R[k]==0) {
n++;
ITEM[n] = V[k];
C = 0;
for(int i=k;i<=N-1;i++) {
if((R[i]==0)&&(V[i]==V[k])) {
R[i] = 1;
C++;
}
}
FREQ[n] = C;
}
}
n++;
}
//============================================
public static void main(String args[]) {
LoadVector();
PrintVector();
CalcularFrecuencias();
PrintFrecuencias();
SortVector();
GenerarCuartiles();
}
//============================================
}

VERSION 2 - ORIENTADO A OBJETOS

import [Link];

public class Prueba_TMuestra {

//--------------------------------------------
public static int V[];
public static int R[];
public static int ITEM[];
public static int FREQ[];
//--------------------------------------------
public static void main(String args[]) {
TLib LIB = new TLib();
int A,B,N,n;
Scanner TECLADO = new Scanner([Link]);

​ ​ ​ ​
 [Link]();
[Link]("LECTURA DE DATOS");
[Link](" - Cantidad de Datos: ");
N = [Link]();
[Link](" - Limite Inferior : ");
A = [Link]();
[Link](" - Limite Superior : ");
B = [Link]();
[Link]();
V = new int[N];
R = new int[N];
ITEM = new int[N];
FREQ = new int[N];
[Link](V,R,ITEM,FREQ,N,A,B);
[Link](V);
n = [Link](V,R,ITEM,FREQ);
[Link](ITEM,FREQ,n);
[Link](V);
[Link](V);
}
//--------------------------------------------
}

class TLib {
//--------------------------------------------
public TLib() {
}
//--------------------------------------------
public void PrintVector(int V[]) {
int N = [Link];
[Link]("ELEMENTOS DE LA MUESTRA");

[Link]("-------------------------------------------------------
----------");
for(int k=0;k<=N-1;k++) {
[Link](V[k] + " ");
}
[Link]();

[Link]("-------------------------------------------------------
----------");
}
//--------------------------------------------
public void PrintFrecuencias(int[] ITEM, int[] FREQ, int n) {
[Link]();
[Link]("FRECUENCIA DE ELEMENTOS");
[Link]("-----------------------");
[Link](" ITEM\t\tFREQ");
[Link]("-----------------------");
for(int k=0;k<=n-1;k++) {
[Link](" " + ITEM[k] + "\t\t" + FREQ[k]);
}
[Link]("-----------------------");
int PosMin = FrecuenciaMinima(FREQ,n);
int PosMax = FrecuenciaMaxima(FREQ,n);

​ ​ ​ ​
 [Link]("Frecuencia Minima:");
[Link](" ITEM: " + ITEM[PosMin]);
[Link](" FREQ: " + FREQ[PosMin]);
[Link]("Frecuencia Maxima:");
[Link](" ITEM: " + ITEM[PosMax]);
[Link](" FREQ: " + FREQ[PosMax]);
}
//--------------------------------------------
public void PrintCuartil(int V[], String TITLE, int A, int B) {
double M;
int T;
T = B-A+1;
M = 0;
[Link](TITLE);
[Link]("------------");
for(int k=A;k<=B; k++) {
[Link](V[k] + " ");
M = M + V[k]/T;
}
[Link]();
[Link]("Promedio: " + M);
[Link]();
}
//--------------------------------------------
public void GenerarCuartiles(int V[]) {
int P1,P2,P3;
int N = [Link];
P1 = (int)(N/4)-1;
P2 = (int)(N/2)-1;
P3 = (int)(3*N/4)-1;
[Link]();
[Link]("CUARTILES DE LA MUESTRA");
PrintCuartil(V,"CUARTIL 1",0,P1);
PrintCuartil(V,"CUARTIL 2",P1+1,P2);
PrintCuartil(V,"CUARTIL 3",P2+1,P3);
PrintCuartil(V,"CUARTIL 4",P3+1,N-1);
}
//--------------------------------------------
public void SortVector(int V[]) {
int TMP;
int N = [Link];
for(int k=1;k<=N-1;k++) {
for(int i=0;i<=N-k-1;i++) {
if(V[i]>V[i+1]) {
TMP = V[i];
V[i] = V[i+1];
V[i+1] = TMP;
}
}
}
}
//--------------------------------------------
public void LoadVector(int[] V, int[] R, int[] ITEM, int[] FREQ, int N, int
A, int B) {
for(int k=0;k<=N-1;k++) {
V[k] = A + (int)([Link]()*(B-A+1));
R[k] = 0;

​ ​ ​ ​
 }
//return V;
}
//--------------------------------------------
public int FrecuenciaMinima(int FREQ[], int n) {
int P;
P = 0;
for(int k=0;k<=n-1;k++) {
if(FREQ[k]<FREQ[P]) {
P = k;
}
}
return P;
}
//--------------------------------------------
public int FrecuenciaMaxima(int FREQ[], int n) {
int P;
P = 0;
for(int k=0;k<=n-1;k++) {
if(FREQ[P]<FREQ[k]) {
P = k;
}
}
return P;
}
//--------------------------------------------
public int CalcularFrecuencias(int[] V, int[] R, int[] ITEM, int[] FREQ) {
int C,n,N = [Link];
n = -1;
for(int k=0;k<=N-1;k++) {
if(R[k]==0) {
n++;
ITEM[n] = V[k];
C = 0;
for(int i=k;i<=N-1;i++) {
if((R[i]==0)&&(V[i]==V[k])) {
R[i] = 1;
C++;
}
}
FREQ[n] = C;
}
}
return n+1;
}
//--------------------------------------------
}

​ ​ ​ ​
​ ​ ​ ​
​ ​ ​ ​
EJERCICIO

Escriba un programa que valide una fecha en el

formato DD/MM/YYYY

Test_Fecha.java
import [Link];

public class Test_Fecha {

private static Lib_Fecha OBJ = new Lib_Fecha();

//---------------------------------------------
public static void main(String[] args) {
String FECHA;
[Link]("--------------------------------");
[Link]("VALIDACION DE FECHAS: DD/MM/AAAA");
[Link]("--------------------------------");
FECHA = [Link]("Ingrese Fecha: ");

​ ​ ​ ​
 if([Link](FECHA,2000,2024)) {
​ [Link]("La Fecha es Correcta");
​ [Link](null,"La Fecha es Correcta");
}
}
//---------------------------------------------
}

Lib_Fecha.java
import [Link];

public class Lib_Fecha {

//---------------------------------------------
public Lib_Fecha() {
}
//---------------------------------------------
public int PosicionIzquierda(String CADENA, char E) {
int i,P,L;
L = [Link]();
P = -1;
i = 0;
while((i<=L-1)&&(P==-1)) {
if([Link](i)==E) {
P = i;
}
i++;
}
return P;
}
//---------------------------------------------
public int TotalOcurrencias(String CADENA, char E) {
int C,L;
L = [Link]();
C = 0;
for(int i=0;i<=L-1;i++) {
if([Link](i)==E) {
C = C + 1;
}
}
return C;
}
//---------------------------------------------
public boolean EsNumerico(String CADENA) {
int i,L;
char E;
boolean Sw;
L = [Link]();
Sw = true;
i = 0;
while((i<=L-1)&&(Sw==true)) {
E = [Link](i);
if((E<'0')||('9'<E)) {
Sw = false;
}
i++;
}
return Sw;
}
//---------------------------------------------
public boolean FechaOK(String FECHA, int MinYear, int MaxYear) {
boolean Sw;
String DD,MM,YYYY;

​ ​ ​ ​
int P,T,L,YEAR,MONTH,DAY,TOTAL=0;
L = [Link]();
Sw = false;
if((8<=L)&&(L<=10)) {
T = TotalOcurrencias(FECHA,'/');
P = PosicionIzquierda(FECHA,'/');
if((T==2)&&(0<P)&&(P<L-6)&&([Link](L-5)=='/')) {
DD = [Link](0,P);
MM = [Link](P+1,L-5);
YYYY = [Link](L-4,L);
if((EsNumerico(DD)==true)&&
(EsNumerico(MM)==true)&&
(EsNumerico(YYYY)==true)) {
YEAR = [Link](YYYY);
if((MinYear<=YEAR)&&(YEAR<=MaxYear)) {
MONTH = [Link](MM);
if((1<=MONTH)&&(MONTH<=12)) {
DAY = [Link](DD);
if((MONTH==1)||(MONTH==3)||(MONTH==5)||(MONTH==7)||(MONTH==8)||(MONTH==10)||(MONTH==12)) {
TOTAL = 31;
}
else {
if((MONTH==4)||(MONTH==6)||(MONTH==9)||(MONTH==11)) {
TOTAL = 30;
}
else {
TOTAL =(((YEAR%4==0)&&(YEAR%100!=0))||((YEAR%400==0)&&(YEAR%100==0))?29:28);
}
}
Sw = ((1<=DAY)&&(DAY<=TOTAL));
if(!Sw) {
[Link]("ERROR: El Dia es Incorrecto!!!");
}
}
else {
[Link]("ERROR: El Mes es Incorrecto!!!");
}
}
else {
[Link]("ERROR: El Año es Incorrecto!!!");
}
}
else {
[Link]("ERROR: Existen Caracteres No Numericos");
}
}
else {
[Link]("ERROR: Los Delimitadores de Fecha son incorrectos!!!");
}
}
else {
[Link]("ERROR: Longitud/Tamaño de Fecha es Incorrecta!!!");
}
return Sw;
}
//---------------------------------------------
public String ReadString(String Texto) {
Scanner OBJ = new Scanner([Link]);
String CAD;
[Link](Texto);
CAD = [Link]();
return CAD;
}
//---------------------------------------------
}

​ ​ ​ ​
​ ​ ​ ​
​ ​ ​ ​
​ ​ ​ ​
■■■■■■■■■■■■■■■■■■■■■■■■■
■■■■■■■■■■■■■■■■■■■■■■■■■
■■■■■■■■■■■■■■■■■■■■■■■■■
■■■■■■■■■■■■■■■■■■■■■■■■■

1.​ Realizar un POO Java para determinar el monto total que

corresponde a cada compañía según los archivos de datos citados a
continuación:

[Link] [Link]

01 Compañía ABC 01 4778.70

02 Inversiones XYZ 01 690.20
03 Manufacturas Alfa 01 8095.50
04 Inka Soft 02 9910.10
05 Ferreteria Beta 02 7770.60
02 8050.60
02 3225.60
02 148.30
03 1410.60
03 75.10
04 6178.50
04 8190.70
04 7365.50
05 780.20
05 8230.20

La salida requerida es:

--------------------------------------
Empresa Monto Total
--------------------------------------
Compañía ABC 13,564.40
Inversiones XYZ 29,105.20
Manufacturas Alfa 1,485.70
Inka Soft 21,734.70
Ferreteria Beta 9,010.40
--------------------------------------

​ ​ ​ ​
 Total General 74,900.40

SOLUCIÓN

Los siguientes módulos (archivos) JAVA

[Link]
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class MontoPorEmpresa {

private static TLib LIB = new TLib();
//-----------------------------------------------
public static void ProcesarArchivo() {
double MontoTotal,Importe,Valor;
String CAD, LINE1="",LINE2="", Id="", RazonSocial="";
DecimalFormat DF = new DecimalFormat("###,###.00");
try {
[Link]("--------------------------------------");
[Link](" Empresa Monto Total ");
[Link]("--------------------------------------");
MontoTotal = 0;
File FILE1 = new File("[Link]");
BufferedReader BR1 = new BufferedReader(new FileReader(FILE1));
while ((LINE1 = [Link]()) != null) {
//-----------------------------------
File FILE2 = new File("[Link]");
BufferedReader BR2 = new BufferedReader(new FileReader(FILE2));
Id = [Link](0,2);
RazonSocial = [Link](3,[Link]());
Importe = 0;
while((LINE2 = [Link]()) != null) {
if([Link](0,2).equals(Id)) {
Valor = [Link]([Link](3,10));
Importe = Importe + Valor;
}
}
[Link]();
MontoTotal = MontoTotal + Importe;
CAD = [Link]([Link](Importe));
[Link](' ' + RazonSocial +
[Link](' ',[Link]()) + '
' +
[Link](' ',[Link]()) + CAD );
}
[Link]();
[Link]("--------------------------------------");
CAD = [Link]([Link](MontoTotal));
[Link](" Total General " +
[Link](' ',[Link]()) +
CAD );

​ ​ ​ ​
 }
catch(IOException e) {
}
}
//------------------------------------------------
public static void main(String[] args) throws IOException, InterruptedException {
[Link]();
ProcesarArchivo();
}
//------------------------------------------------
}

[Link]
import [Link];

public class TLib {

//-----------------------------------------------
public TLib() {
}
//-----------------------------------------------
public void ClearScreen() throws IOException, InterruptedException {
new ProcessBuilder("cmd","/c","cls").inheritIO().start().waitFor();
}
//-----------------------------------------------
public String Replicate(char E, int N) {
String CAD;
CAD = "";
for(int i=1;i<=N;i++) {
CAD = CAD + E;
}
return CAD;
}
//-----------------------------------------------
} //class

generan la siguiente salida en pantalla

​ ​ ​ ​
 2.​ Dado el siguiente archivo de datos

[Link] [Link]

Juan Torres 64,350.50 1 1 Soles

Rosa Perez 7,050.40 3 2 Dólares
Pedro Fernandez 98,440.30 2 3 Euros
Juan Romero 34,250.80 3 4 Reales
Luis Medina 9,650.10 4
Maria Palomino 67,420.30 1
Ana González 7,050.40 2

Realizar un POO Java con controles SWING que genere un comprobante

por cada cliente. Por ejemplo

-------------------------------------------------------
COMPROBANTE DE PAGO
-------------------------------------------------------
CLIENTE: Pedro Fernandez
MONTO: 98,440.30 (Noventa y ocho mil Cuatrocientos
cuarenta y 30/100)
MONEDA : Dólares
-------------------------------------------------------

​ ​ ​ ​
SOLUCIÓN

Los siguientes módulos (archivos) JAVA

[Link]
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class ComprobantePago {

private static TLib LIB = new TLib();

private static int T = 10;
private static String[][] MONEDA = new String[T][2];
//------------------------------------------------
public static void LeerMonedas() {
String LINE="";
int k;
for(int i=0;i<=T-1;i++) {
MONEDA[i][0] = [Link](i);
MONEDA[i][1] = "";
}
try {
File FILE = new File("[Link]");
BufferedReader BR = new BufferedReader(new FileReader(FILE));
while ((LINE = [Link]()) != null) {
k = (int)[Link](0) - 48;
MONEDA[k][0] = [Link]([Link](0));
MONEDA[k][1] = [Link](2,[Link]());
}
[Link]();
}
catch(IOException e) {
}
}
//------------------------------------------------
public static void GenerarComprobante() {
DecimalFormat DF = new DecimalFormat("###,###.00");
String LINE="", Cliente="", CAD;
double Importe;
char IdMoneda;
int n;
try {
n = 0;
File FILE = new File("[Link]");
BufferedReader BR = new BufferedReader(new FileReader(FILE));
while((LINE = [Link]()) != null) {
n++;

[Link]("-------------------------------------------------------");
[Link](" COMPROBANTE DE PAGO - Nro. " + n);

​ ​ ​ ​
[Link]("-------------------------------------------------------");
Cliente = [Link](0,20);
Importe = [Link]([Link](21,30));
IdMoneda = [Link](30);
CAD = [Link]([Link](Importe));
[Link](" CLIENTE: " + Cliente);
[Link](" MONTO: " + CAD + " " +
"(" + [Link](Importe) + ")"
);
[Link](" MONEDA: " + MONEDA[(int)(IdMoneda)-48][1]
);

[Link]("-------------------------------------------------------");
[Link]();
}
[Link]();
}
catch(IOException e) {
}
}
//------------------------------------------------
public static void main(String[] args) throws IOException,
InterruptedException {
[Link]();
LeerMonedas();
GenerarComprobante();
}
//------------------------------------------------
}

[Link]
import [Link];

public class TLib {

//-----------------------------------------------
public TLib() {
}
//-----------------------------------------------
public void ClearScreen() throws IOException, InterruptedException {
new ProcessBuilder("cmd","/c","cls").inheritIO().start().waitFor();
}
//-----------------------------------------------
public String Replicate(char E, int N) {
String CAD;
CAD = "";
for(int i=1;i<=N;i++) {
CAD = CAD + E;
}
return CAD;
}
//-----------------------------------------------
public String ObtenerCentena(int CC, int DDUU) {
String TMP;
TMP = "";
switch(CC) {
case 1: TMP = (DDUU==0?"Cien":"Ciento"); break;
case 2: TMP = "Doscientos"; break;

​ ​ ​ ​
 case 3: TMP = "Trescientos"; break;
case 4: TMP = "Cuatrocientos"; break;
case 5: TMP = "Quinientos"; break;
case 6: TMP = "Seiscientos"; break;
case 7: TMP = "Setecientos"; break;
case 8: TMP = "Ochocientos"; break;
case 9: TMP = "Novecientos"; break;
default: //0
}
return TMP;
}
//------------------------------------------------
public String ObtenerDecenaUnidad(int DD, int UU) {
String AUX="",TMP="";
int DDUU;
TMP = "";
DDUU = 10*DD + UU;
//---------------------------------
if((10<=DDUU)&&(DDUU<=15)) {
switch(DDUU) {
case 10: TMP = "Diez"; break;
case 11: TMP = "Once"; break;
case 12: TMP = "Doce"; break;
case 13: TMP = "Trece"; break;
case 14: TMP = "Catorce"; break;
case 15: TMP = "Quince"; break;
default: //0
}
}
else {
switch(DD) {
case 1: TMP = "Dieci"; break;
case 2: TMP = (UU==0?"Veinte":"Veinti"); break;
case 3: TMP = "Treinta"; break;
case 4: TMP = "Cuarenta"; break;
case 5: TMP = "Cincuenta"; break;
case 6: TMP = "Sesenta"; break;
case 7: TMP = "Setenta"; break;
case 8: TMP = "Ochenta"; break;
case 9: TMP = "Noventa"; break;
default: //0
}
//---------------------------------
if((DD>2)&&(UU>0)) {
TMP = TMP + " y ";
}
//---------------------------------
switch(UU) {
case 1: AUX = "Un"; break;
case 2: AUX = "Dos"; break;
case 3: AUX = "Tres"; break;
case 4: AUX = "Cuatro"; break;
case 5: AUX = "Cinco"; break;
case 6: AUX = "Seis"; break;
case 7: AUX = "Siete"; break;
case 8: AUX = "Ocho"; break;
case 9: AUX = "Nueve"; break;
default: //0
}
TMP = TMP + AUX;
}
return TMP;
}
//------------------------------------------------
public String ConversionNumeroTexto(double Importe) {

​ ​ ​ ​
 String CADENA,CAD1,CAD2;
int TT,XX,YY;
int N654,N54,N6,N5,N4,N321,N21,N3,N2,N1;
XX = (int)Importe;
YY = (int)([Link]((Importe - XX)*100));
TT = XX;
CADENA = "";
CAD1 = "";
CAD2 = "";
if((0<=XX)&&(XX<=999999)) { //Hasta 6 digitos
//------------------------------------
N1 = XX%10; XX = (int)(XX/10);
N2 = XX%10; XX = (int)(XX/10);
N3 = XX%10; XX = (int)(XX/10);
N4 = XX%10; XX = (int)(XX/10);
N5 = XX%10; XX = (int)(XX/10);
N6 = XX%10; XX = (int)(XX/10);
//------------------------------------
N654 = 100*N6 + 10*N5 + N4;
N321 = 100*N3 + 10*N2 + N1;
N54 = 10*N5 + N4;
N21 = 10*N2 + N1;;
//------------------------------------
if(N654>0) {
CAD2 = ObtenerCentena(N6,N54);
CAD1 = ObtenerDecenaUnidad(N5,N4);
CADENA = CAD2 + (N6>0?(N54>0?" ":""):"") + (N654==1?"":CAD1 + " ") +
"Mil" + (N321==0?"":" ");
}
//---------------------------------
if(N321>0) {
CAD2 = ObtenerCentena(N3,N21);
CAD1 = ObtenerDecenaUnidad(N2,N1);
CADENA = CADENA + CAD2 + (N3>0?(N21>0?" ":""):"") + CAD1;
}
//---------------------------------
if(YY>0) {
if(TT>0) {
CADENA = CADENA + " y " + YY + "/100";
}
else {
CADENA = YY + "/100";
}
}
//else { }
}
//else { }
return CADENA;
}
//-----------------------------------------------
} //class

generan la siguiente salida en pantalla

​ ​ ​ ​
 3.​ Dado el archivo de datos con estructura tabular

[Link]
73 40 87 96 56 90 82 51 76 10 38 49 52 79 28
12 35 57 51 43 13 16 75 95 23 25 92 88 91 41
43 16 14 70 83 25 49 85 11 13 33 51 98 52 58
17 74 78 33 39 44 28 51 50 37 16 36 76 77 12
96 96 93 76 40 41 63 76 97 21 72 47 72 22 35
30 34 63 49 62 67 59 54 72 58 69 75 33 24 51
37 23 85 52 58 77 90 24 35 25 86 83 61 63 66
25 69 22 56 52 27 97 16 52 62 29 68 84 90 55
26 52 15 46 77 22 27 27 19 17 72 12 74 35 60
81 52 38 75 70 61 68 82 70 91 86 22 69 32 38
80 41 85 68 65 57 65 27 13 61 73 82 88 68 44
38 32 16 22 43 96 21 67 18 37 38 20 50 57 25
28 99 63 82 56 42 29 21 22 40 95 65 52 26 17
71 84 76 82 15 23 22 49 21 96 18 61 63 85 12
21 37 52 11 12 10 76 72 93 37 42 65 35 33 71

Desarrollar un POO Java que calcule el determinante de todas las

submatrices con filas/columnas adyacentes de orden 2 y [Link] la
salida en HTML

​ ​ ​ ​
[Link]
import [Link];
import [Link];
import [Link];

public class DeterminanteSubMatrices {

private static FileWriter FW;
private static Scanner SCN = new Scanner([Link]);
private static TLib LIB = new TLib();
//---------------------------------------------
public static void PrintSubMatriz(int MTX[][]) {
int N = [Link];
try {
[Link]("<BR>");
[Link]("<TABLE BORDER=1 CELLPADDING=7 CELLSPACING=0
BGCOLOR=#AED6F1>"); //#A3E4D7
for(int i=0;i<=N-1;i++) {
[Link]("<TR>");
for(int j=0;j<=N-1;j++) {
if(i==j) {
[Link]("<TD BGCOLOR=#FADBD8>");
}
else {
[Link]("<TD>");
}
[Link](MTX[i][j] + "</TD>");
}
[Link]("</TR>");
}
[Link]("</TABLE>");
}
catch (IOException E) {
[Link]([Link]());
}
}
//---------------------------------------------
public static void PrintHTML(int A[][], int M, int N) {
double Determinante;
try {
FW = new FileWriter("[Link]");
[Link]("<HTML>");
[Link]("<HEAD>");
[Link]("</HEAD>");
[Link]("<BODY>");
[Link]("<BR>");
//----------------------------------
[Link]("<H1>Matriz de Datos</H1>");
[Link]("<HR SIZE=3 COLOR=#707070>");
PrintSubMatriz(A);
//----------------------------------
//----------------------------------
final int T = 3;

​ ​ ​ ​
 int[][] B = new int[T][T];
for(int i=0;i<=M-T;i++) {
for(int j=0;j<=N-T;j++) {
B[0][0] = A[i ][j ];
B[0][1] = A[i ][j+1];
B[0][2] = A[i ][j+2];
B[1][0] = A[i+1][j ];
B[1][1] = A[i+1][j+1];
B[1][2] = A[i+1][j+2];
B[2][0] = A[i+2][j ];
B[2][1] = A[i+2][j+1];
B[2][2] = A[i+2][j+2];

Determinante = A[0][0]*A[1][1]*A[2][2] +
A[0][1]*A[1][2]*A[2][0] +
A[0][2]*A[1][0]*A[2][1] +
A[0][2]*A[1][1]*A[2][0] -
A[0][0]*A[1][2]*A[2][1] -
A[0][1]*A[1][0]*A[2][2];

[Link]("<H2>Submatriz de Orden 2x2</H2>");

[Link]("<HR SIZE=1 COLOR=#707070>");
PrintSubMatriz(B);
[Link]("<FONT face='Calibri' size=3 color=#0000FF>El
Determinante es: " +
​ [Link](Determinante) +
​ "</FONT>");
//[Link]("<BR>");
}
}
//----------------------------------
[Link]("</BODY>");
[Link]("</HTML>");
[Link]();
}
catch (IOException E) {
[Link]([Link]());
}
}
//---------------------------------------------
public static void main(String[] args) throws IOException,
InterruptedException {
TOperacionesMatriz MTX = new TOperacionesMatriz();
String LINEA;
int[][] A;
final int T = 45; //Longitud de Registro
final int W = 3; //Longitud del Dato
int L,M,N;
[Link]();
LINEA = [Link]("[Link]");
L = [Link]();
M = (int)(L/T); //Numero de Filas
N = (int)(T/W); //Numero de Columnas
A = [Link](LINEA,M,N);
PrintHTML(A,M,N);
}
//---------------------------------------------

​ ​ ​ ​
}

[Link]
import [Link];
import [Link];
import [Link];
import [Link];

public class TLib {

//-----------------------------------------------
public TLib() {
}
//-----------------------------------------------
public void ClearScreen() throws IOException, InterruptedException {
new ProcessBuilder("cmd","/c","cls").inheritIO().start().waitFor();
}
//-----------------------------------------------
public String Replicate(char E, int N) {
String CAD;
CAD = "";
for(int i=1;i<=N;i++) {
CAD = CAD + E;
}
return CAD;
}
//-----------------------------------------------
public int[][] ReadMatrixFromLine(String LINE,int M,int N) {
int[][] MTX = new int[M][N];
int L,T,W;
String ITEM;
L = [Link]();
T = (int)(L/M); //Longitud de Registro
W = (int)(T/N); //Longitud del Dato
//Leer desde MTX desde LINEA
for(int i=0;i<=M-1;i++) {
for(int j=0;j<=N-1;j++) {
ITEM = [Link](i*T+j*W,i*T+j*W+3).trim();
MTX[i][j] = [Link](ITEM);
}
}
return MTX;
}
//--------------------------------------------------------
public String ReadDataFromFile(String FILENAME) {
String LINE="",CADENA="";
try {
File FILE = new File(FILENAME);
BufferedReader BR = new BufferedReader(new FileReader(FILE));

​ ​ ​ ​
 while ((LINE = [Link]()) != null) {
CADENA = CADENA + LINE;
}
}
catch(IOException e) {
}
return CADENA;
}
//-----------------------------------------------
} //class

​ ​ ​ ​
​ ​ ​ ​
​ ​ ​ ​
EJERCICIO
Se desea registrar datos del personal que labora en un
hospital.

El personal puede ser

●​ Personal Administrativo
●​ Personal de Salud

La información requerida para el registro es

-​ DNI
-​ Apellidos y Nombres
-​ Fecha de Nacimiento
-​ Teléfono
-​ Dirección
-​ Sexo
-​ Salario

Además, el Personal Administrativo tiene los

siguientes datos:

-​ OFICINA:
●​ Administración

​ ​ ​ ​
 ●​ Contabilidad
●​ Almacén
●​ Operaciones
●​ Marketing
-​ RÉGIMEN LABORAL:
●​ PLN: Planilla
●​ CAS: Contratacion Administrativa de Servicios
●​ OS: Orden de Servicio

Asi mismo, el Personal de Salud tiene los siguientes

datos:

-​ SERVICIO:
●​ Medicina
●​ Odontología
●​ Psicología,
●​ Laboratorio
●​ Radiología

-​ PROCEDENCIA:
●​ UNI​
●​ UNMSM

​ ​ ​ ​
 ●​ UPSMP​
●​ UPCH
●​ UPC​. . . .​ ​

DEMO_TPERSONA.java
import [Link];
import [Link];

public class DEMO_TPERSONA {

//-----------------------------------------------
private static TLib LIB = new TLib();
private static String FILENAME = "[Link]";
//-----------------------------------------------
//-----------------------------------------------
public static void main(String[] args) throws IOException, InterruptedException {
int nn;
char TIPO,OPCION='?';
Scanner TECLADO = new Scanner([Link]);
TADMINISTRATIVO OBJ1 = new TADMINISTRATIVO();
TSALUD OBJ2 = new TSALUD();
String CAD,LINEA="",DATA="";
nn = 0;
do {
[Link]();
[Link]("=================================================");
[Link](" HOSPITAL NACIONAL UNIVERSITARIO ");
[Link](" MODULO DE REGISTRO DE PERSONAL ");
[Link]("=================================================");
nn++;
[Link]("Registro Nro. " + nn);
do {
[Link](" - Tipo de Personal : ");
CAD = [Link]();
} while(![Link](CAD,"Tipo de Personal",1,1,"12"));
TIPO = [Link](0);

if(TIPO=='1') {
LINEA = TIPO + " | " + OBJ1.Registro_PersonalAdministrativo();
}
else {
LINEA = TIPO + " | " + OBJ2.Registro_PersonalSalud();
}
DATA = DATA + LINEA + "\n";
[Link]("----------------------------------------------------");
[Link]();
[Link]("Desea Continuar? [S/N]: ");
CAD = [Link]();
OPCION = [Link](0);
} while(OPCION!='N');

​ ​ ​ ​
 if([Link](FILENAME)) {
[Link](DATA,FILENAME);
}
else {
[Link](DATA,FILENAME);
}
}
//-----------------------------------------------
}

[Link]
import [Link];

public class TPERSONA {

//----------------------------------
//PROPIEDADES
//----------------------------------
private String DNI;
private String APENOM;
private String FECNAC;
private String TELEFONO;
private String DIRECCION;
private char SEXO;
private double SALARIO;
//----------------------------------
//METODO CONSTRUCTOR
//----------------------------------
public TPERSONA() {
}
//----------------------------------
//METODOS SET
//----------------------------------
public void Establecer_DNI(String dni) {
[Link] = dni;
}
public void Establecer_APENOM(String apenom) {
[Link] = apenom;
}
public void Establecer_FECNAC(String fecnac) {
[Link] = fecnac;
}
public void Establecer_TELEFONO(String telefono) {
[Link] = telefono;
}
public void Establecer_DIRECCION(String direccion) {
[Link] = direccion;
}
public void Establecer_SEXO(String CAD) { //char sexo
[Link] = [Link](0);
}
public void Establecer_SALARIO(String CAD) { //double salario

​ ​ ​ ​
 [Link] = [Link](CAD);
}
//----------------------------------
//METODOS GET
//----------------------------------
public String Obtener_DNI() {
return [Link];
}
public String Obtener_APENOM() {
return [Link];
}
public String Obtener_FECNAC() {
return [Link];
}
public String Obtener_TELEFONO() {
return [Link];
}
public String Obtener_DIRECCION() {
return [Link];
}
public char Obtener_SEXO() {
return [Link];
}
public double Obtener_SALARIO() {
return [Link];
}
//----------------------------------
//----------------------------------
//----------------------------------
public String Registro_DatosGenerales() {
Scanner OBJ = new Scanner([Link]);
TLib LIB = new TLib();
String CAD;

do {
[Link](" - DNI : ");
CAD = [Link]();
} while(![Link](CAD,"DNI",8,8,"0123456789"));
Establecer_DNI(CAD);

do {
[Link](" - Apellidos y Nombres: ");
CAD = [Link]();
}
while(![Link](CAD,"Apellidos/Nombres",3,30,"ABCDEFGHIJKLMNOPQRSTU
VWXYZ abcdefghijklmnopqrstuvwxyz" + (char)164 + (char)165));
Establecer_APENOM(CAD);

do {
[Link](" - Fecha de Nacimiento: ");
CAD = [Link]();
} while();
Establecer_FECNAC(CAD);

do {
[Link](" - Telefono : ");
CAD = [Link]();

​ ​ ​ ​
 } while(![Link](CAD,"Telefono",9,9,"0123456789"));
Establecer_TELEFONO(CAD);

do {
[Link](" - Direccion : ");
CAD = [Link]();
}
while(![Link](CAD,"Direccion",5,30,"ABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz.0123456789"));
Establecer_DIRECCION(CAD);

do {
[Link](" - Sexo : ");
CAD = [Link]();
} while(![Link](CAD,"Sexo",1,1,"MF"));
Establecer_SEXO(CAD);

do {
[Link](" - Salario : ");
CAD = [Link]();
} while(![Link](CAD,"Salario",3,10,"0.123456789"));
Establecer_SALARIO(CAD);

[Link]("----------------------------------------------------");

String TMP = "" + SALARIO;

return DNI + " | " +
APENOM + [Link](' ',30 - [Link]()) + " | " +
FECNAC + " | " +
TELEFONO + " | " +
DIRECCION + [Link](' ',30 - [Link]()) + " | "
+
SEXO + " | " +
[Link](' ',10 - [Link]()) + TMP;

}
//----------------------------------
} //class

[Link]
import [Link];

public class TADMINISTRATIVO extends TPERSONA {

//----------------------------------
//PROPIEDADES
//----------------------------------
private String OFICINA;

​ ​ ​ ​
//----------------------------------
//METODO CONSTRUCTOR
//----------------------------------
public TADMINISTRATIVO() {
super();
}
//----------------------------------
//METODOS SET
//----------------------------------
public void Establecer_OFICINA(String oficina) {
[Link] = oficina;
}
//----------------------------------
//METODOS GET
//----------------------------------
public String Obtener_OFICINA() {
return [Link];
}
//----------------------------------
//----------------------------------
public String Registro_PersonalAdministrativo() {
Scanner OBJ = new Scanner([Link]);
TLib LIB = new TLib();
String CAD,LINEA;
LINEA = Registro_DatosGenerales();
do {
[Link](" - Oficina : ");
CAD = [Link]();
}
while(![Link](CAD,"Oficina",5,20,"ABCDEFGHIJKLMNOPQRSTUVWXYZ.
abcdefghijklmnopqrstuvwxyz"));
Establecer_OFICINA(CAD);
return LINEA + " | " +
OFICINA + [Link](' ',20 - [Link]());
}
//----------------------------------
} //class

[Link]
import [Link];

public class TSALUD extends TPERSONA {

//----------------------------------
//PROPIEDADES
//----------------------------------
private String SERVICIO;
private String PROCEDENCIA;

​ ​ ​ ​
//----------------------------------
//METODO CONSTRUCTOR
//----------------------------------
public TSALUD() {
super();
}
//----------------------------------
//METODOS SET
//----------------------------------
public void Establecer_SERVICIO(String servicio) {
[Link] = servicio;
}
public void Establecer_PROCEDENCIA(String procedencia) {
[Link] = procedencia;
}
//----------------------------------
//METODOS GET
//----------------------------------
public String Obtener_SERVICIO() {
return [Link];
}
public String Obtener_PROCEDENCIA() {
return [Link];
}
//----------------------------------
public String Registro_PersonalSalud() {
Scanner OBJ = new Scanner([Link]);
TLib LIB = new TLib();
String CAD,LINEA;
LINEA = Registro_DatosGenerales();

do {
[Link](" - Servicio : ");
CAD = [Link]();
}
while(![Link](CAD,"Servicio",5,20,"ABCDEFGHIJKLMNOPQRSTUVWXYZ.
abcdefghijklmnopqrstuvwxyz"));
Establecer_SERVICIO(CAD);

do {
[Link](" - Procedencia : ");
CAD = [Link]();
}
while(![Link](CAD,"Procedencia",3,10,"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
));
Establecer_PROCEDENCIA(CAD);

return LINEA + " | " +

SERVICIO + [Link](' ',20 - [Link]()) + " | " +
PROCEDENCIA + [Link](' ',10 - [Link]());
}

//----------------------------------
//----------------------------------
} //class

​ ​ ​ ​
[Link]
import [Link];
import [Link];
import [Link];
import [Link];
import [Link].*;

public class TLib {

//-----------------------------------------------
public TLib() {
}
//-----------------------------------------------
public void ClearScreen() throws IOException, InterruptedException {
new ProcessBuilder("cmd","/c","cls").inheritIO().start().waitFor();
}
//-----------------------------------------------
public String Replicate(char E, int N) {
String T;
T = "";
for(int i=1;i<=N;i++) {
​ T = T + E;
}
return T;
}
//-----------------------------------------------
public boolean InRange(String CADENA, String RANGO){
int L,N,k,i;
char E;
boolean Sw,Hk;
L = [Link]();
N = [Link]();
Sw = true;
k = 0;
while((k<=L-1)&&(Sw==true)){
E = [Link](k);
Hk = false;
i = 0;
while((i<=N-1)&&(Hk==false)){
if([Link](i)==E){
Hk = true;
}
i++;
}
Sw = Hk;
k++;
}
return Sw;
}
//-----------------------------------------------
public boolean EsCadenaNumerica(String CAD) {
/*int i,L;

​ ​ ​ ​
char E;
boolean Sw;
L = [Link]();
Sw = true;
i = 0;
while((i<=L-1)&&(Sw==true)) {
E = [Link](i);
if(!(('0'<=E)&&(E<='9'))) {
Sw = false;
}
i++;
}
return Sw;*/
return InRange(CAD,"0123456789");
}
//-----------------------------------------------
public boolean EsCadenaAlfabetica(String CAD) {
/*int i,L;
char E;
boolean Sw;
L = [Link]();
Sw = true;
i = 0;
while((i<=L-1)&&(Sw==true)) {
E = [Link](i);
if(!((('a'<=E)&&(E<='z'))||
(('A'<=E)&&(E<='Z'))
)) {
Sw = false;
}
i++;
}
return Sw;*/
return
InRange(CAD,"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
}
//---------------------------------------------
public int PosicionIzquierda(String CADENA, char E) {
int i,P,L;
L = [Link]();
P = -1;
i = 0;
while((i<=L-1)&&(P==-1)) {
if([Link](i)==E) {
P = i;
}
i++;
}
return P;
}
//---------------------------------------------
public int TotalOcurrencias(String CADENA, char E) {
int C,L;
L = [Link]();
C = 0;
for(int i=0;i<=L-1;i++) {
if([Link](i)==E) {

​ ​ ​ ​
 C = C + 1;
}
}
return C;
}
//-----------------------------------------------
public boolean FechaOK(String FECHA, int MinYear, int MaxYear) {
boolean Sw;
String DD,MM,YYYY;
int P,T,L,YEAR,MONTH,DAY,TOTAL=0;
L = [Link]();
Sw = false;
if((8<=L)&&(L<=10)) {
T = TotalOcurrencias(FECHA,'/');
P = PosicionIzquierda(FECHA,'/');
if((T==2)&&(0<P)&&(P<L-6)&&([Link](L-5)=='/')) {
DD = [Link](0,P);
MM = [Link](P+1,L-5);
YYYY = [Link](L-4,L);
if((EsCadenaNumerica(DD)==true)&&
(EsCadenaNumerica(MM)==true)&&
(EsCadenaNumerica(YYYY)==true)) {
YEAR = [Link](YYYY);
if((MinYear<=YEAR)&&(YEAR<=MaxYear)) {
MONTH = [Link](MM);
if((1<=MONTH)&&(MONTH<=12)) {
DAY = [Link](DD);

if((MONTH==1)||(MONTH==3)||(MONTH==5)||(MONTH==7)||(MONTH==8)||(MONTH==10)|
|(MONTH==12)) {
TOTAL = 31;
}
else {

if((MONTH==4)||(MONTH==6)||(MONTH==9)||(MONTH==11)) {
TOTAL = 30;
}
else {
TOTAL
=(((YEAR%4==0)&&(YEAR%100!=0))||((YEAR%400==0)&&(YEAR%100==0))?29:28);
}
}
Sw = ((1<=DAY)&&(DAY<=TOTAL));
if(!Sw) {
[Link]("ERROR: El Dia es
Incorrecto!!!");
}
}
else {
[Link]("ERROR: El Mes es
Incorrecto!!!");
}
}
else {
[Link]("ERROR: El Año es Incorrecto!!!");
}
}

​ ​ ​ ​
 else {
[Link]("ERROR: Existen Caracteres No
Numericos");
}
}
else {
[Link]("ERROR: Los Delimitadores de Fecha son
incorrectos!!!");
}
}
else {
[Link]("ERROR: Longitud/Tamaño de Fecha es
Incorrecta!!!");
}
return Sw;
}
//-----------------------------------------------
public boolean ValidacionOK(String CADENA, String HKGZ,int SIZE1, int
SIZE2, String RANGO) {
int L;
boolean Sw;
Sw = false;
L = [Link]();
if(L>0) {
if((SIZE1<=L)&&(L<=SIZE2)) {
if(InRange(CADENA,RANGO)==true) {
Sw = true;
}
else {
if([Link]()>0) {
[Link]("ERROR: " + HKGZ + " contiene
caracteres incorrectos!!!");
}
}
}
else {
if([Link]()>0) {
[Link]("ERROR: " + HKGZ + " tiene Longitud
Incorrecta!!!");
}
}
}
else {
if([Link]()>0) {
[Link]("ERROR: " + HKGZ + " tiene Longitud 0!!!");
}
}
return Sw;
}
//-----------------------------------------------
public boolean ExistDataFile(String FILENAME) {
File F = new File(FILENAME);
boolean Sw;
Sw = false;
if([Link]()) {
Sw = true;
}

​ ​ ​ ​
 return Sw;
}
//-----------------------------------------------
/*
public void WriteDataFile(String CAD, String FILENAME) {
double X;
long num;
try {
FileWriter FW = new FileWriter(FILENAME);
[Link](CAD);
[Link]();
}
catch (IOException E) {
[Link]([Link]());
}
}*/
public void WriteDataFile(String TEXT, String FILENAME) {
File FF;
FF = new File(FILENAME);
try {
FileWriter FW = new FileWriter(FF);
BufferedWriter BW = new BufferedWriter(FW);
PrintWriter PW = new PrintWriter(BW);
[Link](TEXT);
[Link]();
[Link]();
}
catch(IOException e) {
};
}
//-----------------------------------------------
public void AppendDataFile(String TEXT, String FILENAME) {
File FF;
FF = new File(FILENAME);
try {
FileWriter FW = new FileWriter(FF);
BufferedWriter BW = new BufferedWriter(FW);
PrintWriter PW = new PrintWriter(BW);
[Link](TEXT);
[Link]();
[Link]();
}
catch(IOException e) {
};
}

//-----------------------------------------------
public String ReadDataFile(String FILENAME) {
String LINE="",CADENA="";
try {
File FILE = new File(FILENAME);
BufferedReader BR = new BufferedReader(new FileReader(FILE));
while ((LINE = [Link]()) != null) {
CADENA = CADENA + LINE;
}
}
catch(IOException e) {

​ ​ ​ ​
 }
return CADENA;
}
//-----------------------------------------------
//-----------------------------------------------
//-----------------------------------------------
}

​ ​ ​ ​
TAREA: (Fecha de Presentación 10/04/2025)
Adaptar la solución anterior para el caso de una
Universidad que admite dos tipos de entidades o
clases: TAlumno y TDocente.
Implementar una solución visual usando controles
SWING

IMPORTANTE:
La solución anterior ÚNICAMENTE permite el
ingreso (registro) de personas.
Sin embargo, NO ES POSIBLE realizar operaciones
​ ​ ​ ​
de modificación, eliminación y ordenación de
registros debido a que el tipo de archivo utilizado
es SECUENCIAL.
Si se desea realizar operaciones de mantenimiento
(ingreso, eliminación, modificación, ordenación,
consulta) de registros al archivo se debe utilizar
otra clase que permita el acceso directo:
RandomAccessFile lo cual es explicado en el
siguiente programa.

EJERCICIO
Tomando como base el problema anterior (registro de
personal), realizar un programa que realice el
mantenimiento del personal del hospital.

SOLUCIONARIO

Vamos a usar la clase RandomAccesFile

Los registros DEBEN TENER la misma longitud W

●​ El 1º Registro comienza en la posición 0*W

●​ El 2º Registro comienza en la posición 1*W
●​ El 3º Registro comienza en la posición 2*W

​ ...............

​ ​ ​ ​
 ​ ...............
​ ...............
●​ El k-ésimo Registro comienza en la posición
(k-1)*W

[Link]
import [Link];
import [Link];
import [Link];
import [Link];
import [Link].*;

public class TLib {

private int W = 129;

//-----------------------------------------------
public TLib() {
}
//-----------------------------------------------
public void ClearScreen() throws IOException, InterruptedException {
new ProcessBuilder("cmd","/c","cls").inheritIO().start().waitFor();
}
//-----------------------------------------------
public String Replicate(char E, int N) {
String T;
T = "";
for(int i=1;i<=N;i++) {
​ T = T + E;

​ ​ ​ ​
 }
return T;
}
//-----------------------------------------------
public boolean InRange(String CADENA, String RANGO){
int L,N,k,i;
char E;
boolean Sw,Hk;
L = [Link]();
N = [Link]();
Sw = true;
k = 0;
while((k<=L-1)&&(Sw==true)){
E = [Link](k);
Hk = false;
i = 0;
while((i<=N-1)&&(Hk==false)){
if([Link](i)==E){
Hk = true;
}
i++;
}
Sw = Hk;
k++;
}
return Sw;
}
//-----------------------------------------------
public boolean EsCadenaNumerica(String CAD) {
/*int i,L;
char E;
boolean Sw;
L = [Link]();
Sw = true;
i = 0;
while((i<=L-1)&&(Sw==true)) {
E = [Link](i);
if(!(('0'<=E)&&(E<='9'))) {
Sw = false;
}
i++;
}
return Sw;*/
return InRange(CAD,"0123456789");
}
//-----------------------------------------------
public boolean EsCadenaAlfabetica(String CAD) {
/*int i,L;
char E;
boolean Sw;
L = [Link]();
Sw = true;
i = 0;
while((i<=L-1)&&(Sw==true)) {
E = [Link](i);
if(!((('a'<=E)&&(E<='z'))||
(('A'<=E)&&(E<='Z'))

​ ​ ​ ​
 )) {
Sw = false;
}
i++;
}
return Sw;*/
return
InRange(CAD,"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
}
//---------------------------------------------
public int PosicionIzquierda(String CADENA, char E) {
int i,P,L;
L = [Link]();
P = -1;
i = 0;
while((i<=L-1)&&(P==-1)) {
if([Link](i)==E) {
P = i;
}
i++;
}
return P;
}
//---------------------------------------------
public int TotalOcurrencias(String CADENA, char E) {
int C,L;
L = [Link]();
C = 0;
for(int i=0;i<=L-1;i++) {
if([Link](i)==E) {
C = C + 1;
}
}
return C;
}
//-----------------------------------------------
public boolean FechaOK(String FECHA, int MinYear, int MaxYear) {
boolean Sw;
String DD,MM,YYYY;
int P,T,L,YEAR,MONTH,DAY,TOTAL=0;
L = [Link]();
Sw = false;
if((8<=L)&&(L<=10)) {
T = TotalOcurrencias(FECHA,'/');
P = PosicionIzquierda(FECHA,'/');
if((T==2)&&(0<P)&&(P<L-6)&&([Link](L-5)=='/')) {
DD = [Link](0,P);
MM = [Link](P+1,L-5);
YYYY = [Link](L-4,L);
if((EsCadenaNumerica(DD)==true)&&
(EsCadenaNumerica(MM)==true)&&
(EsCadenaNumerica(YYYY)==true)) {
YEAR = [Link](YYYY);
if((MinYear<=YEAR)&&(YEAR<=MaxYear)) {
MONTH = [Link](MM);
if((1<=MONTH)&&(MONTH<=12)) {
DAY = [Link](DD);

​ ​ ​ ​
if((MONTH==1)||(MONTH==3)||(MONTH==5)||(MONTH==7)||(MONTH==8)||(MONTH==10)|
|(MONTH==12)) {
TOTAL = 31;
}
else {

if((MONTH==4)||(MONTH==6)||(MONTH==9)||(MONTH==11)) {
TOTAL = 30;
}
else {
TOTAL
=(((YEAR%4==0)&&(YEAR%100!=0))||((YEAR%400==0)&&(YEAR%100==0))?29:28);
}
}
Sw = ((1<=DAY)&&(DAY<=TOTAL));
if(!Sw) {
[Link]("ERROR: El Dia es
Incorrecto!!!");
}
}
else {
[Link]("ERROR: El Mes es
Incorrecto!!!");
}
}
else {
[Link]("ERROR: El Año es Incorrecto!!!");
}
}
else {
[Link]("ERROR: Existen Caracteres No
Numericos");
}
}
else {
[Link]("ERROR: Los Delimitadores de Fecha son
incorrectos!!!");
}
}
else {
[Link]("ERROR: Longitud/Tamaño de Fecha es
Incorrecta!!!");
}
return Sw;
}
//-----------------------------------------------
public boolean ValidacionOK(String CADENA, String HKGZ,int SIZE1, int
SIZE2, String RANGO) {
int L;
boolean Sw;
Sw = false;
L = [Link]();
if(L>0) {
if((SIZE1<=L)&&(L<=SIZE2)) {
if(InRange(CADENA,RANGO)==true) {
Sw = true;

​ ​ ​ ​
 }
else {
if([Link]()>0) {
[Link]("ERROR: " + HKGZ + " contiene
caracteres incorrectos!!!");
}
}
}
else {
if([Link]()>0) {
[Link]("ERROR: " + HKGZ + " tiene Longitud
Incorrecta!!!");
}
}
}
else {
if([Link]()>0) {
[Link]("ERROR: " + HKGZ + " tiene Longitud 0!!!");
}
}
return Sw;
}
//-----------------------------------------------
public boolean ExistDataFile(String FILENAME) {
File F = new File(FILENAME);
boolean Sw;
Sw = false;
if([Link]()) {
Sw = true;
}
return Sw;
}
//-----------------------------------------------
/*
public void WriteTextFile(String FILENAME, String CAD) {
double X;
long num;
try {
FileWriter FW = new FileWriter(FILENAME);
[Link](CAD);
[Link]();
}
catch (IOException E) {
[Link]([Link]());
}
}*/
public void WriteTextFile(String FILENAME, String TEXT) {
File FF;
FF = new File(FILENAME);
try {
FileWriter FW = new FileWriter(FF);
BufferedWriter BW = new BufferedWriter(FW);
PrintWriter PW = new PrintWriter(BW);
[Link](TEXT);
[Link]();
[Link]();
}

​ ​ ​ ​
 catch(IOException e) {
};
}
//-----------------------------------------------
public void AppendTextFile(String FILENAME, String TEXT) {
File FF;
FF = new File(FILENAME);
try {
FileWriter FW = new FileWriter(FF);
BufferedWriter BW = new BufferedWriter(FW);
PrintWriter PW = new PrintWriter(BW);
[Link](TEXT);
[Link]();
[Link]();
}
catch(IOException e) {
};
}
//-----------------------------------------------
public String ReadTextFile(String FILENAME) {
String LINE="",CADENA="";
try {
File FILE = new File(FILENAME);
BufferedReader BR = new BufferedReader(new FileReader(FILE));
while ((LINE = [Link]()) != null) {
CADENA = CADENA + LINE;
}
}
catch(IOException e) {
}
return CADENA;
}
//-----------------------------------------------
public byte[] StringToBuffer(String CADENA) {
byte[] BUFFER = new byte[W];
int L = [Link]();
for(int i=0;i<=L-1;i++) {
BUFFER[i] = (byte)[Link](i);
}
return BUFFER;
}
//-----------------------------------------------
public String BufferToString(byte[] BUFFER) {
String CADENA="";
int L = [Link];
for(int i=0;i<=L-1;i++) {
CADENA = CADENA + (char)BUFFER[i];
}
return CADENA;
}
//-----------------------------------------------
public void WriteDataFile(String FILENAME, String DATA) {
long T,N;
byte[] BUFFER = StringToBuffer(DATA);
try {
RandomAccessFile RAF = new RandomAccessFile(FILENAME,"rw");
T = [Link]();

​ ​ ​ ​
 N = T/W;
[Link](N*W);
[Link](BUFFER);
[Link]();
}
catch(IOException e) {
[Link](null,FILENAME + '\n' +
​ DATA + '\n' +
​
BufferToString(BUFFER));
}
}
//-----------------------------------------------
public void ReadDataFile(String FILENAME) {
String CADENA;
long T,N;
byte[] BUFFER = new byte[W];
try {
RandomAccessFile RAF = new RandomAccessFile(FILENAME,"r");
T = [Link]();
N = T/W;

for(int k=1;k<=N;k++) {
[Link]((k-1)*W);
[Link](BUFFER);
CADENA = BufferToString(BUFFER);
[Link](CADENA);
}
[Link]("-----------------------------");
[Link]();
}
catch(IOException e) {
}
}
//-----------------------------------------------
public void ListDataFile(String FILENAME, char TIPO, String TITULO) throws
IOException, InterruptedException {
String CADENA;
long T,N;
byte[] BUFFER = new byte[W];
try {
RandomAccessFile RAF = new RandomAccessFile(FILENAME,"r");
T = [Link]();
N = T/W;
[Link]();
[Link](" " + TITULO);

[Link]("-------------------------------------------------------
-----");
[Link]("DNI Apellidos/Nombres Fecha Nac.
Telefono ");

[Link]("-------------------------------------------------------
-----");
for(int k=1;k<=N;k++) {
[Link]((k-1)*W);
[Link](BUFFER);

​ ​ ​ ​
 CADENA = BufferToString(BUFFER);
if([Link](0)==TIPO) {
[Link]( [Link](1,9) + " " +
[Link](9,39) + " " +
[Link](39,49) + " " +
[Link](49,58) );
}
}

[Link]("-------------------------------------------------------
-----");
[Link]();
}
catch(IOException e) {
}
}
//-----------------------------------------------
} //class

GESTION_PERSONAL.java
import [Link];
import [Link];

public class GESTION_PERSONAL {

//-----------------------------------------------
private static TLib LIB = new TLib();
private static String FILENAME = "[Link]";
private static int W = 129;
//-----------------------------------------------
public static void IngresoPersonal() throws IOException,
InterruptedException {
int nn;
char TIPO,OPCION='?';
Scanner TECLADO = new Scanner([Link]);
TADMINISTRATIVO OBJ1 = new TADMINISTRATIVO();
TSALUD OBJ2 = new TSALUD();
String CAD,LINEA="";
nn = 0;
do {
[Link]();
[Link]("============================================");
[Link](" MODULO DE INGRESO DE REGISTROS DE PERSONAL ");
[Link]("============================================");
nn++;
[Link]("Registro Nro. " + nn);
do {
[Link](" - Tipo de Personal : ");
CAD = [Link]();
} while(![Link](CAD,"Tipo de Personal",1,1,"12"));
TIPO = [Link](0);
if(TIPO=='1') {
LINEA = TIPO + OBJ1.Registro_PersonalAdministrativo();

​ ​ ​ ​
 }
else {
LINEA = TIPO + OBJ2.Registro_PersonalSalud();
}
[Link](FILENAME, LINEA + [Link](' ',W -
[Link]()));
[Link]("--------------------------------------------");
[Link]();
do {
[Link]("Desea Continuar? [S/N]: ");
CAD = [Link]();
} while(![Link](CAD,"",1,1,"NnSs"));
OPCION = [Link](0);
} while((OPCION!='N')&&(OPCION!='n'));
}
//-----------------------------------------------
public static void ModificacionPersonal() throws IOException,
InterruptedException {
Scanner TECLADO = new Scanner([Link]);
[Link]();
[Link]("ModificacionPersonal");
[Link]("Pulse una Tecla!!!..."); [Link]();
}
//-----------------------------------------------
public static void EliminacionPersonal() throws IOException,
InterruptedException {
Scanner TECLADO = new Scanner([Link]);
[Link]();
[Link]("EliminacionPersonal");
[Link]("Pulse una Tecla!!!..."); [Link]();
}
//-----------------------------------------------
public static void BusquedaPorDNI() throws IOException,
InterruptedException {
Scanner TECLADO = new Scanner([Link]);
[Link]();
[Link]("BusquedaPorDNI");
[Link]("Pulse una Tecla!!!..."); [Link]();
}
//-----------------------------------------------
public static void BusquedaPorApeNom() throws IOException,
InterruptedException {
Scanner TECLADO = new Scanner([Link]);
[Link]();
[Link]("BusquedaPorApeNom");
[Link]("Pulse una Tecla!!!..."); [Link]();
}
//-----------------------------------------------
public static void ListadoPersonal() throws IOException,
InterruptedException {
Scanner TECLADO = new Scanner([Link]);
[Link]();

[Link]("=======================================================
=====");
[Link](" LISTADO DE REGISTROS DE PERSONAL ");

​ ​ ​ ​
[Link]("=======================================================
=====");
[Link](FILENAME,'1',"PERSONAL ADMINISTRATIVO");
[Link](FILENAME,'2',"PERSONAL DE SALUD");
[Link]("\nPulse una Tecla!!!..."); [Link]();
}
//-----------------------------------------------
public static char MenuPrincipal() throws IOException, InterruptedException
{
Scanner TECLADO = new Scanner([Link]);
String CAD;
[Link]();

//[Link]("=================================================");
[Link](" HOSPITAL NACIONAL UNIVERSITARIO
");
[Link](" MODULO DE REGISTRO DE PERSONAL
");

[Link]("=================================================");
[Link]();
[Link](" -----------------------------------");
[Link](" MENU PRINCIPAL ");
[Link](" -----------------------------------");
[Link](" 1. Ingreso de Personal");
[Link](" 2. Modificacion de Personal");
[Link](" 3. Eliminacion de Personal");
[Link](" 4. Busqueda por DNI");
[Link](" 5. Busqueda por Apellido/Nombre");
[Link](" 6. Listado de Personal");
[Link](" 7. Finalizar Ejecucion");
[Link](" -----------------------------------");
do {
[Link] (" SELECCIONE OPCION: ");
CAD = [Link]();
} while(![Link](CAD,"",1,1,"1234567"));
return [Link](0);
}
//-----------------------------------------------
public static void main(String[] args) throws IOException,
InterruptedException {
int nn;
char OPCION='?';
String CAD;
do {
OPCION = MenuPrincipal();
switch(OPCION) {
case '1': IngresoPersonal(); break;
case '2': ModificacionPersonal(); break;
case '3': EliminacionPersonal(); break;
case '4': BusquedaPorDNI(); break;
case '5': BusquedaPorApeNom(); break;
case '6': ListadoPersonal(); break;
default: [Link](); [Link](0);
}
} while(OPCION!='7');
}

​ ​ ​ ​
//-----------------------------------------------
} //class

[Link]
import [Link];

public class TPERSONA {

//----------------------------------
//PROPIEDADES
//----------------------------------
private String DNI;
private String APENOM;
private String FECNAC;
private String TELEFONO;
private String DIRECCION;
private char SEXO;
private double SALARIO;
//----------------------------------
//METODO CONSTRUCTOR
//----------------------------------
public TPERSONA() {
}
//----------------------------------
//METODOS SET
//----------------------------------
public void Establecer_DNI(String dni) {
[Link] = dni;
}
public void Establecer_APENOM(String apenom) {
[Link] = apenom;
}
public void Establecer_FECNAC(String fecnac) {
[Link] = fecnac;
}
public void Establecer_TELEFONO(String telefono) {
[Link] = telefono;
}
public void Establecer_DIRECCION(String direccion) {
[Link] = direccion;
}
public void Establecer_SEXO(String CAD) { //char sexo
[Link] = [Link](0);
}
public void Establecer_SALARIO(String CAD) { //double salario
[Link] = [Link](CAD);

​ ​ ​ ​
}
//----------------------------------
//METODOS GET
//----------------------------------
public String Obtener_DNI() {
return [Link];
}
public String Obtener_APENOM() {
return [Link];
}
public String Obtener_FECNAC() {
return [Link];
}
public String Obtener_TELEFONO() {
return [Link];
}
public String Obtener_DIRECCION() {
return [Link];
}
public char Obtener_SEXO() {
return [Link];
}
public double Obtener_SALARIO() {
return [Link];
}
//----------------------------------
//----------------------------------
//----------------------------------
public String Registro_DatosGenerales() {
Scanner OBJ = new Scanner([Link]);
TLib LIB = new TLib();
String CAD;

do {
[Link](" - DNI : ");
CAD = [Link]();
} while(![Link](CAD,"DNI",8,8,"0123456789"));
Establecer_DNI(CAD);

do {
[Link](" - Apellidos y Nombres: ");
CAD = [Link]();
}
while(![Link](CAD,"Apellidos/Nombres",3,30,"ABCDEFGHIJKLMNOPQRSTU
VWXYZ abcdefghijklmnopqrstuvwxyz" + (char)164 + (char)165));
Establecer_APENOM(CAD);

do {
[Link](" - Fecha de Nacimiento: ");
CAD = [Link]();
} while();
Establecer_FECNAC(CAD);

do {
[Link](" - Telefono : ");
CAD = [Link]();
} while(![Link](CAD,"Telefono",9,9,"0123456789"));

​ ​ ​ ​
 Establecer_TELEFONO(CAD);

do {
[Link](" - Direccion : ");
CAD = [Link]();
}
while(![Link](CAD,"Direccion",5,30,"ABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz.0123456789"));
Establecer_DIRECCION(CAD);

do {
[Link](" - Sexo : ");
CAD = [Link]();
} while(![Link](CAD,"Sexo",1,1,"MF"));
Establecer_SEXO(CAD);

do {
[Link](" - Salario : ");
CAD = [Link]();
} while(![Link](CAD,"Salario",3,10,"0.123456789"));
Establecer_SALARIO(CAD);

[Link]("--------------------------------------------");

String TMP = "" + SALARIO;

return DNI +
APENOM + [Link](' ',30 - [Link]()) +
FECNAC +
TELEFONO +
DIRECCION + [Link](' ',30 - [Link]()) +
SEXO +
[Link](' ',10 - [Link]()) + TMP;

}
//----------------------------------
} //class

[Link]
import [Link];

public class TADMINISTRATIVO extends TPERSONA {

//----------------------------------
//PROPIEDADES
//----------------------------------
private String OFICINA;
//----------------------------------
//METODO CONSTRUCTOR
//----------------------------------
public TADMINISTRATIVO() {
super();
}

​ ​ ​ ​
//----------------------------------
//METODOS SET
//----------------------------------
public void Establecer_OFICINA(String oficina) {
[Link] = oficina;
}
//----------------------------------
//METODOS GET
//----------------------------------
public String Obtener_OFICINA() {
return [Link];
}
//----------------------------------
//----------------------------------
public String Registro_PersonalAdministrativo() {
Scanner OBJ = new Scanner([Link]);
TLib LIB = new TLib();
String CAD,LINEA;
LINEA = Registro_DatosGenerales();
do {
[Link](" - Oficina : ");
CAD = [Link]();
}
while(![Link](CAD,"Oficina",5,20,"ABCDEFGHIJKLMNOPQRSTUVWXYZ.
abcdefghijklmnopqrstuvwxyz"));
Establecer_OFICINA(CAD);
return LINEA +
OFICINA + [Link](' ',20 - [Link]());
}
//----------------------------------
} //class

[Link]
import [Link];

public class TSALUD extends TPERSONA {

//----------------------------------
//PROPIEDADES
//----------------------------------
private String SERVICIO;
private String PROCEDENCIA;
//----------------------------------
//METODO CONSTRUCTOR
//----------------------------------
public TSALUD() {
super();
}
//----------------------------------

​ ​ ​ ​
//METODOS SET
//----------------------------------
public void Establecer_SERVICIO(String servicio) {
[Link] = servicio;
}
public void Establecer_PROCEDENCIA(String procedencia) {
[Link] = procedencia;
}
//----------------------------------
//METODOS GET
//----------------------------------
public String Obtener_SERVICIO() {
return [Link];
}
public String Obtener_PROCEDENCIA() {
return [Link];
}
//----------------------------------
public String Registro_PersonalSalud() {
Scanner OBJ = new Scanner([Link]);
TLib LIB = new TLib();
String CAD,LINEA;
LINEA = Registro_DatosGenerales();

do {
[Link](" - Servicio : ");
CAD = [Link]();
}
while(![Link](CAD,"Servicio",5,20,"ABCDEFGHIJKLMNOPQRSTUVWXYZ.
abcdefghijklmnopqrstuvwxyz"));
Establecer_SERVICIO(CAD);

do {
[Link](" - Procedencia : ");
CAD = [Link]();
}
while(![Link](CAD,"Procedencia",3,10,"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
));
Establecer_PROCEDENCIA(CAD);

return LINEA +
SERVICIO + [Link](' ',20 - [Link]()) +
PROCEDENCIA + [Link](' ',10 - [Link]());
}
//----------------------------------
} //class

​ ​ ​ ​
​ ​ ​ ​
■■■■■■■■■■■■■■■■■■■■■■■■■
■■■■■■■■■■■■■■■■■■■■■■■■■
■■■■■■■■■■■■■■■■■■■■■■■■■

EJERCICIO
Implementar un POO en Java que realice el
registro de datos de las personas de una
determinada institución o empresa. Los datos
deben de almacenarse en el archivo
[Link] .

​ ​ ​ ​
De manera general, la información requerida para
registrar el personal es

DNI │ Apellidos y Nombres │ Fecha de Nacimiento │ Teléfono │ Dirección │ Sexo

Sin embargo, existen tipos de personas que

adoptan información más específica, acorde a su
rol o perfil.
El programa debe establecer herencia entre
clases (superclase y subclases)

[Link]
import [Link].*;
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];

public class Ventana extends JFrame {

//--------------------------------------------------
private TLib LIB = new TLib();
private TPERSONA PSN = new TPERSONA();
//--------------------------------------------------
private Font TIPO_LETRA1 = new [Link]("Segoe UI", 1, 36);
private Font TIPO_LETRA2 = new [Link]("Segoe UI", 0, 36);
private Font TIPO_LETRA3 = new [Link]("Segoe UI", 1, 18);
//--------------------------------------------------
private Color COLOR_FONDO = new [Link](214,234,248);
//--------------------------------------------------
private JButton btnREGISTRAR = new JButton("Registrar");
private JButton btnLIMPIAR = new JButton("Limpiar");

​ ​ ​ ​
private JButton btnSALIR = new JButton("Salir");
//--------------------------------------------------
private JComboBox<String> cbxDEPARTAMENTO_ACADEMICO = new JComboBox<>();
private JComboBox<String> cbxCONDICION = new JComboBox<>();
private JComboBox<String> cbxAREA_CONOCIMIENTO = new JComboBox<>();
private JComboBox<String> cbxGRADO_ACADEMICO = new JComboBox<>();
//--------------------------------------------------
private JRadioButton rbFEMENINO = new JRadioButton("Femenino");
private JRadioButton rbMASCULINO = new JRadioButton("Masculino");
private ButtonGroup bgSEXO = new ButtonGroup();
//--------------------------------------------------
private JLabel jLabel1 = new JLabel("UNIVERSIDAD NACIONAL PERUANA");
private JLabel jLabel10 = new JLabel("Departamento Academico");
private JLabel jLabel11 = new JLabel("Area del Conocimiento");
private JLabel jLabel12 = new JLabel("Fecha de Ingreso");
private JLabel jLabel13 = new JLabel("Condicion");
private JLabel jLabel14 = new JLabel("Grado Academico");
private JLabel jLabel15 = new JLabel("Titulo Profesional");
private JLabel jLabel2 = new JLabel("Registro de Personal");
private JLabel jLabel3 = new JLabel("DNI");
private JLabel jLabel4 = new JLabel("Nombres y Apellidos");
private JLabel jLabel5 = new JLabel("Telefono");
private JLabel jLabel6 = new JLabel("Fecha de Nacimiento");
private JLabel jLabel7 = new JLabel("Direccion");
private JLabel jLabel8 = new JLabel("Salario");
private JLabel jLabel9 = new JLabel("Sexo");
//--------------------------------------------------
private JTextField txtDNI = new JTextField();
private JTextField txtNOMBRE_APELLIDO = new JTextField();
private JTextField txtFECHA_NACIMIENTO = new JTextField();
private JTextField txtDIRECCION = new JTextField();
private JTextField txtTELEFONO = new JTextField();
private JTextField txtSALARIO = new JTextField();
private JTextField txtFECHA_INGRESO = new JTextField();
private JTextField txtTITULO_PROFESIONAL = new JTextField();
//--------------------------------------------

public Ventana() {
initComponents();
}

private void Cargar_Controles() {

cbxDEPARTAMENTO_ACADEMICO.addItem("NO ESPECIFICADO");
cbxDEPARTAMENTO_ACADEMICO.addItem("SISTEMAS Y TELEMATICA");
cbxDEPARTAMENTO_ACADEMICO.addItem("GESTION Y PRODUCCION");
cbxDEPARTAMENTO_ACADEMICO.addItem("CIENCIAS DE LA COMPUTACION");
cbxDEPARTAMENTO_ACADEMICO.addItem("ECONOMETRIA Y TEORIA ECONOMICA");
cbxDEPARTAMENTO_ACADEMICO.addItem("INTELIGENCIA ARTIFICIAL");
cbxDEPARTAMENTO_ACADEMICO.addItem("MATEMATICAS");
cbxDEPARTAMENTO_ACADEMICO.addItem("FISICA");
cbxDEPARTAMENTO_ACADEMICO.addItem("QUIMICA");
cbxDEPARTAMENTO_ACADEMICO.addItem("REDES Y COMUNICACION DE DATOS");

cbxAREA_CONOCIMIENTO.addItem("NO ESPECIFICADO");
cbxAREA_CONOCIMIENTO.addItem("BASE DE DATOS");
cbxAREA_CONOCIMIENTO.addItem("DESARROLLO DE SISTEMAS");
cbxAREA_CONOCIMIENTO.addItem("INTELIGENCIA ARTIFICIAL");
cbxAREA_CONOCIMIENTO.addItem("COMPUTACION CUANTICA");
cbxAREA_CONOCIMIENTO.addItem("INGENIERIA WEB");
cbxAREA_CONOCIMIENTO.addItem("PLANEMAINTO Y CONTROL DE LA PRODUCCION");
cbxAREA_CONOCIMIENTO.addItem("INVESTIGACION DE OPERACIONES");
cbxAREA_CONOCIMIENTO.addItem("TEORIA DE COLAS Y MODELO DE INVENTARIOS");
cbxAREA_CONOCIMIENTO.addItem("CIENCIAS DE LA COMPUTACION");

​ ​ ​ ​
 cbxAREA_CONOCIMIENTO.addItem("TEORIA ECONOMICA");
cbxAREA_CONOCIMIENTO.addItem("ALGEBRA Y TEORIA DE GRUPOS");
cbxAREA_CONOCIMIENTO.addItem("CALCULO Y ECUACIONES DIFERENCIALES");
cbxAREA_CONOCIMIENTO.addItem("OPTICA");
cbxAREA_CONOCIMIENTO.addItem("QUIMICA ANALITICA");
cbxAREA_CONOCIMIENTO.addItem("REDES Y TELEPROCESO");

cbxAREA_CONOCIMIENTO.addItem("Nombrado");
cbxAREA_CONOCIMIENTO.addItem("Contratado");

//cbxGRADO_ACADEMICO.setModel(new DefaultComboBoxModel<>(new String[] {

"Bachiller", "Diplomado", "Maestria", "Doctorado" }));
cbxGRADO_ACADEMICO.addItem("Bachiller");
cbxGRADO_ACADEMICO.addItem("Diplomado");
cbxGRADO_ACADEMICO.addItem("Maestria");
cbxGRADO_ACADEMICO.addItem("Doctorado");

[Link](rbMASCULINO);
[Link](rbFEMENINO);
}

@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {
Establecer_TipoLetra();
Establecer_Color();
Cargar_Controles();
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

[Link](new [Link]() {
public void actionPerformed([Link] evt) {
btnLIMPIARActionPerformed(evt);
}
});

[Link](new [Link]() {
public void actionPerformed([Link] evt) {
btnSALIRActionPerformed(evt);
}
});

[Link](new [Link]() {
public void actionPerformed([Link] evt) {
btnREGISTRARActionPerformed(evt);
}
});

GroupLayout layout = new GroupLayout(getContentPane());

getContentPane().setLayout(layout);
[Link](
[Link]([Link])
.addGroup([Link]()

.addGroup([Link]([Link])
.addGroup([Link]()
.addGap(132, 132, 132)
.addComponent(jLabel1))
.addGroup([Link]()
.addGap(297, 297, 297)
.addComponent(jLabel2))
.addGroup([Link]()
.addGap(25, 25, 25)
.addComponent(jLabel5)

​ ​ ​ ​
 .addGap(164, 164, 164)
.addComponent(txtTELEFONO, GroupLayout.PREFERRED_SIZE,
135, GroupLayout.PREFERRED_SIZE))
.addGroup([Link]()
.addGap(25, 25, 25)
.addComponent(jLabel7)
.addGap(160, 160, 160)
.addComponent(txtDIRECCION, GroupLayout.PREFERRED_SIZE,
487, GroupLayout.PREFERRED_SIZE))
.addGroup([Link]()
.addGap(25, 25, 25)
.addComponent(jLabel9)
.addGap(199, 199, 199)
.addComponent(rbMASCULINO)
.addGap(18, 18, 18)
.addComponent(rbFEMENINO))
.addGroup([Link]()
.addGap(25, 25, 25)
.addComponent(jLabel8)
.addGap(182, 182, 182)
.addComponent(txtSALARIO, GroupLayout.PREFERRED_SIZE,
135, GroupLayout.PREFERRED_SIZE))
.addGroup([Link]()
.addGap(25, 25, 25)
.addComponent(jLabel10)
.addGap(18, 18, 18)
.addComponent(cbxDEPARTAMENTO_ACADEMICO,
GroupLayout.PREFERRED_SIZE, 336, GroupLayout.PREFERRED_SIZE))
.addGroup([Link]()
.addGap(20, 20, 20)
.addComponent(jLabel12)
.addGap(96, 96, 96)
.addComponent(txtFECHA_INGRESO,
GroupLayout.PREFERRED_SIZE, 135, GroupLayout.PREFERRED_SIZE))
.addGroup([Link]()
.addGap(20, 20, 20)
.addComponent(jLabel11)
.addGap(46, 46, 46)
.addComponent(cbxAREA_CONOCIMIENTO,
GroupLayout.PREFERRED_SIZE, 336, GroupLayout.PREFERRED_SIZE))
.addGroup([Link]()
.addGap(20, 20, 20)

.addGroup([Link]([Link])
.addGroup([Link]()
.addComponent(jLabel14)
.addGap(89, 89, 89)
.addComponent(cbxGRADO_ACADEMICO,
GroupLayout.PREFERRED_SIZE, 336, GroupLayout.PREFERRED_SIZE))
.addGroup([Link]()
.addComponent(jLabel13)
.addGap(155, 155, 155)
.addComponent(cbxCONDICION,
GroupLayout.PREFERRED_SIZE, 336, GroupLayout.PREFERRED_SIZE))
.addGroup([Link]()
.addComponent(jLabel15)
.addGap(89, 89, 89)
.addComponent(txtTITULO_PROFESIONAL,
GroupLayout.PREFERRED_SIZE, 420, GroupLayout.PREFERRED_SIZE))))
.addGroup([Link]()
.addGap(25, 25, 25)

.addGroup([Link]([Link])
.addComponent(jLabel6)
.addComponent(jLabel4)

​ ​ ​ ​
 .addComponent(jLabel3))
.addGap(62, 62, 62)

.addGroup([Link]([Link])
.addComponent(txtDNI, GroupLayout.PREFERRED_SIZE,
135, GroupLayout.PREFERRED_SIZE)
.addComponent(txtNOMBRE_APELLIDO,
GroupLayout.PREFERRED_SIZE, 590, GroupLayout.PREFERRED_SIZE)
.addComponent(txtFECHA_NACIMIENTO,
GroupLayout.PREFERRED_SIZE, 135, GroupLayout.PREFERRED_SIZE)))
.addGroup([Link]()
.addGap(454, 454, 454)
.addComponent(btnREGISTRAR, GroupLayout.PREFERRED_SIZE,
119, GroupLayout.PREFERRED_SIZE)
.addGap(27, 27, 27)
.addComponent(btnLIMPIAR, GroupLayout.PREFERRED_SIZE,
119, GroupLayout.PREFERRED_SIZE)
.addGap(34, 34, 34)
.addComponent(btnSALIR, GroupLayout.PREFERRED_SIZE, 119,
GroupLayout.PREFERRED_SIZE)))
.addContainerGap(114, Short.MAX_VALUE))
);
[Link](
[Link]([Link])
.addGroup([Link]()
.addGap(27, 27, 27)
.addComponent(jLabel1)
.addGap(6, 6, 6)
.addComponent(jLabel2)
.addGap(30, 30, 30)

.addGroup([Link]([Link])
.addComponent(jLabel3)
.addComponent(txtDNI, GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE))
.addGap(6, 6, 6)

.addGroup([Link]([Link])
.addComponent(jLabel4)
.addComponent(txtNOMBRE_APELLIDO, GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE))
.addGap(6, 6, 6)

.addGroup([Link]([Link])
.addGroup([Link]()
.addGap(3, 3, 3)
.addComponent(jLabel6))
.addComponent(txtFECHA_NACIMIENTO,
GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE))
.addGap(6, 6, 6)

.addGroup([Link]([Link])
.addGroup([Link]()
.addGap(3, 3, 3)
.addComponent(jLabel5))
.addComponent(txtTELEFONO, GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE))
.addGap(6, 6, 6)

.addGroup([Link]([Link])
.addGroup([Link]()
.addGap(3, 3, 3)
.addComponent(jLabel7))
.addComponent(txtDIRECCION, GroupLayout.PREFERRED_SIZE,

​ ​ ​ ​
GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE))
.addGap(6, 6, 6)

.addGroup([Link]([Link])
.addGroup([Link]()
.addGap(2, 2, 2)
.addComponent(jLabel9))
.addComponent(rbMASCULINO)
.addComponent(rbFEMENINO))
.addGap(6, 6, 6)

.addGroup([Link]([Link])
.addGroup([Link]()
.addGap(3, 3, 3)
.addComponent(jLabel8))
.addComponent(txtSALARIO, GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE))
.addGap(6, 6, 6)

.addGroup([Link]([Link])
.addGroup([Link]()
.addGap(3, 3, 3)
.addComponent(jLabel10))
.addComponent(cbxDEPARTAMENTO_ACADEMICO,
GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE))
.addGap(12, 12, 12)

.addGroup([Link]([Link])
.addComponent(jLabel12)
.addComponent(txtFECHA_INGRESO, GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE))
.addGap(9, 9, 9)

.addGroup([Link]([Link])
.addComponent(jLabel11)
.addComponent(cbxAREA_CONOCIMIENTO,
GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE))
.addGap(18, 18, 18)

.addGroup([Link]([Link])
.addGroup([Link]()
.addComponent(jLabel13)
.addGap(18, 18, 18)
.addComponent(jLabel14))
.addGroup([Link]()
.addComponent(cbxCONDICION, GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE)
.addPreferredGap([Link])
.addComponent(cbxGRADO_ACADEMICO,
GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE)))
.addPreferredGap([Link])

.addGroup([Link]([Link])
.addComponent(jLabel15)
.addComponent(txtTITULO_PROFESIONAL,
GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE))
.addGap(18, 18, 18)

.addGroup([Link]([Link])
.addComponent(btnLIMPIAR)
.addComponent(btnSALIR)

​ ​ ​ ​
 .addComponent(btnREGISTRAR))
.addContainerGap(56, Short.MAX_VALUE))
);

pack();
}// </editor-fold>

private void Establecer_Color() {

cbxAREA_CONOCIMIENTO.setBackground(COLOR_FONDO);
[Link](COLOR_FONDO);
cbxDEPARTAMENTO_ACADEMICO.setBackground(COLOR_FONDO);
cbxGRADO_ACADEMICO.setBackground(COLOR_FONDO);
[Link](COLOR_FONDO);
[Link](COLOR_FONDO);
txtFECHA_INGRESO.setBackground(COLOR_FONDO);
txtFECHA_NACIMIENTO.setBackground(COLOR_FONDO);
txtNOMBRE_APELLIDO.setBackground(COLOR_FONDO);
[Link](COLOR_FONDO);
[Link](COLOR_FONDO);
txtTITULO_PROFESIONAL.setBackground(COLOR_FONDO);
}

private void Establecer_TipoLetra() {

[Link](TIPO_LETRA3);
[Link](TIPO_LETRA3);
[Link](TIPO_LETRA3);
cbxAREA_CONOCIMIENTO.setFont(TIPO_LETRA3);
[Link](TIPO_LETRA3);
cbxDEPARTAMENTO_ACADEMICO.setFont(TIPO_LETRA3);
cbxGRADO_ACADEMICO.setFont(TIPO_LETRA3);
[Link](TIPO_LETRA1);
[Link](TIPO_LETRA3);
[Link](TIPO_LETRA3);
[Link](TIPO_LETRA3);
[Link](TIPO_LETRA3);
[Link](TIPO_LETRA3);
[Link](TIPO_LETRA3);
[Link](TIPO_LETRA2);
[Link](TIPO_LETRA3);
[Link](TIPO_LETRA3);
[Link](TIPO_LETRA3);
[Link](TIPO_LETRA3);
[Link](TIPO_LETRA3);
[Link](TIPO_LETRA3);
[Link](TIPO_LETRA3);
[Link](TIPO_LETRA3);
[Link](TIPO_LETRA3);
[Link](TIPO_LETRA3);
[Link](TIPO_LETRA3);
txtFECHA_INGRESO.setFont(TIPO_LETRA3);
txtFECHA_NACIMIENTO.setFont(TIPO_LETRA3);
txtNOMBRE_APELLIDO.setFont(TIPO_LETRA3);
[Link](TIPO_LETRA3);
[Link](TIPO_LETRA3);
txtTITULO_PROFESIONAL.setFont(TIPO_LETRA3);
}

private void btnLIMPIARActionPerformed([Link] evt) {

[Link]("");
txtNOMBRE_APELLIDO.setText("");
txtFECHA_NACIMIENTO.setText("");
[Link]("");
[Link]("");

​ ​ ​ ​
 [Link]("");
txtFECHA_INGRESO.setText("");
txtTITULO_PROFESIONAL.setText("");
}

private void btnSALIRActionPerformed([Link] evt) {

[Link](0);
}

private void btnREGISTRARActionPerformed([Link] evt) {

String CAD;
CAD = [Link]().trim();
if([Link](CAD,"DNI",8,8,"0123456789",2)) {
PSN.Establecer_DNI(CAD);
CAD = txtNOMBRE_APELLIDO.getText().trim();

if([Link](CAD,"Apellidos/Nombres",3,30,"ABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz" + (char)164 + (char)165,2)) {
PSN.Establecer_APENOM(CAD);
CAD = txtFECHA_NACIMIENTO.getText().trim();
if([Link](CAD,1960,2006,2)) {
PSN.Establecer_FECNAC(CAD);
CAD = [Link]().trim();
if([Link](CAD,"Telefono",9,9,"0123456789",2)) {
PSN.Establecer_TELEFONO(CAD);
CAD = [Link]().trim();

if([Link](CAD,"Direccion",5,30,"ABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz.0123456789",2)) {
PSN.Establecer_DIRECCION(CAD);

if([Link]() ) {
PSN.Establecer_SEXO("M");
}
if([Link]() ) {
PSN.Establecer_SEXO("F");
}

}
}
}
}
}

/**
* @param args the command line arguments
*/
public static void main(String args[]) {
try {
for ([Link] info :
[Link]()) {
if ("Nimbus".equals([Link]())) {
[Link]([Link]());
break;
}
}
} catch (ClassNotFoundException ex) {

[Link]([Link]()).log([Link]
.[Link], null, ex);

​ ​ ​ ​
 } catch (InstantiationException ex) {

[Link]([Link]()).log([Link]
.[Link], null, ex);
} catch (IllegalAccessException ex) {

[Link]([Link]()).log([Link]
.[Link], null, ex);
} catch (UnsupportedLookAndFeelException ex) {

[Link]([Link]()).log([Link]
.[Link], null, ex);
}

[Link](new Runnable() {
public void run() {
new Ventana().setVisible(true);
}
});
}

[Link]
import [Link];
import [Link];
import [Link];
import [Link];
import [Link].*;

public class TLib {

//-----------------------------------------------
public TLib() {
}
//-----------------------------------------------
public void ClearScreen() throws IOException, InterruptedException {
new ProcessBuilder("cmd","/c","cls").inheritIO().start().waitFor();
}
//-----------------------------------------------
public String Replicate(char E, int N) {
String T;
T = "";
for(int i=1;i<=N;i++) {
​ T = T + E;
}
return T;
}
//-----------------------------------------------
public boolean InRange(String CADENA, String RANGO){
int L,N,k,i;
char E;
boolean Sw,Hk;
L = [Link]();
N = [Link]();
Sw = true;
k = 0;

​ ​ ​ ​
 while((k<=L-1)&&(Sw==true)){
E = [Link](k);
Hk = false;
i = 0;
while((i<=N-1)&&(Hk==false)){
if([Link](i)==E){
Hk = true;
}
i++;
}
Sw = Hk;
k++;
}
return Sw;
}
//-----------------------------------------------
public boolean EsCadenaNumerica(String CAD) {
/*int i,L;
char E;
boolean Sw;
L = [Link]();
Sw = true;
i = 0;
while((i<=L-1)&&(Sw==true)) {
E = [Link](i);
if(!(('0'<=E)&&(E<='9'))) {
Sw = false;
}
i++;
}
return Sw;*/
return InRange(CAD,"0123456789");
}
//-----------------------------------------------
public boolean EsCadenaAlfabetica(String CAD) {
/*int i,L;
char E;
boolean Sw;
L = [Link]();
Sw = true;
i = 0;
while((i<=L-1)&&(Sw==true)) {
E = [Link](i);
if(!((('a'<=E)&&(E<='z'))||
(('A'<=E)&&(E<='Z'))
)) {
Sw = false;
}
i++;
}
return Sw;*/
return InRange(CAD,"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
}
//---------------------------------------------
public int PosicionIzquierda(String CADENA, char E) {
int i,P,L;
L = [Link]();
P = -1;
i = 0;
while((i<=L-1)&&(P==-1)) {
if([Link](i)==E) {
P = i;
}
i++;
}

​ ​ ​ ​
 return P;
}
//---------------------------------------------
public int TotalOcurrencias(String CADENA, char E) {
int C,L;
L = [Link]();
C = 0;
for(int i=0;i<=L-1;i++) {
if([Link](i)==E) {
C = C + 1;
}
}
return C;
}
//-----------------------------------------------
public boolean FechaOK(String FECHA, int MinYear, int MaxYear) {
boolean Sw;
String DD,MM,YYYY;
int P,T,L,YEAR,MONTH,DAY,TOTAL=0;
L = [Link]();
Sw = false;
if((8<=L)&&(L<=10)) {
T = TotalOcurrencias(FECHA,'/');
P = PosicionIzquierda(FECHA,'/');
if((T==2)&&(0<P)&&(P<L-6)&&([Link](L-5)=='/')) {
DD = [Link](0,P);
MM = [Link](P+1,L-5);
YYYY = [Link](L-4,L);
if((EsCadenaNumerica(DD)==true)&&
(EsCadenaNumerica(MM)==true)&&
(EsCadenaNumerica(YYYY)==true)) {
YEAR = [Link](YYYY);
if((MinYear<=YEAR)&&(YEAR<=MaxYear)) {
MONTH = [Link](MM);
if((1<=MONTH)&&(MONTH<=12)) {
DAY = [Link](DD);

if((MONTH==1)||(MONTH==3)||(MONTH==5)||(MONTH==7)||(MONTH==8)||(MONTH==10)||(MONT
H==12)) {
TOTAL = 31;
}
else {
if((MONTH==4)||(MONTH==6)||(MONTH==9)||(MONTH==11)) {
TOTAL = 30;
}
else {
TOTAL
=(((YEAR%4==0)&&(YEAR%100!=0))||((YEAR%400==0)&&(YEAR%100==0))?29:28);
}
}
Sw = ((1<=DAY)&&(DAY<=TOTAL));
if(!Sw) {
[Link]("ERROR: El Dia es Incorrecto!!!");
}
}
else {
[Link]("ERROR: El Mes es Incorrecto!!!");
}
}
else {
[Link]("ERROR: El Año es Incorrecto!!!");
}
}
else {
[Link]("ERROR: Existen Caracteres No Numericos");

​ ​ ​ ​
 }
}
else {
[Link]("ERROR: Los Delimitadores de Fecha son
incorrectos!!!");
}
}
else {
[Link]("ERROR: Longitud/Tamaño de Fecha es Incorrecta!!!");
}
return Sw;
}
//-----------------------------------------------
public boolean ValidacionOK(String CADENA, String HKGZ,int SIZE1, int SIZE2,
String RANGO, int MODE) {
int L;
boolean Sw;
String MessageError;
Sw = false;
L = [Link]();
if(L>0) {
if((SIZE1<=L)&&(L<=SIZE2)) {
if(InRange(CADENA,RANGO)==true) {
Sw = true;
}
else {
MessageError = "ERROR: " + HKGZ + " contiene caracteres
incorrectos!!!";
if([Link]()>0) {
if(MODE==1) {
[Link](MessageError);
}
else if(MODE==2) {
[Link](null,MessageError);
}
else {
}
}
}
}
else {
MessageError = "ERROR: " + HKGZ + " tiene Longitud Incorrecta!!!";
if([Link]()>0) {
if(MODE==1) {
[Link](MessageError);
}
else if(MODE==2) {
[Link](null,MessageError);
}
else {
}
}
}
}
else {
MessageError = "ERROR: " + HKGZ + " tiene Longitud 0!!!";
if([Link]()>0) {
if(MODE==1) {
[Link](MessageError);
}
else if(MODE==2) {
[Link](null,MessageError);
}
else {
}

​ ​ ​ ​
 }
}
return Sw;
}
//-----------------------------------------------
public boolean ExistDataFile(String FILENAME) {
File F = new File(FILENAME);
boolean Sw;
Sw = false;
if([Link]()) {
Sw = true;
}
return Sw;
}
//-----------------------------------------------
/*
public void WriteDataFile(String CAD, String FILENAME) {
double X;
long num;
try {
FileWriter FW = new FileWriter(FILENAME);
[Link](CAD);
[Link]();
}
catch (IOException E) {
[Link]([Link]());
}
}*/
public void WriteDataFile(String TEXT, String FILENAME) {
File FF;
FF = new File(FILENAME);
try {
FileWriter FW = new FileWriter(FF);
BufferedWriter BW = new BufferedWriter(FW);
PrintWriter PW = new PrintWriter(BW);
[Link](TEXT);
[Link]();
[Link]();
}
catch(IOException e) {
};
}
//-----------------------------------------------
public void AppendDataFile(String TEXT, String FILENAME) {
File FF;
FF = new File(FILENAME);
try {
FileWriter FW = new FileWriter(FF);
BufferedWriter BW = new BufferedWriter(FW);
PrintWriter PW = new PrintWriter(BW);
[Link](TEXT);
[Link]();
[Link]();
}
catch(IOException e) {
};
}

//-----------------------------------------------
public String ReadDataFile(String FILENAME) {
String LINE="",CADENA="";
try {
File FILE = new File(FILENAME);
BufferedReader BR = new BufferedReader(new FileReader(FILE));
while ((LINE = [Link]()) != null) {

​ ​ ​ ​
 CADENA = CADENA + LINE;
}
}
catch(IOException e) {
}
return CADENA;
}
//-----------------------------------------------
//-----------------------------------------------
//-----------------------------------------------
}

[Link]
import [Link];

public class TPERSONA {

//----------------------------------
//PROPIEDADES
//----------------------------------
private String DNI;
private String APENOM;
private String FECNAC;
private String TELEFONO;
private String DIRECCION;
private char SEXO;
private double SALARIO;
//----------------------------------
//METODO CONSTRUCTOR
//----------------------------------
public TPERSONA() {
}
//----------------------------------
//METODOS SET
//----------------------------------
public void Establecer_DNI(String dni) {
[Link] = dni;
}
public void Establecer_APENOM(String apenom) {
[Link] = apenom;
}
public void Establecer_FECNAC(String fecnac) {
[Link] = fecnac;
}
public void Establecer_TELEFONO(String telefono) {
[Link] = telefono;
}
public void Establecer_DIRECCION(String direccion) {
[Link] = direccion;
}
public void Establecer_SEXO(String CAD) { //char sexo
[Link] = [Link](0);
}
public void Establecer_SALARIO(String CAD) { //double salario
[Link] = [Link](CAD);

​ ​ ​ ​
}
//----------------------------------
//METODOS GET
//----------------------------------
public String Obtener_DNI() {
return [Link];
}
public String Obtener_APENOM() {
return [Link];
}
public String Obtener_FECNAC() {
return [Link];
}
public String Obtener_TELEFONO() {
return [Link];
}
public String Obtener_DIRECCION() {
return [Link];
}
public char Obtener_SEXO() {
return [Link];
}
public double Obtener_SALARIO() {
return [Link];
}
//----------------------------------
//----------------------------------
//----------------------------------
public String Registro_DatosGenerales() {
Scanner OBJ = new Scanner([Link]);
TLib LIB = new TLib();
String CAD;

do {
[Link](" - DNI : ");
CAD = [Link]();
} while(![Link](CAD,"DNI",8,8,"0123456789",2));
Establecer_DNI(CAD);

do {
[Link](" - Apellidos y Nombres : ");
CAD = [Link]();
}
while(![Link](CAD,"Apellidos/Nombres",3,30,"ABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz" + (char)164 + (char)165,2));
Establecer_APENOM(CAD);

do {
[Link](" - Fecha de Nacimiento : ");
CAD = [Link]();
} while();
Establecer_FECNAC(CAD);

do {
[Link](" - Telefono : ");
CAD = [Link]();
} while(![Link](CAD,"Telefono",9,9,"0123456789",2));
Establecer_TELEFONO(CAD);

do {
[Link](" - Direccion : ");
CAD = [Link]();
} while(![Link](CAD,"Direccion",5,30,"ABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz.0123456789",2));
Establecer_DIRECCION(CAD);

​ ​ ​ ​
 do {
[Link](" - Sexo : ");
CAD = [Link]();
} while(![Link](CAD,"Sexo",1,1,"MF",2));
Establecer_SEXO(CAD);

do {
[Link](" - Salario : ");
CAD = [Link]();
} while(![Link](CAD,"Salario",3,10,"0.123456789",2));
Establecer_SALARIO(CAD);

[Link]("----------------------------------------------------");

String TMP = "" + SALARIO;

return DNI + " | " +
APENOM + [Link](' ',30 - [Link]()) + " | " +
FECNAC + " | " +
TELEFONO + " | " +
DIRECCION + [Link](' ',30 - [Link]()) + " | " +
SEXO + " | " +
[Link](' ',10 - [Link]()) + TMP;

}
//----------------------------------
} //class

[Link]
import [Link];

public class TPROFESOR extends TPERSONA {

//----------------------------------
//PROPIEDADES
//----------------------------------
private String DEPARTAMENTO_ACADEMICO;
private String FECHA_INGRESO;
private String AREA_CONOCIMIENTO;
private String CONDICION; //{"Nombrado","Contratado"}
private String GRADO_ACADEMICO; // {"Bachiller","Maestria","Doctorado"}
private String TITULO_PROFESIONAL; // Ingeniero de Sistemas, ....
//----------------------------------
//METODO CONSTRUCTOR
//----------------------------------
public TPROFESOR() {
super();
}
//----------------------------------
//METODOS SET
//----------------------------------
public void Establecer_DEPARTAMENTO_ACADEMICO(String departamento_academico) {
this.DEPARTAMENTO_ACADEMICO = departamento_academico;

​ ​ ​ ​
}
//----------------------------------
public void Establecer_FECHA_INGRESO(String fecha_ingreso) {
this.FECHA_INGRESO = fecha_ingreso;
}
//----------------------------------
public void Establecer_AREA_CONOCIMIENTO(String area_conocimiento) {
this.AREA_CONOCIMIENTO = area_conocimiento;
}
//----------------------------------
public void Establecer_CONDICION(String condicion) {
[Link]= condicion;
}
//----------------------------------
public void Establecer_GRADO_ACADEMICO(String grado_academico) {
this.GRADO_ACADEMICO = grado_academico;
}
//----------------------------------
public void Establecer_TITULO_PROFESIONAL(String titulo_profesional) {
this.TITULO_PROFESIONAL = titulo_profesional;
}
//----------------------------------
//METODOS GET
//----------------------------------
public String Obtener_DEPARTAMENTO_ACADEMICO() {
return this.DEPARTAMENTO_ACADEMICO;
}
//----------------------------------
public String Obtener_FECHA_INGRESO() {
return this.FECHA_INGRESO;
}
//----------------------------------
public String Obtener_AREA_CONOCIMIENTO() {
return this.AREA_CONOCIMIENTO;
}
//----------------------------------
public String Obtener_CONDICION() {
return [Link];
}
//----------------------------------
public String Obtener_GRADO_ACADEMICO() {
return this.GRADO_ACADEMICO;
}
//----------------------------------
public String Obtener_TITULO_PROFESIONAL() {
return this.TITULO_PROFESIONAL;
}
//----------------------------------
//----------------------------------
//----------------------------------
public String Registro_PersonalDocente() {
Scanner OBJ = new Scanner([Link]);
TLib LIB = new TLib();
String CAD,LINEA;
LINEA = Registro_DatosGenerales();

do {
[Link](" - Departamento Academico : ");
CAD = [Link]();
} while(![Link](CAD,"Departamento
Academico",10,30,"ABCDEFGHIJKLMNOPQRSTUVWXYZ. abcdefghijklmnopqrstuvwxyz",2));
Establecer_DEPARTAMENTO_ACADEMICO(CAD);

do {
[Link](" - Fecha de Ingreso : ");

​ ​ ​ ​
 CAD = [Link]();
} while();
Establecer_FECHA_INGRESO(CAD);

do {
[Link](" - Area del Conocimiento : ");
CAD = [Link]();
} while(![Link](CAD,"Area del
Conocimiento",5,30,"ABCDEFGHIJKLMNOPQRSTUVWXYZ. abcdefghijklmnopqrstuvwxyz",2));
Establecer_AREA_CONOCIMIENTO(CAD);

do {
[Link](" - CONDICION : ");
CAD = [Link]();
}
while(![Link](CAD,"Condicion",8,10,"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghi
jklmnopqrstuvwxyz",2));
Establecer_CONDICION(CAD);

do {
[Link](" - Grado Academico : ");
CAD = [Link]();
} while(![Link](CAD,"Grado
Academico",8,30,"ABCDEFGHIJKLMNOPQRSTUVWXYZ. abcdefghijklmnopqrstuvwxyz",2));
Establecer_GRADO_ACADEMICO(CAD);

do {
[Link](" - Titulo Profesional : ");
CAD = [Link]();
} while(![Link](CAD,"Titulo
Profesional",10,30,"ABCDEFGHIJKLMNOPQRSTUVWXYZ. abcdefghijklmnopqrstuvwxyz",2));
Establecer_TITULO_PROFESIONAL(CAD);
return LINEA + " | " +
DEPARTAMENTO_ACADEMICO + [Link](' ',32 -
DEPARTAMENTO_ACADEMICO.length() ) +
FECHA_INGRESO + [Link](' ',12 - FECHA_INGRESO.length()
) +
AREA_CONOCIMIENTO + [Link](' ',32 -
AREA_CONOCIMIENTO.length() ) +
CONDICION + [Link](' ',12 - [Link]()
) +
GRADO_ACADEMICO + [Link](' ',32 -
GRADO_ACADEMICO.length() ) +
TITULO_PROFESIONAL + [Link](' ',32 -
TITULO_PROFESIONAL.length() );
}
//----------------------------------
} //class

​ ​ ​ ​
Vamos analizar un ejemplo básico usando archivos
secuenciales y archivos de acceso directo

EJERCICIO

Realizar la lectura/escritura de los datos de un

empleado (Id, Sueldo, Gasto) usando archivos
secuenciales y archivos de acceso directo

​ ​ ​ ​
SOLUCIÓN

//import [Link].*;
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];

import [Link];

public class FileRandomSequential {

//-----------------------------------------------
private static String FILENAME1 = "[Link]";
private static String FILENAME2 = "[Link]";
private static int W = 15;
private static long N;
//-----------------------------------------------
//-----------------------------------------------
public static String Replicate(char E, int N) {
String T;
T = "";
for(int i=1;i<=N;i++) {
T = T + E;
}
return T;
}
//-----------------------------------------------
//-----------------------------------------------
//-----------------------------------------------
//-----------------------------------------------
public static void ReadRandomFile(String LINEA) {
}
//-----------------------------------------------
public static void WriteRandomFile(String LINEA) {
}
//-----------------------------------------------
public static String GetLine(int k) {
int SUELDO=0,GASTO=0;
String LINEA,AUX,CODIGO;
AUX = "" + k + "";
CODIGO = "E" + Replicate('0',[Link]()) + AUX;
SUELDO = 1000 + 500*(int)([Link]()*18);
GASTO = (int)(0.60*SUELDO);
LINEA = " " + CODIGO;
AUX = "" + SUELDO + "";
LINEA = LINEA + " " + Replicate(' ',[Link]()) + AUX;
AUX = "" + GASTO + "";
LINEA = LINEA + " " + Replicate(' ',[Link]()) + AUX;

​ ​ ​ ​
 return LINEA;
}
//-----------------------------------------------
public static byte[] StringToBuffer(String LINEA) {
byte[] BUFFER = new byte[W];
for(int i=0;i<=W-1;i++) {
BUFFER[i] = (byte)[Link](i);
}
return BUFFER;
}
//-----------------------------------------------
public static String BufferToString(byte[] BUFFER) {
String LINEA="";
for(int i=0;i<=W-1;i++) {
LINEA = LINEA + (char)BUFFER[i];
}
return LINEA;
}
//-----------------------------------------------
public static void VisualizarDatos() {
Scanner SCN = new Scanner([Link]);
String LINEA;
byte[] BUFFER = new byte[W];
long T;
int i;
try {
[Link]("---------------------------------");
[Link]("i\tCODIGO\tSUELDO\tGASTO");
[Link]("---------------------------------");
File FILE = new File("[Link]");
BufferedReader BR = new BufferedReader(new FileReader(FILE));
i = 1;
while ((LINEA = [Link]()) != null) {
[Link](i + "\t" + LINEA);
i++;
}

[Link]("---------------------------------");
[Link]("i\tCODIGO\tSUELDO\tGASTO");
[Link]("---------------------------------");
RandomAccessFile RAF = new RandomAccessFile("[Link]","rw");
T = [Link]();
N = T/W;
for(long k=N;1<=k;k--) {
[Link]((k-1)*W);
[Link](BUFFER);
LINEA = BufferToString(BUFFER);
[Link](k + "\t" + LINEA);
}
[Link]("---------------------------------");
[Link]();
[Link]();
}
catch (IOException E) {
[Link]([Link]());
}
}
//-----------------------------------------------
public static void GenerarDatos() {
Scanner SCN = new Scanner([Link]);
String LINEA;
byte[] BUFFER;
long T;
try {
FileWriter FW = new FileWriter ("[Link]");

​ ​ ​ ​
 RandomAccessFile RAF = new RandomAccessFile("[Link]","rw");
[Link]("REGISTRO DE DATOS\n");
[Link]("-----------------------\n");
[Link]("Ingrese Total de Registros: ");
N = [Link]();
//[Link]("---------------------------------");
//[Link]("i\tCODIGO\tSUELDO\tGASTO");
//[Link]("---------------------------------");
for(int k=1;k<=N;k++) {
LINEA = GetLine(k);
BUFFER = StringToBuffer(LINEA);

//Escribiendo en Archivo Secuencial

[Link](LINEA + "\n");

//Escribiendo en Archivo Random

T = [Link]();

//N = T/W;
[Link](T); // [Link](N*W);
[Link](BUFFER);

//[Link](k + "\t|" + LINEA + "|");

}
//[Link]("---------------------------------");
[Link]();
[Link]();
}
catch (IOException E) {
[Link]([Link]());
}
}
//-----------------------------------------------
//-----------------------------------------------
//-----------------------------------------------
//-----------------------------------------------
public static void main(String[] args) {
GenerarDatos();
VisualizarDatos();
}
//-----------------------------------------------
} //class

​ ​ ​ ​
EJERCICIO

Realizar el ingreso, modificación, eliminación,

búsqueda y listado de productos usando archivos de
acceso directo

RAF_Demo.java

import [Link];

​ ​ ​ ​
import [Link];
import [Link];

public class RAF_Demo {

//-----------------------------------------------
private static String ARCHIVO = "[Link]";
private static int W = 50; //Longitud del Registro
private static Scanner SCN = new Scanner([Link]);
private static RandomAccessFile RAF;
private static RAF_Library LIB = new RAF_Library();
private static String[] UnidadMedida =
{"Null","Unidades","Kilogramos","Litros"};
private static byte[] BUFFER = new byte[W];
private static String ID,RECORD,NOMBRE,CANTIDAD,PRECIO,FECHA;
private static char FLAG,UMEDIDA,ESTADO;
//-----------------------------------------------
//-----------------------------------------------
private static void BuildRecord() {
RECORD = FLAG +
ID + " " +
NOMBRE + " " +
CANTIDAD + " " +
UMEDIDA + " " +
PRECIO + " " +
FECHA + " " +
ESTADO;
}
//-----------------------------------------------
private static void LoadFields() {
FLAG = [Link](0);
ID = [Link](1,4);
NOMBRE = [Link](5,25);
CANTIDAD = [Link](26,30);
UMEDIDA = [Link](31);
PRECIO = [Link](33,39);
FECHA = [Link](40,48);
ESTADO = [Link](49);
}
//-----------------------------------------------
private static void ViewFields() {
String TMP;
TMP = UnidadMedida[(int)(UMEDIDA)-48];
[Link]("Nombre : " + NOMBRE);
[Link]("Cantidad : " + CANTIDAD);
[Link]("Unidad de Medida : " + TMP + [Link]('
',[Link]()));
[Link]("Precio : " + PRECIO);
[Link]("Fecha de Vencimiento: " + [Link](6,8) +
'/' + [Link](4,6) + '/' + [Link](0,4));
[Link]("Activo : " +
(ESTADO=='1'?"Activo":"Inactivo"));
}
//-----------------------------------------------
public static long BuscarCodigo(String CODIGO) throws IOException,
InterruptedException {
long i,T,N,P;
RAF = new RandomAccessFile(ARCHIVO,"r");

​ ​ ​ ​
 T = [Link]();
N = T/W;
P = 0;
i = 1;
while((i<=N)&&(P==0)) {
[Link]((i-1)*W);
[Link](BUFFER);
RECORD = [Link](BUFFER);
LoadFields();
if([Link](CODIGO)==true) {
P = i;
}
i++;
}
[Link]();
return P;
}
//-----------------------------------------------
private static String RegistrarID() throws IOException,
InterruptedException {
String TMP;
do {
[Link]("Id : ");
TMP = [Link]().trim();
}
while((BuscarCodigo(TMP)>0)||([Link](TMP,"",3,3,"0123456789")==fa
lse));
return TMP;
}
//-----------------------------------------------
//-----------------------------------------------
private static String RegistrarNOMBRE() {
String TMP;
do {
[Link]("Nombre : ");
TMP = [Link]().trim();
}
while(![Link](TMP,"",7,20,"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijkl
mnopqrstuvwxyz. -0123456789"));
TMP = TMP + [Link](' ',[Link]());
return TMP;
}
//-----------------------------------------------
//-----------------------------------------------
private static String RegistrarCANTIDAD() {
String TMP;
do {
[Link]("Cantidad : ");
TMP = [Link]().trim();
} while(![Link](TMP,"",1,4,"0123456789"));
TMP = [Link](' ',[Link]()) + TMP;
return TMP;
}
//-----------------------------------------------
//-----------------------------------------------
private static char RegistrarUMEDIDA() {
String TMP;

​ ​ ​ ​
 do {
[Link]("Unidad de Medida : ");
TMP = [Link]();
} while(![Link](TMP,"",1,1,"0123"));
return [Link](0);
}
//-----------------------------------------------
//-----------------------------------------------
private static String RegistrarPRECIO() {
String TMP;
int L,P;
long T;
boolean Sw;
do {
[Link]("Precio : ");
TMP = [Link]().trim();
L = [Link]();
Sw = [Link](TMP,"",1,6,"0.123456789");
T = [Link](TMP,'.');
P = [Link](TMP,'.');
} while( (Sw==false) || (T!=1) || (P<=0) || (P!=L-3) );
TMP = [Link](' ',[Link]()) + TMP;
return TMP;
}
//-----------------------------------------------
//-----------------------------------------------
private static String RegistrarFECHA() {
String TMP;
do {
[Link]("Fecha de Vencimiento: ");
TMP = [Link]();
} while();
return [Link](6,10) + [Link](3,5) + [Link](0,2);
}
//-----------------------------------------------
//-----------------------------------------------
private static char RegistrarESTADO() {
String TMP;
do {
[Link]("Activo : ");
TMP = [Link]();
} while(![Link](TMP,"",1,1,"01"));
return [Link](0);
}
//-----------------------------------------------
//-----------------------------------------------
//-----------------------------------------------
//-----------------------------------------------
public static void Ingreso() throws IOException, InterruptedException {
String TMP,LINEA;
int L,P;
long T,N;
boolean Sw;
[Link]();
[Link]("INGRESO DE PRODUCTOS");

[Link]("====================================================");

​ ​ ​ ​
//.........................................................................
...........
FLAG = ' ';

//.........................................................................
...........
ID = RegistrarID();
NOMBRE = RegistrarNOMBRE();
CANTIDAD = RegistrarCANTIDAD();
UMEDIDA = RegistrarUMEDIDA();
PRECIO = RegistrarPRECIO();
FECHA = RegistrarFECHA();
ESTADO = RegistrarESTADO();

//.........................................................................
...........

//.........................................................................
...........
BuildRecord();

//.........................................................................
...........
RAF = new RandomAccessFile(ARCHIVO,"rw");
T = [Link]();
[Link](T);
BUFFER = [Link](RECORD,W);
[Link](BUFFER);
[Link]();
[Link]("\n\nPulse [ENTER] para Salir!!!");
TMP = [Link]();
}
//-----------------------------------------------
public static void Modificacion() throws IOException, InterruptedException
{
String TMP;
long P;
[Link]();
[Link]("MODIFICACION DE PRODUCTOS");

[Link]("====================================================");

//.........................................................................
...........
do {
[Link]("Id : ");
TMP = [Link]().trim();
} while(![Link](TMP,"",3,3,"0123456789"));

[Link]("----------------------------------------------------");

//.........................................................................
...........
P = BuscarCodigo(TMP);
if(P>0) {

​ ​ ​ ​
 RAF = new RandomAccessFile(ARCHIVO,"rw");
[Link]((P-1)*W);
[Link](BUFFER);
RECORD = [Link](BUFFER);
LoadFields();
ViewFields();

[Link]("----------------------------------------------------");
do {
[Link] ("Desea Modificar el Registro? [S/N]: ");
TMP = [Link]().trim();
} while(![Link](TMP,"",1,1,"SsNn"));
if(([Link](0)=='S')||
([Link](0)=='s')) {

//.........................................................................
...........
FLAG = ' ';
NOMBRE = RegistrarNOMBRE();
CANTIDAD = RegistrarCANTIDAD();
UMEDIDA = RegistrarUMEDIDA();
PRECIO = RegistrarPRECIO();
FECHA = RegistrarFECHA();
ESTADO = RegistrarESTADO();

//.........................................................................
...........
BuildRecord();

//.........................................................................
...........
RAF = new RandomAccessFile(ARCHIVO,"rw");
[Link]((P-1)*W);
BUFFER = [Link](RECORD,W);
[Link](BUFFER);
[Link]();
}
}
else {
[Link]("ERROR: El codigo especificado No Existe");
}
[Link]("\n\nPulse [ENTER] para Salir!!!");
[Link]();
}
//-----------------------------------------------
public static void Eliminacion() throws IOException, InterruptedException {
String TMP;
long P;
[Link]();
[Link]("ELIMINACION DE PRODUCTOS");

[Link]("====================================================");

//.........................................................................
...........
do {
[Link]("Id : ");

​ ​ ​ ​
 TMP = [Link]().trim();
} while(![Link](TMP,"",3,3,"0123456789"));

[Link]("----------------------------------------------------");

//.........................................................................
...........
P = BuscarCodigo(TMP);
if(P>0) {
RAF = new RandomAccessFile(ARCHIVO,"rw");
[Link]((P-1)*W);
[Link](BUFFER);
RECORD = [Link](BUFFER);
LoadFields();
ViewFields();

[Link]("----------------------------------------------------");
do {
[Link] ("Desea Eliminar el Registro? [S/N]: ");
TMP = [Link]().trim();
} while(![Link](TMP,"",1,1,"SsNn"));
if(([Link](0)=='S')||
([Link](0)=='s')) {
FLAG = '*';
BuildRecord();
BUFFER = [Link](RECORD,W);
[Link]((P-1)*W);
[Link](BUFFER);
[Link]();
[Link]("El Registro ha sido Eliminado!!!");
}
}
else {
[Link]("ERROR: El codigo especificado No Existe");
}
[Link]("\n\nPulse [ENTER] para Salir!!!");
[Link]();
}
//-----------------------------------------------
public static void Busqueda() throws IOException, InterruptedException {
String TMP;
long P;
[Link]();
[Link]("BUSQUEDA DE PRODUCTOS");

[Link]("====================================================");

//.........................................................................
...........
do {
[Link]("Id : ");
TMP = [Link]().trim();
} while(![Link](TMP,"",3,3,"0123456789"));

[Link]("----------------------------------------------------");

//.........................................................................

​ ​ ​ ​
...........
P = BuscarCodigo(TMP);
if(P>0) {
RAF = new RandomAccessFile(ARCHIVO,"rw");
[Link]((P-1)*W);
[Link](BUFFER);
RECORD = [Link](BUFFER);
LoadFields();
if(FLAG!='*') {
ViewFields();
}
else {
[Link]("ERROR: El Registro ha sido Eliminado");
}

[Link]("----------------------------------------------------");
}
else {
[Link]("ERROR: El codigo especificado No Existe");
}
[Link]("\n\nPulse [ENTER] para Salir!!!");
[Link]();
}
//-----------------------------------------------
public static void Listado() throws IOException, InterruptedException {
String TMP;
long T,N;
[Link]();
[Link]("LISTADO DE PRODUCTOS");

[Link]("====================================================");

//.........................................................................
...........
RAF = new RandomAccessFile(ARCHIVO,"r");
T = [Link]();
N = T/W;
for(int i=1;i<=N;i++) {
[Link]((i-1)*W);
[Link](BUFFER);
RECORD = [Link](BUFFER);
LoadFields();
if(FLAG==' ') {
TMP = UnidadMedida[(int)(UMEDIDA)-48];
[Link](ID + ' ' +
NOMBRE + ' ' +
CANTIDAD + ' ' +
TMP + [Link](' ',[Link]()) +
PRECIO + ' ' +
[Link](6,8) + '/' +
[Link](4,6) + '/' + [Link](0,4) + ' ' +
(ESTADO=='1'?"Activo":"Inactivo"));
}
}
[Link]();
[Link]("\n\nPulse [ENTER] para Salir!!!");
TMP = [Link]();

​ ​ ​ ​
}
//-----------------------------------------------
public static char MenuPrincipal() throws IOException, InterruptedException
{
String CAD;
do {
[Link]();
[Link](" G E S T I O N D E P R O D U C T O S ");
[Link]("=========================================");
[Link]();
[Link](" -----------------------------------");
[Link](" MENU PRINCIPAL");
[Link](" -----------------------------------");
[Link](" 1. Ingreso de Productos");
[Link](" 2. Modificacion de Productos");
[Link](" 3. Eliminacion de Productos");
[Link](" 4. Busqueda por Codigo/Nombre");
[Link](" 5. Listado de Productos");
[Link](" 6. Salir");
[Link](" -----------------------------------");
[Link] (" SELECCIONE OPCION: ");
CAD = [Link]();
} while(![Link](CAD,"",1,1,"123456"));
return [Link](0);
}
//-----------------------------------------------
public static void main(String[] args) throws IOException,
InterruptedException {
char OPCION;
do {
OPCION = MenuPrincipal();
switch(OPCION) {
case '1': Ingreso(); break;
case '2': Modificacion(); break;
case '3': Eliminacion(); break;
case '4': Busqueda(); break;
case '5': Listado(); break;
//case '6': [Link](0);
}
} while(OPCION!='6');
[Link]();
}
//-----------------------------------------------
} //class

​ ​ ​ ​
RAF_Library.java
import [Link];

public class RAF_Library {

//-----------------------------------------------
public RAF_Library() {
}
//-----------------------------------------------
public String Replicate(char E, int N) {
String T;
T = "";
for(int i=1;i<=N;i++) {
​ T = T + E;
}
return T;
}
//-----------------------------------------------
public void ClearScreen() throws IOException, InterruptedException {
new ProcessBuilder("cmd","/c","cls").inheritIO().start().waitFor();
}
//-----------------------------------------------
public int PosicionIzquierda(String CADENA, char E) {
int i,P,L;
L = [Link]();
P = -1;
i = 0;
while((i<=L-1)&&(P==-1)) {
if([Link](i)==E) {
P = i;
}
i++;
}
return P;
}
//-----------------------------------------------
public int TotalOcurrencias(String CADENA, char E) {
int C,L;
L = [Link]();
C = 0;
for(int i=0;i<=L-1;i++) {
if([Link](i)==E) {
C = C + 1;
}
}
return C;
}

​ ​ ​ ​
//-----------------------------------------------
public boolean EsCadenaNumerica(String CAD) {
/*int i,L;
char E;
boolean Sw;
L = [Link]();
Sw = true;
i = 0;
while((i<=L-1)&&(Sw==true)) {
E = [Link](i);
if(!(('0'<=E)&&(E<='9'))) {
Sw = false;
}
i++;
}
return Sw;*/
return InRange(CAD,"0123456789");
}

public boolean EsCadenaAlfabetica(String CAD) {

/*int i,L;
char E;
boolean Sw;
L = [Link]();
Sw = true;
i = 0;
while((i<=L-1)&&(Sw==true)) {
E = [Link](i);
if(!((('a'<=E)&&(E<='z'))||
(('A'<=E)&&(E<='Z'))
)) {
Sw = false;
}
i++;
}
return Sw;*/
return
InRange(CAD,"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
}
//-----------------------------------------------
public boolean InRange(String CADENA, String RANGO){
int L,N,k,i;
char E;
boolean Sw,Hk;
L = [Link]();
N = [Link]();
Sw = true;
k = 0;
while((k<=L-1)&&(Sw==true)){
E = [Link](k);
Hk = false;
i = 0;
while((i<=N-1)&&(Hk==false)){
if([Link](i)==E){
Hk = true;
}
i++;

​ ​ ​ ​
 }
Sw = Hk;
k++;
}
return Sw;
}
//-----------------------------------------------
public boolean ValidacionOK(String CADENA, String HKGZ,int SIZE1, int
SIZE2, String RANGO) {
int L;
boolean Sw;
Sw = false;
L = [Link]();
if(L>0) {
if((SIZE1<=L)&&(L<=SIZE2)) {
if(InRange(CADENA,RANGO)==true) {
Sw = true;
}
else {
if([Link]()>0) {
[Link]("ERROR: " + HKGZ + " contiene
caracteres incorrectos!!!");
}
}
}
else {
if([Link]()>0) {
[Link]("ERROR: " + HKGZ + " tiene Longitud
Incorrecta!!!");
}
}
}
else {
if([Link]()>0) {
[Link]("ERROR: " + HKGZ + " tiene Longitud 0!!!");
}
}
return Sw;
}
//-----------------------------------------------
public boolean FechaOK(String FECHA, int MinYear, int MaxYear, boolean HK)
{
boolean Sw;
String DD,MM,YYYY;
int P,T,L,YEAR,MONTH,DAY,TOTAL=0;
L = [Link]();
Sw = false;
if((8<=L)&&(L<=10)) {
T = TotalOcurrencias(FECHA,'/');
P = PosicionIzquierda(FECHA,'/');
if((T==2)&&(0<P)&&(P<L-6)&&([Link](L-5)=='/')) {
DD = [Link](0,P);
MM = [Link](P+1,L-5);
YYYY = [Link](L-4,L);
if((EsCadenaNumerica(DD)==true)&&
(EsCadenaNumerica(MM)==true)&&
(EsCadenaNumerica(YYYY)==true)) {

​ ​ ​ ​
 YEAR = [Link](YYYY);
if((MinYear<=YEAR)&&(YEAR<=MaxYear)) {
MONTH = [Link](MM);
if((1<=MONTH)&&(MONTH<=12)) {
DAY = [Link](DD);

if((MONTH==1)||(MONTH==3)||(MONTH==5)||(MONTH==7)||(MONTH==8)||(MONTH==10)|
|(MONTH==12)) {
TOTAL = 31;
}
else {

if((MONTH==4)||(MONTH==6)||(MONTH==9)||(MONTH==11)) {
TOTAL = 30;
}
else {
TOTAL
=(((YEAR%4==0)&&(YEAR%100!=0))||((YEAR%400==0)&&(YEAR%100==0))?29:28);
}
}
Sw = ((1<=DAY)&&(DAY<=TOTAL));
if(!Sw&&HK) {
[Link]("ERROR: El Dia es
Incorrecto!!!");
}
}
else {
​ ​ ​ ​ if(HK==true) {
[Link]("ERROR: El Mes es
Incorrecto!!!");
​ ​ ​ }
}
}
else {
​ ​ ​ if(HK==true) {
[Link]("ERROR: El Año es Incorrecto!!!");
​ ​ }
}
}
else {
​ ​ if(HK==true) {
[Link]("ERROR: Existen Caracteres No
Numericos");
​ }
}
}
else {
​ if(HK==true) {
[Link]("ERROR: Los Delimitadores de Fecha son
incorrectos!!!");
}
}
}
else {
​ if(HK==true) {
[Link]("ERROR: Longitud/Tamaño de Fecha es
Incorrecta!!!");

​ ​ ​ ​
 }
}
return Sw;
}
//-----------------------------------------------
public byte[] StringToBuffer(String CADENA, int W) {
byte[] BUFFER = new byte[W];
int L = [Link]();
for(int i=0;i<=L-1;i++) {
BUFFER[i] = (byte)[Link](i);
}
return BUFFER;
}
//-----------------------------------------------
public String BufferToString(byte[] BUFFER) {
String CADENA="";
int L = [Link];
for(int i=0;i<=L-1;i++) {
CADENA = CADENA + (char)BUFFER[i];
}
return CADENA;
}
//-----------------------------------------------
} //class

​ ​ ​ ​
​ ​ ​ ​
■■■■■■■■■■■■■■■■■■■■■■■
​ ​ ​ ​
■■■■■■■■■■■■■■■■■■■■■■■
■■■■■■■■■■■■■■■■■■■■■■■

Desarrollo Web

​ ​ ​ ​
​ ​ ​ ​
​ ​ ​ ​
​ ​ ​ ​
​ ​ ​ ​
​ ​ ​ ​
​ ​ ​ ​
—---------------

​ ​ ​ ​
​ ​ ​ ​
​ ​ ​ ​
TAREA
Crear una funcion que realice el tratamiento de cadenas
organizadas en secuencia jerarquica en 2 niveles

public class Niveles {

​ ​ ​ ​
//----------------------------------------
public static int Count(String S, char E) {
int C,A,B,N;
N = [Link]();
A = 0;
B = 0;
C = 0;
while((A<=B)&&(B<=N-1)) {
​ if([Link](B)==E) {
​ ​ C++;
A = B + 1;
B = A - 1;
​ }
B++;
}
C++;
return C;
}
//----------------------------------------
public static String[] List(String S, char E) { //SPLIT
int k,A,B,N;
String T;
String[] V = new String[Count(S,E)];
N = [Link]();
A = 0;
B = 0;
k = -1;
while((A<=B)&&(B<=N-1)) {
​ if([Link](B)==E) {
​ ​ T = [Link](A,B);
​ ​ k++;
​ ​ V[k] = T;
[Link]("|" + T + "|");
A = B + 1;
B = A - 1;
​ }
B++;
}
T = [Link](A,N);
k++;
​ V[k] = T;
[Link]("|" + T + "|");
[Link]();
return V;
}
//----------------------------------------
public static void main(String args[]) {
String[] W;
​
/*​ List("111;222;333;444;555",';');
​ List(";222;333;444;555",';');
​ List("111;222;333;444;",';');
​ List("111;;;;555",';');
​ List(";;;;",';');
*/

​ W = List("111;222;333;444;555",';');

​ ​ ​ ​
​ for(int i=0;i<=[Link]-1;i++) {
​ ​ [Link](i + " ==> |" + W[i] + "|");
​ }

}
//----------------------------------------
//----------------------------------------
//----------------------------------------
}

MODELO DE DATOS PRELIMINAR

[Link]
UaVWtdy0E_bON8Yew/edit?usp=sharing

​ ​ ​ ​
​ ​ ​ ​