UNIVERSIDAD DE GUADALAJARA

CENTRO UNIVERSITARIO DE CIENCIAS EXACTAS E INGENIERÍAS

DEPARTAMENTO DE CIENCIAS COMPUTACIONALES

APUNTES DEL CURSO

PROGRAMACIÓN ORIENTADA A OBJETOS EN JAVA

ELABORADO POR

M. en Cs. Ing. Luis Alberto Muñoz Gómez

Actualización a Mayo 2023

Nota: varias imágenes pertenecen al curso SL-275 de Sun Microsystems, ed. 2002

Introducción al lenguaje

public class Main {

public static void main(String[] args) {

[Link]("Hola Mundo Java!");
byte un=127;
short dos=32767;
int cuatro=0x7FFFFFFF;
long ocho=0x7FFFFFFFFFFFFFFFL;
float flotante=2.5F;
double doble=96.08;
final double PI=3.1416;
boolean sonBienvenidos=true;
[Link](un);
[Link](dos);
[Link](cuatro);
[Link](ocho);
[Link](flotante);
[Link](doble);
[Link](PI);
[Link](sonBienvenidos);
String s1="Bienvenidos.";
String s2="Estructuras "+
"de "+
"Datos "+
"I";
if (sonBienvenidos){
[Link](s1);
[Link](s2);
}
//else siempre son bienvenidos
[Link]("PI=%f\n",PI);
//operador condicional
s1=sonBienvenidos?"Si":"No";
[Link](s1);
[Link](sonBienvenidos?"Si":"No");
}

}
//lenguaje C
int a=20,b=10,c;
c=a-b;
printf("la resta %d-%d=%d",a,b,c); //la resta 20-10=10
//lenguaje Java
[Link]("la resta "+a+"-"+b+"="+c);
[Link]("var1="+a+",var2="+b)
Almacenamiento de Objetos
Arreglos
Almacenamiento de tipos primitivos en arreglos

int i,j;
int[] numeros=new int[4];
for(i=0;i<[Link];i++){
numeros[i]=i*10;
}
[Link]("imprimiendo arreglo de int...");
for(i=0;i<[Link];i++){
[Link](numeros[i]);
}
char[] cars=new char[4];
for(i=0;i<[Link];i++){
cars[i]=(char)(65+i);
}
[Link]("imprimiendo arreglo de chars...");
for(i=0;i<[Link];i++){
[Link](cars[i]);
}
byte[] arreglo1;
arreglo1=new byte[4];
for(i=0;i<[Link];i++){
arreglo1[i]=(byte)(65+i);
}
[Link]("imprimiendo arreglo de bytes #1...");
for(i=0;i<[Link];i++){
[Link](arreglo1[i]);
}
byte[] arreglo2={65,66,67,68};
[Link]("imprimiendo arreglo de bytes #2...");
for(i=0;i<[Link];i++){
[Link](arreglo2[i]);
}
[Link]("Conversión de una cadena a sus ASCII...");
String curso="TPOO";
[Link](curso);
byte[] cursoBytes;
cursoBytes=[Link]();
[Link]("imprimiendo valores ASCII...");
for(i=0;i<[Link];i++){
[Link](cursoBytes[i]);
}
[Link]("imprimiendo caracteres...");
for(i=0;i<[Link];i++){
[Link]((char)cursoBytes[i]);
}
 [Link]("o bien...");
for(i=0;i<[Link];i++){
[Link]((char)cursoBytes[i]);
}

[Link]("\nCopiando arreglos e invirtiendo...");

byte[] destino=new byte[[Link]];
j=[Link];
for(i=0;i<[Link];i++){
j--;
destino[j]=cursoBytes[i];
}
for(;j<[Link];j++){
[Link]((char)destino[j]);
}

Almacenamiento de objetos en arreglos

[Link]("Arreglo de Objetos:");
String cadenas[]=new String[6];
cadenas[0]="Curso";
cadenas[1]="de";
cadenas[2]="Estructuras";
cadenas[3]="de";
cadenas[4]="Datos";
cadenas[5]="I";
for(i=0;i<[Link];i++){
[Link](cadenas[i]);
}
for(i=0;i<[Link];i++){
[Link](cadenas[i]);
[Link](" ");
}
public static void main(String args[]){
if ([Link]>0){
for(i=0;i<[Link];i++){
[Link](args[i]);
}
}
}

