HERENCIA EN POO

solucionario del 1er parcial : pregunta 3

PREGUNTA 3:

import examen.Cancion;

/**
 *
 * @author Conde
 */
public class main {
    public static void main(String[] args) {
        Cd objCd= new Cd();
        Cancion objC= new Cancion();
        int op; int opBorrar;
        Lectura leer= new Lectura();
        do {            
             System.out.println("1 Insertar Cancion");
             System.out.println("2 Borrar Cancion");
             System.out.println("3 Mostrar Canciones");
             System.out.println("4 Cambiar Canciones");
             System.out.println("5 Salir");
             op=leer.getInt();
             switch(op){
              case 1:      
                objC= new Cancion();
                System.out.println("Ingrese el nombre");
                objC.setNombre(leer.getString());

                System.out.println("Ingrese el autor de ");
                objC.setAutor(leer.getString());

                //Agregamos la cancion
                objCd.AgregaCancion(objC);                             
          break;

          case 2:           
               if(objCd.numCanciones()>0){
               
                    System.out.println("Ingrese Posicion que se borrará");
                    opBorrar= leer.getInt();               
                    objCd.EliminaCancion(opBorrar);
                    System.out.println("borrado");
               }
              else{
                  System.out.println("No hay elementos");
              }
               
          break;
          case 3:
              System.out.println("--------------");
                for (int i = 0; i < objCd.numCanciones(); i++) {
                        objCd.dameCancion(i).Mostrar();
                }
          break;
             
          case 4:
                 objC= new Cancion();
                System.out.println("Ingrese el nombre");
                objC.setNombre(leer.getString());

                System.out.println("Ingrese el autor ");
                objC.setAutor(leer.getString());
               
                System.out.println("Ahora Ingrese Posicion que se cambiara");
                    opBorrar= leer.getInt();    
                    objCd.GrabaCancion(opBorrar,objC);
          break;
         }    
       
        } while (op!=5);       
       
       
    }
}

public class Cancion {
    private String  Nombre;
    private String Autor;

    public void setNombre(String Nombre) {
        this.Nombre = Nombre;
    }

    public void setAutor(String Autor) {
        this.Autor = Autor;
    }

    public String getNombre() {
        return Nombre;
    }

    public String getAutor() {
        return Autor;
    }

    public void Mostrar() {
        System.out.println( "Nombre: " + Nombre + ", Autor: " + Autor) ;
    }       
}

package examen;

import examen.Cancion;

/**
 *
 * @author Conde
 */
public class Cd {
    private Cancion[] listCanciones;
    private int contadorCanciones;
    //private int limiteCanciones;
   
    public Cd() {
        this.listCanciones = new Cancion[20];
        this.contadorCanciones = 0;
    }
   
    public int numCanciones(){
        return contadorCanciones;
    }
   
    public Cancion dameCancion(int i){
        return listCanciones[i];       
    }
       
    public void GrabaCancion(int pos,Cancion c){   
        for (int i = 0; i < contadorCanciones; i++) {
            if(i==pos-1){
                listCanciones[i]=c;
            }
        }
    }
   
    public void AgregaCancion(Cancion c){
        listCanciones[contadorCanciones]=c;
        contadorCanciones++;
    }
   
