Include Import

Parrafos y Titulos

2015-09-18T12:04:00.000-05:00

Hola que tal programadores!!
El dia de hoy vamos a ver como colocar parrafos y Titulos y sus caracteristicas de estos. Es muy sencillo, es por eso que junte los temas

Recuerden que al final pueden descargar la sesion del tema que se este viendo.

PARRAFO

Los parrafos se colocan dentro de la etiqueta:
<p>Ejemplo de un parrafo</p>
<p>Otro ejemplo de un parrafo</p>

Hay que tomar en cuenta que esta etiqueta no lee los "enter" dentro del codigo HTML. Veamos el ejemplo:

********************** Resultado **********************

Pero si deseamos que mantenga el formato con "enter" y espacios, tenemos dos opciones :
1. Utilizar la etiqueta <br> para colocar "enter"
2. Utilizar la etiqueta <pre> para mantener el formato

Veamos un ejemplo en donde utilicemos esas dos opciones:

********************** Resultado **********************

TITULOS (Encabezados)

Los titulos se caracterizan por presentarse con tipo de letra bold, y en algunas ocasiones es mas grande.

Para colocar titulos predeterminados en HTML utilizaremos las siguientes etiquetas:

<h1> Titulo 1 </h1>
<h2> Titulo 2 </h2>
<h3> Titulo 3 </h3>
<h4> Titulo 4 </h4>
<h5> Titulo 5 </h5>
<h6> Titulo 6 </h6>

Tambien en ocasiones Visualizamos una linea debajo del titulo. Esta la pondremos con la etiqueta <hr>

Tomando en cuenta lo anterior, la etiqueta <h1> es el titulo mas grande y la etiqueta <h6> es el mas pequeño. Veamos el ejemplo:

********************** Resultado **********************

Si quieren descargar los ejemplos den click en la siguiente imagen:

Hemos llegado al final de este tema, Se que son temas muy sencillos, pero son muy utiles. Mas adelante entraremos a HTML5 pero es importante primero conocer la base.

SI TIENEN ALGUNA DUDA COMENTEN !!

Siganos en FACEBOOK y TWITTER para que esten pendientes de nuestros proximos temas

Hasta la proxima !! B-)

JList, JScrollPane y clase interna anónima de eventos

2014-07-02T20:43:00.002-05:00

Que tal compañeros, hoy vamos a continuar con otro componente que es JList y JScollPan además del uso de una clase interna anónima para el manejo de eventos. La clase interna anónima no es más una instancia de una clase interna anónima, y se declara sin tener un nombre y por lo general aparece dentro de la declaración de un método.

Ahora para entender y sobre todo aprender de los componentes JList y JScrollPane, para ello realizamos un ejercicio donde se muestra una lista de colores y al seleccionar un color el background de nuestra ventana cambiara con respecto al color seleccionado.

Codigo vtnColores:

import java.awt.Color;
import java.awt.FlowLayout;
import javax.swing.JFrame;
import javax.swing.JList;
import javax.swing.JScrollPane;
import javax.swing.ListSelectionModel;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;

public class vtnColores extends JFrame{
 private JList listaColores;
 //Declaramos un arreglo con los nombres de los colores esto para mostrarlo en el JList
 private final String ArrayColores[]={"Negro", "Azul", "Cyan", "Gris obscuro", "Gris", "Verde", 
         "Gris claro", "Magenta", "Naranja", "Rosa", "Rojo", "Blanco",
         "Amarillo"};
 //Declaramos un arreglo de colores del objeto Color y dentro colocamos los colores del array anterior
 private final Color colores[]={Color.BLACK, Color.BLUE, Color.CYAN, Color.DARK_GRAY, Color.GRAY,
         Color.GREEN, Color.LIGHT_GRAY, Color.MAGENTA, Color.ORANGE, 
         Color.PINK, Color.RED, Color.WHITE, Color.YELLOW};
 
 //Constructor
 public vtnColores(){
  super("DEMO VENTANA COLORES");
  setLayout(new FlowLayout());
  
  listaColores = new JList(ArrayColores);
  listaColores.setVisibleRowCount(5);//Muestra solo cinco filas del JList
  //No permitimos la seleccion multiple
  listaColores.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
  add(new JScrollPane(listaColores));
  listaColores.addListSelectionListener(
    new ListSelectionListener(){//Creamos una clase anonima
     //Aqui desarrollamos los eventos que se realizaran de la lista
     @Override
     public void valueChanged(ListSelectionEvent evento) {
      getContentPane().setBackground(colores[listaColores.getSelectedIndex()]);
      
     }//FIN del metodo valueChanged
    }//FIN de la clase interna anonima
    );//FIN de la llamada addListSelectionListener
 }//FIN de Constructor
 
 
}

Codigo ColoresMain:

import javax.swing.JFrame;

public class ColoresMain {
 public static void main(String[] args) {
  vtnColores demo = new vtnColores();
  demo.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  demo.setSize(350, 350);
  demo.setVisible(true);
 }
}

Resultado:

Descargar archivo en Eclipse

Muy bien compañeros hemos llegado al fin de este post donde aprendimos a realizar listas con un Scroll ademas de editar el fondo de nuestra ventana, si te gusto el post compartelo con tus amigos y sobretodo seguirnos en nuestras redes sociales.

FACEBOOK, TWITTER y GOOGLE+

JCheckBox, JComboBox y JButton en Java

2014-06-28T21:38:00.001-05:00

Que tal compañeros el día de hoy vamos aprender cómo realizar JCheckBox, JComboBox y JButton además de los eventos ActionListener e ItemListener. Para esto nos dimos a la tarea de realizar un ejercicio en donde practicamos todo estos componentes además de los eventos de escucha para los respectivos componentes.

Empecemos como crear un JCheckBox, para ello tenemos que realizar lo siguiente:

Importamos el paquete que contiene a este componente.

import javax.swing.JComboBox;

A continuación declaramos nuestro JComboBox de la siguiente manera.

private JComboBox NombreDelCombo;

Después instanciamos un objeto de JComboBox de la siguiente manera.

NombreDelCombo = new JComboBox(Variable);

Nota:

En la parte donde dice variables, nosotros podemos crear un arreglo de cadenas para poderlo mostrar en el JComboBox.

Algunos atributos del JComboBox son los siguientes:

A la hora de desplegar el JComboBox a veces solo queremos mostrar una cantidad en específico y para esto realizamos de la siguiente forma donde el número es la cantidad que se mostrara al desplegar.

NombreDelCombo.setMaximumRowCount(4);

Nosotros podemos colocarle una fuente en específico así como el tamaño de la letra y esto se realiza de la siguiente forma.

NombreDelCombo.setFont(new Font("Ubuntu", Font.PLAIN, 16));

Para darle una posición dentro del JFrame utilizamos setBounds donde esto lo vimos en el anterior post.

NombreDelCombo.setBounds(150, 100, 150, 20);

Una de las propiedades muy importantes es el escuchador de eventos y el JComboBox lo necesita ya que al seleccionar una opción es un evento y para saber esto necesitamos agregarlo y esto se hace de la siguiente forma.

NombreDelCombo.addItemListener(this);

Ahora para el componente JCheckBox necesitamos de igual forma importar el paquete necesario para tener el JCheckBox.

import javax.swing.JCheckBox;

Ahora declaramos nuestro JCheckBox y le colocamos un nombre.

private JCheckBox NombreDelCheck;

Después de declarar nuestro JCheckBox lo instanciamos.

NombreDelCheck = new JCheckBox("Le colocamos un nombre");

Ahora como el JComboBox le podemos colocar al JCheckBox las propiedades de: setFont y setBounds

Para agregarle el escuchador de eventos al JCheckBox lo hacemos de la siguiente forma:

NombreDelCheck.addItemListener(this);

Ahora para el último componente JButton agregamos los paquetes necesarios que es el siguiente:

De igual forma le podemos agregar los atributos de setFont y setBounds.

Ahora la parte esencial de un botón es el evento que realizara a la hora de presionarlo y para aregarle el evento lo realizamos de la siguiente forma:

NombreBoton.addActionListener(this);

A la hora de que lo agreguemos nos marcara un error, puede ser porque en la clase no le colocamos el implements ActionListener. Ahora si al agregar el implements nos marca error en la clase le damos click al error y nos mostrara

Seleccionamos Add unimplemented methods y después de seleccionarlo en la parte inferior de nuestro programa se colocara el método:

public void actionPerformed(ActionEvent evento)

Esto es para el ActionListener el mismo procedimiento se hace con el de ItemListener.

Ahora después de explicar cada componente nuestro ejercicio consiste en un registro de usuarios sencilla pero bastante practico para estos componentes.

El código es el siguiente:

import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;

import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JTextField;


public class VtnRegistro extends JFrame implements ActionListener, ItemListener{
 private JLabel lblNombre;
 private JLabel lblApPaterno;
 private JLabel lblApMaterno;
 private JLabel lblGenero;
 private JLabel lblEstado;
 
 private JTextField txtNombre;
 private JTextField txtApPaterno;
 private JTextField txtApMaterno;
 
 private JCheckBox checkFemenino;
 private JCheckBox checkMasculino;
 
 private JComboBox comboEstados;
 
 private JButton btnRegistrar;
 private JButton btnCancelar;
 
 //Declaramos un arreglo en donde colocamos los estados y mostrarlos en el JComboBox
 String Estados[]={"Aguascalientes", "Baja California", "Baja California Sur", "Campeche",
     "Coahuila", "Colima", "Chiapas", "Chihuahua", "Distrito Federal", "Durango"};
 