* Así como String es una class en Java, podemos tener un arreglo de objetos tipo Persona, solo
que para colocar una persona en el arreglo se requiere de:
Persona personas[]=new Persona[4];
personas[0]=new Persona(“Hugo”);
personas[1]=new Persona(“Paco”);
personas{2]=new Persona(“Luis”);
personas[3]=new Persona(“Rosy”);
Comunicación entre objetos

class Circulo{
private double radio;
private int colorBorde;
private int colorFondo;
private final double PI=3.1416;

public void fijaRadio(double radiox){

radio=radiox;
}

public void fijaColorBorde(int colorBordex){

colorBorde=colorBordex;
}

public void fijaColorFondo(int colorFondox){

colorFondo=colorFondox;
}

public double dameRadio(){

return radio;
}

public int dameColorBorde(){

return colorBorde;
}

public int dameColorFondo(){

return colorFondo;
}

public double dameArea(){

return PI*radio*radio;
}

public boolean esIgualA(Circulo c){

boolean resultado;
if (radio==[Link]() &&
colorBorde==[Link]() &&
colorFondo==[Link]()){
resultado=true;
}
else{
resultado=false;
}
return resultado;
}
}
public class Main {

public static void main(String[] args) {

Circulo c1=new Circulo();
[Link](10);
[Link](11);
[Link](14);
Circulo c2=new Circulo();
[Link](10);
[Link](11);
[Link](14);
Circulo c3=new Circulo();
[Link](10);
[Link](4);
[Link](14);
if ([Link](c2)){
[Link]("c1 y c2 son iguales");
}
else{
[Link]("c1 y c2 son diferentes");
}
if ([Link](c3)){
[Link]("c2 y c3 son iguales");
}
else{
[Link]("c2 y c3 son diferentes");
}
}
}
Un package es un conjunto de clases que tienen características en común; “[Link]” es un
paquete de clases para modelar interfaces gráficas con un estilo sencillo pero funcional.
“[Link]” es un paquete para clases más estilizadas y con mayor versatilidad para diseño de
interfaces, pero son de mayor complejidad. Un paquete puede ser subpaquete de otro paquete,
como “[Link]” que es un subpaquete de “[Link]”.
Clase Abstracta

public class Main {

public static void main(String[] args) {
//Vehiculo v=new Vehiculo(); //no compila
Automovil auto=new Automovil("Ford","Mustang","Chido",2,4,4,6);
Avion avi=new Avion("USAF","F-14","Unico",1,1,2);
[Link](auto);
[Link](avi);
}
}
abstract class Vehiculo{
private String marca;
private String modelo;
private String tipoMotor;
private int numPuertas;
private int numVentanas;
public Vehiculo(String marcax,String modelox,String tipoMotorx,
int numPuertasx,int numVentanasx){
marca=marcax;
modelo=modelox;
tipoMotor=tipoMotorx;
numPuertas=numPuertasx;
numVentanas=numVentanasx;
}
public String toString(){ //sobreescritura de [Link]()
return marca+" "+modelo+" con motor "+tipoMotor+" con "+
numPuertas+" puerta(s) y "+numVentanas+" ventana(s)";
}
}
class Automovil extends Vehiculo{
private int numLlantas;
private int numVelocidades;

public Automovil(String marcax,String modelox,String tipoMotorx,

int numPuertasx,int numVentanasx,int numLlantasx,int
numVelocidadesx){
super(marcax,modelox,tipoMotorx,numPuertasx,numVentanasx);
numLlantas=numLlantasx;
numVelocidades=numVelocidadesx;
}

public String toString(){ //sobreescritura de [Link]()

return [Link]()+" y además "+numLlantas+" llantas y "+
numVelocidades+" velocidades";
}
}

class Avion extends Vehiculo{

private int tipoAlas;

public Avion(String marcax,String modelox,String tipoMotorx,

int numPuertasx,int numVentanasx,int tipoAlasx){
super(marcax,modelox,tipoMotorx,numPuertasx,numVentanasx);
tipoAlas=tipoAlasx;
}

public String toString(){ //sobreescritura de [Link]()

return [Link]()+" y además alas tipo "+tipoAlas;
}
}

Herencia Múltiple
Expresiones del Polimorfismo

1.6.1 Definición del Polimorfismo

 Polimorfismo es la habilidad de tener muchas formas diferentes; por ejemplo la clase

Encargado tiene acceso a los métodos de la clase Empleado
 Un objeto tiene únicamente una forma
 Una variable de instancia puede referenciar a objetos de diferentes formas

Empleado e1=new Empleado();

