COMPUTACION

1. PAQUETES Y CLASES
PAQUETE.-
Definición.- Es un conjunto de clases que se han agrupado porque tienen alguna relación,
pueden ser clases de un mismo proyecto, o clases de un mismo estilo.
Declaración.- Se declaran en la clase genérica componente utilizando la palabra package
seguida del nombre del paquete. Esta instrucción debe ir al inicio del archivo y debe ser la
primera sentencia que debe ejecutarse:
package factura;
public class persona{
---------------
}
Creación.- Al crearse un paquete se crea una carpeta con el mismo nombre del paquete,
En el caso del ejemplo se creara la carpeta factura si se coloca la misma instrucción
package al inicio de otras clase se lograra agrupar varias clase en el mismo paquete
Para ello luego de crear el area de trabajo y la clase principal elegir la carpeta src y
adicionar una nueva clase, en el recuadro que indica nombre del paquete escribir el nombre
del
paquete asi Luego en la ventana de creación de la clase
consignar el nombre del paquete

2. 2
Utilización.- Para utilizar las clases que están en un paquete(package), se utiliza la
sentencia import. Esto permitirá utilizarla haciendo referencia a una clase desde otra que se
encuentra fuera del paquete. Para ello tendrá que escribir
import nombredelpaquete.nombredelaclase;
ejemplo import factura.persona;
La sentencia anterior permitirá tener acceso pleno a todos los miembros (variables y
metodos) de la clase.persona del paquete factura
Si se desea tener acceso a todas las clases del paquete bastaría reemplazar la sentencia
anterior por import factura.*;
CLASE
Definición.- Es una plantilla que especifica los atributos y el comportamiento de un
determinado tipo de objeto. Los atributos se especifican mediante variables (variables
miembro) y el comportamiento mediante métodos (métodos miembro). En la programación
por objetos una clase define un nueto tipo de dato. Una vez definido este nuevo tipo se
puede utilizar para crear objetos.
Declaracion y estructura de una clase
package nombredelpaquete;
public class nombredeclase{
// declaración de variables miembro
- - - - - - - - - - - - - - - - - - - - - -
// Definición el constructor
Public nombredeclase(parámetros){
- - - - - - - - - - - - - - - - - - - - - -
}
//Definición de métodos miembro
Public nombredeclase(parámetros){
- - - - - - - - - - - - - - - - - - - - - -
}
}
OBSERVACIONES una clase posee
Atributos: que son todas las variables que tendrá la clase.
Constructor: es un método que inicializa dichas variables.
Métodos: los que sean necesarios para el manejo de dicha clase.

3. 3
CONSTRUCTOR Y OBJETOS
CONSTRUCTOR
Constructor es un método especial que se utiliza para inicializar un objeto inmediatamente
después de su creación.
El constructor de una clase debe tener el mismo nombre de su clase y no tener tipo de retorno
Si una clase no define un constructo, Java crea un constructor por defecto que no tiene
parámetros y que no realiza ninguna inicialización especial.
Si el constructor es definido por segunda o tercera vez ocasiona una sobrecarga.
public class persona{
//atributos: acceso tipo nombre_variable;
public String nombre;
private int edad;
//constructor, este método debe tener el mismo nombre de la Clase
public persona( ){
}
//métodos propios
}// fin de la clase persona
Objeto: es una instancia de una clase (entendiéndose como ejemplar de)
La JVM, carga a la memoria el código de btes de una clase la primera vez que la clase sea
mencionada durante la ejecución del programa. De aquí en adelante la clase cargada será
utilizada como una fabrica de objetos. Es decir un objeto no es mas que una variable cuyo
tipo es una clase, si es propia de Java (JLabel, JButton,etc.) o creada por nosotros. Esta
llamada de clase tendrá la siguiente forma:
Creación de objetos
Se declara una variable referencia que almacenara la direion de memoria del objeto a crear
asi: nombredeclase nombrereferencia;
Se crea en seguida el objeto y se le asigna una dirección de memoria a la variable referencia
en forma dinámica asi: nombredereferencia = new nombredeclase(argumentos): Al nombre
de referencia lo vamos a usar como una variable.
Los dos pasos anteriores se pueden hacer en uno solo:
nombredeclase variable = new nombre de clase(argumentos);

