Conceptos Básicos Poo

Conceptos bsicos
POO: La programacin orientada a objetos consiste en ordenar datos en conjuntos modulares de elementos de informacin
del mundo real (denominado un dominio). Estos elementos de datos se llaman objetos. Estos datos se agrupan de acuerdo a
las caractersticas principales del mundo real de estos elementos (tamao, color, etc.).
Objeto: En el paradigma de programacin orientada a objetos (POO, o bien OOP en ingls), un objeto es una unidad dentro
de un programa de computadora que consta de un estado y de un comportamiento, que a su vez constan respectivamente de
datos almacenados y de tareas realizables durante el tiempo de ejecucin. Un objeto puede ser creado
instanciando una clase, como ocurre en la programacin orientada a objetos, o mediante escritura directa de cdigo y la
replicacin otros objetos, como ocurre en la programacin basada en prototipos.
Un objeto se caracteriza por varios conceptos:
Atributos: estos son los datos que caracterizan al objeto. Son variables que almacenan datos relacionados al estado de
un objeto.
Mtodos (usualmente llamados funciones de miembro): Los mtodos de un objeto caracterizan su comportamiento, es
decir, son todas las acciones (denominadas operaciones) que el objeto puede realizar por s mismo. Estas operaciones
hacen posible que el objeto responda a las solicitudes externas (o que acte sobre otros objetos).
Identidad: El objeto tiene una identidad, que lo distingue de otros objetos, sin considerar su estado.
CLASE: Una Clase es la Implementacin total o parcial de un tipo abstracto de dato (TAD)
Una clase es un tipo definido que determina la estructura de datos y las operaciones asociadas a ese
tipo.
Una clase se puede ver como una plantilla que describe objetos que van a tener la misma estructura y
el mismo comportamiento.
Un programa OO es una coleccin estructurada de clases.
Una clase es un generador de objeto (las instancias de la clase)
Herencia:
Se establece una estructura jerrquica en la que cada clase hereda atributos y mtodos de las clases
que estn por encima de ella. La clase derivada (Subclase) puede usar los procedimientos y los
atributos de su Super- Clase.
Cada subclase puede tener nuevos atributos y mtodos y/o redefinir los heredados.
Encapsulamiento: Significa reunir a todos los elementos que pueden considerarse pertenecientes a
una misma entidad, al mismo nivel de abstraccin. Esto permite aumentar la cohesin de los
componentes del sistema. Algunos autores confunden este concepto con el principio de ocultacin,
principalmente porque se suelen emplear conjuntamente
La encapsulacin: Se refiere a la capacidad de agrupar y condensar en un entorno con lmites bien-
definidos distintos elementos. Cuando hablemos de encapsulacin en general siempre nos
referiremos, pues, a encapsulacin abstracta. De manera informal, primero generalizamos (la
abstraccin) y luego decimos: la generalizacin est bien, pero dentro de un cierto orden: hay que
poner lmites (la encapsulacin), y dentro de esos lmites vamos a meter, a saco, todo lo relacionado
con lo abstrado: no slo datos, sino tambin mtodos, comportamientos, etc.
pblico: funciones de toda clase pueden acceder a los datos o mtodos de una clase que se define con el nivel
de acceso pblico. Este es el nivel de proteccin de datos ms bajo
protegido: el acceso a los datos est restringido a las funciones de clases heredadas, es decir, las funciones
miembro de esa clase y todas las subclases
privado: el acceso a los datos est restringido a los mtodos de esa clase en particular. Este es nivel ms
alto de proteccin de datos (10)
ABSTRACCION: expresa las caractersticas esenciales de un objeto, las cuales distinguen del objeto de los dems.
La abstraccin, un principio por el cual se asla toda aquella informacin que no resulta relevante a un determinado nivel de
conocimiento.
Abstraccin: Es una descripcin de especificacin que enfatiza algunos de los detalles o propiedades de algo. La abstraccin
consiste en captar las caractersticas esenciales de un objeto, as como su comportamiento. Es un mtodo por el cual
abstraemos valga la redundancia, una determinada entidad de la realidad de sus caractersticas y funciones que
desempean, estos son representados en clases por medio de atributos y mtodos de dicha clase.
Uso del This
El This se utiliza para invocar atributos y mtodos dentro de la misma clase, se utiliza generalemnte cuando existe
ambiguedad entre atributos y parametros mtodos , es decir, cuando tiene el mismo nombre.
package entidades;
public class Empleado {
private int valor;
public Empleado(int valor){
this.valor=valor
}
}