    public void EliminaCancion(int pos){       
        for (int i = pos-1; i < contadorCanciones; i++) {
            listCanciones[i]=listCanciones[i+1];
        }
        listCanciones[contadorCanciones-1]=new Cancion();  //Inicializa las canciones
        contadorCanciones--; // Al eliminar reduce el numero de canciones
    }
   
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Lectura
{
    public static String getString()
    {
        String CadNum="";
        try
        {
            BufferedReader Teclado = new BufferedReader(new InputStreamReader(System.in));
            CadNum = Teclado.readLine();
        }
        catch(IOException e)
        {
            System.out.println("Error: "+e.getMessage());
        }
        return(CadNum);
    }
    public static short EnteroCorto()
    {
        try
        {
            return(Short.parseShort(getString()));
        }
        catch(NumberFormatException e)
        {
            return(Short.MIN_VALUE);
        }
    }
    public static int getInt()
    {
        try
        {
            return(Integer.parseInt(getString()));
        }
        catch(NumberFormatException e)
        {
            return(Integer.MIN_VALUE);
        }
    }
    public static long EnteroLargo()
    {
        try
        {
            return(Long.parseLong((getString())));
        }
        catch(NumberFormatException e)
        {
            return(Long.MIN_VALUE);
        }
    }
    public static float Real()
    {
        try
        {
            Float NumReal = new Float(getString());
            return(NumReal.floatValue());
        }
        catch(NumberFormatException e)
        {
            return(Float.NaN);
        }
    }
    public static double RealLargo()
    {
        try
        {
            Double NumReal = new Double(getString());
            return(NumReal.doubleValue());
        }
        catch(NumberFormatException e)
        {
            return(Double.NaN);
        }
    }
    public static char Caracter()
    {
        try
        {
            return(getString().charAt(0));
        }
        catch(Exception e)
        {
            return('\0');
        }
       
    }
    public static char CaracterMayuscula()
    {
        try
        {
            String Temp;
            Temp = getString().toUpperCase();
            return(Temp.charAt(0));
        }
        catch(Exception e)
        {
            return('\0');
        }
       
    }
}

solucionario del 1er parcial : pregunta 2

PREGUNTA 2:

public class Libro {
    Persona p=new Persona();
    Lugar l=new Lugar();
    Fecha f=new Fecha();
   
   
    String titulo="Introduccion to java programing ";
    String ISBN="0-13-031997-x";
    int paginas=784;
    String edicion="3a. edicion";
    String editorial="prentice-hall";

    public Libro(String titulo, String ISBN, int paginas, String edicion, String editorial) {
        this.titulo = titulo;
        this.ISBN = ISBN;
        this.paginas = paginas;
        this.edicion = edicion;
        this.editorial = editorial;
    }
   
    public Libro(){}

    public String getTitulo() {
        return titulo;
    }

    public void setTitulo(String titulo) {
        this.titulo = titulo;
    }

    public String getISBN() {
        return ISBN;
    }

    public void setISBN(String ISBN) {
        this.ISBN = ISBN;
    }

    public int getPaginas() {
        return paginas;
    }

    public void setPaginas(int paginas) {
        this.paginas = paginas;
    }

    public String getEdicion() {
        return edicion;
    }

    public void setEdicion(String edicion) {
        this.edicion = edicion;
    }

    public String getEditorial() {
        return editorial;
    }

    public void setEditorial(String editorial) {
        this.editorial = editorial;
    }
    void mostrar(){
        System.out.println("Titulo: "+this.titulo+edicion+
                "\nAutor: "+p.nombre+
                "\nISBN: "+ISBN+" "+editorial+","+l.ciudad+","+l.pais+","+f.dia+" "+f.numDia+" "+f.mes+" "+f.año+
                "\n"+paginas+" paginas");
    }
    public static void main(String[] args) {
        Libro l1=new Libro();
        l1.mostrar();
    }
}
class Lugar{
    String ciudad="new jersey";
    String pais="(USA)";

    public Lugar(String ciudad, String pais) {
        this.ciudad = ciudad;
        this.pais = pais;
    }
    public Lugar(){
       
    }

    public String getCiudad() {
        return ciudad;
    }

    public void setCiudad(String ciudad) {
        this.ciudad = ciudad;
    }

    public String getPais() {
        return pais;
    }

    public void setPais(String pais) {
        this.pais = pais;
    }
  
}

class Fecha {
    String dia="viernes";
    int numDia=16;
    String mes="noviembre";
    int año=2001;

    public Fecha(String dia,int numDia, String mes, int año) {
        this.numDia=numDia;
        this.dia = dia;
        this.mes = mes;
        this.año = año;
    }
   
    public Fecha(){
       
    }

    public String getDia() {
        return dia;
    }

    public void setDia(String dia) {
        this.dia = dia;
    }

    public int getNumDia() {
        return numDia;
    }

    public void setNumDia(int numDia) {
        this.numDia = numDia;
    }

    public String getMes() {
        return mes;
    }

    public void setMes(String mes) {
        this.mes = mes;
    }

    public int getAño() {
        return año;
    }

    public void setAño(int año) {
        this.año = año;
    }
   
   
}
class Persona{
    String nombre="liang,y daniel";

    public Persona() {
    }

    public Persona(String nombre) {
        this.nombre = nombre;
    }
   

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
}

import java.util.Scanner;

/**
 *
 * @author CARLOS-D
 */
public class Fechas {
    private int dia;
    private int mes;
    private int año;
    private int diaSemana;
    String[] dias={"Domingo","Lunes","Martes", "Miércoles","Jueves","Viernes","Sábado"};
    String[] meses={"Enero","Febrero","Marzo","Abril","Mayo","Junio","Julio","Agosto","Septiembre","Octubre","Noviembre","Diciembre"};