4. 4
ejemplo persona p = new persona();
La variable p es de tipo persona, la cual contendrá dicha clase. De esta manera podremos
utilizar todos los métodos y variables creados en esta clase.
ACCESO A LOS MIEMBROS DE UNA CLASE
Para acceder a los miembros de una clase se escribe el nombre la la variable de referencia,
un punto y el nombre del miembro(variable miembro o método miembro) al que se desea
acceder.
Ejemplo Crear un proyecto con dos clases una llamada principal y otra llamada persona
la clase Persona en el paquete ficha que tenga como atributos públicos:nombre, apellido,
edad, talla y peso. Implemente los siguientes métodos:
- Un constructor que inicialice a los atributos.
- Un método que retorne si la persona es mayor o menor de edad.
En la clase principal
- Crear un objeto persona con datos fijos e imprimir sus datos.
Modificar los datos del objeto creado:
- Aumentar la edad actual en 5 años
- Disminuir el peso actual en 3 kg
Luego, imprima la nueva edad y el nuevo peso.
mport java.awt.event.*;
import java.awt.*;
import javax.swing.*;
import ficha.persona;
public class Principal extends JApplet
implements ActionListener{
// Declaración de variables globales
JButton btnProcesar, btnBorrar;
JTextArea txtS;
JScrollPane scpScroll;
public void init() {
getContentPane().setLayout(null);
getContentPane().setBackground(new
Color(214,211,206));
// btnProcesar
btnProcesar = new JButton("Procesar");
btnProcesar.setBounds(50, 30, 100, 20);
btnProcesar.addActionListener(this);
getContentPane().add(btnProcesar);
// btnBorrar
btnBorrar = new JButton("Borrar");
btnBorrar.setBounds(180, 30, 100, 20);
btnBorrar.addActionListener(this);
getContentPane().add(btnBorrar);
// txtS
txtS = new JTextArea();
txtS.setFont(new Font("monospaced", 0,
12));
//scpScroll
scpScroll=new JScrollPane(txtS);
scpScroll.setBounds(10, 70, 350, 300);
getContentPane().add(scpScroll);
}
// Procesa eventos de tipo ActionEvent
public void actionPerformed( ActionEvent e
){
if( e.getSource() == btnProcesar )
procesar();
if( e.getSource() == btnBorrar )
borrar();
}
void procesar(){
persona p = new persona(
"Mabel",

5. 5
"Romo",
27,
165.5,
50.5);
imprimir("Nombre : " + p.nombre);
imprimir("Apellido : " + p.apellido);
imprimir("Edad : " + p.edad);
imprimir("Peso : " + p.peso);
imprimir("Talla : " + p.talla);
imprimir("Es Mayor : " +
p.isMayorDeEdad());
p.edad += 5;
p.peso -= 3;
imprimir("---------------------------");
imprimir("Nombre : " + p.nombre);
imprimir("Apellido : " + p.apellido);
imprimir("Edad : " + p.edad);
imprimir("Peso : " + p.peso);
imprimir("Talla : " + p.talla);
imprimir("Es Mayor : " +
p.isMayorDeEdad());
}
void borrar(){
imprimir();
}
void imprimir( String s ){
txtS.append(s + "n");
}
void imprimir(){
txtS.setText("");
}
}
CLASE PERSONA
package ficha;
public class persona {
public String nombre, apellido;
public int edad;
public double talla, peso;
public persona(
String nombre,
String apellido,
int edad,
double talla,
double peso){
this.nombre = nombre;
this.apellido = apellido;
this.edad = edad;
this.talla = talla;
this.peso = peso;
}
public boolean isMayorDeEdad(){
if(edad>=18) return true;
else return false;
}
}
EJERCICIOS
Ejercicio:
1. Crear la clase video en el paquete casavideo que tenga como atributos
privados:codigo, nombre del video, duración y precio en soles.Implemente los
siguientes métodos:
 Un constructor que inicialice a los atributos.
 Métodos de acceso set y get para todos los atributos.
 Un método que retorne el precio del video en dolares.
 En la clase principal crear un objeto video que cada vez que se haga clic al botón
procesar con datos extraídos de la GUI.
a. Aumente el precio del video en 2 soles.
b. Imprima el nuevo precio del video en dólares.
2. Crear la clase empleado en el paquete empresa que tenga como atributos privados:
codigo, nombre, horas trabajadas y tarifa. Implemente los siguientes métodos:
 Un constructor que inicialice a los atributos.

6. 6
 métodos de acceso: set/get para cada atributo.
 un método que retorne el sueldo bruto (horas*tarifa)
 un método que retorne el descuento (13% del sueldo bruto)
 un método que retorne el sueldo neto (neto = bruto - descuento)
 En la clase principal:Cree un objeto empleado cada vez que le de clic al botón
