Para comprender cualquier lenguaje de programación moderno hay que entender varios conceptos, éstos conceptos luego son plenamente aplicables al momento de programar y sirven un montón.
Dicha utilidad está determinada en el hecho de que uno al sentarse a programar debe saber qué es lo que está haciendo y cómo lo está haciendo.
Lo primero en principal hay que saber del paradigma principal que hoy en día impera... para aquellos que no sepan, paradigma es el modelo o modo de organizar conceptos, un punto de vista propio de una corriente teórica que hace que las cosas se vislumbren de una forma específica.
En todas las ramas de la ciencia hay paradigmas, en su mayor o menor medida. Dentro de la informática existe la programación orientada a objetos.
¿Que es un objeto?
En la vida real un objeto es algo táctil, como una cabra, una mesa o cualquier cosa. En esos objetos se guarda en nuestra mente un concepto del mismo, o sea, cuando a ustedes le dicen "Televisor" se les viene a la cabeza la idea de un televisor, pero no distinguen en ese pensamiento un televisor particular, o sea, se imaginan un televisor, pero puede ser el que tienen en su cuarto, en su casa, el que tiene el vecino, cualquier televisor.
Esa idea que guardan en la cabeza sobre las cosas es lo que se llama "abstracción" de un objeto. Por lo tanto si yo les digo que algo es abstracto, está en el mundo de las ideas. Cuando ustedes describen algo es por que tienen esa idea en la cabeza y la comienzan a describir.
En ese sentido cuando se usa la palabra "objeto" en el mundo de la programación, se está refiriendo a eso abstracto, o sea, si modelamos dentro de la programación una camisa, comprenderemos las descripciones de una camisa dentro de nuestro código.
Si nos damos cuenta, un programa es un conjunto de objetos que interactúan entre sí para lograr su funcionamiento.
Encapsulamiento
El encapsulamiento es un modo de poner los datos para que funcionen juntos.
Para que se den una mejor idea, ustedes tienen el control remoto de tu Tv en la mano, pues ese control remoto comprende botones, placas, cables, baterías, luces, etc. Para que eso pueda ser llamado "control remoto" debe tener que poder funcionar como un mando a distancia de una Tv.
Pues todo eso que comprende para poder funcionar (cables, placa, etc) está "Encapsulado" dentro del control.
Dentro del lenguaje de programación veremos mucho esto.
<?
//C#
public int metodo(int numero1, int numero2)
{
int resultado = numero1 + numero2; //En este caso el encapsulamiento se da entre las comillas
return resultado; //que encierran la suma y devolución del resultado.
}
>
<?
//java
public Integer metodo (Integer numero1, Integer numero2){
Integer resultado = numero1 + numero2; //En java funciona igual que en C# si bien se pueden declarar variables con int, acá usé Integer que es parecido.
return resultado;
>
<?
#Python
def metodo(numero1, numero2):
resultado = numero1 + numero2 #En python el encapsulamiento está dado por la tabulación.
return resultado #Puede ser tabulación o cuatro espacios.
>
Declaración de variables
En primer término, la declaración de variables lo que conlleva es que nombremos un tipo de datos o un conjunto de datos dentro de una sola variable, esto produce dos cosas, la primera es que sea más fácil manejarlos, y la segunda es que esto genera el uso de la encapsulación antes explicada.
Una declaración sencilla de una variable es cuando generamos un tipo de dato de cualquier especie, como números enteros, quebrados, numeros enteros largos y quebrados grandes, cadena de caracteres, caracteres singulares y booleanos (true o false, si o no, verdadero o falso)
<?
//C#
int numero_entero = 2;
float numero_quebrado = 3,5;
Int64 numero_largo = 50000000000000;
double quebrado_largo = 0,000000005; //No soporta grandes cantidades de cifras, hay otro que si lo hace, pero al cuete darles hoy eso.
string palabra = "hola mundo"; //Cadena de caracteres
char caracter = 'A';
bool X = true;
//O si queremos ver el método que hicimos mas arriba:
int resultado = metodo(5, 6); // resultado es una variable entera que toma el valor que retorna el método como resultado. Va a tener valor 11.
>
<?
//java: Si bien tiene casi los mismas formas de variables int, float, boolean, etc, por una razón objetiva del lenguaje es preferible usar las variables que trae suplantando éstas.
Integer numero_entero = 3;
Float numero_quebrado = 4,5f; //La letra "f" al final, en java es importante... le tenés que decir que ese numero es del tipo double.
Long numero_largo = 50000000000l;//Ojo la letra "l" al final
Double quebrado_largo = 2,55500394d; //Ojo la letra "d" al final
String palabra = "Hola mundo";
Char letra = 'a';
Boolean X = false;
//Y el método que hicimos más arriba:
Integer resultado = metodo(4, 5); //resultado valdrá 9
>
<?
#En Python es otra historia... no tienen que declarar tipos de variables.
entero = 1
float_o_double = 2,5 #Si quisiera que sea un número redondo, le pongo un ,0 después del número.
entero_largo = 45L #La "L" en mayúsculas para decirle que es un entero largo.
palabra = "Hola mundo" #No existe tal como se lo entiende en otros lenguajes las chars.
letra = "H" #Las comillas no hacen diferencia en este lenguaje, pueden ser escritas 'hola mundo', que vale lo mismo que "hola mundo". Del mismo modo, """Hola mundo""" tres comillas de cada lado es un string en el lenguaje que permite hacer saltos de línea (aunque en el resultado no se vean por obvias razones).
X = True #Verdadero y falso se escriben con mayúsculas para que sean tomado como tales (True, False)
#El método que antes hicimos:
resultado = metodo(3, 9) #Esto da 12.
>
Tipo de datos null
Los datos null son aquellos que no contienen nada, o sea, si tenemos un tipo de dato String y no le metemos nada, de inicio va a tener el tipo de valor null (de nulo ).
Ojo, las variables numéricas que sean declaradas van a ser con valor inicial 0, y las variables booleanas declaradas van a tener como valor inicial true.
Null en java es con minúscula como en C#, pero en Python no existe la palabra, aunque si el valor. Para Python null es igual a None
¿Que es una clase?
Una clase es un conjunto de datos que luego, gracias a ellos, el programa tomará dinamismo y podrá manejar los datos en función de cómo estén escritas las clases.
Para que se den una idea de lo que es, las clases reflejan un tipo de datos específicos, el que ustedes quieran, y ahí se describe el tipo de datos y se describe su ejecución.
En síntesis, las clases determinan el modo de ejecución de los objetos. O sea, que el programa creará objetos abstractos gracias a las clases que los describen y determinan que es lo que hacen, como funcionan y como se relacionan con otros objetos dentro del programa.
Por ejemplo, tengo la clase televisor y en esta habrá un conjunto de variables como es, pantalla plana, pulgadas, consumo de electricidad, etc.
<?
//C#
class TV
{
string modelo;
string descripcion;
double pulgadas;
bool pantallaPlana;
double consumo;
public string prop_descripcion
{
set
{
descripcion = value;
}
get
{
return descripcion;
}
}
public double prop_consumo
{
set
{
consumo = value;
}
get
{
return consumo;
}
}
public bool prop_pantalla
{
set
{
pantalla_plana = value;
}
get
{
return pantallaPlana;
}
}
public double prop_pulbadas
{
set
{
pulgadas = value;
}
get
{
return pulgadas;
}
}
public string prop_modelo
{
set
{
modelo = value;
}
get
{
return modelo;
}
}
}
>
<?
//Java
public class TV
{
String modelo;
String descripcion;
Double pulgadas;
Boolean pantallaPlana;
Double consumo;
public void setModelo(String Modelo){
modelo = Modelo;
}
public String getModelo(){
return modelo;
}
public void setDescripcion(String Desc){
descripcion = Desc;
}
public String getDescripcion(){
return descripcion;
}
public void setPulgadas(Double Pulgadas){
pulgadas = Pulgadas;
}
public Double getPulgadas(){
return Pulgadas;
}
public void setConsumo(Double Consumo){
consumo = Consumo;
}
public Double getConsumo(){
return consumo;
}
public void setPantalla(Boolean Pantalla){
pantallaPlana = Pantalla;
}
public Boolean getPantalla(){
return pantallaPlana;
}
}>
<?
#python
class Tv:
modelo = ""
descripcion = ""
pulgadas = 0,0
pantallaPlana = False
consumo = 0,0
#Si quieren y necesitan hacen los métodos, pero en python todas las variables son públicas, por lo tanto con que se instancien las clases ya andan y se pueden usar... nada de getters y setters
>
Instancias de clase
Las instancias de clase es cuando efectivamente usamos las clases, como las que mostré como se hacen mas arriba.
Instanciar una clase es generar en nuestro programa un objeto gracias a la descripción de la clase. O sea, si generamos una clase que guarda las medidas de un rectángulo, vamos a tener en nuestro objeto dos medidas, el ancho y el largo. Al mismo tiempo, esa clase puede ser instanciada otra y otra y otra vez. En definitiva, las clases funcionan como si fueran un molde para realizar objetos... estilo un molde de tortas.
<?
//C#
Tv TV1 = new Tv();
TV1.prop_descripcion = "Tv de última tecnología";
TV1.prop_consumo = 25,6; //Wats...
TV1.prop_pantalla = true;
TV1.prop_pulbadas = 20,5;
TV1.prop_modelo = "Samsung" //Acá tengo el objeto TV1 ya formado. Los datos que guardé acá van a estar en memoria hasta que yo los borre.
Tv TV2 = new Tv();
TV2.prop_descripcion = "Tv usada";
TV2.prop_consumo = 30,0; //Wats...
TV2.prop_pantalla = false;
TV2.prop_pulbadas = 20;
TV2.prop_modelo = "Delos"
//TV2 es distinto a TV1, son dos objetos distintos que nada tienen que ver uno del otro. Los dos nacieron de la clase Tv, pero son distintos.
//En java es totalmente igual. No hago como es en java por que sería copiar el código.
>
<?
MiTv = Tv()
MiTv.modelo = "Samsung"
MiTv.descripcion = "Tv de última tecnología"
MiTv.pulgadas = 20,5
MiTv.pantallaPlana = True
MiTv.consumo = 25,6
>
En el post siguiente voy a explicar condicionales, iteradores, arrays (vectores), listas y mapas (diccionarios)