Uso 02

El This se utiliza para invocar constructores de la misma clase, la invocacin debe ir simpre en la misma linea

package entidades;
public class Empleado {
private int valor;
public Empleado(){
this(125); //Este llama al segundo constructor
}
}
public Empleado(int valor){
this.valor=valor
}
Las definiciones me dicen principalmente que :
-la referencia this siempre apunta al objeto sobre el que se ejecuta un metodo.
-this permite especificar que la variable que seala (y la seala haciendo this.nombreVariable) es de la misma
clase en la que se usa.
class RGB {
int red=1;
int green=2;
int blue=3;

void RGBB(int red, int green, int blue) {//metodo

this.green = green;
this.blue = blue;
// con (this.nombreVAr=nombreVAr hago que la referencia this
// que apunta a la variable
// de la clase coja el valor de la variable que apunta al objeto
// sobre el que se ejecuta el metodo
// aunque si no lo pusiese el programa seguiria haciendo la
// misma funcion

System.out.println( "valor de rojo "+ this.red );
// en este caso this.red hace que se apunte al valor de la variable
// de la clase ...red=1

System.out.println( "valor verde "+ green );
System.out.println( "valor azul "+ blue );
//tanto green como blue apuntan al objeto
// sobre el que se ejecuta el metodo
}

public static void main( String args[] ) {

RGB obj = new RGB();

obj.RGBB( 10,12,13 );
}
}
class MiClase {

int miVariable; // Variable de instancia-> int MiClase.miVariable

public MiClase() {//Constructor de la clase : MiClase.MiClase()
miVariable = 5;
}

void miMetodo(int miVariable) { // Metodo con argumentos->void MiClase.miMetodo(int
miVariable)

System.out.println( "La variable Local miVariable contiene "
+ miVariable );//int miVariable -> MiClase.miMetodo(int)

System.out.println( "La variable de Instancia miVariable contiene "
+ this.miVariable );//int MiClase.miVariable
//La palabra reservada this permite especificar que
//la variable que seala (y la seala haciendo this.nombreVariable)
//es de la misma clase en la que se usa.
}

public static void main( String args[] ) {
// Instanciamos un objeto del tipo de la clase
MiClase obj = new MiClase();
// que utilizamos para llamar a su unico metodo
obj.miMetodo( 10 ); //void MiClase.miMetodo(int miVariable)
}
}
Constructor:

public class Arboles {

public Arboles() {
System.out.println("Un rbol genrico");
}

public Arboles(String tipo) {
System.out.println("Un rbol tipo " + tipo);
}

public Arboles(int altura) {
System.out.println("Un rbol de " + altura + " metros");
}

public Arboles(int altura,String tipo) {
System.out.println("Un " + tipo + " de " + altura + " metros");
}

public static void main(String args[]) {
Arboles arbol1 = new Arboles(4);
Arboles arbol2 = new Arboles("Roble");
Arboles arbol3 = new Arboles();
Arboles arbol4 = new Arboles(5,"Pino");
}
}

