¿QUÉ ES LA HERENCIA EN PROGRAMACIÓN ORIENTADA A OBJETOS? (Emilio Ampuero)

Muchas veces distintos objetos comparten campos y métodos que hacen aproximadamente lo mismo (por ejemplo almacenar y devolver un nombre del ámbito humano con el que se designa al objeto, como el título de un álbum de música, el título de un libro, el título de una película, etc.).

Por ejemplo en un proyecto que utilice objetos Taxi y objetos Autobus podríamos encontrarnos algo así:

Para una aplicación de gestión de una empresa de transporte que tenga entre sus vehículos taxis y autobuses podríamos tener otra clase denominada FlotaCirculante donde tendríamos posibilidad de almacenar ambos tipos de objeto (por ejemplo taxis en un ArrayList y autobuses en otro ArrayList) como reflejo de los vehículos que se encuentran en circulación en una fecha dada. Esas listas conllevarían una gestión para añadir o eliminar vehículos de la flota circulante, modificar datos, etc. resultando que cada una de las listas necesitaría un tratamiento o mantenimiento.

Si nos fijamos en el planteamiento del problema, encontramos lo siguiente:

a) La definición de clases nos permite identificar campos y métodos que son comunes a Taxis y Autobuses. Si implementamos ambas clases tal y como lo venimos haciendo, incurriremos en duplicidad de código. Por ejemplo si el campo matricula es en ambas clases un tipo String, el código para gestionar este campo será idéntico en ambas clases.

b) La definición de clases nos permite identificar campos y métodos que difieren entre una clase y otra. Por ejemplo en la clase Taxi se gestiona información sobre un campo denominado numeroDeLicencia que no existe en la clase Autobus.

c)  Conceptualmente podemos imaginar una abstracción que engloba a Taxis y Autobuses: ambos podríamos englobarlos bajo la denominación de “Vehículos”. Un Taxi sería un tipo de Vehiculo y un Autobus otro tipo de Vehiculo.

d) Si la empresa añade otros vehículos como minibuses, tranvías, etc. manteniendo la definición de clases tal y como la veníamos viendo, seguiríamos engrosando la duplicidad de código. Por ejemplo, un minibús también tendría matrícula, potencia… y los métodos asociados.

La duplicidad de código nos implicará problemas de mantenimiento. Por ejemplo inicialmente tenemos una potencia en caballos y posteriormente queremos definirla en kilowatios. O tenemos simplemente que modificar el código de un método que aparece en distintas clases. El tener el código duplicado nos obliga a tener que hacer dos o más modificaciones en sitios distintos. Pueden ser dos modificaciones, tres, cuatro o n modificaciones dependiendo del número de clases que se vieran afectadas, y esto a la larga genera errores al no ser el mantenimiento razonable.

En la clase FlotaCirculante también tendremos seguramente duplicidades: por un lado un ArrayList de taxis y por otro un ArrayList de autobuses, por un lado una operación de adición de taxis y otra operación de adición de autobuses, por un lado una operación para mostrar los elementos de la lista de taxis y otra para los elementos de la lista de autobuses…

¿No sería más razonable, si una propiedad o método va a ser siempre común para varios tipos de objetos, que estuviera localizada en un sitio único del que ambos tipos de objeto “bebieran”? En los lenguajes con orientación a objetos la solución a esta problemática se llama herencia. La herencia es precisamente uno de los puntos clave de este tipo de lenguajes. 

La herencia nos permite definir una clase como extensión de otra: de esta manera decimos “la clase 1.1 tiene todas las características de la clase 1 y además sus características particulares”. Todo lo que es común a ambas clases queda comprendido en la clase “superior”, mientras lo que es específico, queda restringido a las clases “inferiores”. En nuestro ejemplo definiríamos una clase denominada Vehiculo, de forma que la clase Taxi tuviera todas las propiedades de la clase Vehiculo, más algunas propiedades y métodos específicos. Lo mismo ocurriría con la clase Autobus y otras que pudieran “heredar” de Vehiculo. Podríamos seguir creando clases con herencia en un número indefinido: tantas como queramos. Si piensas en el API de Java, hay cientos de clases que heredan de clases jerárquicamente superiores como la clase Object. En un proyecto propio, podremos tener varias clases que hereden de una clase común.

                      Esquema básico de herencia

