Fotos de las SICS

Mentiras

Hoy ehh estado con mi noviaa en el  Carnaval de veracruz y como siempre desmotivacion completada de mi novia al dacirmeee q iba a ir con ellaa y q no podiaa ver viejass uenas es la peor desmotivacion q puede aver en la vida.

Area Restringida!!!

Una buena- de echo execelente paguina de Cositas Medias Hackers es:

http://area-r.blogspot.com/

Security & Networking: USB FL-2016G con chipset RTL8187 en Ubuntu 11.10

Security & Networking: USB FL-2016G con chipset RTL8187 en Ubuntu 11.10: Aquí se muestra el FL-2016G en acción desde Ubuntu en su versión 11.10. El FL-2016G es un dispositivo USB también conocido como el dragon qu...

Usar la Clase SCANNER para la entrada de Datos

Los objetos de salida estándar System.out permiten a las aplicaciones de Java mostrar caracteres en la ventana de comandos. De manera similar, el objeto que veremos en este post, llamado el objeto de entrada estándar System.in permite a las aplicaciones de Java leer la información escrita por el usuario.

Los programas recuerdan números y otros datos en la memoria de la computadora y acceden a esos datos a través de elementos del programa conocidos como variables. En esto post veremos una aplicación donde utilizaremos estos variables para que realicen una operación de suma de dos enteros introducidos por el usuario mediante el teclado.

//Programa que muestra la suma de dos enteros.
import java.util.Scanner; // Este programa usa la clase Scanner

public class Suma
{
 public static void main ( String args[] )
 {
  Scanner entrada = new Scanner( System.in );
  
  int valor1; // Primer Numero a sumar
  int valor2; // Segundo Numero a sumar
  int suma;   // Suma de valor1 y valor2
  
  System.out.print( "Escriba el primer numero a sumar: ");
  valor1 = entrada.nextInt(); // Lee el primer numero del usuario
  
  System.out.print( "Escriba el segundo numero a sumar: ");
  valor2 = entrada.nextInt(); // Lee el segundo numero del usaurio
  
  suma = valor1 + valor2; // Suma el valor1 + valor2
  
  System.out.printf( "La suma es %d\n", suma); // Muestra el resultado
 }
}

Programa que calcula la suma y muestra el resultado en consola.

Salida del Programa.
Escriba el primer numero a sumar: 50
Escriba el segundo numero a sumar: 75
La suma es 125

import java.util.Scanner; // Este programa usa la clase Scanner

La declaración import indica que este programa utiliza la clase Scanner predefinida de Java del paquete java.util.

Scanner entrada = new Scanner( System.in );

La línea anterior es una instrucción de declaración de variable (también conocido como declaración), la cual especifica el nombre (entrada) y tipo (Scanner) de una variable utilizada en este programa. Una variable como lo mencionamos, es una ubicación en la memoria de la computadora, en donde se puede guardar un valor para utilizarlo posteriormente en un programa. Todas las variables deben declararse con un nombre y un tipo antes de poder usarse. Este nombre permite al programa acceder el valor de la variable en memoria y puede ser cualquier identificador valido. El tipo de una variable especifica el tipo de información que se guarda en esa ubicación de memoria. Al igual que los demás instrucciones, las instrucciones de declaración terminan con un punto y como (;).

Entonces la variable llamada entrada es de tipo Scanner. Un objeto Scanner permite a un programa leer datos (como números) para usarlos. Los datos pueden provenir de muchas fuentes, como archivos de disco o datos de teclado. Antes de usar el objeto Scanner, primero debemos crearlo y especificar el origen de los datos.

El signo ( = ) indica que la variable entrada tipo Scanner debe inicializarse en su declaración con el resultado de la expresión new Scanner ( System.ini ) a la derecha del signo igual. Cuando decimos que la variable entrada tipo Scanner debe inicializarse, significa que hay que prepararla para usarla en el programa. Así que esta expresión crea un objeto Scanner que lee los datos escritos por el usuario mediante el teclado.

int valor1; // Primer Numero a sumar
int valor2; // Segundo Numero a sumar
int suma; // Suma de valor1 y valor2