Clase Arboles
Como en todo programa Java , primeramente se define la Clase a travs del vocablo class.
Posteriormente son definidos 4 Constructores; ntese que cada uno recibe el mismo nombre de la
Clase y posee distintos argumentos de entrada.
Dentro del mtodo principal (main) son generadas cuatro instancias de la Clase, como se puede
observar, al ser generada la instancia a travs del vocablo new se pasa un parmetro, y es
dependiendo de este parmetro que es llamado el Constructor correspondiente, el cual a su vez invoca
la Clase System.out.println que imprime a pantalla.
Constructor Obligatorio...
En los ejemplos anteriores del curso se pudo notar que no se hizo uso de Constructor alguno, y la razn es
que el compilador lleva acabo esta definicin de Constructor vaco detrs de los escenarios, sin embargo,
existe una situacin en la que es necesario definir un Constructor vaco y esta es cuando se hace uso de
otros constructores.
Lo anterior significa que si el compilador observa un mtodo con el mismo nombre de la clase con
argumentos (Constructor), deber existir un mtodo vaco por el mismo nombre, esto de cierta manera
salvaguarda a un programador al momento de definir mtodos que no vayan a ser definidos errneamente
como Constructores.
Un constructor es un mtodo especial de una clase que se llama automticamente siempre que se declara
un objeto de esa clase.
Su funcin es inicializar el objeto y sirve para asegurarnos que los objetos siempre contengan valores vlidos.

Cuando se crea un objeto en Java se realizan las siguientes operaciones de forma automtica:
1. Se asigna memoria para el objeto.
2. Se inicializan los atributos de ese objeto con los valores predeterminados por el sistema.
3. Se llama al constructor de la clase que puede ser uno entre varios.
El constructor de una clase tiene las siguientes caractersticas:
Tiene el mismo nombre que la clase a la que pertenece.

En una clase puede haber varios constructores con el mismo nombre y distinto nmero de argumentos (se
puede sobrecargar)

No se hereda.

No puede devolver ningn valor (incluyendo void).

Debe declararse pblico (salvo casos excepcionales) para que pueda ser invocado desde cualquier parte
donde se desee crear un objeto de su clase.
MTODO CONSTRUCTOR POR DEFECTO
Si para una clase no se define ningn mtodo constructor se crea uno automticamente por defecto.
El constructor por defecto es un constructor sin parmetros que no hace nada. Los atributos del objeto son
iniciados con los valores predeterminados por el sistema.
Por ejemplo, en la clase Fecha:
import java.util.*;
public class Fecha {

private int dia;
private int mes;
private int ao;

private boolean esBisiesto() {
return ((ao % 4 == 0) && (ao % 100 != 0) || (ao % 400 == 0));
}

public void setDia(int d) {
dia = d;
}

public void setMes(int m) {
mes = m;
}

public void setAo(int a) {
ao = a;
}

public void asignarFecha() {
Calendar fechaSistema = Calendar.getInstance();
setDia(fechaSistema.get(Calendar.DAY_OF_MONTH));
setMes(fechaSistema.get(Calendar.MONTH));
setAo(fechaSistema.get(Calendar.YEAR));
}

public void asignarFecha(int d) {
setDia(d);
}

public void asignarFecha(int d, int m) {
setDia(d);
setMes(m);
}

public void asignarFecha(int d, int m, int a) {
setDia(d);
setMes(m);
setAo(a);
}

public int getDia() {
return dia;
}

public int getMes() {
return mes;
}

public int getAo() {
return ao;
}

public boolean fechaCorrecta() {
boolean diaCorrecto, mesCorrecto, anyoCorrecto;
anyoCorrecto = (ao > 0);
mesCorrecto = (mes >= 1) && (mes <= 12);
switch (mes) {
case 2:
if (esBisiesto()) {
diaCorrecto = (dia >= 1 && dia <= 29);
} else {
}
break;
case 4:
case 6:
case 9:
case 11:
break;
default:
}
return diaCorrecto && mesCorrecto && anyoCorrecto;
}
}
no se ha definido ningn constructor, por lo que al declarar un objeto el compilador utilizar un constructor
por defecto.
En este caso el mtodo constructor por defecto es:
Fecha() { }
Vamos a aadir un constructor a la clase Fecha para poder iniciar los atributos de los nuevos objetos con
valores determinados que se envan como parmetros. Si los valores corresponden a una fecha incorrecta se
asigna la fecha del sistema:

public Fecha(int d, int m, int a) {
dia = d;
mes = m;
ao = a;

if (!fechaCorrecta()) {
setDia(fechaSistema.get(Calendar.DAY_OF_MONTH));
}
}
Con este mtodo constructor podremos crear objetos de la siguiente manera:
Fecha fecha1 = new Fecha(10,2,2011);
Se crea un objeto fecha1 y se le asignan esos valores a sus atributos.
Si se crea un objeto con una fecha no vlida:
Fecha fecha2 = new Fecha(10,20,2011);
A dia, mes y ao se les asignar los valores del sistema.
Java crea un constructor por defecto si no hemos definido ninguno en la clase, pero si en una clase definimos
un constructor ya no se crea automticamente el constructor por defecto, por lo tanto si queremos usarlo
deberemos escribirlo expresamente dentro de la clase.
En este ejemplo hemos definido un mtodo constructor por lo que tambin es necesario poner el mtodo
constructor por defecto.
public Fecha(){}
Este constructor se invocar cuando se declare un objeto sin parmetros.
La clase tiene ahora dos constructores por lo que podemos crear objetos Fecha de dos formas:
Fecha f1 = new Fecha(); //se ejecuta el constructor sin parmetros
Fecha f2 = new Fecha(1,1,2010); //se ejecuta el constructor con parmetros
INVOCAR A UN MTODO CONSTRUCTOR
Un constructor se invoca cuando se crea un objeto de la clase mediante el operador new.
Si es necesario invocarlo en otras situaciones, la llamada a un constructor solo puede realizarse desde dentro
de otro constructor de su misma clase y debe ser siempre la primera instruccin.
Si tenemos varios mtodos constructores en la clase, podemos llamar a un constructor desde otro
utilizandothis.
Por ejemplo, si en el constructor con parmetros de la clase Fecha fuese necesario llamar al constructor sin
parmetros de la misma clase escribimos:
public Fecha(int d, int m, int a) {
this(); //llamada al constructor sin parmetros
dia = d;
.
}
CONSTRUCTOR COPIA
Se puede crear un objeto a partir de otro de su misma clase escribiendo un constructor llamado constructor
copia.
Este constructor copia los atributos de un objeto existente al objeto que se est creando.
Los constructores copia tiene un solo argumento, el cual es una referencia a un objeto de la misma clase que
ser desde el que queremos copiar.
Por ejemplo, para la clase Fecha podemos escribir un constructor copia que permita crear objetos con los
valores de otro ya existente:
Fecha fecha = new Fecha(1,1,2011); //se invoca al constructor con parmetros
Fecha fecha1 = new Fecha(fecha); //se invoca al constructor copia
El constructor copia que escribimos para la clase es:
//constructor copia de la clase Fecha
public Fecha(final Fecha f) {
dia = f.dia;
mes = f.mes;
ao = f.ao;
}
El constructor copia recibe una referencia al objeto a copiar y asigna sus atributos uno a uno a cada atributo
del objeto creado.
Declarar el parmetro como final no es necesario pero protege al objeto a copiar de cualquier modificacin
accidental que se pudiera realizar sobre l.

INSTANCIAR

