ACTIVIDAD DE APRENDIZAJE 7.

2: APLICAR LOS PRINCIPIOS DE LA

PROGRAMACIÓN ORIENTADA A OBJETOS JAVA

Presentado por:

ALEJANDRO LUIS LOPEZ TRESPALACIOS

FABIÁN DELGADO

JUAN ESTEBAN PALACIO

SEBASTIAN VICTORIA HERMAN

GAES 2

Instructor:
JULIÁN EFRÉN
VARGAS

SERVICIO NACIONAL DE APRENDIZAJE SENA TECNOLOGIA EN ANALISIS Y

DISEÑO DE SISTEMAS DE INFORMACIÓN

JUNIO DE 2016
INTRODUCION

JAVA es un lenguaje de programación creado por SUN Microsystems, muy parecido al

estilo de programación del lenguaje “C” y basado en lo que se llama Programación
Orientada a Objetos POO.

Los principios de la programación orientada a objetos es “modelar” y representar, a través

de elementos de programación, objetos que existen en la realidad (tangible o intangible).
Por ejemplo, un lenguaje en donde se pueda modelar a una persona con todas las
operaciones que pueda realizar.

Es así como se encapsula y representa un objeto de la siguiente forma (notación UML):

Profesor
 Enseña
 Aprende
 ...
PROGRAMACIÓN EN JAVA

Los programas en Java son archivos de texto planos con extensión .java (se utiliza
cualquier programa que escriba archivos de texto como son el Notepad de Windows,
Wordpad, Textpad e inclusive Word cuando guarda en formato texto) que deben ser
compilados con una JVM (Java Virtual Machine) y convertidos en un archivo .class, con el
cuál pueden ser ejecutados. Actualmente existe IDE como Netbeans, Kawa, Jcreator, los
cuales ya cuentan con una interfaz para una mejor programación. Archivo Java.

Un archivo .java debe contener la siguiente estructura base:

/ Área de inclusión de librerías (package) [Opcional]

import.*;
// Definición de la clase
[public] class {
// Definición de métodos
[static] [public/protected/private]
(, , ..., ) {
...
}
}

Clase
La estructura anteriormente vista la llamaremos Clase y representará algún objeto o
entidad, tangible o intangible que queramos modelar. En un principio escribiremos clases
que sean nuestros Programas Principales, es decir, aquellos que resuelven los problemas
que nos planteemos. Por ejemplo:

Public class HolaMundo {

static public void main (String [] args) {
Console c = new Console ();
c.println (“Hola Mundo”);
}
}

Esta clase representa mi programa llamado HolaMundo y solo escribe en pantalla la frase
“Hola Mundo”.

Tipos de Clases
Existen 2 tipos básicos de clases: Las clases ejecutables y las que no lo son. La diferencia
entre estas 2 clases radica físicamente en que algunas de ellas son invocadas desde otras
clases. Por ejemplo, Console es una clase (Console.class) que es invocada o utilizada por la
clase HolaMundo anteriormente vista.

Esta clase puede tener muchos métodos o funcionalidades, que son utilizadas dentro de los
otros programas.
public class Console {
public void print(String s) { ... }
public void println(String s) { ... }
public int readInt() { ... }
public double readDouble() { ... }
public long readLong() { ... }
...
}

La clase HolaMundo es del tipo que se puede ejecutar, es decir, al tener el método main
significa que lo que está dentro de los paréntesis de llave corresponde a lo ejecutable:
Public class HolaMundo {
static public void main (String[] args) { //Ejecutable
Console c = new Console();
c.println (“Hola Mundo”);
}
}

Instrucciones

Cada línea en Java es conocida como una Instrucción, y significa que es lo que uno manda
a realizar al computador en un determinado momento. Por ejemplo:

c.println(“Hola Mundo”); // Indica al computador que debe

// imprimir en pantalla la frase
// “HOLA MUNDO”

Todas las instrucciones llevan un separador al final: “;” (punto y coma). Este separador
funciona como si se le indicara al computador DONDE termina una línea, ya que Java
permite que en una línea física escribir más de una instrucción:

c.print(“Hola”); c.println(“ Mundo”);

Equivale a:
c.print(“Hola”);
c.println(“ Mundo”);

Bloques
En Java se pueden agrupar las instrucciones en Bloques de instrucciones. Los bloques son
delimitados por los paréntesis de llaves (“{“ y “}”).
Las clases se componen de 2 partes: un encabezado y un cuerpo:

//ENCABEZADO
public class HolaMundo {
//CUERPO
static public void main (String[] args) {
Console c = new Console();
c.println(“Hola Mundo”);
}
}

El cuerpo de una clase es considerado un bloque de programa, ya que almacena múltiples

bloques (métodos) y otras instrucciones. Los bloques también pueden almacenar otros
bloques como en este caso.
EJERCICIOS

PROGRAMACIÓN ORIENTADA A OBJETOS EN JAVA

EJERCICIO 1

Cree y compile la siguiente clase:

Cita

Notas: • El método getTipo() debe retornar un String que puede ser “especialista” o
“general”, será general si la cita es tipo 1, 2 o 3 y será especialista si el tipo de cita es 4
o 5. • El valor final de la cita depende de la tarifa y el tipo de cita, las citas de tipo
“especialista” tienen un incremento del 50% sobre la tarifa y las citas de tipo “general”
tiene un descuento del 50% sobre la tarifa

package citas;

public class Citas {

int numero;
int tipo;
double tarifa;
double valorFinal=0;

public Citas (int numero, int tipo, double tarifa)

{
this.numero=numero;
this.tipo=tipo;
this.tarifa=tarifa;
}

public int getNumero()

{
 return numero;
}

public String getTipo()

{
if(tipo<=3)
return "General";
else
return "Especialista";
}
public double getTarifa()
{
return tarifa;
}

public double calcularValorFinal()

{
duble percent=tarifa*0.5;
if(tipo<=3){

valorFinal=tarifa-percent;
}

else{

valorFinal=tarifa+percent;
}

return valorFinal;
}
}

. Cree la clase Principal.java donde solicite al usuario los datos para crear una cita
(objeto de la clase Cita) y a continuación presente los siguientes mensajes: El número
de la cita es: XXXXXX Esta cita es de tipo: XXXXXXXX
Su tarifa normal es: XXXXXXXX
Pero por ser de tipo XXXXXXXX
Queda con un valor final de XXXXXXXX