Empleado e2=new Encargado();
Empleado e3=new Ingeniero();

 Si una variable de instancia es de tipo Empleado, solo le son válidos de invocar los
atributos y métodos (públicos) de la clase Empleado, aunque el objeto instanciado fuese
por ejemplo de tipo Ingeniero
Algo que no funcionaría…
Sobrecarga de métodos

public class Main {

public void imprimeBits(byte b){
byte test=(byte)0x80;
[Link](b+"=");
for(int i=0;i<8;i++){
if ((b&test)!=0){
[Link]("1");
}
else{
[Link]("0");
}
test=(byte)((test>>1)&0x7F);
}
[Link]("");
}
public void imprimeBits(short s){
short test=(short)0x8000;
[Link](s+"=");
for(int i=0;i<16;i++){
if ((s&test)!=0){
[Link]("1");
}
else{
[Link]("0");
}
test=(short)((test>>1)&0x7FFF);
}
[Link]("");
}
public static void main(String[] args) {
SobreCarga1 sc=new SobreCarga1();
byte b1;
short s1;
int limitePositivo=16,limiteNegativo=-112;
[Link]("Positivos byte");
for(b1=0;b1<limitePositivo;b1++){
[Link](b1);
}
[Link]("Negativos byte");
for(b1=-128;b1<limiteNegativo;b1++){
[Link](b1);
}
[Link]("Positivos short");
for(s1=0;s1<limitePositivo;s1++){
[Link](s1);
}
[Link]("Negativos short");
for(s1=-128;s1<limiteNegativo;s1++){
 [Link](s1);
}
}
}

Otro ejemplo:
public class Main {
public static void main(String[] args) {
Empleado e=new Empleado();
[Link]([Link]());
[Link]("- - -");
[Link]("Luis");
[Link]([Link]());
[Link]("- - -");
[Link]("Alberto",1000);
[Link]([Link]());
[Link]("- - -");
[Link]("Luis Alberto",4400,new MiFecha(1979,9,12));
[Link]([Link]());
}

}
class Empleado{
private String nombre;
private double salario;
private MiFecha fechaNacimiento;
public Empleado(){
nombre="staff";
salario=0;
fechaNacimiento=new MiFecha(2007,8,1);
}
public void fijaInfo(String nombrex){
nombre=nombrex;
}
public void fijaInfo(String nombrex,double salariox){
fijaInfo(nombrex);
salario=salariox;
}
public void fijaInfo(String nombrex,double salariox,
MiFecha fechaNacimientox){
fijaInfo(nombrex,salariox);
fechaNacimiento=fechaNacimientox;
}
public String dameInfo(){
String info="Nombre: "+nombre+"\n"+
"Salario: "+salario+"\n"+
"Fecha Nacimiento: "+fechaNacimiento;
return info;
}
}
Sobre-escritura de métodos
o bien usando la palabra clave super …

Método Abstracto
Retomando las clases Empleado e Ingeniero (tema 1.5.1)…

Empleado e1=new Empleado(); //bien

Ingeniero ing=new Ingeniero(); //bien
Empleado e2=new Ingeniero(); //bien
[Link]=”Luis”; //bien
[Link]=”Software”; //bien
[Link]=”Luis Alberto”; //bien
[Link]=”Hardware”; /*no compila ya que especialidad
no es atributo de Empleado*/
((Ingeniero)e2).especialidad=”Software de Sistemas”; //esta sí compila
((Ingeniero)e1).especialidad=”Sistemas Digitales”; /*también compila
pero truena en tiempo de ejecución*/
A a=new A(); //suponiendo que A tiene el método andar()
B b=new B(); //suponiendo que B hereda de A
C c=new C(); //suponiendo que C hereda de A
[Link]();
[Link]();
[Link]();

A[] andadores=new A[3];

andadores[0]=new A();
andadores[1]=new B();
andadores[2]=new C();
for(i=0;i<[Link];i++){
andadores[i].andar();
}
public class Main {

public static void main(String[] args) {

Empleado emp=new Empleado("Luis",9000,new MiFecha(1980,2,1));
Secretario sec=new Secretario("Alberto",5000,
new MiFecha(1981,3,2),"7-15hrs.");
Ingeniero ing=new Ingeniero("Luis Alberto",15000,
new MiFecha(1979,9,12),"Software de Sistemas");
Encargado jefe=new Encargado("LA",20000,new MiFecha(1979,9,16),
"Computación");
Empleado empleados[]=new Empleado[4];
empleados[0]=emp;
empleados[1]=sec;
empleados[2]=ing;
empleados[3]=jefe;
for(int i=0;i<[Link];i++){
[Link](empleados[i].dameInfo());
}
}
}
Almacenamiento de objetos en arreglos dinámicos