//creacion de la clase Automovil
public class Automovil
{
//atributos de la clase automovil
private int anio,cantidadPuertas; //el objeto no tiene acceso a miembros privados
private double galonesGas,kiloRecorridos;
private String marca;
//creamos el constructor de la clase
public Automovil()
{
//inicializamos algunos valores
marca=;
anio=1990;
galonesGas = kiloRecorridos =0.0;
}
//metodo para darle otros valores a los atributos
public void set (int an, int can, double gal, double kil, String mar)
{
anio=an;
cantidadPuertas = can;
galonesGas= gal;
kiloRecorridos=kil;
marca= mar;
}
//metodo para arrancar el auto
public boolean arrancar()
{
//aqu iria tu cdigo
}
//metodo para frenar el auto
public boolean arrancar()
{
//aqu iria tu cdigo
}
/* como el objeto no puede acceder a los atributos
* podemos crear metodo para dicho trabajo */
public int getAnio()
{
return anio;
}
public double getGasolina()
{
return galonesGas;
}
}// fin de la clase Automovil
/* ahora desde la clase main podemos crear y acceder a dicha clase*/
class ProgramaPrincipal
{ public static void main(String arg[]) {
//instanciamos el objeto llamado objetoA a la clase Automovil
Automovil objetoA = new Automovil();
//asignamos valores a los atributos
objetoA.set (2012, 4, 12, 0,Toyota);
//llamada a un mtodo de la clase
boolean arranco = objetoA.arrancar();
//obtener un atributo de la clase
int annio = objetoA.getAnio();
}//fin del main
}//fin de la clase ProgramaPrincipal
Instanciacin: e produce con la creacin de un objeto perteneciente a una clase (se dice que se instancia la clase). El objeto
que se crea tiene los atributos, propiedades y mtodos de la clase a la que pertenece. Los objetos y sus caractersticas se
usan en la construccin de programas, ya sea como contenedores de datos o como partes funcionales del programa.

SOBRECARGA DE METODOS

Sobrecarga de mtodos y de constructores

La firma de un mtodo es la combinacin del tipo de dato que regresa, su nombre y su lista de argumentos.

La sobrecarga de mtodos es la creacin de varios mtodos con el mismo nombre pero con diferentes firmas y definiciones.
Java utiliza el nmero y tipo de argumentos para seleccionar cul definicin de mtodo ejecutar.

Java diferencia los mtodos sobrecargados con base en el nmero y tipo de argumentos que tiene el mtodo y no por el tipo
que devuelve.

Tambien existe la sobrecarga de constructores: Cuando en una clase existen constructores mltiples, se dice que
hay sobrecarga de constructores.

Ejemplo

/* Mtodos sobrecargados */
int calculaSuma(int x, int y, int z){
...
}
int calculaSuma(double x, double y, double z){
...
}

/* Error: estos mtodos no estn sobrecargados */
int calculaSuma(int x, int y, int z){
...
}
double calculaSuma(int x, int y, int z){
...
}

Ejemplo

/* Usuario4.java */

class Usuario4
{
String nombre;
int edad;
String direccion;

/* El constructor de la clase Usuario4 esta sobrecargado */
Usuario4( )
{
nombre = null;
edad = 0;
direccion = null;
}

Usuario4(String nombre, int edad, String direccion)
{
this.nombre = nombre;
this.edad = edad;
this.direccion = direccion;
}

Usuario4(Usuario4 usr)
{
nombre = usr.getNombre();
edad = usr.getEdad();
direccion = usr.getDireccion();
}

void setNombre(String n)
{
nombre = n;
}

String getNombre()
{
return nombre;
}

/* El metodo setEdad() est sobrecargado */
void setEdad(int e)
{
edad = e;
}

void setEdad(float e)
{
edad = (int)e;
}

int getEdad()
{
return edad;
}

void setDireccion(String d)
{
direccion = d;
}

String getDireccion()
{
return direccion;
}
}

Ejemplo

/* ProgUsuario4.java */