 String Nombre, ApPaterno, ApMaterno, Genero, Estado;
 //Constructor
 public VtnRegistro(){
  super("Registro Usuario");
  setLayout(null);
  
  lblNombre = new JLabel("Nombre:");
  lblNombre.setBounds(85, 20, 80, 20);
  //Le colocamos un tipo de fuente y tamaño a la letra
  lblNombre.setFont(new Font("Ubuntu", Font.PLAIN, 16));
  add(lblNombre);
  
  lblApPaterno = new JLabel("Apellido paterno:");
  lblApPaterno.setBounds(20, 40, 140, 20);
  //Le colocamos un tipo de fuente y tamaño a la letra
  lblApPaterno.setFont(new Font("Ubuntu", Font.PLAIN, 16));
  add(lblApPaterno);
  
  lblApMaterno = new JLabel("Apellido materno:");
  lblApMaterno.setBounds(20, 60, 140, 20);
  //Le colocamos un tipo de fuente y tamaño a la letra
  lblApMaterno.setFont(new Font("Ubuntu", Font.PLAIN, 16));
  add(lblApMaterno);
  
  lblGenero = new JLabel("Genero:");
  lblGenero.setBounds(90, 80, 80, 20);
  //Le colocamos un tipo de fuente y tamaño a la letra
  lblGenero.setFont(new Font("Ubuntu", Font.PLAIN, 16));
  add(lblGenero);
  
  lblEstado = new JLabel("Estado:");
  lblEstado.setBounds(95, 100, 80, 20);
  //Le colocamos un tipo de fuente y tamaño a la letra
  lblEstado.setFont(new Font("Ubuntu", Font.PLAIN, 16));
  add(lblEstado);
  
  txtNombre = new JTextField();
  txtNombre.setFont(new Font("Ubuntu", Font.PLAIN, 16));
  txtNombre.setBounds(150, 20, 150, 20);
  add(txtNombre);
  
  txtApPaterno = new JTextField();
  //Le colocamos un tipo de fuente y tamaño a la letra
  txtApPaterno.setFont(new Font("Ubuntu", Font.PLAIN, 16));
  txtApPaterno.setBounds(150, 40, 150, 20);
  add(txtApPaterno);
  
  txtApMaterno = new JTextField();
  //Le colocamos un tipo de fuente y tamaño a la letra
  txtApMaterno.setFont(new Font("Ubuntu", Font.PLAIN, 16));
  txtApMaterno.setBounds(150, 60, 150, 20);
  add(txtApMaterno);
  
  checkFemenino = new JCheckBox("F");
  //Le colocamos un tipo de fuente y tamaño a la letra
  checkFemenino.setFont(new Font("Ubuntu", Font.PLAIN, 16));
  checkFemenino.setBounds(160, 80, 40, 20);
  checkFemenino.addItemListener(this);//Agregamos el escucha eventos al check
  add(checkFemenino);
  
  checkMasculino = new JCheckBox("M");
  //Le colocamos un tipo de fuente y tamaño a la letra
  checkMasculino.setFont(new Font("Ubuntu", Font.PLAIN, 16));
  checkMasculino.setBounds(240, 80, 40, 20);
  checkMasculino.addItemListener(this);//Agregamos el escucha eventos al check
  add(checkMasculino);
  
  comboEstados = new JComboBox(Estados);
  comboEstados.setMaximumRowCount(4);
  comboEstados.setFont(new Font("Ubuntu", Font.PLAIN, 16));
  comboEstados.setBounds(150, 100, 150, 20);
  comboEstados.addItemListener(this);
  add(comboEstados);
  
  btnRegistrar = new JButton("Registrar");
  //Le colocamos un tipo de fuente y tamaño a la letra
  btnRegistrar.setFont(new Font("Ubuntu", Font.PLAIN, 16));
  btnRegistrar.setBounds(60, 150, 100, 20);
  btnRegistrar.addActionListener(this);
  add(btnRegistrar);
  
  btnCancelar = new JButton("Cancelar");
  //Le colocamos un tipo de fuente y tamaño a la letra
  btnCancelar.setFont(new Font("Ubuntu", Font.PLAIN, 16));
  btnCancelar.setBounds(200, 150, 100, 20);
  btnCancelar.addActionListener(this);
  add(btnCancelar);
  
  
 }
 @Override
 public void actionPerformed(ActionEvent evento) {
  /*Para nosotros identificar de donde probiene el evento utilizamos el getSource esto
   * para saber la fuente (componente de donde probiene el evento), el equals es similar
   * al ==, solo que el equals nos permite igualar objetos que en este caso son los componentes
   */
  if(evento.getSource().equals(btnRegistrar)){
   //Inicializamos las variables obteniendo los datos de los JTextField
   Nombre = txtNombre.getText();
   ApPaterno = txtApPaterno.getText();
   ApMaterno = txtApMaterno.getText();
   JOptionPane.showMessageDialog(null, "Nombre: "+Nombre+
     "\nApellido Paterno: "+ApPaterno+
     "\nApellido Materno: "+ApMaterno+
     "\nGenero: "+Genero+
     "\nEstado: "+Estado);
  }
  else if(evento.getSource().equals(btnCancelar)){
   //La accion que le dimos a cancelar fue Salir y se hace de la siguiente forma
   System.exit(EXIT_ON_CLOSE);
  }
 }
 @Override
 public void itemStateChanged(ItemEvent evento) {
  if(evento.getSource() == comboEstados){
   //Aqui realizamos un cast que es comvertir el dato seleccionado a String
   Estado = (String)comboEstados.getSelectedItem();
  }
  //Si el checkFemenino es seleccionado se le asignara "Femenino" a la variable Genero
  else if(checkFemenino.isSelected() == true){
   Genero = "Femenino";
  }
  //Si el checkMasculino es seleccionado se le asignara "Masculino" a la variable Genero
  else if(checkMasculino.isSelected() == true){
   Genero = "Masculino";
  }
 }
}

Main:

import javax.swing.JFrame;

public class MainRegistro {

 public static void main(String[] args) {
  VtnRegistro Usuario = new VtnRegistro();
  Usuario.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  Usuario.setSize(350, 300);
  Usuario.setVisible(true);
 }
}

Resultado:

DESCARGARPROYECTO EN ECLIPSE.

Muy bien compañeros hemos llegado al final de este post espero que les haya sido de gran utilidad a la hora de crear sus GUI y que mejor que aprender como se hace desde 0. Si te gusto no olvides seguirnos por nuestras redes sociales.

FACEBOOK, TWITTER y GOOGLE+

Administrador de esquemas

2014-06-23T11:27:00.000-05:00

Que tal compañeros hoy vamos a ver los administradores de esquemas los cuales nos servirán para ordenar los componentes de la GUI en un contenedor. Existen tres formas para poder ordenar los componentes en una GUI:

1.-Posicionamiento absoluto: aquí podemos especificar la posición absoluta de cada componente de la GUI con respecto a la esquina superior izquierda, si realizamos esto, también debemos especificar el tamaño de cada componente.

2.-Administradores de esquemas: el uso de administradores de esquemas para posicionar elementos poder ser un proceso aún más simple y rápido para la creación de GUI, pero como todo tiene sus desventajas y al utilizar administradores de esquemas se pierde el control sobre el tamaño y el posicionamiento preciso de los componente.

3.-Programacion visual en un IDE: como sabemos están eclipse y netbeans con sus respectivos plugins para nosotros poder crear interfaces con tan solo arrastrar los componentes necesarios esta es una manera muy valida de hacer, pero les recomiendo que primero aprendan como se hace desde 0 y después hacerlo con un IDE.

Empezaremos a describir los administradores de esquemas los cuales son:

FlowLayout: Se colocan los componentes secuencialmente (de izquierda a derecha) en el orden que se agregaron.

Ejemplos:

BorderLayout: Se recomienda para los objetos JFrame (y otras ventanas). Con BorderLayout se ordenan los componentes en cinco ares: NORT, SOUTH, EAST, WEST y CENTER que al español son NORTE, SUR, ESTE, OESTE y CENTRO.

GridLayout: Ordena los componentes en filas y columnas.

En resumen estos administradores de esquemas son de gran ayuda a la hora de crear nuestra GUI desde 0, ahora no necesariamente tienes que limitarte a usar uno, al contrario puedes combinarlos para que puedas tener una mayor manipulación a la hora de ordenar tus componentes. Y así tener una interfaz más entendible para tu usuario.

Recuerda que nos puedes seguir por FACEBOOK, TWITTER y GOOGLE+.

componentes JTextField y JButton

2014-06-13T21:17:00.004-05:00

Que tal compañeros, el día de hoy vamos aprender los siguientes componentes:

JTextField: Son las cajas de texto donde nosotros como usuarios colocamos información, visto como programador todo lo que se escriba dentro de estas cajas se guardara como String, ahora para guardar números es necesario utilizar el PARSE para así convertir de un dato tipo cadena a un entero o al que necesiten.

JButton: Son los botones con las cuales el programa realiza acciones al presionarlos, ahora visto como programador aquí es donde nosotros colocamos los eventos o las acciones que realizara el botón al ser presionado por el usuario, esto dependerá al tipo de software que realices.

Ahora para entender mejor esto vamos a realizar el tradicional ejercicio de FACTORIAL, pero con su GUI respectivamente. Este ejercicio está dividido en dos archivos o dos clases recuerden que al final estará el link de descarga.

Codigo:

Archivo VentanaFactorial.

/*
 * Programa: Realiza la operacion del factorial
 * Autor: Include Import
 */
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JTextField;

//Lo nuevo aqui es implements ActionListener esto para poder activar las acciones al boton al ser presionado
public class VentanaFactorial extends JFrame implements ActionListener{
 //Declaramos las variables JLabel, JButton y JTextField necesarios para la ventana.
 private JLabel lblTitulo;
 private JLabel lblInstrucciones;
 private JLabel lblNumero;
 private JTextField txtNumero;
 private JButton btnCalcular; 
 
 //Constructor aqui agregamos los componentes al JFrame
 public VentanaFactorial(){
  super("::: F A C T O R I A L :::");//Le colocamos un titulo a la ventana
  setLayout(null);//Colocamos el layout vacio para que nosotros agreguemos los componentes
  
  //Construimos los componentes 
  lblTitulo = new JLabel("FACTORIAL");
  //Acomodamos nuestro componente mediante cordenadas y definiendo el ancho y el alto
  //De esta manera es el setBounds(x, y, width, height)
  lblTitulo.setBounds(120, 20, 300, 20);
  add(lblTitulo);
  
  //lblInstrucciones
  lblInstrucciones=new JLabel("Ingresa un numero para obtener su factorial");
  //De esta manera es el setBounds(x, y, width, height)
  lblInstrucciones.setBounds(15, 60, 300, 20);
  add(lblInstrucciones);//Agregamos el componente al JFrame
  
  //lblNumero
  lblNumero=new JLabel("Numero: ");
  //De esta manera es el setBounds(x, y, width, height)
  lblNumero.setBounds(25, 100, 300, 20);
  lblNumero.setToolTipText("Ingresa solo numeros..");//Mensaje al estar el mouse puesto encima
  add(lblNumero);//Agregamos el componente al JFrame
  
  //txtNumero
  txtNumero= new JTextField();
  //De esta manera es el setBounds(x, y, width, height)
  txtNumero.setBounds(75, 100, 150, 20);
  add(txtNumero);//Agregamos el componente al JFrame
  
  //btnCalcular
  btnCalcular = new JButton("Calcular");
  //De esta manera es el setBounds(x, y, width, height)
  btnCalcular.setBounds(100, 140, 100, 20);
  add(btnCalcular);//Agregamos el componente al JFrame
  /*
   * Le agregamos al boton el escucha eventos el this significa que al presionar 
   * este boton calcular 
   */
  btnCalcular.addActionListener(this);
 }
 