    public Fechas(int dia, int mes, int año) {
        this.dia = dia;
        this.mes = mes;
        this.año = año;
    }
   
    private  boolean esBisiesto( int año ) {
      return (( ((año % 4) == 0) && ((año % 100) != 0) )
             || ((año % 400) == 0) );
   }
   
    public void calcularDia(){
        int[] mesCode = { 0, 6, 2, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4 };
        int result = año % 100 + (año % 100) / 4 + dia + mesCode[mes];
       
        if (año / 100 == 17) result += 5;
        else if (año / 100 == 18) result += 3;
        else if (año / 100 == 19) result += 1;
        else if (año / 100 == 20) result += 0;
        else if (año / 100 == 21) result += -2;
        else if (año / 100 == 22) result += -4;
        
        if (esBisiesto(año) && (mes == 1 || mes == 2))
                result += -1;
        diaSemana= result % 7;
    }
   
    public void mostrar(){
        System.out.println("hoy es: "+dias[this.diaSemana]+" "+dia+" de "+meses[mes-1]+" del "+año);
    }
   
    public void sumarFechas(){
        Scanner sc=new Scanner(System.in);
        System.out.println("ingrese dia: ");
        dia=sc.nextInt();
        System.out.println("ingrese mes: ");
        mes=sc.nextInt();
        System.out.println("ingrese año: ");
        año=sc.nextInt();
       
       
    }
   
    public static void main(String[] args) {
        Fechas fech=new Fechas(1, 5, 2007);
        Fechas f2=new Fechas(2, 7, 2004);
        fech.calcularDia();
        fech.mostrar();
    }
}

solucionario del 1er parcial : pregunta 1

PREGUNTA 1:

public class Cuenta extends porcentaje{
    long numCuenta=100001;
    long DNI;
   

    public Cuenta(long numCuenta, long DNI, double saldoActual, double interes) {
        super(saldoActual, interes);
        this.numCuenta = 0;
        this.DNI = 0;
        this.saldoActual = 0;
        this.interes = 0;
       
    }
    public Cuenta( long DNI, double saldoActual, double interes) {
        super(saldoActual, interes);
        this.DNI = DNI;
        this.saldoActual = saldoActual;
        this.interes = interes;
        ++numCuenta;
    }   

    public long getNumCuenta() {
        return numCuenta;
    }

    public long getDNI() {
        return DNI;
    }

    public void setDNI(long DNI) {
        this.DNI = DNI;
    }

    void actualizarSaldo(){
        saldoActual=saldoActual-(interes/365);
    }
    double ingresar(double monto){
        return saldoActual=saldoActual+monto;
    }
    double retirar(double monto){
        if (saldoActual>0) {
            saldoActual=saldoActual-monto;
        }
        else{
            System.out.println("no hay saldo");
        }
        return saldoActual;
    }
    void mostrar(){
        System.out.println("cuenta bancaria");
        System.out.println("Numero de cuenta: "+this.numCuenta);
        System.out.println("Dni del cliente: "+this.DNI);
        System.out.println("Saldo actual $: "+this.saldoActual);
        System.out.println("interes anual: "+this.interes);
    }
   
    public static void main(String[] args) {
        Cuenta c1=new Cuenta(100001,123, 200.0, 0.1);
        System.out.println(c1.getNumCuenta());
        c1.mostrar();
        //c1.actualizarSaldo();
        //c1.ingresar(100);
        //c1.retirar(50);
        //System.out.println(c1.getSaldoActual());
        //System.out.println("Saldo actual $:"+c1.getSaldoActual());
        //c1.mostrar();
        Cuenta c2=new Cuenta(456, 100, 0.3);
        c2.actualizarSaldo();
        c2.mostrar();
        Cuenta c3=new Cuenta(789, 50, 0.25);
        c3.mostrar();
        //System.out.println(c1.getSaldoActual());
    }
   
}


public class porcentaje {
     double saldoActual;
     double interes;

    public porcentaje(double saldoActual, double interes) {
        this.saldoActual = 0.0;
        this.interes = 0.1;
    }
    
     public double getSaldoActual() {
        return saldoActual;
    }

    public void setSaldoActual(double saldoActual) {
        this.saldoActual = saldoActual;
    }

    public double getInteres() {
        return interes;
    }