class ProgUsuario4
{
void imprimeUsuario(Usuario4 usr)
{
// usr.nombre equivale en este caso a usr.getNombre()
System.out.println("\nNombre: " + usr.nombre );
System.out.println("Edad: " + usr.getEdad() );
System.out.println("Direccion: " + usr.getDireccion() +"\n");
}

public static void main(String args[])
{
ProgUsuario4 prog = new ProgUsuario4( );
/* Se declaran dos objetos de la clase Usuario4 */
Usuario4 usr1,usr2;

/* Se utiliza el constructor por omisin */
usr1 = new Usuario4( );
prog.imprimeUsuario(usr1);

/* Se utiliza el segundo constructor de Usuario4 */
usr2 = new Usuario4("Eduardo",24,"Mi direccion");

/* Se utiliza el tercer constructor de Usuario4 */
usr1 = new Usuario4(usr2);

usr1.setEdad(50);
usr2.setEdad(30.45f);

}
}
METODOS ESTATICOS

Los atributos y mtodos estticos tambin se llaman atributos de clase y mtodos de clase.
Se declaran como static.
Supongamos una clase Coche sencilla que se utiliza en un programa de compra-venta de coches usados y de
la que se crean 3 objetos de tipo Coche:

La clase contiene 6 atributos: marca, modelo, color, matrcula, precio y descuento. Supongamos que el
descuento es una cantidad que se aplica a todos los coches sobre el precio de venta. Como este dato es el
mismo para todos los coches y es un valor que se puede modificar en cualquier momento no debe formar
parte de cada coche sino que es un dato que deben compartir todos. Esto se consigue declarndolo
como static.

compartido por todos los objetos de la clase.
- Podemos considerarlo como una variable global a la que tienen acceso todos los objetos de la clase.
- Existe y puede utilizarse aunque no existan objetos de la clase.
Para acceder a un atributo de clase se escibe:
NombreClase.atributo
Un Mtodo static:
- Tiene acceso solo a los atributos estticos de la clase.
- No es necesario instanciar un objeto para poder utilizarlo.
Para acceder a un mtodo de clase se escribe:
NombreClase.mtodo()
Ejemplo:

Vamos a escribir una clase Persona que contendr un atributo contadorPersonas que indique cuantos objetos
de la clase se han creado.
contadorPersonas debe ser un atributo de clase ya que no es un valor que se deba guardar en cada objeto
persona que se crea, por lo tanto se debe declarar static:
static int contadorPersonas;
Un ejemplo de uso desde fuera de la clase Persona:
System.out.println(Persona.contadorPersonas);
Si lo declaramos como private:
private static int contadorPersonas;
solo podremos acceder al atributo desde fuera de la clase a travs de mtodos static:
public static void incrementarContador(){
contadorPersonas++;
}
public static int getContadorPersonas() {
return contadorPersonas;
}
En este caso un ejemplo de uso puede ser:
System.out.println(Persona.getContadorPersonas());

Cada vez que se crea una persona se incrementar su valor.
Si no es private, desde otra clase podemos hacerlo as:
Persona.contadorPersonas++;
Si es private, desde otra clase debemos incrementarlo as:
Persona.incrementarContador();

El cdigo de la clase Persona y de la clase principal quedara ahora as:

//Clase Persona

public class Persona {

private String nombre;
private int edad;
private static int contadorPersonas;

public Persona() {
contadorPersonas++;
}

public Persona(String nombre, int edad) {
this.edad = edad;
contadorPersonas++;
}

public void setNombre(String nom) {
nombre = nom;
}

public String getNombre() {
return nombre;
}

public void setEdad(int ed) {
edad = ed;
}

public int getEdad() {
return edad;
}

public static int getContadorPersonas() {
return contadorPersonas;
}
}

//Clase Principal
public class Estatico1 {

public static void main(String[] args) {
Persona p1 = new Persona("Toms Navarra", 22);
Persona p3 = new Persona("Jons Estacio", 23);
System.out.println("Se han creado: " + Persona.getContadorPersonas() + " personas");
}
}

VARIABLES ESTATICAS