 //Metodo de actividades en donde aceptamos un evento
 public void actionPerformed(ActionEvent evento) {
        if (evento.getSource()==btnCalcular) {//Si el btnCalcular es presionado
            int num = Integer.parseInt(txtNumero.getText());//Convertimos el String a int
            int res=1;
            for(int cont=1; cont&lt;=num; cont++){
             res*=cont;
            }
            JOptionPane.showMessageDialog(null,"El resultado de es: "+res);//Mostramos el resultado en mensaje
        }
 
 }
}

Archivo MainFactorial.

/*
 * Programa: Realiza la operacion del factorial
 * Autor: Include Import
 */
import javax.swing.JFrame;

public class MainFactorial {
 public static void main(String[] args) {
  //Creamos nuestra ventana
  VentanaFactorial MiFactorial = new VentanaFactorial();
  //Que finalize al presionar la X en la parte superior derecha
  MiFactorial.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  //Tamaño de nuestra ventana
  MiFactorial.setSize(300,300);
  //Que se muestre nuestra ventana y prueben en colocarle false y veran por que...
  MiFactorial.setVisible(true);
  //Para que no nos de los controles de modificar las propiedades de la ventana
  //Pruebenlo colocando el mouse sobre los bordes y veran que no se puede agrandar
  MiFactorial.setResizable(false);
 }

}

Resultado:

DESCARGAR PROYECTO EN ECLIPSE.

Posibles errores:

Al utilizar setBounds podemos colocar un componente encima de uno es necesario imaginarse las coordenadas y sobre todo la posición en la que estará el componente.

Si al botón no le colocas addActionListener(this) es probable que el botón no funcione o en la clase no le coloques implements ActionListener de igual forma no funcionara si no lo colocas.

Muy bien compañeros hemos llegado al final del post, espero que les haya gustado este ejercicio básico, sobre todo lo hayan entendido y aprendido. No olvides seguirnos por nuestras redes sociales.

FACEBOOK, TWITTER y GOOGLE+

Mostrar texto e imágenes en una ventana

2014-06-11T10:46:00.000-05:00

Que tal compañeros hoy vamos a ver los componentes del paquete javax.swing que son los siguientes:

Componente	Descripción
JLabel	Muestra texto que no puede editarse, o iconos
JTextField	Permite al usuario introducir datos mediante el teclado. También se puede utilizar para mostrar textos que se puede o no editar.
JButton	Activa un evento cuando se oprime mediante el ratón.
JCheckBox	Especifica una opción que puede seleccionarse o no seleccionarse
JComboBox	Proporciona una lista desplegable de elementos, a partir de los cuales el usuario puede realizar una selección, haciendo clic en cualquier elemento o escribiendo en el cuadro.
JList	Proporciona una lista de elementos a partir delos cuales el usuario puede realizar una selección, haciendo clic en cualquier elemento en la lista. Pueden seleccionar varios elementos.
JPanel	Proporciona una área en la que pueden colocarse y organizarse los componentes. También puede utilizarse como un área de dibujo para gráficos.

Empecemos con el JLabel como ya algunos saben y para los que no lo sepan son los textos que comúnmente podemos ver en sistemas o hasta en las páginas web.

Ahora para crear un JLabel es necesario realizar lo siguiente:

Importar el paquete el cual nos permitirá usarlo que es:

import javax.swing.JLabel;

Después declaramos nuestro JLabel con el nombre que nosotros queramos.

private JLabel etiqueta1;

Nota:

Cuando se tiene un sistema mas robusto es recomendable colocarle lbl + nombre de acuerdo a lo que representa ejemplo: lblNumero, lblNombre, etcétera.

- Por ultimo instanciamos nuestra etiqueta de la siguiente manera:

etiqueta1 = new JLabel("Nombre de acuerdo a la acción que corresponda");

Nota:

Dentro del constructor del JLabel puede ir el nombre que nosotros queremos que aparezca o podemos colocarle un texto de otra forma utilizando:

Etiqueta1.setText("Texto que tomara nuestra etiqueta");

Ahora para entender mejor esto mostramos con un ejercicio donde utilizamos las etiquetas con texto y con iconos.

Código:
Archivo Etiqueta

/*
 * Programa: Demostración de la clase JLabel
 * Autor: Include Import
 */
//Paquetes a utilizar
import java.awt.FlowLayout;//Especifica como se van a ordenar los componentes
import javax.swing.Icon;//Interfaz utilizada para manipular imagenes
import javax.swing.ImageIcon;//carga las imagenes
import javax.swing.JFrame;//proporciona las caracteristicas basicas de una ventana
import javax.swing.JLabel;//Muestra texto e imagenes
import javax.swing.SwingConstants;

public class Etiqueta extends JFrame{
 private JLabel etiqueta1;//JLabel solo texto
 private JLabel etiqueta2;//JLabel texto y un Icono
 private JLabel etiqueta3;//JLabel texto largo e icono
 
 //Constructor de Etiqueta agrega objetos JLabel a JFrame
 public Etiqueta(){
  super("Titulo de ventana");
  setLayout(new FlowLayout());//Establece el marco
  
  //Constructor del JLabel con un argumento String
  etiqueta1 = new JLabel("Hola compañeros de Include Import");
  etiqueta1.setToolTipText("Etiqueta con texto");
  add(etiqueta1);//agregamos etiqueta1 al JFrame
  
  //Constructor de JLabel  con argumentos de cadena, Icono y alineacion
  Icon logo = new ImageIcon(getClass().getResource("foto.jpg"));
  etiqueta2 = new JLabel("Programa de etiquetas e imagenes", logo, SwingConstants.LEFT);
  etiqueta2.setToolTipText("Etiqueta con texto y un icono");
  add(etiqueta2);//Agregamos etiqueta2 al JFrame
  
  //Constructor  de JLabel sin argumentos
  etiqueta3= new JLabel();
  etiqueta3.setText("Solo en Include Import vas a ver ejercicios basicos pero muy funcionales..");
  etiqueta3.setIcon(logo);
  etiqueta3.setHorizontalTextPosition(SwingConstants.CENTER);//Alineamos el JLabel
  etiqueta3.setVerticalTextPosition(SwingConstants.BOTTOM);
  etiqueta3.setToolTipText("Etiqueta con texto e icono alineado");
  add(etiqueta3);//agrega etiqueta3 al JFrame
  
 }
}

Archivo MainGUI

public class MainGUI {
 public static void main(String[] args) {
  Etiqueta ventanaEtiquetas = new Etiqueta();//Crea objeto Etiqueta
  //para finalizar la ventana al darle en la x de la ventana
  ventanaEtiquetas.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  ventanaEtiquetas.setSize(500, 600);//Tamaño de la ventana
  ventanaEtiquetas.setVisible(true);//Muestra la ventana
 }

}

Resultado:

Nota:
Para colocar la imagen deben colocar el nombre de la imagen mas la extensión, si tu imagen no aparece puede ser por que el nombre no esta correcto o la extensión, y si aun así te marca error es por que la imagen debe estar donde están los código fuente de nuestro ejercicio y de esta manera no debe marcar error.

Extensiones que soporta: .gif, .png y .jpg(o .jpeg)

Muy bien hasta aquí el post esperamos que les haya gustado y de ser así no olvides compartirlo con tus amigos y no te vayas sin seguirnos por FACEBOOK, TWITTER y GOOGLE+.

DESCARGAR PROYECTO

GUI con JOptionPane

2014-06-06T19:24:00.004-05:00

Que tal compañeros hoy vamos a continuar con JAVA comenzando con algunos componentes de GUI, para empezar entrada/salida simple con JOptionPane, los cuales son diálogos que se muestran mediante la invocación de los métodos JOptionPane del paquete javax.swin ahora la sintaxis para estos diálogos es la siguiente:

String Variable = JOptionPane.showInputDialog(“El texto que queremos mostrar”);

Ahora todo lo que se capture en los diálogos se capturara de manera de cadenas de texto, si nosotros queremos guardar un dato numérico es necesario convertirlo de la siguiente manera:

Opción 1:

Capturamos en una variable String

String variable = JOptionPane.showInputDialog(“Ingresa un número”);

Convertimos la variable a tipo entero o al que nosotros queramos seria de la siguiente forma:

Int numero = Integer.parseInt(variable);

Si nosotros queremos a un Double o Float seria cambiar el Integer por Double o Float seguido del parteDouble(variable) o parseFloat(variable) esto dependerá a que lo queremos convertir.

Opción 2:

Es capturar y convertir al mismo tiempo, la ventaja es que reducimos bastante el código y no tenemos que declarar otra variable para guardar y esto se reduce de la siguiente forma:

Int numero = Integer.parseInt(JOptionPane.showInputDialog(“Texto”));

Y con eso nos reducimos bastantes pasos y líneas de código, volviendo a nuestro programa más entendible.

Ahora para la salida de información necesitamos mandar un mensaje y esto se logra de la siguiente forma:

JOptionPane.showMessageDialog(//variable a mostrar o mensaje a mostrar);

Ahora para ejemplificar esto realizaremos un arreglo de celulares con los diálogos que acabamos de aprender.

Codigo:

import javax.swing.JOptionPane;

/*
 * Programa: Entrada / Salida por JOptionPane con arreglo de objetos
 * Autor: Include Import
 */
public class Celular {

 private String Nombre;
 private String Marca;
 private double Precio;
 
 //SET'S
 public void setNombre(String nombre)
 {Nombre=nombre;}
 public void setMarca(String marca)
 {Marca=marca;}
 public void setPrecio(double precio)
 {Precio=precio;}
 //GET'S
 public String getNombre()
 {return this.Nombre;}
 public String getMarca()
 {return this.Marca;}
 public double getPrecio()
 {return this.Precio;}
 
 
 public static void main(String[] args) {
  //Creamos nuestro arreglo de Clases y de declara de la misma forma que un arreglo normal
  Celular []CatCelulares = new Celular [3];//El valor de 3 lo pueden cambiar a como lo necesiten
  
  //Variables
  String nombre, marca;
  double precio=0.0;
  //Recorremos el arreglo y guardamos informacion por cada posicion
  for(int cont=0; cont<3; cont++){
   CatCelulares[cont]=new Celular();//Instanciamos un objeto celular para poder guardar
   nombre=JOptionPane.showInputDialog(null,"Ingresa el nombre del celular: ","Nombre",1);
   marca=JOptionPane.showInputDialog(null,"Ingresa la marca del celular:","Marca",1);
   precio=Double.parseDouble(JOptionPane.showInputDialog(null,"Ingresa el precio: ","Precio",1));
   //Mandamos los datos a los metodos set para establecer los valores
   CatCelulares[cont].setNombre(nombre);
   CatCelulares[cont].setMarca(marca);
   CatCelulares[cont].setPrecio(precio);
  }
  
  //Mostramos la informacion del arreglo
  String cadena="";
  for(int cont=0; cont<3; cont++){
   //Concatenamos los valores del arreglo y los guardamos en una cadena
   cadena+="\nNombre: "+CatCelulares[cont].getNombre()+
     "\nMarca: "+CatCelulares[cont].getMarca()+
     "\nPrecio: "+CatCelulares[cont].getPrecio()+
     "\n************************";
  }
  //Mostramos los resultados obtenidos 
  JOptionPane.showMessageDialog(null,cadena);
 }//End Main

}//End class

Resultado

Muy bien compañeros hasta aquí el post, esperamos que con este ejercicio se haya entendido los diálogos en JAVA. Si te gusto la información recuerda compartirla con tus amigos y asi podamos crecer como comunidad no olvides sin antes seguirnos por FACEBOOK, TWITTER y GOOGLE+.

DESCARGAR PROYECTO.

Uso de MySQL Worckbench

2014-06-03T21:24:00.001-05:00

Que tal compañeros hoy vamos a trabajar con la parte grafica de MySQL que en este caso utilizaremos Workbench y su interfaz es la siguiente:

Ahora para crear una base de datos desde worckbench, es necesario darle un click al símbolo de “ + “ en la parte donde dice “MySQL Connections” y enseguida nos colocara la siguiente pantalla.

Le colocamos un nombre y le damos en el botón de test para confirmar que se haya echo la conexión, te pedirá tu contraseña para que se pueda establecer la ingresas y te mostrara lo siguiente

Ya que se haya agregado le damos click y empezaremos a crear nuestra base de datos y aquí es aún más sencillo que a consola aquí solo le daremos click en el siguiente símbolo.

Y le damos click y nos mostrara lo siguiente donde le colocamos un nombre y al terminar le damos en el botón de apply

Al finalizar lo que haremos es seleccionar nuestra base de datos para ello le damos doble click sobre nuestra base de datos y se mostrara con el texto en negritas eso significa que la hemos seleccionado para poder trabajar sobre esa base de datos.

Ahora para crear nuestras tablas es necesario dirigirnos a la parte donde dice “tables” damos click derecho y seleccionamos “créate table” y nos mostrara lo siguiente:

Lo llenamos y por ultimo le damos apply y nos mostrara el código SQL que se ejecutara para crear la tabla. Ahora al llenar nuestra tabla con sus respetivos atributos podemos colocarle a nuestros atributos algunas características como son NOT NULL, PRIMARY KEY, AUTO INCREMENT, etc. pero dependerá de cómo crearemos nuestra base de datos.

Ahora para ingresarle los datos a nuestra tabla es necesario el siguiente código SQL.

INSERT INTO casa VALUES (1,'casa1',14);

Y al tener este código le damos click al icono de un rayo ejecutara el código SQL y hay otro rayo con un prom este icono ejecutara el código seleccionado por nosotros y solo ejecutara esas instrucciones seleccionadas.

O lo podemos hacer aún más fácil, damos click derecho a nuestra tabla que en este caso es casa y seleccionamos “Select rows” , y nos mostrara en caso de tener ya información nos aparecerá de lo contrario mostrara la tabla vacia, en esta tabla nosotros nos dedicamos a ingresar datos y cuando terminemos le damos en apply y nos mostrara en la parte de abajo el mensaje que se ejecutó bien.

Muy bien compañeros hasta aquí el post de cómo utilizar MySQL Workbench, si te gusto el post no olvides seguirnos por nuestras redes sociales para que no te pierdas ninguna información. FACEBOOK, TWITTER y GOOGLE+

Ejercicios Básicos en Java

2014-06-02T21:27:00.002-05:00

Que tal compañeros el día de hoy les compartimos tres ejercicios que les pueden ser de utilidad son básicos pero de mucha ayuda a la hora de razonar y echar andar a nuestra mente.

1.-Pedir los coeficientes de una ecuación se 2º grado, y muestre sus soluciones reales. Si no existen, debe indicarlo.

Solución:

public static void main(String[] args) {
 Scanner Entrada = new Scanner(System.in); 
 double a,b,c; // coeficientes ax^2+bx+c=0
 double x1,x2,d; // soluciones y determinante
 System.out.println("Introduzca primer coeficiente (a):");
 a=Entrada.nextInt();
 System.out.println("Introduzca segundo coeficiente: (b):");
 b=Entrada.nextInt();
 System.out.println("Introduzca tercer coeficiente: (c):");
 c=Entrada.nextInt();
 // calculamos el determinante
 d=((b*b)-4*a*c);
 if(d&lt0)
     System.out.println("No existen soluciones reales"+d);
 else{
     // queda confirmar que a sea distinto de 0.
     // si a=0 nos encontramos una división por cero.  
     x1=(-b+Math.sqrt(d))/(2*a);
     x2=(-b-Math.sqrt(d))/(2*a);
     System.out.println("Solución: " + x1);
     System.out.println("Solución: " + x2);
 }
}

2.- Pedir el radio de un círculo y calcular su área. A=PI*r^2.

Solución:

public static void main(String[] args) {
 Scanner Entrada = new Scanner(System.in);
 double a,r; // área y radio
 System.out.print("Introduce el radio de un circulo: ");
 r=Entrada.nextDouble();
 a=Math.PI*(r*r); // para elevar al cuadrado otra opción es: Math.pow (r, 2)
 System.out.println("El área de una circunferencia de radio " + r+ " es: " + a);
}

3.- Pedir dos números y decir si son iguales o no.

Solución:

public static void main(String[] args) {
 Scanner guardar = new Scanner(System.in);
 int num1,num2;
 System.out.print("Introduce un número: ");
 num1=guardar.nextInt();
 System.out.print("Introduce otro número: ");
 num2=guardar.nextInt();
 if(num1==num2)
  System.out.println("Son iguales");
 else
  System.out.println("No son iguales");
}

Muy bien esperamos que les haya gustado estos pequeños ejercicios hechos en el lenguaje Java. Recuerda seguirnos por nuestras redes sociales FACEBOOK, TWITTER, GOOGLE+.

Como crear una base de datos en mysql

2014-05-24T21:43:00.002-05:00

Que tal compañeros hoy vamos a ver cómo crear una base de datos con el lenguaje SQL, el cual es un lenguaje estándar para las bases de datos.

Muy bien vamos a empezar por definir el Nombre de la base de datos que en esta ocasión, se llamara Agenda, dentro de esta base tendremos una tabla que se llamara Contacto con los siguientes atributos nombre, apellidos, teléfono y celular.

Ahora para crear nuestra base de datos necesitamos entrar a nuestro ambiente de trabajo el cual nos pedirá nuestra contraseña y si la contraseña es correcta nos mostrara lo siguiente:

Ahora para ver que bases de datos ya existen ejecutaremos la siguiente instrucción.

SHOW DATABASES;

Y nos mostrara lo siguiente:

Ahora al ver que no hay una base de datos, con el nombre de nuestra base de datos que vamos a crear, la crearemos de la siguiente forma:

CREATE DATABASE nombredelabasededatos;

En este caso seria:

CREATE DATABASE Agenda;

Y nos deberá decir que: Query OK, 1 row affected (0.20 sec)

Ahora para crear una tabla dentro de nuestra base de datos ya creada primero debemos seleccionarla y posteriormente crear la tabla.

Para seleccionar nuestra base de datos colocamos lo siguiente:

USE nombredelabasededatos;

Así nos quedaría a nosotros:

Para crear una tabla se hace de la siguiente forma:

CREATE TABLE NombreTabla (aquí adentro se colocaran nuestros atributos que contendrán nuestra tabla separados por una coma asi como el tipo de dato que será, y entre paréntesis el tamaño de cada atributo);

Nuestro ejemplo quedaría de la siguiente forma:

CREATE TABLE Contacto (nombre varchar(20), apellidos varchar(40), teléfono integer(10), celular integer(10));

Ahora para corroborar que se ha creado nuestra tabla colocaremos lo siguiente:

DESCRIBE nombreTabla;

En nuestro caso seria:

DESCRIBE Contacto;

Y se nos mostraría lo siguiente:

Ahora ya corroborando nuestras tablas que coincidan a como las queremos proseguiremos a ingresar datos a la tabla que se hace de la siguiente forma:

INSERT INTO nombreTabla VALUES (Aquí hay que ingresar los datos en orden a los atributos antes realizados, si son textos tendrán que estar dentro de comillas simples, si son números se colocan de manera normal, cada atributo se separa por comas);

Para entender mejor los ejemplos de este ejercicio serían los siguientes:

INSERT INTO Contacto VALUES (‘Simon’, ‘Hernandez’, 45789865, 55784512);

INSERT INTO Contacto VALUES (‘Karen’, ‘Cruz, 12326598, 51232659);

Los insert's dependerán de cuantos registros quieran dar de alta en la base de datos.

Nota:

Recuerden que a la hora de insertar los datos debes ser con el orden de los atributos según se haya creado la tabla, ya que de lo contrario les marcara un error.

Esperamos que este post les haya servido para aquellos que apenas se adentran al mundo de las bases de datos, si te gusto no olvides recomendar el sitio para que seamos mas quienes aprendamos junto.

Siguenos por nuestras redes sociales. FACEBOOK, TWITTER y GOOGLE+

Introducción a MySQL

2014-05-22T22:46:00.000-05:00

Que tal compañeros hoy vamos a ver una introducción a lo que es MySQL, el cual es un gestor de base de datos que nos permite conectarnos a un servidor, donde podemos ejecutar consultas y ver resultados. Básicamente podremos guardar información y en base a esa información realizar ciertas consultas, con algunas condiciones pero esto lo veremos mas adelante.

Algunas de las características de este gestor de base de datos son:

Escrito en C y en C++
Funciona en diferentes plataformas.
APIs disponibles para C, C++, Eiffel, Java, Perl, PHP, Python, Ruby, y Tcl.
Proporciona sistemas de almacenamiento transaccionales y no transaccionales.
Proporciona sistemas de almacenamiento transaccionales y no transaccionales.

La instalación de MySQL se realiza de la siguiente forma:

Recuerden su usuario y su contraseña, ya que cada vez que inicien el servicio se los pedirá para poder acceder al gestor de base de datos.

Muy bien compañeros nos veremos en la próxima si te gusto síguenos por FACEBOOK, TWITTER y GOOGLE+, para que no te pierdas ninguna información.

JAVA: Sobrecarga de Metodos

2014-05-10T12:15:00.000-05:00

Que tal compañeros programadores, esperamos que estén listos así como nosotros para programar sin más vamos al tema.

Sobrecarga de métodos consiste en tener varios métodos que se llamen igual, pero con la única diferencia de que reciben parámetros completamente diferentes, por ejemplo:

Saludo() //No recibe ningún parámetro

Saludo(String nombre) //Recibe un parámetro de tipo cadena

Saludo(String nombre, int edad) //Recibe dos parámetros uno de tipo cadena y otro de tipo entero.

Y visto esto con código seria de la siguiente forma:

/*
 * Programa:Sobrecarga de metodos
 * Autor: Include Import
 */
package Clases;
public class Saluda {
 //Realizamos tres metodos que se llaman igual, pero resiben diferentes parametros
 public void Saludo(){
  System.out.println("Soy el primer metodo Saludo" +
    " y no resibo ningun parametro");
 }
 public void Saludo(String nombre){
  System.out.println("Hola que tal: "+nombre+
    " te saluda Include Import");
 }
 public void Saludo(String nombre, int edad){
  System.out.println("Hola que tal: "+nombre+
    " tu edad es: "+edad+", te saluda Include Import");
 }
 //Inicio de Main
 public static void main(String [] args){
  Saluda saludo = new Saluda();
  saludo.Saludo();
  saludo.Saludo("Luis");
  saludo.Saludo("Jose", 22);
 }
}

Y el resultado seria el siguiente:

Muy bien amigos hemos terminado el curso de java Básico, comenten que les gustaría ver en el curso de java avanzado.

No olvides seguirnos por nuestras redes sociales para que no te pierdas ninguna información. FACEBOOK, TWITTER y GOOGLE+

Hipervinculos en HTML

2014-05-03T08:13:00.002-05:00

Hola que tal programadores!!
El dia de hoy vamos a ver un tema super sencillo que son los hipervinculos.

Recuerden que al final pueden descargar la sesion del tema que se este viendo.

Para comenzar vamos a ver que etiquetas son las necesarias y que atributos ocuparemos para crear un hipervinculo:

<a href="nombre.extension">Este es un hipervinculo</a>

El atributo href Nos sirve para redireccionar ese texto hacia alguna otra pagina o direccion, podemos poner direcciones como "carpeta/nombre.extension" o bien "http://include-import.blogspot.mx"

Otros atributo que podemos ocupar es target en el que podemos ocupar los siguientes valores:

_blank: Este valor te abre una nueva pestaña
_parent: Te muestra el enlace en la misma pagina
_self: Es la forma predeterminada, es decir te abre el enlace en la misma ventana.
_ top: Abre el enlace en la ventana completa del navegador

Un ejemplo de como se ponen los valores anteriores es:

<a href="http://include-import.blogspot.mx" target="_self">Este es un hipervinculo </a>

Aveces queremos ponerle color al hipervinculo. Los atributos siguientes iran dentro de la etiqueta <body> ...</body>

Link : Este atributo mostrara un color a un enlace que no se ha visitado.
alink: Aqui mostrara un color cuando el link esta activo, es decir que acaba de ser pulsado
vlink: Muestra el color de enlaces que ya fueron visitados

La forma de colocar los atributos anteriores seria la siguiente:

<body link="red" alink="green" vlink="orange">

...

....

.....

</body>

Un ejemplo juntando los atributos y valores anteriores seria el siguiente:

Si quieren descargar el codigo den click en la siguiente imagen:

Hemos llegado al final de esta entrada, Se que fue muy cortita, pero creo que es información indispensable.

SI TIENEN ALGUNA DUDA COMENTEN !!

Siganos en FACEBOOK y TWITTER para que esten pendientes de nuestros proximos temas

Hasta la proxima !! B-)