Otro ejemplo: para la gestión de un centro educativo, podemos definir la clase Persona que comprende los campos y métodos comunes a todas las personas. Luego podremos definir la clase Estudiante, que es extensión de Persona, y comprende los campos y métodos de la clase superior, más algunos específicos. También podrían heredar de Persona la clase Profesor, la clase Director, la clase JefeDeEstudios, la clase PersonalAdministrativo, etc.

La primera aproximación a la herencia en Java la plantearemos para plasmar todo lo que hemos discutido en párrafos anteriores: en vez de definir cada clase por separado con operaciones o campos duplicados en cierta medida, definiremos una clase “padre” que contendrá todas las cosas que tengan en común otras clases. Luego definiremos las otras clases “hijo” como extensión de la clase padre, especificando para ellas únicamente aquello que tienen específico y distinto de la clase padre. Una característica esencial de la herencia es que permite evitar la duplicidad de código: aquello que es común a varias clases se escribe solo una vez (en la clase padre). La duplicidad de información, ya sea código o datos, es algo que por todos los medios hay que tratar de evitar en los sistemas informáticos por ser fuente de errores y de problemas de mantenimiento.

Si nos remitimos al esquema básico de herencia donde hemos representado las clases Vehiculo, Taxi y Autobus, la clase Vehiculo diremos que actúa como clase padre de las clases Taxi y Autobus. Vehiculo recogería todo aquello que tienen o hacen en común taxis y autobuses. Aunque aquello que tienen en común se agrupa, tanto Taxi como Autobus tienen sus campos o métodos específicos.

Que una clase derive de otra en Java se indica mediante la palabra clave “extends”. Por eso muchas veces se usa la expresión “esta clase es extensión de aquella otra”. En los diagramas de clase la herencia se representa con una flecha de punta vacía. El aspecto en BlueJ sería algo así:

Este diagrama refleja que la clase FlotaCirculante usa a la clase Vehiculo, mientras que las clases Taxi y Autobus heredan de la clase Vehiculo (son extensión de la clase Vehiculo). Podemos decir que la clase hijo extiende (hace más extensa) a la clase padre. Una clase de la que derivan otras se denomina clase padre, clase base o superclase. Las clases que heredan se denominan clases derivadas, clases hijos o subclases. A partir de ahora los términos superclase y subclase son los que usaremos con más frecuencia. Una subclase podrá tener un acceso “más o menos directo” a los campos y métodos de la superclase en función de lo que defina el programador, como veremos más adelante. Para referirnos a la herencia también se usa la terminología “es un”. En concreto decimos que un objeto de la subclase es un objeto de la superclase, o más bien en casos concretos, que un Taxi es un Vehiculo, o que un Estudiante es una Persona. Sin embargo, al revés esto no es cierto, es decir, un Vehiculo no es un Taxi, ni una Persona es un Estudiante.

Dos subclases que heredan de una clase no deben tener información duplicada. Esto se consideraría un mal diseño. La información común debe estar en una superclase.

Polimorfismo en JAVA (Emilio Ampuero)

Polimorfismo en JAVA (Emilio Ampuero)

El polimorfismo consiste en obtener un mismo método con diferentes funciones, es decir, suponiendo que tengamos una clase Saludo con el método Saludo el cual sería su constructor, pero en este caso tendríamos varios constructores pero siempre siguiendo las reglas de independencia en cuestión a los parámetros de cada constructor para que así puedan diferenciarse uno de otro, sin embargo cada uno tendrá diferentes procesos internos en sí mismo.

CREACIÓN DEL POLIMORFISMO

Primero crearemos una clase ajena a la clase main la cual denominaremos Saludo. Dentro de saludo crearemos un atributo llamado “MensajeSaludo” de la siguiente manera.

String MensajeSaludo;