Son propias nicamente de la clase y no de los objetos que pueden crearse de la misma, por lo tanto, sus valores son
compartidos por todos los objetos de la clase. Van precedidas del modificador static.
Para invocar a una variable esttica no se necesita crear un objeto de la clase en la que se define:
Si se invoca desde la clase en la que se encuentra definido, basta con escribir su nombre.
Si se le invoca desde una clase distinta, debe anteponerse a su nombre, el de la clase en la que se encuentra
seguido del operador punto (.) <NombreClase>.variableEstatica
Suelen emplearse para definir constantes comunes a todos los objetos de la clase.
Ejemplo 1:

Cdigo

SETTER Y GETTER
Setters & Getters
Los Setters & Getters son mtodos de acceso lo que indica que son siempre declarados pblicos, y nos sirven para dos
cosas:

Setters: Del Ingls Set, que significa establecer, pues nos sirve para asignar un valor inicial a un atributo, pero de forma
explcita, adems el Setter nunca retorna nada (Siempre es void), y solo nos permite dar acceso pblico a ciertos atributos
que deseemos el usuario pueda modificar.

Getters: Del Ingls Get, que significa obtener, pues nos sirve para obtener (recuperar o acceder) el valor ya asignado a un
atributo y utilizarlo para cierto mtodo.

Entonces veamos en un ejemplo, si tenemos una Clase de nombre Estudiante, cmo seran sus Setters & sus Getters?

public Class Estudiante
{
private String nombre;
private String apellido;
private String correo;

public String getNombre()
{
return nombre;
}
public void setNombre(String nombre)
{
}

public String getApellido()
{
return apellido;
}
public void setApellido(String apellido)
{
this.apellido = apellido;
}

public String getCorreo()
{
return correo;
}
public void setCorreo(String correo)
{
this.correo = correo;
}
}

Y en el main la implementacin sera:

public Class Principal
{
public static void main(String args[])
{
Estudiante estudiante1 = new Estudiante();
//Ingreso los datos con los Setter a la nueva instancia de
//Estudiante, estos datos pueden ingresarse desde teclado
//o a travs de una GUI
estudiante1.setNombre("Mara");
estudiante1.setApellido("Paucar");
estudiante1.setCorreo("maria.paucar@epn.edu.ec");

//Para obtener los datos uso los Getter
//y los podemos imprimir en Consola o a una GUI
System.out.println(estudiante1.getNombre());
System.out.println(estudiante1.getApellido());
System.out.println(estudiante1.getCorreo());
}
}
Figuras geometricas Herencia
//clase ABSTRACTA
public abstract class Figura {
/**anbstractas es de la cual no se crea objetos*/
/**son clses genericas*/
private String color;

public Figura(String col)
{
setColor(col);

}

public void setColor(String col)
{
color=col;
}

public String getColor()
{
return color;
}

public String nombre()
{
return "Figura";
}

public String toString()
{
return nombre()+" Color: "+getColor();
}

}
--------------------------------

public abstract class FiguraBidimencional extends Figura{
//clase ABSTRACTA
private String unidades;

public FiguraBidimencional(String col,String un)
{
super(col);
setUnidades(un);

}

public void setUnidades(String un)
{
unidades=un;
}

public String getUnidades()
{
return unidades;
}

{
return "Figura";
}

{
return " "+getUnidades();
}

}

-------------------------------------------------

import java.text.DecimalFormat;

public class Circulo extends FiguraBidimencional {
private double radio;

public Circulo(String col,String un,double rad)
{
super(col,un);
setRadio(rad);
}

public void setRadio(double rad)
{
radio=(rad>=0)?rad:0.0;
}

public double getRadio()
{
return radio;
}

{
return "\nCrculo";
}

public double area()
{
return Math.PI*Math.pow(radio, 2);
}

{
DecimalFormat dosDigitos=new DecimalFormat("0.00");
return nombre()+"\nColor:"+super.getColor()+"\nRadio: "+getRadio()+"\nArea: "+
dosDigitos.format(area())+super.getUnidades();
}
}
-------------------------------------------