Java: HERENCIA

2014-04-30T22:50:00.003-05:00

Que tal programadores!!

Hoy nos dimos a la tarea de explicar la herencia, el que comúnmente es temido en las escuelas por el echo de que lo dicen de manera que se ve tan complicada, pero hoooo! Sorpresa es muy sencillo, pero para ello necesitamos los siguientes temas para entenderlo.

Encapsulamiento
Constructor

La definición de herencia: Como su nombre lo dice, la herencia es una transmisión de datos, hacia alguien que lo necesite.

Para entender mejor esto, nos dimos la tarea de plantear el siguiente ejercicio en un diagrama.

Como podemos observar la clase PAPA o SUPERCLASE ya tiene atributos que son privados y que las clases que lo heredan pueden tener ese tipo de atributos, para utilizar los SET’s y los GET’s, ahora el código de las clases quedan de la siguiente forma.

Casa clase estará en un archivo diferente y en el mismo package.

Código de la Clase Persona.

public class Persona {
 private String Nombre;
 private String ApPaterno;
 private String ApMaterno;
 private int Edad;
 
 //SET's
 public void setNombre(String nombre){
  Nombre=nombre;
 }
 public void setApPaterno(String paterno){
  ApPaterno=paterno;
 }
 public void setApMaterno(String materno){
  ApMaterno=materno;
 }
 public void setEdad(int edad){
  Edad=edad;
 }
 //GET's
 public String getNombre(){
  return this.Nombre;
 }
 public String getApPaterno(){
  return this.ApPaterno;
 }
 public String getApMaterno(){
  return this.ApMaterno;
 }
 public int getEdad(){
  return this.Edad;
 }
 //Constructor que recibe 4 argumentos
 public Persona(String nom, String paterno, String materno, int edad){
  //se lo mandamos a los set para establecer los valores
  setNombre(nom);
  setApPaterno(paterno);
  setApMaterno(materno);
  setEdad(edad);
 }
 //Funciones o Metodos
 public void MostrarDatos(){
  System.out.println("::: PERSONA :::");
  System.out.println("Nombre: "+Nombre+
    "\nApellido Paterno: "+ApPaterno+
    "\nApellido Materno: "+ApMaterno+
    "\nEdad: "+Edad);
 }
}

Código de la Clase Estudiante.

//CLASE ESTUDIANTE QUE HEREDA DE PERSONA
 class Estudiante extends Persona{
  private String NomEscuela;
  private int numSemestre;
  //SET's
  public void setNombreEscuela(String escuela){
   NomEscuela=escuela;
  }
  public void setNumSemestre(int semestre){
   numSemestre=semestre;
  }
  //GET's
  public String getNombreEscuela(){
   return this.NomEscuela;
  }
  public int getNumSemestre(){
   return this.numSemestre;
  }
  //Constructor que recibe 6 argumentos
  public Estudiante(String nom, String paterno, String materno, int edad, String escuela, int semestre) {
   //Para heredar los atributos de la clase Persona utilizamos la palabra super
   //y dentro del parentesis escogemos las variables que queremos heredar
   super(nom, paterno, materno, edad);
   //Pasamos los datos a los SET que se reciben en el constructor
   setNombreEscuela(escuela);
   setNumSemestre(semestre);
  }
  //Funciones o Metodos
  public void MostrarDatos(){
   System.out.println("\n::: ESTUDIANTE :::");
   System.out.println("Nombre: "+super.getApMaterno()+
     "\nApellido Paterno: "+super.getApPaterno()+
     "\nApellido Materno: "+super.getApMaterno()+
     "\nEdad: "+super.getEdad()+
     "\nEscuela: "+NomEscuela+
     "\nSemestre: "+numSemestre);   
  }
}

Código de la Clase Empleado.

//CLASE EMPLEADO QUE HEREDA DE PERSONA
 class Empleado extends Persona{
  private int numEmpleado;
  private String Puesto;
  //SET's
  public void setNumeroEmpleado(int numero){
   numEmpleado=numero;
  }
  public void setPuesto(String puesto){
   Puesto=puesto;
  }
  //GET's
  public int getNumeroEmpleado(){
   return this.numEmpleado;
  }
  public String getPuesto(){
   return this.Puesto;
  }
  //Constructor que recibe 6 argumentos
  public Empleado(String nom, String paterno, String materno, int edad, int numero, String puesto){
   //Para heredar los atributos de la clase Persona utilizamos la palabra super
   //y dentro del parentesis escogemos las variables que queremos heredar
   super(nom, paterno, materno, edad);
   //Pasamos los datos a los SET que se reciben en el constructor
   setNumeroEmpleado(numero);
   setPuesto(puesto);
  }
  //Funciones o Metodos
  public void MostrarDatos(){
   System.out.println("\n::: EMPLEADO :::");
   System.out.println("Nombre: "+super.getApMaterno()+
     "\nApellido Paterno: "+super.getApPaterno()+
     "\nApellido Materno: "+super.getApMaterno()+
     "\nEdad: "+super.getEdad()+
     "\nEmpleado #: "+numEmpleado+
     "\nPuesto: "+Puesto);   
  }
}

Código de la Clase Principal.

//Creamos la clase principal 
 class Principal {
  public static void main(String [] args){
   //Creamos nuestros objetos y mandamos la informacion en orden
   Persona Jose = new Persona("Jose", "Ramires", "Hernandez", 40);
   Estudiante Pepe = new Estudiante("Luis","Rodriguez","Gomez", 20, "ESCOM",5);
   Empleado Maria = new Empleado("Maria","Iglesias","Jimenez", 35, 123456,"Analista");
   //Mandamos a llamar los datos resultantes de cada clase
   Jose.MostrarDatos();
   Pepe.MostrarDatos();
   Maria.MostrarDatos();
  }
}