    public void setInteres(double interes) {
        this.interes = interes;
    }
}

Clase abstracta,herencia,polimorfismo,encapsulamientoy sobrecarga de constructores

Una clase abstracta es aquella que no se instancia
La herencia se utiliza para heredar ciertos metodos y atributos a otra clase se hace uso de la palabra "extends" y tamabien pos permite evitar asi la duplicidad de codigo
Polimorfismo es hacer varias cosas con el mismo codigo
Encapsulamiento aqui tenemos lo public,private,protect se usan para manejar el acceso 
Sobrecarga de Constructores tener varios contructores con diferentes parametros

 la siguiente imajen nos ilustra un poco de la programacion orientada a objetos en java

aqui un ejemplo en codigo para su mejor entendimiento

 public abstract class AbstracClassAnimal {
    String nombre;
    String comida;
  
    public AbstracClassAnimal(String nombre){
        this.nombre="pez";
    }
    public AbstracClassAnimal(String nombre,String comida){
        this.nombre="perro";
        this.comida="carne";
    }
  
    abstract void mover();
  
    public void comer(){
        System.out.println("el animal esta comiedo");
    }  
    public String getNombre(){
        return nombre;
    }
    public void setNombre(String n){
        this.nombre=n;
    }
}


 public class ave extends AbstracClassAnimal{
    public ave(){
        super("ave");
      
        setNombre("gorrion");
    }
    void mover() {
        System.out.println("el ave esta volando");
    }
    void mover(String alas,String patas) {
        System.out.println("el ave no quiere utilizar sus "+alas+" para moverse y "
                + "esta utilizando sus "+patas+" para caminar");
    }
    public static void main(String[] args) {
      
        ave ave1=new ave();
        System.out.println(ave1.nombre);
        ave1.mover();
        ave1.comer();
    }
 
}

Ejercicio con BufferedWiter y BufferedReader

public class promedioEdades {
    public static void main(String[] args) throws Exception{
        BufferedReader in;
        in=new BufferedReader(new InputStreamReader(System.in));
        double m=1,aux=0,n=0,o=0;
        System.out.println("Programa q calcula el promedio de edades ingresadas y "
                + "el porcentaje de edades mayores a50 años");
        System.out.println("La edad 0 indica el final de als edades");
        while (m!=0){
            System.out.println("Ingrese las edades: ");
            m=Integer.parseInt(in.readLine());
            n++;
            aux=aux+m;
            if (m>50) {
                o++;
            }
        }   
        double s=o*100/n-1;
        double aux2=aux/n-1;
        System.out.println("El promedio es: "+aux2);
        System.out.println("El porcentaje de personas mayores a 50 años es de :"+s);
    }
}

Libreria tipo Scanner

En la siguiente clase se muestra como esta hecha una libreria semejante a Scanner pueden interactuar con el codigo para su mayor comprension: 

package clase4;
import java.io.*;
import java.io.IOException;

public class Lectura{
    public static String Cadena(){
        String CadNum="";
        try{
            BufferedReader Teclado = new BufferedReader(new InputStreamReader(System.in));
            CadNum = Teclado.readLine();
        }catch(IOException e){
            System.out.println("Error: "+e.getMessage());
        }
        return(CadNum);
    }
    public static short EnteroCorto(){
        try{
            return(Short.parseShort(Cadena()));
        }catch(NumberFormatException e){
            return(Short.MIN_VALUE);
        }
    }
    public static int Entero(){
        try{
            return(Integer.parseInt(Cadena()));
        }catch(NumberFormatException e){
            return(Integer.MIN_VALUE);
        }
    }
    public static long EnteroLargo(){
        try{
            return(Long.parseLong((Cadena())));
        }catch(NumberFormatException e){
            return(Long.MIN_VALUE);
        }
    }
    public static float Real(){
        try{
            Float NumReal = new Float(Cadena());
            return(NumReal.floatValue());
        }catch(NumberFormatException e){
            return(Float.NaN);
        }
    }
    public static double RealLargo(){
        try{
            Double NumReal = new Double(Cadena());
            return(NumReal.doubleValue());
        }catch(NumberFormatException e){
            return(Double.NaN);
        }
    }
    public static char Caracter(){
        try{
            return(Cadena().charAt(0));
        }catch(Exception e){
            return('\0');
        }
    }
    public static char CaracterMayuscula(){
        try{
            String Temp;
            Temp = Cadena().toUpperCase();
            return(Temp.charAt(0));
        }catch(Exception e){
            return('\0');
        }
    }
}

public class sumaConLibreria {
    public static void main(String[] args) {
        int x,y,suma=0;
        System.out.println("Suma de 2 numeros con libreria Lectura ");
        System.out.println("Ingrese primer numero: ");
        x=Lectura.Entero();
        System.out.println("Ingrese segundo numero: ");
        y=Lectura.Entero();
        suma=x+y;
        System.out.println("la suma es: "+suma);
    }
}
 

Paradigmas de la POO

1. Abstracción:

 Visión de un problema que extrae la información esencial para un determinado propósito,                   omitiendo los detalles menos significativos. 

 Puede existir diferentes niveles de abstracción. 

 Existe dos tipos: 

          – Funcional 

          – De datos

 Un objeto es una abstracción de la realidad

2. Encapsulamiento

 Es un agrupamiento bajo un mismo nombre de la información y las operaciones que acceden a ella  Materializa la abstracción. Los objetos son encapsulaciones de abstracciones.

 Paquete de información y operaciones.

3. Ocultamiento de la Información

 Principio por el cual solo es accesible el interfaz del objeto. 

 Los métodos no son utilizados por su implementación (contenido), sino por su interfaz (aspecto).  Concepto complementado con el de encapsulamiento.  Objetivo final: Restringir el acceso a los       métodos.

 En java se consigue gracias a los modificadores de acceso. 

 Estos pueden afectar a la clase, a los atributos y/o métodos. 

 Modificadores: 

          – public: Objetos de todas las clases pueden acceder al método con este modificador.

          – protected: Sólo objetos de las clases heredadas y las del paquete. 

          – (defecto): Sólo objetos de las clases del paquete. 

          – private: Sólo objetos de la misma clase. 

4. Herencia

 La herencia permite crear una clase nueva que tenga el mismo comportamiento que otra, y además     extienda o adapte ese comportamiento a unas necesidades específicas. 

 Permite especializar o refinar una clase, y/o generalizar conceptos de otras clase ya existentes. 

 En la especialización, la nueva clase creada tomará o heredará los atributos y métodos de la clase       padre, los cuales se añadirán a los definidos por la propia clase.

   
 
  Ejemplo:
               class Reloj
               {
               //atributos
               static String MARCA; //atributo de clase
               String hora; //Tomamos un tipo
               String para simplificar
               String dia; //idem
               int numSerie;
               //métodos
               ..............
               }  

               class RelojCrono extends Reloj
               {
                //atributos
                int cronoHora;
                int cronoMin;
                int cronSeg;
                //métodos
                ..............
                }

4.1 Herencia Múltiple

 Se da este concepto cuando una clase hereda de varias superclases. La mayoría de los lenguajes no     soportan esta característica.

 Consiste en utilizar un mismo símbolo para fines distintos. 