public class Triangulo extends FiguraBidimencional{
//clase ABSTRACTA
private int base;
private int altura;

public Triangulo(String col,String un,int b,int al)
{
super(col,un);
setBase(b);
setAltura(al);

}

public void setBase(int b)
{
base=b;
}
public void setAltura(int al)
{
altura=al;
}
public int getBase()
{
return base;
}
public int getAltura()
{
return altura;
}
{
return "Triangulo";
}
public double Area()
{

return (getBase()*getAltura())/2;

}
{
return nombre()+"\nColor "+super.getColor()+"\nArea "+
Area()+super.getUnidades();
}

}
-----------------------------------------
//Figura tridimencional:

public abstract class FiguraTridimencional extends Figura{
//clase ABSTRACTA
/**son clases genericas*/
private String uniTri;

public FiguraTridimencional(String col,String uT)
{
super(col);
setUniTri(uT);

}

public void setUniTri(String uT)
{
uniTri=uT;
}

public String getUniTri()
{
return uniTri;
}

{
return "";
}

{
return nombre()+" Color: "+super.getColor()+" :"+getUniTri();
}

}

-------------------------------------------

public class Cilindro extends FiguraTridimencional {

private double altura;
private double aBase;

public Cilindro(String col,double aB,double alt,String uT)
{
super(col,uT);
setAltura(alt);
setABase(aB);
}
public void setABase(double aB)
{
aBase=aB;
}
public void setAltura(double alt)
{
altura=alt;
}
public double getAltura()
{
return altura;
}
public double getABase()
{
return aBase;
}
public double VolumenCilindro()
{
return aBase*altura;
}

public String Nombre()
{
return "\nCilindro ";
}
{
return Nombre()+"\nColor: "+super.getColor()+"\nVolumen"+VolumenCilindro()+super.getUniTri();

}

}
------------------------------------
import java.text.DecimalFormat;
public class Esfera extends FiguraTridimencional {
//clase ABSTRACTA
private double radio;

public Esfera(String col,double rad,String uT)
{
super(col,uT);
setRadio(rad);

}

public void setRadio(double rad)
{
radio=rad;
}
public double getRadio()
{
return radio;
}

{
return "\nEsfera";
}
public double volEsfera()
{

return (4/3)*Math.PI*getRadio()*getRadio()*getRadio();

}
{
DecimalFormat dosDigitos=new DecimalFormat("0.00");
return nombre()+"\nColor: "+super.getColor()+"\nVolumen: "+
dosDigitos.format(volEsfera())+super.getUniTri();
}

}
------------------------------------------

public class PruebaFigura {

//figura bidimencional
Triangulo t=new Triangulo("rojo"," cm2",15,21);
System.out.println(t);

Circulo c=new Circulo("naranja"," m2",05);
System.out.println(c);

Cilindro ci=new Cilindro("verde",2.2,5.1,"m3");
System.out.println(ci);

Esfera es=new Esfera("amarillo",4.0," m3");
System.out.println(es);
}

}

HASNEXT
package com.tutorialspoint;

import java.util.*;
import java.util.regex.Pattern;

public class ScannerDemo {


String s = "Hello World! 3+3.0=6";

// create a new scanner with the specified String Object
Scanner scanner = new Scanner(s);

// check if the scanner has a token
System.out.println("" + scanner.hasNext());

// print the rest of the string
System.out.println("" + scanner.nextLine());

// check if the scanner has a token after printing the line
System.out.println("" + scanner.hasNext());

// close the scanner
scanner.close();
}
}
Let us compile and run the above program, this will produce the following result:
true
Hello World! 3+3.0=6
false

Conceptos Básicos Poo

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Conceptos Básicos Poo

Uploaded by

Copyright:

Available Formats

Conceptos bsicos

You might also like