procesar cuyos datos se ingresaran desde la GUI e imprima sus atributos, el sueldo
bruto, descuento y sueldo neto.
a. Aumente la tarifa actual en 10 soles e imprima la nueva tarifa y el
b. sueldo neto del empleado.
3. Realizar un programa que defina la clase alumno dentro del paquete notas que permita
registrar un nombre y 3 notas. y contenga un método que calcule el promedio y desde
la clase Principal acceder a la clase alumno enviándole los datos. e imprimiendo el
reporte
CONTROL DE ACCESO Y ENCAPSULAMIENTO
CONTROL DE ACCESO
Una clase puede controlar que partes de un programa puedan acceder a los componentes o
miembros de su clase: variables miembro y métodos miembro.
Una clase bien diseñada impide el acceso directo a sus variables miembro proporcionado a
cambio un conjunto de METODOS DE ACCESO que sirvan como intermediarios entre las
variables miembro.
Algunos métodos de la clase pueden ser necesarios solo desde el interior de la clase por lo
ue deben quedar restringidos solo para uso interno
Especificador
de acceso
Acceso a los miembros
Desde la
misma clase
Desde una
subclase
Desde una
clase del mismo
paquete
Desde el
exterior de la
misma clase
public X X X X
Private X
protected X X X
sinespecificar X X
ENCAPSULAMIENTO
Es la capacidad que tiene una aplicación de ocultar detalles internos del comportamiento
de una clase y dar a conocer solo los detalles ue sean necesario para el resto de las clase.
Este ocultamiento permite restringir y controlar el uso de la clase.
Se restringe porque existen ciertos atributos y métodos privados o protegidos y se controla
porque habrán ciertos mecanismos para modificar el estado de una clase como por ejemplo
los métodos de acceso
Ejercicios

7. 7
26. ARREGLOS (ARRAY)
26.1 Definición: son estructuras de datos, donde cada elemento conserva una posición en
memoria. Los datos de un array, están diseñados de forma que unos están a continuación de
otros.
Para manejar la posición de sus elementos disponen de un sub-índice:
- Si tiene un sub-índice serán “unidimensionales” o “vectores”.
- Si tienen 2 sub-índices serán “bidimensionales” o “matrices”.
- Si tienen más de 2 sub-índices serán multidimensionales.
Los arrays serán del mismo tipo de los datos que guardaremos en estos.
26.2 Arreglos Unidimensionales: los array serán declarados de la misma manera que
cualquier variable, con la diferencia que se le agregarán un par de corchetes “[ ]” al final de
su nombre, lo que representará que son de una sola dimensión. A continuación los tipos
básicos para declarar un array.
Array de tipo cadena:
String nombre[ ];
posición 0
posición 1
posición 2
posición 3
Array de tipo entero:
Laura
Esteban
Paula
Juan

8. 8
int edad[ ];
posición 0
posición 1
posición 2
posición 3
Array de tipo real:
double talla[ ];
posición 0
posición 1
posición 2
posición 3
19
21
18
23
1.55
1.72
1.60
1.68

9. 9
Otra forma de declaración es colocando los corchetes luego del tipo del array.
Ejemplo:
String[ ] nombre;
int[ ] edad;
double[ ] talla;
Creación del array: para la creación del array se usará la siguiente forma:
nombre_array = new tipo[ tamaño];
Ejemplo:
nombre = new String[4];
edad = new int[4];
talla = new double[4];
Estos array tienen 4 espacios para datos, la posición de cada dato va del 0 al 3.
Ingresar elementos: para el ingreso de datos a un array, es necesario mencionar el
nombre del array y la posición en la que se agregará dicho dato.
Ejemplo: ingresar los datos del array nombre.
nombre[0] = “Laura”;
nombre [1] = “Esteban”;
nombre [2] = “Paula”;
nombre [3] = “Juan”;

10. 10
Otra forma de cargar los datos es:
nombre[ ] = {“Laura”,” Esteban”,“ Paula”,” Juan”};
Acceso a un elemento: para acceder a un elemento de cualquier array, es necesario
mencionar el nombre del array y la posición, del dato que necesitamos.
Ejemplo: imprimir los datos del array edad.
imprimir(“Edad de la posición 0: ”+edad[0] );
imprimir(“Edad de la posición 1: ”+edad[1] );
imprimir(“Edad de la posición 2: ”+edad[2] );
imprimir(“Edad de la posición 3: ”+edad[3] );
Lo más aconsejable para manejar arrays es crear Clases propias, las cuales nos permitirán
manejar en una clase la GUI y la lógica, y en la otra clase el array y los métodos necesarios
para su funcionamiento.
A continuación mostrares un pequeño programa que permite el ingreso de precios y los
almacena en el array.
Clase Principal: “ArregloUnidimensional”
// invocación de librerías
import java.awt.*;
import java.awt.event.*;

