Ya se lo que dice el título, pero te garantizo que al final del posts sabes por lo menos lo básico
Este post va mas o menos para aquellos usuarios que le interesan la programación, pero prefieren hacerlo de forma autodidacta 
Como yo por ejemplo. Programar es un arte, requiere bastante tiempo y conocimientos matemáticos previos. Pero los conceptos básicos son bastante simple y divertidos, tanto que cualquiera que lo desee puede introducirse en los principios básicos para programar. Tampoco creas que vas a salir vuelto un profesional de este post, es solo para que veas como es. Esto es como ver la punta de un iceberg, pero no quita que sea divertido ya que con estas bases y con un poco de imaginación puedes hacer muchísimos experimentos. Sin mas que abundar empezaré de inmediato Quiero aclarar que todo el contenido está escrito por mi. y que el lenguaje de programación que usare es Java por motivos que explicaré mas adelantes con el IDE Eclipse, que no es mas que el programa que utilizaremos para programar. Con estos puntos ya aclarados, continuemos
Porque programar en Java?
Existen muchísimos lenguajes de programación, algunos mejores que otros, pero en esta ocasión utilizaremos Java, porque? Bueno me gusta mas java sobre los demás, porque es bien práctico, fácil de aprender y porque funciona en cualquier plataforma, desde tu navegador hasta tu dispositivo android. Aunque esta vez nos reservaremos a solo una aplicación de escritorio. Además es muy similar a C/C++, por lo que si ya programabas en C no te resultará muy difícil adaptarte.
-bytecodes
Los programas de java no son ejecutables, no se compilan como los programas de C/C++, si no que necesitan de la maquina virtual de java (JVM) para ser interpretados y ejecutarse. Gracias a esto no tienen que incluir todo el código ni librerías propias de cada sistema. El bytecode es el código intermedio entre el código fuente y el código máquina, este código es el que es ejecutado por JVM. El bytecode puede ser ejecutado en cualquier plataforma si se tiene el intérprete adecuado. No tienen que entender completamente este parte para programar, es solo teoría para conocer un poco.
ENLACE RECOMENDADO
-Preparaciones previas
Como ya dije anteriormente necesitamos un interprete para ejecutas aplicaciones de Java en nuestra pc. Para ello necesitaremos descargar el Java Develpment Kit (JDK) que lo conseguimos gratuitamente en su sitio web. Este contiene todas las librerías necesarias para programar ademas de que incluye el Java Runtime Environment(JRE) que incluye a su ves la máquina virtual que nos permite ejecutar apps java. Lo puedes descargar desde el enlace de mas abajo.
DESCARGAR
-Entorno de desarrollo
Eclipse es un entorno completo de código abierto que admite numerosas extensiones (incluido un módulo para J2EE) y posibilidades. Es uno de los más utilizados por su compatibilidad con todo tipo de aplicaciones Java y sus interesantes opciones de ayuda al escribir código. Existen varios entornos de desarrollo que son bastante buenos, pero en lo personal prefiero Eclipse, aunque puedes programar con el que desees, pero recomiendo ampliamente este para comenzar por uso tan dinámico y fácil. Lo puedes descargar gratuitamente desde su página oficial.
DESCARGAR
-A programar!!!
Si si, ya se que estas ansioso
pero primero hay unos conceptos básicos que hay que saber antes de empezar. Si ya sabes esto, solo debes saltártelo.
- En java (como en C) hay diferencia entre mayúsculas y minúsculas
- Cada línea de código debe terminar con ;
- Los comentarios; si son de una línea debe comenzar con “//” y si ocupan más de una línea deben comenzar con “/*” y terminar con “*/”
- Cerramos todo con llaves { }
Con estos puntos aclarados, vamos a nuestro primer programa
Abrimos eclipse y tendremos algo como esto:
Vamos a File-->New-->Java Project
Le ponemos el nombre que queramos al proyecto y continuamos.
En el panel izquierdo salen los proyectos ya creados, das click derecho en el proyecto que acabamos de crear y a New-->Class
Ponemos el nombre de nuestra clase y marcamos la casilla que ves en la imagen. OJO esto es para ahorranos código escribiendo el main que viene siendo el cuerpo del programa, o mas bien el código de donde lo iniciamos. Después entenderás mejor.
Tendremos algo mas o menos así:
Bien ahora haremos el tan popular "Hola Mundo" pero al estilo Taringuero
Escribimos el siguiente código(no copien y peguen eh):
[color=#000000]System.out.println("Hola Linces Troesmas de Taringa!");
//Este código imprime "Hola Linces Troesmas de Taringa!" en la consola[/color]
Le damos al botón verde de play y KABOOM!
Okey no es lo mas sorprendente del universo, pero es lo básico para un principiante, nos pondremos mas serios ahora
-Tipos y Variables
Las variables son los contenedores de los datos que utiliza un programa. Cada variable ocupa un espacio en la memoria RAM del ordenador para almacenar un dato determinado. Las variables tienen un nombre (un identificador) que sólo puede contener letras, números y el carácter de subrayado (también vale el símbolo $). El nombre puede contener cualquier carácter Unicode.
O podemos definir variable a una palabra que se le da un valor y que puede variar, fin
Mientras que los tipos son los tipos de datos que almacenan las variables.. Para esto debemos declarar la variable y de que tipo será de la siguiente forma"
tipo nombreVariable;
Haremos unas pruebas sencillas con números
estos son los tipos primitivos.
Por ahora solo usaremos int y boolean para las pruebas, nos vamos a eclipse creamos nueva clase o borramos todo lo anterior y declaramos las siguientes variables:
[color=#000000]public static void main(String[] args) {
int x=10;
int y=40;
int z=x+y;
System.out.println("Valor z: "+z);
}[/color]
Lo que hemos hecho es darle un valor a las primeras dos variables y a la tercera "Z" le decimos a la máquina que sume y que imprima el valor que corresponde que sería "x + y".Ponemos la cadena de texto que queramos que imprima y el valor de la variable "z" añadiéndola con simbolo"+". El signo "+" es un operador lógico que te permite realizar operaciones matemáticas, sumar valores de variables, añadir componentes, etc. Aquí te dejos los demás para que abras tu imaginación y experimentes un poco:
Boolean y función if else
Boolean es un tipo primitivo que sirve para decir si algo es verdadero o falso. Así de simple. Mientras que las funciones if y else nos sirven para hacer eventos a determinadas condiciones que especificamos. Bueno para explicarlo mejor escribamos el siguiente código en una clase nueva si prefieren:
public static void main(String[] args) {
boolean hoyEsLunes = false; //Hoy es lunes? Valor: Falso
if(hoyEsLunes){
System.out.println("Hoy es lunes"); //Si hoy es lunes imprimir esto
} else {
System.out.println("Hoy no es lunes"); //Si hoy no es lunes imprimir esto
}
}
}
Tenemos la variable hoyEsLunes de tipo boolean con valor falso. Y debajo la función if con la variable entre los paréntesis (ojo esto es muy importante) al detectar la variable boolean el sistema hace lo del comando if, que sería imprimir "Hoy es lunes", cerramos con llave y usamos el comado else, que no es mas que una alternativa de si la primera condición no se cumplió. Entonces tenemos:
Hoy es lunes?Si. Entonces imprimir en la consola "Hoy es lunes"
No. Entonces imprimir en la consola "Hoy no es lunes"
En este caso le di el valor false por lo que si le damos a play nos devolverá que hoy no es lunes.
Aquí un ejemplo al estilo Diamond
Si el post es un crap imprime "Denunciado lince troesma, despedite de tu cuenta maquinola" de lo contrario imprime "+10 favoritos, te sigo, denunciado, te dejo de seguir, y despedite de tu cuenta"
public static void main(String[] args) {
boolean esUnCrap = true; //Este post es un crap?
if(esUnCrap){
System.out.println("Denunciado lince troesma, despedite de tu cuenta maquinola");
} else {
System.out.println("+10 favoritos, te sigo, denunciado, te dejo de seguir, y despedite de tu cuenta");
}
}
-Ventanas
Hasta ahora no habíamos salido de la consola, es hora de programar nuestra propia ventana. Para esto tenemos crear una clases extendida de JFrame que nos dará las librerías necesarias, para esto agregamos "extends JFrame" justo después de declarar la clase, "JFrame" no s quedara subrayado en rojo, pasamos el puntero y le damos a "import" y nos importa JFrame desde java.swing:
Una ventana se puede crear de varias formas, pero prefiero crear una varible de JFrame para poder modificar o ajustar a mi gusto la ventana. Por lo que sería de la siguiente manera:
public class PrimeraClase extends JFrame {
JFrame frame; //creamos el frame que será la ventana
PrimeraClase(){
/*Creamos un constructor para modificar los parametros del frame
* OJO el constructor lleva el mismo nombre de la clase seguido por un paréntesis
*/
frame = new JFrame("DragonBall_AF Taringa!");
/*Con este codigo iniciamos el frame
* entre los parentesis del JFrame escribimos el nombre de la ventana
* En este caso "DragonBall_AF Taringa!"
*/
frame.setVisible(true); //El comando .setVisible nos permite elegir si es visible o no.
frame.setSize(600,600); //el comando .setSize me permite modificar el tamaño de la ventana
frame.setDefaultCloseOperation(EXIT_ON_CLOSE);/*
*Esto hace que se cierre la aplicación al cerrar la ventana
*y no siga ejecutandose el segundo plano
*/
}
public static void main(String[] args) {
PrimeraClase frame = new PrimeraClase(); /*Este codigo se pone el el main
*De la forma nombreDeLaClase nombreDelFrame = new nombreDeLaClase();
*/
}
Si pegan el código le queda mas o menos así. Se los dejé comentado para que entiendan para que sirve cada parte del código. Si ejecutamos ahora tendremos una ventana como la siguiente:
Obviamente vacía ya que no hemos agregado ningún componente todavía. Aquí he puesto un constructor que lleva el mismo nombre de la clase seguido de parentesis y las llaves, pero te preguntaras, que es un constructor?
En programación orientada a objetos (POO), un constructor es una subrutina cuya misión es inicializar un objeto de una clase. En el constructor se asignan los valores iniciales del nuevo objeto.
En este caso utilicé el constructor para asignarle los valores al frame
-Añadiendo botones y Eventos
Ahora haremos todo lo que aprendimos hasta ahora mas algunas cosas nuevas: añadir botones y que ocurra algún evento al pulsar estos botones
Ya tenemos que ir aprendiendo nuevos conceptos como los Layouts y los ActionListener.
-Layouts
En pocas palabras nos permiten elegir de que forma queremos que se organicen todos los componentes en la pantalla. Existen varios tipos de Layouts, voy a definir los dos mas utilizados.Los layout managers ayudan a adaptar los diversos Componentes que se desean incorporar a un Panel, frame o Applet, es decir, especifican la apariencia que tendrán los Componentes a la hora de colocarlos sobre un Contenedor controlando el tamaño y posición del componente.
-Grid Layout
*Captura no propia
Crea distribuciones en forma de malla que posee una serie de columnas y filas. Estas filas y columnas crean celdas de exactamente el mismo tamaño. Los componentes se distribuyen desde la primer celda a la izquierda de la primera fila; y van rellenando fila a fila toda la malla hasta la celda más a la derecha de la última fila.
-Flow Layout
*Captura no propia
Distribuye los componentes del contenedor de izquierda a derecha y de arriba abajo. Es la distribución más fácil y una de las más efectivas.
-ActionListener
ActionListener es un controlador de eventos que ejecuta una tarea cuando una determinada acción se lleva a cabo por el usuario. Esta acción puede ser cualquier cosa que el usuario pueda hacer, como mover el ratón o pulsar una tecla en el teclado.
Bien! Ahora añadiré diez botones al frame para eso creamos 10 objetos de la siguiente manera:
JButton boton1,boton2,boton3,boton4,boton5,boton6,boton7,boton8,boton9,boton10;
Recuerden siempre importar las librerías correspondientes correspondientes.Iniciamos todos los botones en un constructor y además añadimos lo que queremos que digan los botones.
PrimeraClase(){
boton1 = new JButton("+1");
boton2 = new JButton("+2");
boton3 = new JButton("+3");
boton4 = new JButton("+4");
boton5 = new JButton("+5");
boton6 = new JButton("+6");
boton7 = new JButton("+7");
boton8 = new JButton("+8");
boton9 = new JButton("+9");
boton10 = new JButton("+10");
}
Ya tenemos todos los botones, pero necesitamos una forma de organizarlos en la pantalla, para ellos utilizaremos un Layout en este caso utilizaremos un GridLayout, utilizamos el siguiente código para crear el objeto layout:
[color=#000000]GridLayout layout;[/color]
Importamos GridLayout como debe ser, y en el constructor lo iniciamos de la siguiente manera.
[color=#000000]layout = new GridLayout(5,2); 2 Columnas con 5 filas[/color]
En los paréntesis especificamos el numero de filas y columnas que queremos que tenga el frame, en este caso puse 2 Columnas con 5 filas para que queden bien organizados los diez botones. Luego de este tenemos que definir el layout que creamos como el layout del frame, con el siguiente código:
[color=#000000]frame.setLayout(layout);[/color]
Esto lo hacemos con el comando ".setLayout()" poniendo entre los paréntesis el layout antes creado, así el frame adquiere estas propiedades antes mencionadas.Bien ahora añadiremos todos los botones al frame en el constructor de la siguiente forma:
frame.add(boton1);
frame.add(boton2);
frame.add(boton3);
frame.add(boton4);
frame.add(boton5);
frame.add(boton6);
frame.add(boton7);
frame.add(boton8);
frame.add(boton9);
frame.add(boton10);
Bien aquí dejo ya todo el código hasta esta parte completo y el resultado al ejecutarlo:
import java.awt.GridLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
public class PrimeraClase extends JFrame {
JFrame frame; //creamos el frame que será la ventana
JButton boton1,boton2,boton3,boton4,boton5,boton6,boton7,boton8,boton9,boton10; //Crear los botones
GridLayout layout; //Crear Layout
PrimeraClase(){
layout = new GridLayout(5,2);//2 Columnas con 5 filas en el layout
//Iniciar los botones y escribir lo que llevara cada uno
boton1 = new JButton("+1");
boton2 = new JButton("+2");
boton3 = new JButton("+3");
boton4 = new JButton("+4");
boton5 = new JButton("+5");
boton6 = new JButton("+6");
boton7 = new JButton("+7");
boton8 = new JButton("+8");
boton9 = new JButton("+9");
boton10 = new JButton("+10");
//Propiedades del frame
frame = new JFrame("DragonBall_AF Taringa!");
frame.setVisible(true);
frame.setSize(600,600);
frame.setDefaultCloseOperation(EXIT_ON_CLOSE);
frame.setLayout(layout); //Establecemos el layout creado anteriormente al frame
//Añadir todos los botones al frame
frame.add(boton1);
frame.add(boton2);
frame.add(boton3);
frame.add(boton4);
frame.add(boton5);
frame.add(boton6);
frame.add(boton7);
frame.add(boton8);
frame.add(boton9);
frame.add(boton10);
}
public static void main(String[] args) {
PrimeraClase frame = new PrimeraClase(); //Iniciar la ventana
}
}
Al ejecutar tenemos esto:
Cuando pulsamos un botón no pasa nada
Tranquilo fiera que para allá vamos. Tenemos que agregarle un oyente a los botones, para que suceda un evento cada vez que hagamos click sobre ellos. Para eso implementaremos la interfaz ActionListener a la clase. Esto empieza a ponerse emocionante pero primero: Interfaz(Java):
Una interfaz en Java es una colección de métodos abstractos y propiedades. En ellas se especifica qué se debe hacer pero no su implementación. Serán las clases que implementen estas interfaces las que describan la lógica del comportamiento de los métodos.La principal diferencia entre interface y abstract es que un interface proporciona un mecanismo de encapsulación de los protocolos de los métodos sin forzar al usuario a utilizar la herencia.
-Eventos
No se si habrán notado que estos 10 botones estan ambientados en el sistema de puntos de T!
Para hacerlo sencillo lo haré de la siguiente manera: cuando hagamos click a un determinado botón saldrá una ventana emergente con una imagen Esta vez utilizaremos JLabel y JDialog para esto Primero lo primero! Implementamos la interface ActionListener a la Clase:
[color=#000000]public class PrimeraClase extends JFrame implements ActionListener[/color]
OJO También nos pedirá crear el siguiente método:
public void actionPerformed(ActionEvent e) {
}
Por ahora lo dejamos ahí. Ahora crearé dos JDialogs que son ventanas emergentes, en las que pondré dos imágenes con dos JLabels incluyéndole los ImageIcon para no complicarme tanto ni a ustedes. Y como ya es común declaramos las variables. Recuerden importar todo!
JDialog dialog1,dialog2;
ImageIcon icon1,icon2;
JLabel label1,label2;
Importaré las dos imágenes a mi proyecto! Para esto arrastramos las imágenes hasta nuestro proyecto en Eclipse así de fácil! Ahí les dejo las dos imágenes que utilicé
Usamos las imágenes con ImageIconiniciamos los ImageIcon creados anteriormente en el constructor, también los JLabels y JDialogs:
icon1 = new ImageIcon("b.jpg");//Ponemos los nombre de las imagenes entre comillas
icon2 = new ImageIcon("a.jpg");
label1 = new JLabel(icon1); //Agregamos la imagen a un JLabel
label2 = new JLabel(icon2);
dialog1 = new JDialog();
dialog1.setTitle("Buen post Maquina!");//Titulo de la ventana
dialog1.setSize(500, 400);//Ponemos tamaño perzonalizable a la ventana
dialog1.setResizable(false);//Evitamos que puede ser redimensionada
dialog1.add(label1);
dialog2 = new JDialog();
dialog2.setTitle("Denunciado por crapero, gracias por los 3 puntos lince");
dialog2.setSize(500,750);
dialog2.setResizable(false);
dialog2.add(label2);
Hacemos que todos los botones puedan recibir una acción con el siguiente código:
[color=#000000]boton1.addActionListener(this);
boton2.addActionListener(this);
//Y así sucesivamente[/color]
Ahora vamos al método que creamos anteriormente, el de ActionListener y usaremos las condiciones if else para hacer cumplir los eventos de la siguiente manera:
public void actionPerformed(ActionEvent e) {
if ((e.getSource()== boton10)||(e.getSource()== boton9)){ //Si se preciona el b9 o el b10
dialog1.setVisible(true);//hacer la ventana 1 visible
} else{ //Si se presiona cualquier otro boton, hacer la ventana 2 visible
dialog2.setVisible(true);
}
}
Les dejo todo el código, que se hizo medio largo. Esta todo comentado para que lo puedan analizar con calma y ver todo el progreso hasta ahora. Aquí les dejo también los resultados de clickear uno de los botones
CLICK AQUI PARA VER TODO EL CODIGO
Al pulsar de los botones +1 al +8 nos sale la siguiente ventana:
Si pulsamos el botón +9 o +10 nos sale esta
Que sabemos hasta ahora?
Lo que hemos aprendido hasta ahora:
- Creación, declaración y uso de variables.
- Operadores lógicos y operaciones matematicas
- Tipos primitivos
- Condiciones if else
- Como crear una ventana personalizable
- Layouts y tipos de layouts
- Añadir elementos a la ventana
- JButtons, JLabels e ImageIcon
- ActionListener
- Eventos a determinadas acciones, como pulsar un boton.
Que aprenderemos en la parte 2 de post??
Continuaría pero el post se bastante largo y aveces hasta aburre. Lo que han visto hasta ahora es lo mas básico, la estructura del código no es la mejor, se puede hacer esto con menos código y mejor organizado. Todavía no han visto como es en realidad la Programación orientada a objetos (POO) , programar con multiples clases,etc. Esto no es nada
Para el siguiente post haremos interfaces gráficas para darle un poco mas de estilo, organizaremos mejor el código y utilizaremos Paneles para no tener que mostrar contenido en una ventana emergente. Los usuarios avanzados por favor en vez de dar malas críticas den un comentario constructivo, así me ayudan a mí que todavía soy un principiante y la comunidad. Bueno esto queda para el siguiente post, no olvides seguirme!
- Programación orientada a objetos (POO)
- Utilización de varias clases para tener el código mas ordenado
- Añadir menús a la ventana
- Interfaces gráficas a los botones
- Utilización de JPanels
- Extras