Y todo este código o choro de código es para el siguiente resultado:

Como vieron la herencia no es tan complicada en JAVA a comparación de en C++, bueno compañeros esperamos que se haya entendido y si te gusto no olvides compartirlo con tus compañeros y sobre todo seguirnos en nuestras redes Sociales FACEBOOK, TWITTER y ahora por GOOGLE+.

TABLAS EN HTML

2014-04-26T09:30:00.000-05:00

Que tal programadores!!

El día de hoy veremos este tema que es muy interesante para los que apenas van empezando..

Es muy usual que cuando acomodemos imágenes o texto, no se alinean de la forma en la que queremos, pues la solución es colocar una tabla. Vamos a conocer las etiquetas que nos ayudaran a conformar una tabla:

ESTRUCTURA

Para entender mejor como se conforman las tablas veamos gráficamente como se compone:

ATRIBUTOS

Los siguientes atributos que mencionare, son opcionales, va a depender de que es lo que quieran poner cada uno en su tabla.

border ="1" Este atributo se ocupa para colocarle un tamaño al borde de la tabla, el "1" se puede cambiar por cualquier otro numero "2", "3"... dependiendo del grosor que quieran el borde.
align="center" Este atributo nos ayudara a alinear el texto que lo contiene o bien centrar la tabla va a depender de la etiqueta en que lo ocupes, tambien podemos ocupar "right", "left" y "center". (izquierda, derecha, centrado).
width="10" Este atributo es el ancho y se puede ocupar en pixeles "10" o en porcentajes "50%"
height="10" Este atributo es el alto de igual forma se puede colocar el tamaño en pixeles o en porcentaje "10" o "30%".
cellspacing="2" Espacio entre las celdas
cellpading="2" Es el espacio entre el contenido de las celdas y el borde.
bgcolor="red" Esta etiqueta es para colocarle un color a una celda o bien a toda la tabla. Puede escribirse el nombre del color en ingles o bien codigos hexadecimales ("red" o "#DF0101").
bordercolor="blue" Poner color en el borde de la tabla, pueden escribir su nombre en ingles o en hexadecimal ("blue" o "#0040FF")

Los siguientes atributos son muy importantes :

colspan="2" Quiere decir que ocuparemos dos celdas horizontalmente
rowspan="2" Quiere decir que ocuparemos dos celdas verticalmente

EJERCICIO O EJEMPLO

Vamos a realizar un ejemplo de lo que antes ya vimos, vamos a plantear un tipo de tabla graficamente y esa misma la pasaremos a codigo. Recuerden que al final de esta publicacion pueden descargar el ejercicio que realicemos.

Ahora vayamos al código, recuerden antes poner su estructura básica :

Y EL RESULTADO FINAL !!

HEMOS LLEGADO AL FINAL DE ESTA PUBLICACION!!

SI tienen alguna duda comenten !!

o siganos en FACEBOOK Y TWITTER

NOS VEMOS A LA PROXIMA B-) !!

JAVA: Constructor

2014-04-19T08:00:00.000-05:00

Que tal programadores!!

Hoy vamos a ver un tema bastante interesante que son los CONSTRUCTORES, además de agregar lo anterior que fue ENCAPSULAMIENTO.

Para comenzar definiremos un Constructor como una parte importante de una clase porque nos permite inicializar variables que se encuentran encapsuladas.

Debemos considerar las siguientes características:

1. Debe tener el mismo nombre que la clase

2. Los constructores aceptan variables pero no retornan

3. Siempre deben tener visibilidad publica

Ahora para entender mejor, lo de los constructores realizaremos el siguiente ejercicio.

Y nuestro ejercicio codificado es el siguiente:

public class Rectangulo {
     private double Base;
     private double Altura;
     //SET's
     public void setBase (double base){
         this.Base=base;
     }
     public void setAltura(double altura){
         this.Altura=altura;
     }
     //GET's
     public double getBase(){
         return this.Base;
     }
     public double getAltura(){
         return this.Altura;
     }
     //Constuctor que recibe parametros y se los pasa a los SET'S 
     //para establecerlos a los datos private
     public Rectangulo(double base, double altura){
         setBase(base);
         setAltura(altura);
     }
     //Funciones
     public void Area(){
         System.out.println("El area del rectangulo es: "+(this.Base*this.Altura));
     }
     public void Perimetro(){
         System.out.println("El perimetro del rectangulo es: "+(2*(this.Base)+2*(this.Altura)));
     }
     public static void main(String[] args) {
         Scanner leer = new Scanner(System.in);
         double base, altura;
         System.out.println(":::R E C T A N G U L O:::");
         System.out.print("Ingresa la base: ");
         base=leer.nextDouble();
         System.out.print("Ingresa la altura: ");
         altura=leer.nextDouble();
         //Instanciamos nuestro Rectangulo y le mandamos los datos al constructor
         Rectangulo rectangulo = new Rectangulo (base,altura);
         //Mostramos los resultados
         rectangulo.Area();
         rectangulo.Perimetro();
     }
}

El resultado es el siguiente:

Muy bien compañeros programadores espero que les haya gustado este tema tan interesante de manejar, así que no olvides que suscribirte a nuestras redes sociales (FACEBOOK y TWITTER) ya que son GRATIS!!!!!!!.....

INSERTAR IMAGEN EN HTML

2014-04-17T09:19:00.002-05:00

Que tal programadores !!

El día de hoy veremos como insertar una imagen en html.

Comencemos !!

Antes de pasar a la etiqueta que nos permitirá insertar una imagen necesitamos saber lo siguiente:

Es recomendable que dentro de una carpeta que se llame "insertar imagenes" (o el nombre que gusten) este otra carpeta llamada "imagenes" y nuestros html como en la siguiente representación:

al abrir la carpeta

Al hacer lo anterior nos facilita el llevar y traer nuestra pagina a cualquier lado ademas de que la ruta que se le colocara a las imagenes sera corta por ejemplo esta imagenes/miimagen.extencion de lo contrario sera C:/users/usuario/imagenes/micarpeta/miimagen.extencion y esto provocara que cuando quieras llevártela en tu usb tendras que buscar las imagenes insertadas y si se te olvida alguna no correra tu pagina web.

Para insertar una imagen es muy sencillo solo necesitaremos una etiqueta llamada <img> vamos a ver como se utiliza

Primero debemos escribir la estructura necesaria para que podamos visualizar nuestra pagina de html CLIC PARA CONOCER LA ESTRUCTURA BASICA.
Vamos a colocar entre las etiquetas <body>... </body> el siguiente codigo:

en donde extencion puede ser: jpg, png, gif,... etc.(formatos de imagen).

3. Si la imagen excede los limites deseados o nosotros deseamos que se vea mas grande vamos a escribir los atributos width (ancho) y height (alto) y colocaremos el numero de pixeles de la imagen (por lo general para que se vea una pagina bien en cualquier pantalla son 1000 px)
<img src="ruta/de/imagen.extencion" width="600" height="300">

AHORA HAGAMOS UN EJEMPLO !!

En mi carpeta de imagenes tengo una imagen que se llama logo y es de extencion .png tambien veo que sus dimensiones son de 312px de ancho y 174px de altura por lo que la hare mas grande.
El código para colocar esta imagen SIN anchura ni tamaño seria el siguiente:

3. Ahora pondre debajo del primer <img> otro pero con dimensiones (anchura y altura) para agrandar la imagen

4. Ahora veamos si lo abrimos en un navegador que es lo que observamos:

Si desean descargar esta practica den click en el siguiente link

insertarImagenes.rar

Hemos terminado con nuestra practica

Si tienen alguna duda COMENTEN

Sigannos en FACEBOOK y TWITTER para que estén pendientes de los siguientes temas

NOS VEMOS A LA PROXIMA !!

Java: Encapsulamiento

2014-04-16T08:00:00.000-05:00

Que tal programadores!!

Ahora vamos a continuar con lo de encapsulamiento con el tipo de dato PRIVATE, para ello vamos a plantear un diagrama UML, para ejemplificarlo de la mejor forma y es el siguiente:

Este problema nos indica lo siguiente:

Nombre de la clase: Persona

Datos privados: Nombre, Edad, Profesión

Funciones públicas: Mostrar Datos

Cuando se colocan los datos privados quiere decir que únicamente la clase puede tener acceso a esos datos, ni el mismo main puede acceder así que para poder utilizar esos datos vamos a necesitar la ayuda de la palabra THIS que hace referencia a las variables privadas:

SET: Es una FUNCION que nos va a permitir manipularla desde el main, y estamos apuntando hacia la variable que está en modo privado para que pueda ser accesada.

GET: Es una FUNCION que nos va a permitir visualizar la variable si la invocamos desde el main.

Retomando el problema con respecto a los datos privados quedarían de la siguiente forma:

//SET
     public void setNombre(String nombre){
         this.nombre=nombre;
     }
     public void setEdad(int edad){
         this.edad=edad;
     }
     public void setProfesion(String profesion){
         this.profesion=profesion;
     }
//GET
     public String getNombre(){
         return this.nombre;
     }
     public int getEdad(){
         return this.edad;
     }
     public String getProfesion(){
         return this.profesion;
     }

Como se darán cuenta que por cada dato private tenemos un set y un get, para almacenar información en el SET y después mostrarla mediante el GET desde el main.

Ahora para terminar este ejercicio pediremos al usuario estos datos y los pasaremos a los set’s y después los mostraremos mediante los get’s. Y el código quedo de la siguiente manera:

public class Persona {
     private String nombre;
     private int edad;
     private String profesion;
     //SET
     public void setNombre(String nombre){
         this.nombre=nombre;
     }
     public void setEdad(int edad){
         this.edad=edad;
     }
     public void setProfesion(String profesion){
         this.profesion=profesion;
     }
     //GET
     public String getNombre(){
         return this.nombre;
     }
     public int getEdad(){
         return this.edad;
     }
     public String getProfesion(){
         return this.profesion;
     }
     //Función
     public void MostrarDatos(){
         System.out.println(": : :T U S  D A T O S : : :");
         System.out.println("Nombre: "+this.nombre);
         System.out.println("Edad: "+this.edad);
         System.out.println("Profesion: "+this.profesion);
     }
     public static void main(String[] args) {
         Scanner guardar = new Scanner(System.in);
         //Declaramos nuestras variables
         String nomIngresado, profIngresada;
         int edadIngresada;
        
         //Instanciamos nuestro objeto persona
         Persona Hombre = new Persona();
        
         //Pedimos los datos
         System.out.println("Ingresa tu nombre:");
         nomIngresado=guardar.next();
         System.out.println("Ingresa tu edad: ");
         edadIngresada=guardar.nextInt();
         System.out.println("Ingresa tu profesion: ");
         profIngresada=guardar.next();
        
         //Mandamos la informacion a los SET's de cada variable PRIVATE
         Hombre.setNombre(nomIngresado);
         Hombre.setEdad(edadIngresada);
         Hombre.setProfesion(profIngresada);
        
         //Mandamos a llamar la funcion MostrarDatos
         Hombre.MostrarDatos();
     }
}