import [Link];

public class Main {

public static void imprimeVector(Vector v){

String s;
for(int i=0;i<[Link]();i++){
s=(String)[Link](i);
[Link](s);
}
[Link]("- - - - - - - - - -");
}

public static void main(String[] args) {

Vector v=new Vector();
String s="Taller ";
[Link](s);
s="de ";
[Link](s);
s="Programación ";
[Link](s);
s="Orientada ";
[Link](s);
s="a ";
[Link](s);
s="Objetos ";
[Link](s);
[Link](v);
[Link](1);
[Link](v);
[Link](3);
[Link](v);
}

}
//la edición 2002 del SL-275 tiene lo anterior así escrito, funciona así con atributos prívate?
Interno de [Link]()

int a=10;
char[] c=new char[2]
c[0]=//codigo ascii del "1"
c[1]=//codigo ascii del "0"
[Link](""+a);
Clase Administradora

public class Main {

public static void main(String[] args) {
AdminMaterias admin=new AdminMaterias();
Materia m;
[Link]("CC200","Programación Orientada a Objetos");
[Link]("CC201","Taller de POO");
m=[Link](1); //asumo que existe
[Link]([Link]());
[Link](m);
[Link]("registro:"+m);
[Link]("CC202","Estructuras de Datos");
[Link]("CC203","Taller de Estructuras de Datos");
[Link]([Link]());
if ([Link]("CC202")){
[Link]([Link]());
}
else{
[Link]("No se pudo eliminar");
}
}
}
class Materia{
public String clave;
public String nombre;
/*aquí constructor*/
//este método ya se explicó como funciona
public String dameInfo(){
String s;
s=clave+"\t"+nombre;
return s;
}
//y que tal si se sobreescribiera de Object?
public String toString(){
String s;
s=clave+"\t"+nombre;
return s;
}
}
class AdminMaterias{
private Vector lista;
/* un constructor inicializaría lista */
public void alta(String clave,String nombre){
Materia m;
m=new Materia(clave,nombre);
[Link](m);
/* se podría usar
* [Link](posicion,m);
* para dar de alta en orden por clave
*/
} //el método podría regresar boolean
/* se podría implementar un método:
* public void alta(String clave,String nombre,int posicion)
*/
public Materia consulta(int posicion){
Materia m;
if (posicion<[Link]()){
m=(Materia)[Link](posicion);
}
else{
m=null;
}
return m;
}
/* podría implementarse un método:
* public Materia consulta(String clave);*/
public boolean baja(String clave){
boolean encontro=false; //hay casos así
int i,j;
Materia m;
for(i=0,j=[Link]();i<j;i++){
m=(Materia)[Link](i);
if ([Link](clave)){
[Link](i);
encontro=true;
break;
}
else{
//seguir buscando
}
}
return encontro;
 /* podría implementarse un método:
* public boolean baja(int posicion);
*/
public String dameInfo(){
String s="";
Materia m;
int i,j;
for(i=0,j=[Link]();i<j;i++){
m=(Materia)[Link](i);
s+=[Link]()+"\n";
// y que tal? si...
//s+=m+"\n";
//funciona igual?
}
return s;
}
//sería bueno sin dameInfo() y sobreescribir toString()?
}
Uso de interfaces
Múltiples interfaces
Representación de datos y objetos en la memoria RAM

0 0 0 1 0 0 1 0 0 0 7 4 # # # # # # # # … # 0 0 7 4
Dirección Memoria

20000 0 8 4 8 4
20001
20002
20003
20004
20005
20006
20007
20008

20009
20010
20011
20012
20013
20014
20015
20016
20017
20018
20019
20020
21500
20501
20502
20503
20504
a b inge (instancia de Ingeniero) maestro
Variable
u objeto

(10) (256) (20012) (20012)

int a=10,b=256;
Ingeniero inge=new Ingeniero();
Ingeniero maestro=inge;
Ingeniero otroInge=new Ingeniero();

if (inge==maestro){ //comparación de direcciones de memoria

//somos el mismo objeto
}
else{
//somos distintos objetos,
}
if (inge==otroInge){ //comparación de direcciones de memoria
//somos el mismo objeto
}
else{
//somos distintos objetos,
}