Las líneas anteriores declaran que las variables valor1, valor2 y suma contienen datos de tipo int. Estas variables pueden contener valores enteros. Las instrucciones de declaración de variables pueden dividirse en varias líneas, separando los nombres de las variables por comas. Por ejemplo, las líneas anteriores se pueden declarar como una sola instrucción, de la siguiente manera.

int valor1, int valor2, int suma; // Declaración de variables en una sola instrucción.

El seleccionar nombres de variables significativos ayudan a que un programa se mas fácil de entender con solo leerlo.

System.out.print( "Escriba el primer numero a sumar: ");

Estas líneas utilizan System.out.print para mostrar el mensaje "Escriba el primer número a sumar: ". Ese mensaje se conoce como indicador, ya que indica al usuario que debe realizar una acción específica, en este caso a que introduzca el primer número a sumar. Los identificadores que empiezan con letras mayúsculas representan nombre de clases. Por lo tanto, System es una clase que forma parte del paquete java.lang. Esta clase (System) no se importa con una declaración import al principio del programa ya que el paquete java.lang se importa de manera predeterminada en todos los programas de Java. Las clases que se encuentran en el paquete java.lang son las únicas que no requieren una declaración import.

valor1 = entrada.nextInt(); // Lee el primer numero del usuario

La línea anterior utiliza el método nextInt del objeto entrada de la clase Scanner para obtener un entero introducido por el usuario. El resultado de llamar al método nextInt (un valor int) se coloca en la variable valor1 mediante el uso del operador de asignación =. La instrucción se lee como valor1 obtiene el valor de entrada.nextInt(). El operador = se le llama operador binario, ya que tiene dos operandos, valor1 y el resultado de la llamada al método entrada.nextInt(). Esta instrucción se le llama instrucción de asignación, ya que asigna un valor a una variable. Todo lo que esta después (a la derecha= del operador de asignación (=) se evalúa siempre antes de realizar la asignación.

System.out.print( "Escriba el segundo numero a sumar: ");

Pide al usuario que introduzca el segundo numero a sumar.

valor2 = entrada.nextInt(); // Lee el segundo numero del usuario

Lee el segundo numero introducido por el usuario y lo asigna a la variable valor2.

suma = valor1 + valor2; // Suma el valor1 + valor2

Esta línea es una instrucción de asignación que calcula la suma de las variables valor1 y valor2 y asigna el resultado de estos dos variables a la variable suma mediante el uso del operador de asignación =. La instrucción se lee como suma obtiene el valor de valor1 + valor2. La mayoría de los cálculos se realizan en instrucciones de asignación. Cuando el programa encuentra la operación de suma utiliza los valores almacenados en las variables valor1 y valor2 para realizar el cálculo. La operación de suma es binaria, sus dos operandos son valor1 y valor2. Las partes de las instrucciones contienen cálculos que se llaman expresiones.

System.out.printf( "La suma es %d\n", suma); // Muestra el resultado

Una vez realizado el cálculo, se utiliza el método Sistem.out.printf para mostrar la suma en la consola. El especificador %d es un receptáculo para un valor int, en este caso, el valor de suma, la letra d representa entero decimal. El método printf imprime en pantalla “La suma es “, seguido del valor de suma y una nueva línea. Los cálculos también pueden realzarse dentro de la instrucción printf, en este caso, también podríamos haberlo hecho de la siguiente manera.

System.out.printf( "La suma es %d\n", ( valor1 + valor2 ) );

Los paréntesis alrededor de la expresión valor1 + valor2 no son requeridos;

Otro ejemplo sencillo utilizando la clase Scanner.

import java.util.Scanner;

public class ClaseScanner 
{
 public static void main ( String args[] )
 {
  int años;
  String nombre;
  
  Scanner entrada = new Scanner( System.in );
  System.out.print( "Escribe tu nombre >> " );
  nombre = entrada.nextLine();
  System.out.print( "Introduce tus años >> " );
  años = entrada.nextInt();
  System.out.println( "Tu nombre es " + nombre + " y tienes " + años + " años ");
 }
}

Escribe tu nombre >> delfirosales
Introduce tus años >> 10
Tu nombre es delfirosales y tienes 10 años

Utilizando el Metodo JFileChooser

JFileChooser es un componente JAVA, que nos permite selecionar y/o grabar cualquier archivo basicamente dentro de nuestro ordenador, en este oportunidad fijaremos la antencion en la funcion de “Seleccion o Abrir”

El ejemplo demostracion trata sobre: “Selecionar un archivo imagen (.jpg, .gif, .png) y luego tendremos q visualizar dicha imagen” aqui la ventana ilustrativa.

Lo Primero q tendremos q hacer es dibujar nuestra interface grafica de usuario(GUI) en este caso “WindowDemoFile”, lo unico nuevo en esta clase es el “JFileChooser”

public JFileChooser jfcExaminarEntrada;
jfcExaminarEntrada = new JFileChooser();

Esta demas decir q la imagen se visualizara dentro de un “JDesktopPane”, aqui en fuente:

import  javax.swing.*;
public class WindowDemoFile extends JFrame {

    public WindowDemoFile() {
        initComponents(); }

   private void initComponents() {
  setTitle("DEMO POR INFORUX");
  setResizable(false);
  jfcExaminarEntrada = new JFileChooser();
        jPanel1 = new  JPanel();
        jtfRutaEntrada = new  JTextField();
        jbExaminar = new  JButton();
        jbLoad = new  JButton();
        jPanel3 = new  JPanel();
        jDesktopPane1 = new  JDesktopPane();

        setDefaultCloseOperation( WindowConstants.EXIT_ON_CLOSE);
        getContentPane().setLayout(null);

        jPanel1.setBorder( BorderFactory.createTitledBorder("Ubica el Archivo Imagen"));
        jPanel1.setLayout(null);
        jPanel1.add(jtfRutaEntrada);
        jtfRutaEntrada.setBounds(20, 30, 350, 19);

        jbExaminar.setText("...");
        jPanel1.add(jbExaminar);
        jbExaminar.setBounds(400, 30, 50, 25);

        jbLoad.setText("load");
        jPanel1.add(jbLoad);
        jbLoad.setBounds(460, 30, 70, 25);

        getContentPane().add(jPanel1);
        jPanel1.setBounds(30, 30, 550, 70);

        jPanel3.setBorder( BorderFactory.createTitledBorder("Imagen Cargada"));
        jPanel3.setLayout(null);
        jPanel3.add(jDesktopPane1);
        jDesktopPane1.setBounds(20, 30, 530, 340);

        getContentPane().add(jPanel3);
        jPanel3.setBounds(20, 110, 570, 390);

        java.awt.Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
        setBounds((screenSize.width-618)/2, (screenSize.height-542)/2, 618, 542);

  /*declaramos una referencia a nuestra clase control de eventos*/
  ControlaEventos controlaEventos =new ControlaEventos (this);
  jbExaminar.addActionListener(controlaEventos);
  jbLoad.addActionListener(controlaEventos);
    }

    public static void main(String args[]) {
              new WindowDemoFile().setVisible(true); }

 public JFileChooser jfcExaminarEntrada;
    public JButton jbExaminar;
    public JButton jbLoad;
    public JDesktopPane jDesktopPane1;
    public JPanel jPanel1;
    public JPanel jPanel3;
    public JTextField jtfRutaEntrada;

}

La segunda clase es de nombre “ControlaEventos”, su mismo nombre lo dice, controla todos los eventos producidos por el usuario. solo controlaremos los 2 botones con nombres q muestran “…” y “load”.
La novedad de esto, es q al producirse el evento en el boton q llama al “JFileChoose”. este mostrara un dialogo y dentro de el, estara el componente. Para decirle cual de lo 2 tipos (open y/o save), utilizamos los metodos showOpenDialog o showSaveDialog, segun nuestras necesidades.

int result = d.showOpenDialog(ventana para seleccionar un archivo);
 int result =d.showSaveDialog(ventana para guardar un archivo);

donde “d” es el frame, internalFrame, mejro dicho es la ventana donde se sobrepondra, ademas esta llamada no entrega nada hasta que el usuario ha aceptado un archivo o cancelado la entrada de ldialogo. El valor de retorno es:
JFileChooser.APROVE_OPTION (si haces click en entrar o gravar)
JFileChooser.CANCEL_OPTION. ( si hay evento en el boton cancelar del JFileChooser.)
Aqui el fuente:

import java.awt.event.*;
import java.io.File;
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;
public class ControlaEventos implements ActionListener{
 WindowDemoFile ventana;
 File fileImagen;
 public ControlaEventos(WindowDemoFile objeto){
  ventana = objeto;
 }
 public void actionPerformed(ActionEvent evento)
    {
  if (evento.getSource()==ventana.jbExaminar){//si hay evento en el boton examinar
   int returnVal = ventana.jfcExaminarEntrada.showOpenDialog(ventana);//mostramos el jFileChooser
    if (returnVal == ventana.jfcExaminarEntrada.APPROVE_OPTION) {//nos aseguramos q haya selecionado algun archivo
              fileImagen = ventana.jfcExaminarEntrada.getSelectedFile();//obtenemos el archivo selecionado
    ventana.jtfRutaEntrada.setText(fileImagen.toString()); }}//mostramos la ruta del archivo en la caja de texto

  if (evento.getSource()==ventana.jbLoad){//si hay evento en el boton load
    if ( fileImagen != null) {
              cargarImagen(ventana.jDesktopPane1,fileImagen);}}
 }

 /*este metodo recibe el jdeskopPane y el archivo imagen*/
 public  void cargarImagen(javax.swing.JDesktopPane jDeskp,File fileImagen)
 {
        try{
   BufferedImage image = ImageIO.read(fileImagen);
           jDeskp.setBorder(new PintaImagen(image)); }
        catch (Exception e){   System.out.println("No cargo imagen, sorry");   }
    }
}

La ultima clase, es la misma a la entrada anterior, ahy se explica la clase “PintaImagen”
de todas formas aqui el fuente:

import java.awt.Component;
import java.awt.Graphics;
import java.awt.Insets;
import java.awt.image.BufferedImage;
import javax.swing.border.Border;

public class PintaImagen implements Border{

 private   BufferedImage image ;

 public PintaImagen(BufferedImage image ) {
  this.image=image;}

 public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
 int x0 = x+ (width-image.getWidth())/2;
 int y0 = y+ (height-image.getHeight())/2;
 g.drawImage(image,x0,y0,null); }

    public Insets getBorderInsets(Component c) {
 return new Insets(0,0,0,0);}

    public boolean isBorderOpaque() {
 return true; }
}