Resultado Final:

Ahora para mostrar los datos mediante los GET’s es necesario colocar las siguientes líneas dentro del main y quitando el método MostrarDatos.

System.out.println(": : :T U S  D A T O S : : :");
System.out.println("Nombre: "+Hombre.getNombre());
System.out.println("Edad: "+Hombre.getEdad());
System.out.println("Profesion: "+Hombre.getProfesion());

NOTA:

SETTERS: esta función siempre debe aceptar una variable, esta variable puede ser con el mismo nombre o diferente, se recomienda con el mismo nombre. Dentro de esta función colocamos un “this” quiere decir que apuntaremos a la variable que acaba de recibir y daremos el mismo valor a la variable que se encuentra en modo privado.

GETTERS: Esta función es importante si se desea utilizar en el main, por lo que siempre va a retornar el mismo tipo de dato del que recibió en el SET, y retornara la variable privada para ser mostrada dentro del main.

Muy bien, hasta aquí el post del dia de hoy, espero que les haya gustado y no olvides unirte a nuestras redes sociales FACEBOOK y TWITTER, es GRATIS!!!.

Tipo PUBLIC en java

2014-04-12T08:00:00.000-05:00

Que tal compañeros programadores!!

Hoy vamos a ver el control a acceso a los miembros de la clase, los cuales pueden ser de tipo PUBLIC, PRIVATE, PROTECTED. En donde con estos datos existe el tema de ENCAPSULAMIENTO, la cual definiremos como el nivel de seguridad que se le brinda a la CLASE para que esta tenga o no acceso.

Se utiliza cuando:

Private: Únicamente la clase donde se encuentran estos atributos tendrán acceso
Protected: Acceso dentro de esa clase y clases heredadas.
Public: Cualquier clase tiene acceso

Para entender aún mejor este tema vamos a realizar un ejercicio utilizando el tipo de acceso PUBLIC, como se mencionó anteriormente cualquier método o clase puede tener acceso a la información.

Ejercicio:

Realizar el siguiente diagrama UML.

El código es el siguiente:

import java.util.Scanner;
public class Computadora {
        //Declaramos las vairables de manera publica a como el diagrama
        public String Marca;
        public int memoria;
        public double costo;
        public int garantia;
        //Metodos
        public void PedirDatos(){
                //Creamos nuestra clase Scanner para guardar los datos
                Scanner leer = new Scanner (System.in);
                //Pedimos los datos y los guardamos en cada una de las variables
                System.out.println("Ingresa la marca: ");
                Marca=leer.nextLine();
                System.out.println("Ingresa la memoria RAM: ");
                memoria=leer.nextInt();
                System.out.println("Ingresa el costo: ");
                costo=leer.nextDouble();
                System.out.println("Ingresa la garantia: ");
                garantia=leer.nextInt();
        }
        public void MostrarDatos(){
                System.out.println("Marca: "+Marca+"\nMemoria RAM: "+memoria+" Gb\nCosto: $"+costo+
                                "\nGarantia: "+garantia+" año");
        }
        public static void main(String[] args) {
                //Creamos un objeto de la clase computadora
                Computadora mipc = new Computadora();
                //Mandamos a llamar los metodos que hemos creado
                mipc.PedirDatos();
                mipc.MostrarDatos();
        }
}

El resultado es:

Muy bien compañeros espero que les haya gustado este tema sobre el acceso de tipo PUBLIC, no olvides comentarnos tus dudas o sugerencias con respecto a los ejercicios mostrados.

No te vayas sin antes seguirnos por nuestras redes sociales FACEBOOK y TWITTER, para que no te pierdas ninguna información.

Resaltado de texto

2014-04-11T20:33:00.001-05:00

Que tal programadores !!
El día de hoy veremos con que etiquetas podemos resaltar un texto, es decir subrayarlo, ponerlo cursiva, tachado, negrita, etc etc..
Recuerden que para poder ser expertos, se necesita primero empezar con lo basico...
Sin mas comencemos analizando algunas de las etiquetas que nos van a servir para resaltar un texto:

1. Texto en cursiva o itálica:

Para hacer un resaltado tipo italica podemos hacerlo con varias etiquetas aqui mostrare 3:

<i> Cursiva con etiqueta-- i --</i> (Esta es la mas común).
<em> Cursiva con etiqueta-- em --</em>
<dfn> Cursiva con etiqueta --dfn--</dfn>

2. Texto en negrita o bold:

Esta de igual forma se pueden hacer con varias etiquetas aquí enumerare 2:

<b> Negrita con etiqueta--b-- </b>
<strong> Negrita con etiqueta--strong--</strong>

3. Texto con subrayado:

Para subrayar un texto tenemos que ponerlo entre las siguientes etiquetas:

<u> Subrayado con etiqueta -- u -- </u>
<ins> Subrayado con etiqueta -- ins -- </ins>

4. Texto ~~tachado~~

Para tachar un texto necesitamos ponerlo entre las siguientes etiquetas:

<strike> Tachado con etiqueta --strike-- </strike>
<del> Tachado con etiqueta --del -- </del>

5. Texto con subindice

Para colocar un subindice, es decir una palabra o texto que sea mas pequeño y que aparezca abajo de la linea normal del texto.

Este es un <sub> subindice </sub>

6. Texto con superindice

Texto que es mas pequeño pero que se encuentra en la parte superior del texto normal

Este es un <sup> superindice </sup>

Ahora coloquemos todas las etiquetas antes vistas en un html con su estructura basica, aqui dejare un codigo :

<!DOCTYPE html>
<html>
<head>
<title>
RESALTADO DE TEXTO
</title>
</head>
<body>
<font face="Comic Sans MS" color="BLACK" size="4">
ITALICA
<br>
<dfn>dfn: include-import.blogspot.com</dfn>
<br>
<em>em: include-import.blogspot.com</em>
<br>
<i>i: include-import.blogspot.com</i>
<br><br>
NEGRITA:
<br>
<b>b: include-import.blogspot.com</b>
<br>
<strong>strong: include-import.blogspot.com</strong>
<br><br>
SUBRAYADO:
<br>
<u>u: include-import.blogspot.com</u>
<br>
<ins>ins: include-import.blogspot.com</ins>
<br><br>
TACHADO:
<br>
<strike>strike: include-import.blogspot.com</strike>
<br>
<del>del: include-import.blogspot.com</del>
<br><br>
SUBINDICE
<br>
sub: include-<sub>import</sub>.blogspot.com
<br><br>
SUPERINDICE:
<br>
sup: include-<sup>import</sup>.blogspot.com
</font>
</body>
</html>

Lo que obtendremos seria lo siguiente:

Finalmente para colocar en un texto mas de una etiqueta primero debemos cerrar la ultima que abrimos, aqui dejare un ejemplo :

<!DOCTYPE html>
<html>
<head>
<title>
RESALTADO DE TEXTO
</title>
</head>
<body>
<font face="Comic Sans MS" color="BLACK" size="4">

<strike>No olvides visitar nuestros <sup><i>nuevos temas</i></sup> en</strike> <u><b>www.include-import.blogspot.com<b></u>

</font>
</body>
</html>

Y el resultado de compilar el código anterior seria el siguiente:

Hemos llegado al final de esta publicación :(

Pero esperen los nuevos temas y para eso estén pendientes mediante FACEBOOK y TWITTER ,

Si tienen alguna duda COMENTEN !!

Nos leemos a la próxima.. B-)

Java: Arreglos parte2

2014-04-05T08:00:00.000-06:00

Que tal compañeros programadores!!!!

Hoy vamos a ver la segunda parte de los arreglos, en donde vamos a realizar un ejercicio con un arreglo indefinido, esto quiere decir que el arreglo no sera definido por nosotros si no por el usuario. Ahora bien este arreglo puede ser recorrido de igual forma, para manipular los datos que contenga, para ello lo mostraremos en dos ejercicios que se muestran a continuación.

Necesitamos saber:

Ejercicio 1.

Realizar un arreglo de números, y que este sea definido por el usuario, además de invertir sus datos ingresados. Mostrar el resultado en pantalla.

Código:

public static void main(String [] args){
       int x[],temp;
       Scanner leer=new Scanner(System.in);
       int n, i, j;
       do{
           System.out.println("Cantidad de elementos del arreglo");
           n=leer.nextInt();
       //mientras sea un numero negativo o un numero grande se realizara el ciclo
       }while(n<=0 || n>100);
       //le damos un tamaño a nuestro arreglo con el valor del usuario
       x=new int[n];
       //le pedimos al usuario que ingrese los datos y guardamos en cada posicion del arreglo
       for(i=0;i<n; i++){
           System.out.println("x["+i+"]:");
           x[i]=leer.nextInt();
       }
       //Mostramos el arreglo con los valores que tiene
       System.out.println("Arreglo Ingresado");
       for(i=0;i<n; i++)
           System.out.println("x["+i+"]:");
       /*Recorremos el arreglo desde la posicion i, pero a la par recorremos el arreglo desde la ultima
       posicion, esto para invertir la cadena utilizando una variable temporal, la cual nos permitira
       alojar el valor mientras lo recorremos e invertimos la cadena*/
       for(i=0,j=n-1; i<n/2;i++,j--){
           temp=x[i];
           x[i]=x[j];
           x[j]=temp;
       }
       //Por ultimo mostramos el arreglo invertido
       System.out.println("Arreglo Invertido ");
       for(i=0; i<n; i++)
           System.out.println("x["+i+"]:"+x[i]);

   }
}

Resultado:

Ejercicio 2.

Programa para ingresar n elementos en un arreglo y luego reportarlo en la pantalla. Además ingresar un numero y verificar si este se encuentra en el arreglo, si se encuentra reportar la posición donde se encontró y si no se encontró reportar “numero no se encuentra”.