 Respuesta distinta frente a un mensaje dependiendo de la naturaleza del objeto. 

5. Polimorfismo

1.  Consiste en utilizar un mismo símbolo para fines distintos. 
2.  Respuesta distinta frente a un mensaje dependiendo de la naturaleza del objeto.
3.  Supongamos que tenemos relojes, uno analógico y otro digital. Cada reloj tiene un método para           adelantar una hora. No tiene ningún sentido que si los dos hacen lo mismo (cada uno a su manera),     se tenga que llamar con nombres distintos. Cada vez que invoquemos el método adelantarHora de       cada reloj, cada uno lo hará a su manera.
4.  Tenemos distintos objetos gráficos (cuadrados, circunferencias, triángulos,...) y todos tienen un            método pintar. Cuando yo lance un mensaje sobre cada objeto invocando el método pintar, cada          uno se pintará a su manera.

QUE ES Y COMO FUNCIONA LA POO

Es importante aclarar desde un principio la diferencia que existe entre programación

orientada a objetos y un lenguaje orientado a objetos. 

Es muy importante destacar que cuando hacemos referencia a la programación orientada

a objetos no estamos hablando de unas cuantas características nuevas añadidas a un

lenguaje de programación. Estamos hablando de una nueva forma de pensar acerca del

proceso de descomposición de problemas y de desarrollo de soluciones de

programación

La programación orientada a objetos es otra forma de descomponer problemas. Este

nuevo método de descomposición es la descomposición en objetos; vamos a fijarnos no

en lo que hay que hacer en el problema, sino en cuál es el escenario real del mismo, y

vamos a intentar simular ese escenario en nuestro programa. 

Si nos detenemos a pensar sobre cómo se nos plantea un problema cualquiera en la

realidad podremos ver que lo que hay en la realidad son entidades (otros nombres que

podríamos usar para describir lo que aquí llamo entidades son “agentes” u “objetos”).

Estas entidades poseen un conjunto de propiedades o atributos, y un conjunto de

métodos mediante los cuales muestran su comportamiento. Y no sólo eso, también

podremos descubrir, a poco que nos fijemos, todo un conjunto de interrelaciones entre

las entidades, guiadas por el intercambio de mensajes; las entidades del problema

responden a estos mensajes mediante la ejecución de ciertas acciones. El siguiente

ejemplo, aunque pueda parecer un poco extraño, creo que aclarará algunos conceptos y

nos servirá como introducción para desarrollarlos con profundidad. 

LOS CONCEPTOS FUNDAMENTALES DE LA POO.

como ya se mencionado la programación orientada a objetos es una filosofía, el la cual

los conceptos de abstracción, encapsulación, herencia y polimorfismo; y los conceptos básicos

que las forman: objetos, mensajes, clases, instancias y métodos, nunca deben faltar

Un objeto es una encapsulación abstracta de información, junto con los métodos o 

procedimientos para manipularla. Un objeto contiene operaciones que definen su 

comportamiento y variables que definen su estado entre las llamadas a las operaciones.

Una clase equivale a la generalización o abstracción de un tipo específico de objetos.

Un mensaje representa una acción a tomar por un determinado objeto.

Una instancia es la concrección de una clase.

Un método consiste en la implementación en una clase de un protocolo de respuesta a 

los mensajes dirigidos a los objetos de la misma. La respuesta a tales mensajes puede

incluir el envío por el método de mensajes al propio objeto y aun a otros, también como 

el cambio del estado interno del objeto.

Herencia

las clases no están aisladas, sino que se relacionan entre sí, formando una jerarquía de clasificación. 

Los objetos heredan las propiedades y el comportamiento de todas las clases a las que pertenecen.

Conceptos Básicos de POO.

LENGUAJES DE PROGRAMACIÓN ORIENTADO A OBJETOS

Se le llama así a cualquier lenguaje de programación que implemente los conceptos definidos por la programación orientada a objetos.

Cabe notar que los conceptos definidos en la programación orientada a objetos no son una condición sino que son para definir que un lenguaje es orientado a objetos. Existen conceptos que pueden estar ausentes en un lenguaje dado y sin embargo, no invalidar su definición como lenguaje orientado a objetos.

Quizás las condiciones mínimas necesarias las provee el formalismo que modeliza mejor las propiedades de un sistema orientado a objetos: los tipos de datos abstractos.

Siguiendo esa idea, cualquier lenguaje que permita la definición de tipos de datos, de operaciones nuevas sobre esos tipos de datos, y de instanciar el tipo de datos podría ser considerado orientado a objetos.

Esta definición concuerda incluso con ciertos ejemplos prácticos, que no son considerados dentro de la programación orientada a objetos, pero que podrían serlo. Por ejemplo, la programación de interfaces gráficas de usuario para los sistemas X utilizando infraestructuras de funciones y API como Motif, Xview y Xlib, son realizadas usualmente en lenguaje C, pero organizando el código en una manera que "parecen objetos".

Aquí tenemos algunos:

Ruby es un lenguaje de programación interpretado, reflexivo y orientado a objetos, creado por el programador japonés Yukihiro "Matz" Matsumoto, quien comenzó a trabajar en Ruby en 1993, y lo presentó públicamente en 1995. Combina una sintaxis inspirada en Python y Perl con características de programación orientada a objetos similares a Smalltalk. Comparte también funcionalidad con otros lenguajes de programación como Lisp, Lua, Dylan y CLU. Ruby es un lenguaje de programación interpretado en una sola pasada y su implementación oficial es distribuida bajo una licencia de software libre.

Python es un lenguaje de programación interpretado cuya filosofía hace hincapié en una sintaxis que favorezca un código legible.
Se trata de un lenguaje de programación multiparadigma, ya que soporta orientación a objetos, programación imperativa y, en menor medida, programación funcional. Es un lenguaje interpretado, usa tipado dinámico y es multiplataforma.
Es administrado por la Python Software Foundation. Posee una licencia de código abierto, denominada Python Software Foundation License, que es compatible con la Licencia pública general de GNU a partir de la versión 2.1.1, e incompatible en ciertas versiones anteriores