Atravez de esta clase convertirlos el “File” a una imagen para pintarse en un JDesktopPane.
Aqui el pantallazo

Security & Networking: Instalación JDK + Netbeans en Ubuntu

Primero descargamos el JDK + NetBeans desde la siguiente pagina http://www.oracle.com/technetwork/java/javase/downloads/jdk-7-netbeans-download-432126.html. NetBeans es un entorno de desarrollo integrado (IDE) libre, hecho principalmente para el lenguaje de programación Java. En la pagina descargamos el archivo para linux, de nombre jdk-7u1-nb-7_0_1-linux-ml.sh, este archivo contiene el JDK y NetBeans.

Versiones:
NetBeans versión 7.0.1
Java versión 1.7.0_01
Ubuntu 11.10

Una vez finalizado la descarga, nos dirigimos desde consola en la ubicación donde tenemos el archivo descargado y realizamos lo siguiente.

chmod a+x jdk-7u1-nb-7_0_1-linux-ml.sh
./jdk-7u1-nb-7_0_1-linux-ml.sh
gedit /etc/bash.bashrc

Si en el asistente de instalación lo dejamos todo por defecto (es decir siguiente, siguiente y finalizar) al final del archivo bash.bashrc, agregamos los siguiente.

export JAVA_HOME=/usr/local/jdk1.7.0_01
export NETBEANS_HOME=/usr/local/netbeans-7.0.1
export PATH=$JAVA_HOME/bin:$NETBEANS_HOME/bin:$PATH

Una vez realizado este proceso podremos verificar que todo este correcto escribiendo en consola el comando java -version, este comando invoca el compilador de Java y nos muestra la version de Java instalado.

root@computer:/home/delfi# java -versión
java version "1.7.0_01"
Java(TM) SE Runtime Environment (build 1.7.0_01-b08)
Java HotSpot(TM) Server VM (build 21.1-b02, mixed mode)

Lo anterior comprueba que tenemos instalado Java correctamente y esta listo para escribir y compilar código Java desde nuestro Ubuntu. Si no sale lo anterior es necesario que tengamos que reiniciar nuestro equipo.