Código:

public static void main(String [] args){
        Scanner leer=new Scanner(System.in);
        int n,buscar,posicion=0;
        int x[];
       //Pedimos los datos mientras que el numero dado no sea negativo
        do{
            System.out.print("Numero de elementos de los vectores : ");
            n=leer.nextInt();
        }while(n<=0);
        x=new int[n];//Creamos el arreglo conforme el tamaño dado por el usuario
        System.out.println("Ingresa los valores del arreglo:");
       //Pedimos los numeros y lo guardamos en cada posicion del arreglo
        for(int i=0;i%lt;n; i++){
            System.out.print("X["+i+"]=");
            x[i]=leer.nextInt();      
        }
       //Mostramos sus datos que estan en el arreglo
        System.out.println("Tus datos son:");
        for(int i=0;i<n; i++){
            System.out.println("X["+i+"]="+x[i]);     
        }
       //Le pedimos un numero, para buscarlo en el arreglo
        System.out.println("Ingresa un numero a buscar: ");
        buscar=leer.nextInt();
       //Recorremos el arreglo para buscar el numero que nos dieron
        for(int i=0;i<n; i++){
       /*si el numero dado es igual al dato que esta guardado en la posicion del arreglo, la posicion       
            va a ser igual al contador i*/
            if(x[i]== buscar)
                posicion=i;
        }
       /*Si nuestra posicion es menor a n mostrara la posicion y el numero que se busco, de lo             
        contrario nos mostrara tu numero no se encuentra en el arreglo*/
        if (posicion<n)
            System.out.println("Tu numero esta en la posicion: X["+posicion+"]="+buscar);
        else
            System.out.println("Tu numero no se encuentra en el arreglo");

    }

Resultado:

Muy bien compañeros espero que les haya gustado estos dos ejercicios, donde se ve claramente como se recorre un arreglo.

Si hubo algo que no hayas entendido coméntalo y con gusto te contestaremos.

Síguenos por FACEBOOK y TWITTER para que no te pierdas de ningun detalle sobre este lenguaje XD.

Java: Arreglos parte 1

2014-03-29T09:28:00.000-06:00

Que tal compañeros programadores!!!

Hoy nos toca ver el tema de arreglos, para ello definimos un arreglo como: un grupo de variables, que contienen valores, todos del mismo tipo.

Para declarar un arreglo es de la siguiente forma:

Int [] arreglo; //se declara el arreglo el cual puede ser de cualquier tipo de dato

arreglo=new int[ //tamaño]; //se crea el arreglo y este puede ser ya definido o indefinido en cuanto al tamaño del arreglo.

Ahora la forma resumida seria la siguiente:

Int [] arreglo=new int[//tamaño]

Ambas declaraciones son válidas, ya ustedes usaran con el que más se acomoden para usar los arreglos. Cabe mencionar que los arreglos tienen posición y cada una de las posiciones podemos almacenar información y después consultarla, así que vamos a hacer ejercicios para entender mejor esto.

Ahora para ejemplificar esto realizaremos un ejercicio, donde asignamos valores manualmente y lo recorremos con el uso de un FOR, el código es el siguiente:

Resultado es:

Vamos a realizar otro ejercicio donde definiremos un arreglo y mostraremos sus datos almacenados. Y el código es el siguiente:

Resultado es:

Muy bien programadores, hasta aquí hemos concluido por el día de hoy, esperen más informacion de los arreglos.

Síguenos por FACEBOOK y TWITTER para que no te pierdas de nuestros siguientes post.

TEXTO: tildes, acentos, etc..

2014-03-29T07:40:00.000-06:00

Que tal programadores !!

Como nos habremos dado cuenta, si en el codigo de html escribimos palabras que contengan caracteres especiales, es decir acentos , tildes etc (mamá, niño..), nos aprecera un simbolito en lugar de la letra (MamÃ¡ NiÃ±o).
El dia de hoy veremos como hacer que aparezcan esos caracteres especiales

La lista de abajo, muestra algunos de los caracteres mas conocidos y cual va a ser su forma de representarlo cuando lo escribamos en el codigo HTML

Ahora veamos un ejemplo codificado ya en cada uno de ellos para ver como es que se comporta cada uno de los caracteres anteriores

<!DOCTYPE html>
<html>
<head>
   <title>
      Caracteres especiales
   </title>
</head>
<body>
   <font face="Comic Sans MS" color="green" size="5">
     ------------------------------ACENTO-----------
     <br>
     Mamá
     EDUCACIÓN
     <br>
     ------------------------------TILDE-----------
     <br>
     Niño
     AÑEJO
     <br>
     ------------------------------DIERESIS-----------
     <br>
     pingüino
     ANTIGÜEDAD
     <br>
     ------------------------------INTERROGACION------
     <br>
     ¿Cuanto cuesta?
     <br>
     ------------------------------ADMIRACION---------
     <br>
     ¡ Llegaste !
     <br>
     ------------------------------COMILLAS------
     <br>
     "IMPORTANTE"
     <br>
     ------------------------------COPYRIGHT------
     <br>
     Derechos reservados &copy include-import
     <br>
   </font>
</body>
</html>

NOTAS IMPORTANTES:

<br> Esta etiqueta es un salto de linea, es decir un enter.

EL resultado final de el codigo anterior seria el siguiente

Bueno hemos terminado esta publicacion :-(

Pero nos veremos la proxima semana con mas temas interesantes

SI tienen dudas COMENTEN con gusto les contestaremos

Siganos en FACEBOOK y TWITTER para que estén pendientes de nuestros nuevos temas :o

HASTA LA PROXIMA ! B-)

Utilización de la clase MATH en java

2014-03-26T08:00:00.000-06:00

Que tal programadores!!!

Espero que anden de lo mejor en este día, donde vamos aprender sobre las constantes de MATH, básicamente nos servirá para utilizar operaciones ya están definidas en la clase MATH, las cuales nos pueden funcionar a la hora de realizar alguna operación. Ahora algunas de las operaciones son:

Método	Descripción	Ejemplo
Abs(x)	Es el valor absoluto	abs(5.2) es 5.2 abs(0.0) es 0.0 abs(-5.2) es 5.2
Ceil(x)	Redondea el valor de x al número mayo	ceil(9.2) es 10 ceil(-6.8) es 6
Cos(x)	Realiza la operación de coseno	Cos(0.0) es 1
Exp	Es el método exponencial E^x	Exp(1.0) es 2.71828
Floor(x)	Redondea el valor de x al número menor	Floor(8.2) es 8 Floor(-8.7) es -9
Log(x)	Logaritmo natural de x	Log(Math.E) es 1.0
Max(x,y)	Determina el valor más grande entre X y Y	Max(2.3, 10.5) es10.5
Min(x,y)	Determina el valor más pequeño entre X y Y	Min(5, -2.3) es -2.3
Pow(x,y)	X se eleva a la potencia de Y	Pow(2,3) es 8
Sin(x)	Realiza la operación seno	Sin(0.0) es 0.0
Sqrt(x)	Realiza la raíz cuadrada	Sqrt(900) es 30
Tan(x)	Realiza la operación de tangente	Tan(0.0) es 0.0

Todas las operaciones anteriores las pueden comprobar con una calculadora científica o de lo contrario a programarJ.

Ahora voy a realizar un programa que muestre algunos de los métodos ya expuestos en la tabla de arriba y el código es el siguiente.

Codigo:

public static void main(String [] args){
     double x=16.0, y=2;

     System.out.println("El resultado de la raiz es: "+Math.sqrt(x));
     System.out.println("El resultado de la potencia es:"+Math.pow(x, y));
     System.out.println("El valor mas grande es:"+Math.max(x,y));                     System.out.println("El valor minimo es: "+Math.min(x, y));
}

Como resultado del ejercicio:

Muy bien amigos hemos llegado al fin de este post, esperamos que haya sido de gran utilidad y si ya los sabían no se preocupen, nunca esta demás recordar.

Síguenos por FACEBOOK y TWITTER para que estés al pendiente de nuestras actividades.

Etiquetas para Edición de Texto

2014-03-23T08:29:00.000-06:00

Hola que tal programadores !!

En el tema de hoy veremos algunas etiquetas para modificar un texto por ejemplo con la fuente, el tamaño, el color, etc etc...

Pero antes si no tienen conocimiento sobre la estructura básica les recomiendo visitar el siguiente link:

INTRODUCCIÓN - Estructura Básica en HTML

Comencemos :

Una de las etiquetas mas importantes y comunes para poder modificar el tamaño del texto son las etiquetas <h1></h1>....hasta .... <h6></h6> en donde , mientras el numero del lado derecho de la 'h' si es mas grande la letra es mas chica veamos como se comporta cada uno:

<h1>

La etiqueta H1 Se utiliza para escribir titulos

</h1>

<h2>

La etiqueta H2 Se utiliza para subtitulos

</h2>

Como nos damos cuenta mientras sea mas grande el numero la letra es mas pequeña, esta etiqueta llega hasta el numero 6

</h3> </h4> </h5> </h6>

EJEMPLO UTILIZANDO CADA UNA DE LAS ETIQUETAS ANTERIORES

y lo que obtendremos si lo abrimos en un navegador seria lo siguiente:

Sigamos con la siguiente etiqueta que tenemos que aprender

<font>

Esta etiqueta si la traducimos al español es fuente, quiere decir que podrán poner el tipo de letra que gusten, tambien colocarle un color, el tamaño de letra, etc.

</font> También esta etiqueta tiene una etiqueta de cierre

Para esta etiqueta realizaremos un ejemplo con las siguientes modificaciones a cualquier texto :

TIpo de letra : Le colocaremos letra Comic Sans MS

Añadiremos un color:

NOTA: Los colores pueden ser sus nombres en ingles, red, green, blue, pink, etc etc.

Finalmente colocaremos un tamaño de 6 (Este tamaño se define en pixeles, pueden jugar con los números para que se den cuenta de lo que pasa)

<font face="Comic Sans MS" color="green" size="12">

El código completo de esta etiqueta seria el siguiente

y lo que veremos si lo ejecutamos con el navegador seria lo siguiente : )

BUENO PROGRAMADORES HEMOS LLEGADO AL FINAL DE ESTA PUBLICACION : (

No olviden comentar si tienen dudas, con gusto les responderemos B-)

Siganos en FACEBOOK Y TWITTER para que esten pendientes de nuestros siguientes temas

HASTA LA PROXIMA !!