Posteriormente pasamos a crear los constructores con diferentes atributos y funciones lo cual vendría a ser el polimorfismo de la clase Saludo.

public Saludo(){
        MensajeSaludo="Hola Amigo";
}
public Saludo(String Palabra){
        MensajeSaludo=Palabra;
}
public Saludo(String Palabra, String Nombre){
        MensajeSaludo=Palabra.concat(" ").concat(Nombre);
}

Realizado esto podríamos instanciar a los diferentes constructores de la clase Saludo en nuestro main principal o donde lo requiramos. En este caso usaremos el polimorfismo en nuestro main.

INSTANCIANDO NUESTRO POLIMORFISMO

Para usar el primer constructor de nuestro polimorfismo (El que no cuenta con atributos) instanciamos de la siguiente manera:

Saludo x=new Saludo();

Para el segundo sería de la misma pero almacenando en otra variable:

Saludo y=new Saludo("Hola Kevin");

Y luego tendríamos el tercero:

Saludo z=new Saludo("Hola", "Kevin Arnold");

IMPRESIÓN DE CADA CONSTRUCTOR

Para poder imprimir en pantalla el atributo que fue asignado por los diferentes constructores de nuestra clase Saludo, debemos introducir el siguiente código:

System.out.println(x.MensajeSaludo);
System.out.println(y.MensajeSaludo);
System.out.println(z.MensajeSaludo);

Donde indicamos con nuestras variables “x”, “y” y “z” los diferentes constructores (Polimorfismo de la clase Saludo). Y el “MensajeSaludo” sería el atributo que tomó diferentes valores según el polimorfismo asignado a cada variable de la clase Saludo.

Explcacion de "try /catch" en JAVA (Emilio ampuero)

Sintaxis del Bloque try/catch:

try { // Código que pueda generar Errores ("Exception's") } catch(Tipo1 id1) { // Manejar "Exception's" para la Clase Tipo1 } catch(Tipo2 id2) { // Manejar "Exception's" para la Clase Tipo2 } catch(Tipo3 id3) { // Manejar "Exception's" para la Clase Tipo3 }

La primer sección del Bloque es iniciada con el vocablo try y una llave ({ ) que indica el principio de la zona protegida, dentro de esta primer sección es colocado todo código que pueda generar algún tipo de error, al terminar esta sección se define un grupo de estructuras con el elemento catch.

Como se puede observar en la ilustración, cada vocablo catch es seguido de un paréntesis que contiene una Clase así como una referencia, estos son considerados los Datos de Entrada para cada sección catch; el tipo de Clases definidas dentro de cada sección catch depende del numero de "Exceptions" que pueden ser generadas por el programa; lo anterior permite definir un numero ilimitado de "Exceptions" cada uno con su propio código para manejar el error.

Para todo Bloque try/catch debe ser definida al menos una sección catch; si son definidos más de dos Clases para errores ("Exceptions") estas deben ser declaradas de más a menos especifica, siendo la menos especifica la Clase java.lang.Throwable; es de esta Clase que son Heredadas ("Inherited") todo "Exception" en Java, esto será descrito en la siguiente sección de este curso.

C++ (Emilio Ampuero)

C++ es un lenguaje de programacion diseñado a mediados de los años 1980 por Bjarne Stroustrup. La intención de su creación fue el extender al lenguaje de programación C mecanismos que permiten la manipulación de objetos. En ese sentido, desde el punto de vista de los lenguajes orientados a objetos, el C++ es un lenguaje híbrido.

Posteriormente se añadieron facilidades de programacion generica, que se sumaron a los paradigmas de programacion extructurada y POO. Por esto se suele decir que el C++ es un lenguaje deprogramacion multiparadigma.

Actualmente existe un estándar, denominado ISO C++, al que se han adherido la mayoría de los fabricantes de compiladores más modernos. Existen también algunos intérpretes, tales como ROOT.

Una particularidad del C++ es la posibilidad de redefinir los operadores, y de poder crear nuevos tipos que se comporten como tipos fundamentales.

El nombre C++ fue propuesto por Rick Masciti en el año 1983, cuando el lenguaje fue utilizado por primera vez fuera de un laboratorio científico. Antes se había usado el nombre "C con clases". En C++, la expresión "C++" significa "incremento de C" y se refiere a que C++ es una extensión de C.

Un ejemplo de programa

A continuación se cita un programa de ejemplo Hola mundo escrito en C++:

/* Esta cabecera permite usar los objetos que encapsulan los descriptores stdout 
y stdin: cout(<<) y cin(>>)*/
#include 

using namespace std;

int main()
{
   cout << "Hola mundo" << endl;
   cin.get();
}

Al usar la directiva #include se le dice al compilador que busque e interprete todos los elementos definidos en el archivo que acompaña la directiva (en este caso,iostream). Para evitar sobrescribir los elementos ya definidos al ponerles igual nombre, se crearon los espacios de nombres o namespace del singular en inglés. En este caso hay un espacio de nombres llamado std, que es donde se incluyen las definiciones de todas las funciones y clases que conforman la biblioteca estándar de C++. Al incluir la sentencia using namespace std le estamos diciendo al compilador que usaremos el espacio de nombres std por lo que no tendremos que incluirlo cuando usemos elementos de este espacio de nombres, como pueden ser los objetos cout y cin, que representan el flujo de salida estándar (típicamente la pantalla o una ventana de texto) y el flujo de entrada estándar (típicamente el teclado).

La definición de funciones es igual que en C, salvo por la característica de que si main no va a recoger argumentos, no tenemos por qué ponérselos, a diferencia de C, donde había que ponerlos explícitamente, aunque no se fueran a usar. Queda solo comentar que el símbolo << se conoce como operador de inserción, y grosso modo está enviando a cout lo que queremos mostrar por pantalla para que lo pinte, en este caso la cadena "Hola mundo". El mismo operador << se puede usar varias veces en la misma sentencia, de forma que gracias a esta característica podremos concatenar el objeto endl al final, cuyo resultado será imprimir un retorno de línea.

Por último tomaremos una secuencia de caracteres del teclado hasta el retorno de línea (presionando ENTER), llamando al método get del objeto cin.

Break & Continue(while)- Benjamin Pacheco

Break & Continue

Las instrucciones repetitivas for y while, cuentan con dos instrucciones que permiten abandonar la ejecución del bloque de instrucciones antes de su finalización. Estas instrucciones son: break y continue. Tambien se le conoce como salida forzada de un bucle

#Break: Su uso, ademas de la instruccion Switch también se puede extender a las instrucciones repetitivas. En estas, la utilización de break provoca una salida forzada del bucle, continuando la ejecución del programa en la primera sentencia situada después del mismo.

Estructura de la instruccion Break:

for( int i = 0 ; ; i++){
  System.out.println(i);
          if ( i == 30 ){
                System.out.println("i es igual a 30 | Salir ");
                break;
             }
   }
   System.out.println("1ª sentencia después del bucle");

#Continue:La instrucción continue provoca que el bucle detenga la iteración actual y pase, en el caso del for, a ejecutar la instrucción de incremento o en el caso de while, a comprobar la condición de entrada.

Estructura de la instruccion Continue:

int i = 0;
        while ( i < 10 ) 
        {
          if ( i == 5 ){
           //continue;
           //break;
          }
          System.out.println("i: " + i );
          i++;
        }

Try-Catch-Finally- Benjamin Pacheco

Try – Catch – Finally -Benjamín Pacheco

Instruccion Try – Catch – Finally 

El control de flujo de un programa Java sabemos hasta ahora que se lleva a cabo con sentencias del tipo if, while, for, return, break, etc… Estas sentencias forman un conjunto de palabras reservardas que determinan cierta funcionalidad. Pues bien, ninguna de ellas tiene en cuenta que se puedan producir errores en tiempo de ejecución de un programa y por tanto Java necesita de un conjunto de palabras nuevas para tener en cuenta que cualquier código puede fallar o ser mal interpretado en tiempo de ejecución El uso de try – catch – finally corresponde a la captura de errores. Estas instrucciones se usan en ejercicios tales como divisiones por cero, cambio de tipo de datos, lectura de archivos, conexiones con bases de datos, entre otras.

Estructura de Try – Catch – Finally:

try
{
 //Instrucciones que pueden producir una excepción
}
catch(excepción variable)
{
 //Tratamiento de la excepción
}
finally
{
 //Instrucciones de ultima ejecución 
}

Definicion de las instrucciones:

#TRY: Todo el código que vaya dentro de esta sentencia será el código sobre el que se intentará capturar el error si se produce y una vez capturado hacer algo con él.

#CATCH: Conjunto de instrucciones necesarias o de tratamiento del problema capturado con el bloque try anterior. Es decir, cuando se produce un error o excepción en el código que se encuentra dentro de un bloque try, pasa directamente a ejecutar el conjunto de sentencias que hay en el bloque catch.

#FINALLY: Es un bloque donde se puede definir un conjunto de instrucciones necesarias tanto si se produce error o excepción como si no y que por tanto se ejecuta siempre.

Bases de Datos- Benjamin Pacheco

Bases de Datos-Benjamín Pacheco

Bases de Datos

Es una colección de datos interrelacionados y un conjunto de programas para acceder a dichos datos. El objetivo principal de SGBD es proporcionar una forma de almacenar y recuperar la información de la base de datos de manera que sea tanto practica como eficiente.

  Modelos de los datos 

Es una colección de herramientas conceptuales para describir los datos, las relaciones, la semántica y las restricciones. Existen varios tipos de modelo de datos:

             >>Modelo Entidad-Relación 
             >>Modelo Relacional (tablas) 
             >>Modelo de datos relacional orientado a objetos
             >>Modelo de datos orientado a objetos
       

 Lenguaje de bases de datos 

Un sistema de bases de datos proporciona un lenguaje de definición de datos para especificar el esquema de la base de datos y un lenguaje de manipulación de datos para expresar las consultas a la base de datos y las modificaciones.

This & Super- Benjamin Pacheco

This & Super-Benjamín Pacheco

This & Super

Son dos palabras claves que usa el metodo para referirse a un objeto.
>>THIS: Es siempre una referencia al objeto sobre el que ha sido llamado el método. Para permitir esta situación, Java define la palabra clave this, la cual puede ser utilizada dentro de cualquier método para referirse al objeto actual.
>>SUPER: Tiene dos formas generales. La primera llama al constructor de la superclase. La segunda se usa para acceder a un miembro de la superclase que ha sido escondido por un miembro de una subclase. Cuando queramos referirnos a la superclase (o clase padre) se utilizara la palabra reservada super.

A continuación veremos un ejemplo de cada referencia:

THIS:

import javax.swing.*;

public class Ventana extends JFrame{
    
    public Ventana(){
        
        this.setLayout(null);
        this.setVisible(true);
        this.setSize(400, 400);
        this.setLocationRelativeTo(null);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            
    }//fin constructor
    
}//fin clase

SUPER:

public class Ventana extends JFrame{
    
    public Ventana(String titulo){
        
 this.setTitle(titulo);
        this.setVisible(true);   
    }//fin constructor
}//fin clase

class EjecutarVentana extends Ventana{
    
    public EjecutarVentana(){
        super("Este es el título de la ventana");  
    }//fin constructor
}//Fin clase

Herencia- Benjamin Pacheco

Herencia-Benjamín Pacheco

Herencia

Es una instrucción de tipo alternativa que comprueba una condición dentro de un programa. Si esta condición se cumple, dará paso a un determinado conjunto de opciones, y si ésta no se cumple, se puede optar por ejecutar un conjunto diferente. La herencia es un mecanismo que permite la definición de una clase a partir de la definición de otra ya existente. La herencia permite compartir automáticamente métodos y datos entre clases, subclases y objetos.
En la herencia existen 2 tipos:
>Superclase:

 Es una clase que es heredada.

>Subclase:

 Es una clase que se hereda.

A continuación veremos un ejemplo de herencia:

class FiguraGeometrica{
    
    public double area;
    public double perimetro;
    
    public void calcular(){}
    public void dibujar(){}
}//Fin Clase

class Rectangulo extends FiguraGeometrica{
    
    public double base;
    public double altura;
    
    @Override
    public void calcular(){ }
    
    @Override
    public void dibujar(){}
}//Fin Clase

Constructores-Benjamin Pacheco

Constructores-Benjamín Pacheco

Constructores

Los constructores son métodos especiales que sirven para inicializar las instancias de una clase. se llaman igual que la clase, no tienen tipo de retorno (ni siquiera void) y solamente se les pueden aplicar los modificadores de visibilidad. Los constructores también se pueden sobrecargar, como cualquier método, variando la cantidad de parámetros que reciben.

A continuación, un ejemplo de constructores:

public class Principal {

    public static void main(String[] args) {
        
        Persona Vr = new Persona();
        
        Vr.mostrarInformacion();
        
    }
    
}

public class Persona{
    
    public String nombre;
    public String apellido;
    
    public Persona()
    {        
        nombre = "Ana";
        apellido = "Solis";
    }//fin constructor
    
    public void mostrarInformacion(){
        
        System.out.println("El nombre es: " +nombre);
        System.out.println("El apellido es: " + apellido);
    }//fin metodo
    
}//fin clase

Sobrecarga de metodos- Benjamin Pacheco

Sobrecarga de metodos-Benjamín Pacheco

Sobrecarga de metodos

Un método sobrecargado se utiliza para reutilizar el nombre de un método pero con diferentes argumentos. Las reglas para sobrecargar un método son las siguientes:

+ Los métodos sobrecargados deben cambiar la lista de argumentos.

+ Pueden cambiar el tipo de retorno.

+ Pueden cambiar el modificador de acceso.

+ Pueden declarar nuevas o más amplias excepciones.

+ Un método puede ser sobrecargado en la misma clase o en una subclase.

Hay 2 tipos de sobrecarga de metodos:

 >Por cantidad de parámetros

public void sumar (int a){}

public void sumar (int a, int b){}

 >Por diferencia de parámetros

public void sumar (int a){}

public void sumar (float a){}

A continuación, un ejemplo de sobrecarga de metodos:

public class principal {

    public static void main(String[] args) {
          
        Electricidad vRef;
        vRef = new Electricidad();
        
        vRef.LeyOhm(50d, 35d);
        vRef.LeyOhm(40, 20);
        vRef.LeyOhm(10f, 30f);
        
    }//fin metodo main
    
}//fin clase

public class Electricidad {
    
    //cantidad de parámetros
    public void LeyOhm(double v, double i){
        
        System.out.println("La resistencia es de: "+ (v / i));
    }
    
    public void LeyOhm(int v, int r){
        
        System.out.println("La intensidad es de: "+ (v / r));
    }
    
    public void LeyOhm(float i, float r){
        
        System.out.println("Los voltios son de: "+ (i * r));
    }
    
}//fin clase

Métodos- Benjamin Pacheco

Metodos-benjamin pacheco

Metodos

Los métodos son funciones que determinan el comportamiento de los objetos. Éstos permiten dividir el trabajo que realiza un programa en tareas o comportamientos lógicos de forma separada.

 Invocación de metodos

Para invocar o ejecutar un método en una clase diferente, se utiliza el operador punto (.) con una variable de referencia a un objeto.

Tipos de metodos

Existen varios tipos de metodos, entre ellos están:

-Metodos llamadores y trabajadores:

Cuando un método llamador llama a uno trabajador, el método llamador detiene su ejecución hasta que el método trabajador finalice.

-Metodos con argumentos:

Aquí los métodos se declaran con parámetros y reciben argumentos. Ejemplo de metodos:

public class Ejercicios29_09 {
     
        public void operacionesAritmeticas(){
            
            
               System.out.println("Ingrese ( s ) para sumar");
        
System.out.println("Ingrese ( r ) para restar");
       
 System.out.println("Ingrese ( m ) para multiplicar");
        
System.out.println("Ingrese ( d ) para dividir");
        
System.out.println("\n"+"Ingrese una opción: ");
        
char opcion = objeto.nextLine().toLowerCase().charAt(0);
        
switch(opcion)
        {
           
 case 's':
               
 int a = 12;
                
 int b = 30;
               
 int suma = a + b;
                
                
if(suma > 50){
                   
 System.out.println("número elevado");
               
 }
                
               
 break;
            
 case 'r':
                
               
 int c = 12;
               
 int z = 4;
                
 int resta = c-z;      
               
 if (resta<0){
               
 System.out.println("es negativo");
               
 }
               
                
 break;
            
 case 'm':
                
 int m = 12;
               
 int o = 4;
               
 int multi = m*o; 
               
 System.out.println(multi);
              
 if (multi %2==0){
               
 System.out.println("es par");
               
 }
                
                
 break;
            
 case 'd': 
                 
 int d = 12;
                
 int l = 4;
                
 int dv = d/l; 
                
 System.out.println(dv);
                
 if (dv %2==1){
                
 System.out.println("es impar");
               
 }
                
 break;
            
 default:
               
 System.out.println("Incorrecto");
       
 }
    }//Fin metodo main
}//Fin de la clase

Programacion Orientada a Objetos - Benjamín Pacheco

Programación Orientada a Objetos

Es un modelo de programación que utiliza objetos, ligados mediante mensajes, para la solución de problemas. Es decir organizar los programas a imagen y semejanza de la organización de los objetos en el mundo real.Los objetos poseen un conjunto de propiedades o atributos y un conjunto de métodos mediante os cuales muestran su comportamiento y además los objetos muestran un conjunto de interrelaciones entre ellos mediante mensajes a los que responden mediante métodos.Un mecanismo importante de la POO, son las clases y los objetos están contenidos dentro de ellas, por eso se dice que un objeto es la instancia de una clase.
Un programa orientado a objetos se compone solamente de objetos, cada uno de ellos es una entidad que tiene unas propiedades particulares, los atributos y las formas de operar de ellos los métodos. Por ejemplo esta página Web es un objeto, tiene colores de fondo, anchura y altura, etc. son los atributos (características) y las rutinas que ejecuta el usuario cerrar, abrir, recorrer, etc. son los métodos.

 Aqui hay un ejemplo en Java de la POO:

public class Persona{
        private String nombre;
        private String apellido;
        private int edad;
    
        public  Persona(String n, String a, int e){
           nombre   = n;
           apellido = a;
           edad     = e;
       }
       
       public void saludar(){
           System.out.println("Hola, mi nombre es " + nombre);
      }
       public int  getEdad(){
          return edad;
      }
  }
    }//Fin metodo main
}//Fin de la clase

Do While - Manuel Sanchez

Instruccion Do While

La sentencia de iteración do-while es de tipo pos prueba. Primero realiza las acciones luego pregunta. La sintaxis es la siguiente

 

Es los mismo que while, solamente que ahora la instrucción es al revés, Primero se ejecuta la sentencia y luego evalúa la condición, Permite ejecutar un bloque de instrucciones mientras se cumpla una determinada condición dentro del programa. 

 

En ambos casos While  como en Do While, el bloque de instrucciones se ejecuta mientras la condición se cumple. En el segundo formato se ejecutan las instrucciones y luego se comprueba la condición, lo que garantiza que el bloque de instrucciones se ejecute por lo menos una vez.

Ahora Veamos Un Ejemplo En Do While:

// Mostrar los números del 30 al 10.

  
 package DoWhile;

public class DoWhile {

    public static void main(String[] args) {

         int i = 30;

       do {

           System.out.println(i);

           i --;

       }

       while(i >= 10);

    }
   
}


Ahora Veamos Un Ejemplo De DoWhile - Mientras En Pseudocodigo:

//La Suma De Los 100 Primeros Numeros

 

Ahora Veamos Un Ejemplo De DoWhile En Scratch:




Link Del Proyecto