Mensajes

Cuando creo variables de estos tipos y le asigno un caracter, cuando lo imprimo por pantalla tengo que hacerle casting de char para ver el caracter. ¿Para que sirven entonces? Ya hay tipos de variables con el mismo tamaño que estos.

Parece que hay 3 formas de inicializar variables, pero no me queda claro cuando usar una u otra.

Código (cpp) [Seleccionar] Expandir

int n1 = 2;//c-like
int n2 (3);//constructor
int n3 {5};//uniform

Las 3 formas funcionan igual y hacen lo mismo de la misma manera.
Mi pregunta es ¿Cuando es mas recomendable usar una u otra?

Amigo mio, siento mucho tener que decirte que te equivocas, ya que ImageIcon en realidad no hereda de Image ni directa ni indirectamente. De lo contrario no habria utilizado el metodo createImage().

Tengo entendido que el metodo que tiene simplemente devuelve un booleano para indicar si se ha cargado o no la imagen y que se usa cuando se utilizan imagenes de internet, pero ¿Podrían poner un ejemplo? Esque no entiendo, por ejemplo, como debería ser implementado ese método o como influye el hecho de que usemos null para pintar una imagen cuando esa imagen esta en el ordenador en lugar de internet. He buscado mucho en internet al respecto pero en todos los ejemplos que encuentro solo veo que utilizan null.

Cuando ejecuto el siguiente codigo utilizando Toolkit, no aparece la imagen hasta que le cambio el tamaño a la ventana. Se que se puede solucionar utilizando ImageIO o ImageIcon, pero me gustaria saber que diferencia hay entre usar uno y otro y por que tengo que cambiar el tamaño de la ventana cuando utilizo Toolkit para que se muestre la imagen.

Código [Seleccionar] Expandir

package main;

import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Toolkit;

import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Test {

public static void main(String[] args) throws IOException{
JFrame ventana = new JFrame();
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Image imagen =
//DESCOMENTA UNO DE LOS TRES COMENTARIOS SIGUIENTES PARA APRECIAR LA DIFERENCIA ENTRE UNO Y OTRO
// ImageIO.read(new File("IMAGEN.png"));
// Toolkit.getDefaultToolkit().getImage("IMAGEN.png");
// new ImageIcon("IMAGEN.png").getImage()
JPanel panel = new JPanel(){
private final static long serialVersionUID = 1L;
@Override
public void paint(Graphics g) {
g.drawImage(imagen, 0, 0, null);
}
};
panel.setPreferredSize(new Dimension(300,300));
ventana.add(panel);
ventana.pack();
ventana.setVisible(true);
}

}PD: Acabo de descubrir algo de lo mas inquietante: Si creo un ImageIcon con la imagen antes o despues de usar Toolkit, tambien se soluciona. ¿Alguna idea de porque sucede esto?

Cuando lo probeis tened en cuenta que le teneis que poner una imagen para ver el resultado y llamarla IMAGEN.png.

A todo esto, ¿Cual es la diferencia entre obtener una imagen usando ImageIcon, Toolkit e ImageIO?

Código [Seleccionar] Expandir

new ImageIcon("IMAGEN.png");
Toolkit.getDefaultToolkit().getImage("IMAGEN.png");
ImageIO.read(new File("IMAGEN.png"));

Ok acabo de descubrirlo yo solo:

Lo que hace es centrar la ventana, haciendo que el centro de la misma coincida con el centro del componente (hasta ahi todo bien). El problema es que cuando la ventana cambia de posicion respecto de la pantalla, tambien lo hacen todos sus componentes respecto de la ventana, ya que los componentes tienen una posicion fija respecto de la ventana. Entonces lo que sucede es lo siguiente:

1- El componente debe estar añadido a la ventana y debe de poder mostrarse. Es decir, la ventana debe estar visible.(De lo contrario simplemente centrará la ventana en la pantalla).

2- Mueve la ventana a una posicion de tal forma que su centro coincida con el del componente

3- Mueve los componentes respecto de la pantalla para que conserven su posicion respecto de la ventana

Si quieres ver bien como funciona haz lo siguiente: Ejecuta sin utilizar el setLocationRelativeTo, y sin terminar la ejecucion cambia el codigo y añade el setLocationRelativeTo para tener en ejecucion uno con y otro sin el metodo, y despues cambia rapidamente de una ventana a otra SIN CAMBIAR LA VENTANA DE SITIO dejando la ventana tal y como se ha creado. Cuando lo cambies rapidamente de una ventana a otra podrás ver mejor que el componente de una ventana coincide con el centro de otra

Ejemplo:

Código [Seleccionar] Expandir

package ejemplos;

import java.awt.Color;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class EjemploSetLocationRelativeTo {

public static void main(String[] args) {
JFrame ventana = new JFrame();
ventana.setLayout(null);//Para usar coordenadas absolutas
/*
* IMPORTANTE
* antes de usar el metodo setLocationRelativeTo
* los componentes deben estar visibles
* asi que la ventana debe de estarlo tambien
* de lo contrario la ventana se centrará
* respecto la pantalla
*/
ventana.setVisible(true);
JPanel p = new JPanel();
p.setBackground(Color.GRAY);//Para distinguirlo. Si no no se vería =D
p.setBounds(200,200,50,50);
ventana.add(p);
ventana.setSize(300, 300);
/*
* Para ver mejor como funciona el metodo haz lo siguiente:
* 1- Ejecuta el codigo (IMPORTANTE no muevas la ventana ni le cambies el tamaño)
* 2- Descomenta la linea 36 (La que contiene el metodo)
* 3- Vuelve a ejecutar
* 4- Cambia rapidamente de una ventana a otra
* Como puedes ver el centro de una ventana coincide
* con el cuadrado gris de la otra
*/
// ventana.setLocationRelativeTo(p);
}

}


No se mucho al respecto, pero por norma general tengo entendido que lo que ralentiza las consultas son la falta de uso de indices donde mas hace falta. Haz las consultas sin utilizar java. Si te sigue demorando probablemente sea eso.

Para que sirve el metoo setLocationRelativeTo?
Por mas que busco en internet solo encuentro ejemplos en los que se le pasa por parametro 'null', que lo que hace es centrar la ventana:

Código [Seleccionar] Expandir

setLocationRelativeTo(null);
Pero no encuentro ningun ejemplo que utilize un valor distinto de null. Se supone que lo que hace es colocar la ventana relativo al objeto que se le pasa, pero lo he probado y nada, que sigo sin ver como funciona.
¿Alguien puede ayudarme?
Gracias de antemano.

Teniendo en cuenta que C es un lenguaje que depende en gran parte de la maquina, ¿Se puede programar en C para la maquina virtual de java? La ventaja de java esque es portable, pero lento por ser de alto nivel. Sin embargo C es mas rapido por ser de mas bajo nivel, pero no portable, asi que se me ocurrió que sería buena idea programar directamente en C para la maquina virtual de java, de modo que los programas contarian con las ventajas de los 2 lenguajes.

Lo mismo digo para ensamblador.

Corrigeme si me equivoco, pero creo que lo que quieres es crear un objeto en la funcion preparacion() y usarlo en la funcion testExceptionPutLineal1() ¿Correcto? Si es asi lo mejor sera que declares el objeto a nivel de clase, es decir, como atributo de la clase, así puedes usarlo en los 2 metodos.
De todos modos creo que no te estoy entendiendo bien