package citas;
import javax.swing,JOptionPane;
public class Principal1 {
public static void main(String[] args) {
int numero=Integer.parseInt(JOptionPane.showInputDialog(null,"Introduzca el numero
de la cita"));
int tipo=Integer.parseInt(JOptionPane.showInputDialog(null,"Introduzca el tipo de
cita (Para general: 1,2 y 3 y para especialista: 4 y 5)"));
 double tarifa= Double.parseDouble(JOptionPanel.showInputDialog(null,
"Introduzca la tarifa"));
Citas cita= new Citas(numero,tipo,tarifa);
System.out.println("El numero de la cita es: "+cita.getNumero());
System.out.println("El tipo de cita es: "+cita.getTipo());
System.out.println("Su tarifa normal es: "+cita.getTarifa());
System.out.println("Pero por ser de tipo "+cita.getTipo()+" queda con un valor
final de: " + cita.calcularValorFinal());
}
}

Ejercico 2

2. Cree y compile la siguiente clase:

Bus

Notas:

• getPlaca: Obtiene la placa del bus

• getCapacidad: Obtiene la capacidad de pasajeros del bus

• getPrecioPasaje: Obtiene el valor del pasaje

• getPasajerosActuales: Obtiene el número de pasajeros que se encuentra en el bus

• getPasajerosTotales: Obtiene el número de pasajeros que se han subido al bus

• subirPasajeros: sube una cantidad de pasajeros al bus, teniendo en cuenta que no

sobrepase la capacidad del bus.
• bajarPasajeros: baja una cantidad de pasajeros del bus, teniendo en cuenta que no baje
más pasajeros de los que realmente existen en el bus. • getDineroAcumulado: Obtiene todo
el dinero que ha acumulado el bus teniendo en cuenta todos los pasajeros que se han subido
y el valor del pasaje.

package bus;

import javax.swing.JOptionPane;

public class Bus {

String placa;

int capacidadPasajeros;

double precioPasaje;

int pasajerosActuales;

int totalPasajeros;

double dineroAcumulado;

public int pasajeroSsubidos;

int pasajeros1;

int totalAcumulado;

public Bus (String placa, int capacidad, double pasaje, int actuales){

this.placa=placa;

this.capacidadPasajeros=capacidad;

this.precioPasaje=pasaje;

this.pasajerosActuales=actuales;

}
public String getplaca(){

return placa;

public int getCapacidad(){

return capacidadPasajeros;

public double getPrecioPasaje(){

return precioPasaje;

public double getPasajerosTotales(){

return totalPasajeros;

public double getPasajerosActuales(){

return pasajerosActuales;

public void subirPasajeros(int pasajeros){

if (pasajeros > capacidadPasajeros){

JOptionPane.showMes.sageDialog(null, "No se pueden subir ' + pasajeros + ", por

SOBRECUPO');

}
 else{

if ((pasajerosActuales + pasajeros), capacidadPasajeros) (

JOptionPane.showMes.sageDialog(null, "No se pueden subir ' + pasajeros + ", por

SOBRECUPO');

}else{

totalPasajeros=pasajeros;

pasajerosActuales=pasajerosActuales+pasajeros;

totalAcumulado=pasajerosActuales+pasajeros;

public void getDineroAcumulado(){

dineroAcumulado=(pasajerosActuales*precioPasaje);

public double totalDineroAcumulado(){

return dineroAcumulado;

public void bajarPasajeros(int pasajeros1){

if (pasajeros1>pasajerosActuales) {

JOptionPane.showMessageDialog(null, "cantidad de pasajeros a bajar es mayor de

pasajeros que actualmente hay en el bus");

else{

pasajerosActuales-pasajerosActuales-pasajeros1;
 }

public void getDineroAcumulado(){

dineroAcumulado=(pasajerosActuales*precioPasaje);

public double totalDineroAcumulado(){

return dineroAcumulado;

public void bajarPasajeros(int pasajeros1){

if (pasajeros1>pasajerosActuales) {

JOptionPane.showMessageDialog(null, "La cantidad de pasajeros que desea bajar es

mayor al numero de pasajeros que actualmente hay en el bus!!!");

else{

pasajerosActuales=pasajerosActuales-pasajeros1;

}
}

Cree y compile la clase Principal.java donde instancie un objeto de la clase Bus y pruebe
cada uno de sus métodos.

package bus;

import javax.swing.JOptionPane;

public class Principal2 {

public static void main(String[] args) {

String placa=JOptionPane.showInputDialog("Placa del bus");

int capacidad = Integer.parseInt(JOptionPane.ShowInputDialog(null,"Ingrese la

capacidad del bus"));

int actuales = Integer.parseInt(JOptionPane.ShowInputDialog(null,"Numero de

pasajeros que estan en el bus"));

double pasaje = Double.parseDouble(JOptionPane.ShowInputDialog(null,"Valor

pasaje"));

if (actuales>capacidad) {

System.out.println("Error! El numero actual de pasajeros sobrepasa la capacidad

del bus");

}else{
 Bus bus = new Bus(placa,capacidad,actuales);

int pasajeros=Integer.parseInt(JOtionPane.showInputDialog(null, "Cantidad de

pasajeros a subir al bus!"));

bus.subirPasajeros(pasajeros);

JOptionPane.showMessageDialog(null, "El numero de pasajeros en el bus

es:"+bus.getPasajerosActuales());

JOptionPane.showMessageDialog(null, "El bus tiene una capacidad

de:"+bus.getCapacidad());

JOptionPane.showMessageDialog(null, "La placa del bus es:"+bus.getPlaca());

bus.getDineroAcumulado();

JOptionPane.showMessageDialog(null, "Numero de pasajeros que se han subido

es:"+bus.getPasajerosTotales());

int pasajeros1= Integer.parseInt(JOptionPane.showInputDialog(null, "Ingrese el

numero de pasajeros que va abajar del bus"));

bus.bajarPasajeros(pasajeros1);

JOptionPane.showMessageDialog(null, "El dinero acumulado es: $" +

bus.totalDineroAcumulado());

}
EJERCICIO 3

Notas: • Las cuentas solo pueden ser de tipo “ahorro” o “crédito” • El saldo mínimo de una
cuenta es el 10% del valor inicial con que se crea la cuenta. • Consignar (double monto):
incrementa el dinero de la cuenta con base en el monto de dinero que se desea consignar. •
Retirar (double monto): retira el monto dado de la cuenta siempre y cuando la cuenta no
quede con un saldo inferior al saldo mínimo, si esto ocurre, solo se retirará el dinero
autorizado. • getSaldo(): obtiene el saldo actual de la cuenta. • getSaldoMinimo(): obtiene
el saldo mínimo de la cuenta. • getCapacidadCredito(): Para cuentas de ahorro, la capacidad
de crédito es igual a la diferencia entre al saldo actual y el saldo mínimo y para cuentas de
crédito, la capacidad de crédito es 3 veces el saldo actual.

package cuenta;

import javax.swing.JOptionPane;

public class Cuenta {

/* Atributos de la clase cuenta */

int numero;
String tipo;
double valorInicial;
double saldoActual;
double saldoMinimo;
double capacidad;
double autorizado;
double capacidadCredito;

/* Metodos de la clase cuenta */

// Constructor
Cuenta(int numero,String tipo, double valorInicial){
this.numero=numero;
 this.tipo=tipo;
this.saldoActual=valorInicial;
this.valorInicial=valorInicial;

}
/* Para consignar en la cuenta */
public void consignar (double monto){
saldoActual=saldoActual+monto;
}

/* Para saber el saldo minimo */

double getSaldoMinimo(){
saldoMinimo=valorInicial*0.1;
return saldoMinimo;
}
/* Retirar Dinero */
public void retirar (double monto1){
saldoActual=saldoActual-monto1;

if (saldoActual<saldoMinimo) {
saldoActual=saldoActual+monto1;
autoirizado=saldoActual-saldoMinimo;
JOptionPane.showMessageDialog(null, "Saldo insuficiente"
+ ",maximo a retirar:" + autorizado);
saldoActual=saldoActual-autorizado;
}
}

/* consultar saldo */
double getSaldo(){
return saldoActual;
}

/* capacidad de credito */
double getCapacidadCredito(){
if ("ahorro".equals(tipo)){
capacidadCredito=saldoActual-saldoMinimo;
}

if ("credito".equals(tipo)){
capacidadCredito=saldoActual*3;
}
return capacidadCredito;
}
}
.Cree y compile la clase Principal.java y en ella cree un objeto de la clase Cuenta y pruebe
cada uno de sus métodos.

package cuenta;

import javax.swing.JOptionPane;

public class Principal3 {

public static void main(String[] args) {

/* Datos Iniciales */
int numero=Integer.parseInt(JOptionPane.showInputDialog("Digite el numero de
la cuenta"));
String tipo=JOptionPanel.showInputDialog("Digite el tipo de cuenta, ahorro o
credito");
double valorInicial=Double.parseDouble(JOptionPane.showInputDialog("Digite
el valor que va a consignar inicialmente"));

/* Objeto Cuenta */

Cuenta cuenta=new Cuenta(numero,tipo,valorInicial);

double monto=Double.parseDouble(JOptionPane.showInputDialog("Digite la
cantidad de dinero a consignar"));
cuenta.consignar(monto);

cuenta.getSaldoMinimo();

double monto1=Double.parseDouble(JOptionPane.showInputDialog("Digite la
cantidad de dinero a retirar"));

cuenta.retirar(monto1);

JOptionPane.showMessageDialog(null,"Su Saldo Actual es:" +

cuenta.getSaldo());
JOptionPane.showMessageDialog(null,"El saldo minimo de su cuenta es:" +
cuenta.getSaldoMinimo());
JOptionPane.showMessageDialog(null,"Su Capacidad de Credito es:" +
cuenta.getCapacidadCredito());
}
}
EJERCICIO 4

4. A partir del siguiente diseño, cree las clases correspondientes y su respectivo código para
generar los listados que se solicitan a continuación:
Banco

1.BANCO
package banco;
import javax.swing.JOptionPane;
class Banco{
String nombre;
Cliente clientes[];
int numeroDeClientes;

public Banco(String nomb){

this.nombre=nomb;

}
public String obtnombre(){
return nombre;
}

public void cambiarNombre(String nombre){

}
public void adCliente(Cliente Clie){
}
public int obtNumClientes(){
return numeroDeClientes;
 }

Cliente obtCliente(int posicion){

return null;

}
Cliente[] obtClientes(){
return null;
}
}

2.CLIENTE

package banco;

abstract class Cliente{

protected String nombre;

public Cliente(String nom)

{
this.nombre=nom;

public String obtNombre() {

return nombre;
}

abstract String obtIdentificscion();

abstract String obtRepresentante();

abstract int obtEdad();

}

3.EMPRESA
package banco;

class Empresa extends Cliente{

String nit;
String representante;

public Empresa(String n, String nom, String r){

super(nom);
this.nit=n;
 this.representante=r;
}
public String obtIdentificacion(){
return nit;

}
public String obtRepresentante(){
return representante;

}
public String cambiarRepres(String repres){
return null;

}
public int obtEdad(){
return 1000;

}
}

4. PERSONA

package banco;

public class Persona extends Cliente{

String cedula;
int edad;

public Persona(String ced, String nom, int ed){

super(nom);
this.cedula=ced;
this.edad=ed;
}
public String obtIdentificacion(){
return cedula;
}
public int obtEdad(){
return edad;
}
public void cumpliranos(){

}
public String obtRepresentante(){
return null;

}
}
5. PRINCIPAL

package banco;
import javax.swing.JOptionPane;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Principal4 {

private static Cliente per;

public static void main(String args[]) {

List<Cliente> lista = new ArrayList<>();
int numeroDeClientes =
Integer.parseInt(JOptionPane.showInputDialog(null,"Numero de clientes"));
for (int i = 1; i <= numeroDeClientes; i++) {
int topoCliente = Integer.parseInt(JOptionPane.showInputDialog(null, "Tipo de
cliente: 1 para Empresa; 2 para Persona"));
String nom = JOptionPane.showInputDialog(null, "Nombre del cliente");
if (tipoCliente = 1) {
String nit = JOptionPane.showInputDialog(null, "NIT de la empresa");
String r = JOptionPane.showInputDialog(null, "Nombre de representante
legal");
emp.obtIdentificacion();
lista.add(emp);
} else {
String ced = JOptionPane.showInputDialog(null, "No de Cedula cliente");
int ed = Integer.parseInt(JOptionPane.showInputDialog(null, "Edad cliente"));
Persona per = new Persona(ced, nom, ed);

lista.add(per);
}
}
System.out.println("Nombres que tiene el banco son:");
for(int cuenta = 0; cuenta < lista.size(); cuenta++){
System.out.println(lista.get(cuenta).nombre);

}
System.out.println("Nombres y cedulas de las personas clientes son:");
for(int cuenta = 0; cuenta < lista.size(); cuenta++){
if (lista.get(cuenta) instanceof Persona){
System.out.println("La cedula del cliente es"
+lista.get(cuenta).obtIdentificacion());
 System.out.println("El nombre del cliente es" +lista.get(cuenta).obtNombre());
}
}
System.out.println("Nombres y representantes de cada empresa son:");
for(int cuenta = 0; cuenta < lista.size(); cuenta++){
if (lista.get(cuenta) instanceof Empresa){
System.out.println("Nombre del cliente es" +lista.get(cuenta).obtNombre());
System.out.println("Nombre del representante es"
+lista.get(cuenta).obtRepresentante());
}
}
System.out.println("Nombres de los clientes menores de edad son:");
for(int cuenta = 0; cuenta < lista.size(); cuenta++){
if (lista.get(cuenta) instanceof Persona){
if (lista.get(cuenta).obtEdad()<18){
System.out.println("Nombre del cliente es" +lista.get(cuenta).obtNombre());
}
}
}
int menor=1000;
for(int cuenta = 0; cuenta < lista.size(); cuenta++){
if (lista.get(cuenta) instanceof Persona){
if (lista.get(cuenta).obtEdad()>1){
if (lista.get(cuenta).obtEdad()<menor){
menor=lista.get(cuenta).obtEdad();
}
}
}
}
System.out.println("Edad del cliente mas joven es"+menor );
int mayor=0;
for(int cuenta = 0; cuenta < lista.size(); cuenta++){
if (lista.get(cuenta) instanceof Persona){
if (lista.get(cuenta).obtEdad()>18){
if (lista.get(cuenta).obtEdad()>mayor){
mayor=lista.get(cuenta).obtEdad();
}
}
}
}
System.out.println("Edad del cliente mas viejo es"+mayor);
}
}
BIBLIOGRAFIA

https://www.youtube.com/playlist?list=PLU8oAlHdN5BktAXdEVCLUYzvDyqRQJ2lk

http://jc-mouse.blogspot.com.co/2009/10/principios-basicos-java.html

FUNDAMENTOS DL LENGUAJE DE PROGRAMACION JAVA, SENA 2016

ARREGLOS Y COLECCIONES EN JAVA, SENA, 2016

PROGRAMACION ORIENTADA A OBJETOS, SENA, 2016

http://jc-mouse.blogspot.com.co/2009/10/principios-basicos-java.html