11. 11
import javax.swing.*;
public class ArregloUnidimensional extends JApplet implements ActionListener{
//declaración de variables globales
JLabel lblTitulo,lblPrecio;
JTextField txtPrecio;
JButton btnProcesar,btnBorrar;
JTextArea txtArea;
JScrollPane scpScroll;
//llamada a la Clase Precios
/*creamos una variable "p" de tipo Precios que contendrá a la clase Precios
con esto podremos utilizar todos los métodos creados en esa clase*/
Precios p=new Precios( );
// GUI
public void init( ) {
getContentPane( ).setLayout(null);
//creamos el titulo centrado
lblTitulo = new JLabel("REGISTRO DE PRECIOS",SwingConstants.CENTER);
lblTitulo.setBounds(150,20,200,20);
getContentPane( ).add(lblTitulo);
lblPrecio = new JLabel("Ingrese un precio:");
lblPrecio.setBounds(50,60,150,20);
getContentPane( ).add(lblPrecio);
txtPrecio = new JTextField( );
txtPrecio.setBounds(200,60,50,20);
getContentPane( ).add(txtPrecio);

12. 12
btnProcesar = new JButton("Procesar");
btnProcesar.setBounds(125,100,100,20);
btnProcesar.addActionListener(this);
getContentPane( ).add(btnProcesar);
btnBorrar = new JButton("Borrar");
btnBorrar.setBounds(275,100,100,20);
btnBorrar.addActionListener(this);
getContentPane( ).add(btnBorrar);
txtArea = new JTextArea( );
//el área no se podrá editar
txtArea.setEditable(false);
scpScroll = new JScrollPane(txtArea);
scpScroll.setBounds(50,150,400,130);
getContentPane( ).add(scpScroll);
}
public void actionPerformed(ActionEvent e){
if(e.getSource( ) = = btnProcesar)
procesar( );
if(e.getSource( ) = = btnBorrar)
borrar( );
}

13. 13
//método procesar
public void procesar( ){
//leemos el precio ingresado en la GUI
double precio = getPrecio( );
//verificamos si el array esta lleno
if(p.getIndice( ) = = p.getTamaño( ))
mensaje("El array esta lleno");
//sino, si hay espacio
else{
//adicionamos un precio al array
p.adicionar(precio);
borrar( );
listar( );
}
}
//método listar, mostrara los precios del array
public void listar( ){
//recorremos todo el array imprimiendo los precios en cada posición
for(int i=0;i<p.getIndice( );i++)
imprimir("Precio de la posicion "+i+" : S/."+p.obtener(i));
}
//método que lee el precio de la GUI

14. 14
public double getPrecio( ){
return Double.parseDouble(txtPrecio.getText( ));
}
//método borrar
public void borrar( ){
txtPrecio.setText("");
txtArea.setText("");
txtPrecio.requestFocus( );
}
//método imprimir
public void imprimir(String s){
txtArea.append(s+"n");
}
//método mensaje para validar
public void mensaje(String s){
JOptionPane.showMessageDialog(this,s,"ERROR",0);
}
}//fin del programa

15. 15
Clase genérica: “Precios”
/*en la clase Precios creamos nuestro array el cual nos permitirá
guardar precios en la memoria*/
public class Precios{
//declaramos nuestras variables
private double array[ ];
private int indice;
//método constructor inicializa variables
public Precios( ){
//creamos nuestro array de tipo double el cual contendrá máximo 10 precios
array = new double[10];
//inicializamos nuestro índice en 0
índice = 0;
}
//método que retorna el índice
public int getIndice( ){
return indice;
}

16. 16
//método que retorna el tamaño máximo del array
public int getTamaño( ){
return array.length;
}
//método que recibe un precio y lo adiciona al array
public void adicionar(double precio){
array[indice]=precio;
indice++;
}
//método que recibe una posicion y retorna el precio de esa posicion
public double obtener(int posicion){
return array[posicion];
}
}//fin de la clase Precios
Como vemos, en la clase genérica se manejan 4 métodos básicos:
public int getIndice( ){
return indice;
}
Este método nos retornara el índice, esto nos permitirá saber en que posición del array
nos encontramos, nos será útil para las repeticiones como la del método listar de la clase
principal.
public int getTamaño( ){
return array.length;

17. 17
}
Este método nos retornará el tamaño máximo del array, en este caso nos retornará 10, ya
que ese fue el tamaño que le dimos a nuestro array en el constructor. Como vemos basta
con colocar el nombre del array seguido de la función “length” que significa “longitud”.
public void adicionar(double precio){
array[indice]=precio;
indice++;
}
Este método recibirá un “precio” de tipo “double” y lo adicionara en el array en la
posición en la que se encuentre en el “índice”, la primera vez agregará un precio en la
posición “0”, ya que este fue el valor inicial que le dimo, luego aumentamos el índice en
“1”, así la próxima vez que se ingrese un dato, este será ingresado en la siguiente posición.
public double obtener(int posicion){
return array[posicion];
}
Este método recibirá una “posición” y retorna el valor guardado en dicha posición. Por
ejemplo visualicemos los datos ingresados en el ejemplo anterior.
Si a este método le enviáramos la posición “2” este nos retornará “array[ 2 ]” lo que es
igual a “45.0”.