Estoy llevando un curso sobre "Procesadores digitales" y el profesor nos comentó que en la 1ra unidad veríamos un poco del lenguaje ensamblador (que creo que es ASM, de assembler, y por ello publico acá).

Bueno, nos dijo que no es posible ejecutar el Debug en Windows 7, ya que sólo hasta Windows XP es posible usarlo, y que deberíamos instalar una máquina virtual en la que tengamos XP para poder seguir las clases.

El punto es que, según me comentaron, si instalo una máquina virtual voy a tener que compartir recursos a ese 2do sistema operativo y mi computadora estaría funcionando a una velocidad menor. ¿Qué tan cierto es esto? ¿La velocidad se reduce a la mitad?

Por otro lado, hoy en la primera clase, usamos computadoras con Windows 7 y allí mismo ejecutamos el Debug. El profesor dijo que instalaron una aplicación que hacía eso posible (y no se trataba de una máquina virtual). ¿Cómo podría hacer eso?
Cuando le preguntaban decía que teníamos que instalar una máquina virtual... nadie preguntó sobre esa aplicación que permitía ejecutar Debug sin una máquina virtual (por alguna razón no lo decía). Iba a preguntarle yo pero la verdad es que por falta de tiempo preferí no interrumpir y tratar de entender lo tanto que él trataba de explicar... y luego tuve que salir rápidamente hacia mi clase siguiente.

Entonces tal vez alguien conozca acerca de esto y pueda ayudarme. Gracias de antemano.

EDIT: He estado buscando por internet y veo que existe una aplicación "WinDbg" pero según la descripción permite encontrar errores en programas. Creo que eso es más complejo. Al menos tengo entendido que nosotros sólo ejecutaremos algunas instrucciones al procesador directamente. Además una captura de pantalla muestra un programa con interfaz gráfica, y el Debug debería ser solo consola.

Gracias por contestar.

En realidad es una aplicación un tanto extensa pero solo la estoy realizando a modo de práctica, es decir, no va a ser usada... pero desde ya quería escribir un código bien estructurado.

Los métodos serían:

    public String agregarEmpleado(String apellidos, String nombres, String DNI, String sueldoCadena, String password, boolean tipoTrabajador) {
 
        // Borramos espacios al inicio y al final con trim()
        apellidos = apellidos.trim();
        nombres = nombres.trim();
        DNI = DNI.trim();
 
        if(apellidos.isEmpty() || nombres.isEmpty() || DNI.isEmpty() || password.isEmpty())
            return "Se han encontrados datos vacíos o que sólo contienen espacios.";
 
        if(password.length()<6)
            return "La contraseña debe tener al menos 6 caracteres.";
 
        if(DNI.length() != 8)
            return "El DNI debe tener 8 dígitos.";
 
        if(buscarPorDNI(DNI) != -1)
            return "Ya existe un empleado registrado con este DNI.";
 
        Double sueldo;
        try{
            sueldo = Double.parseDouble(sueldoCadena);
        }catch(NumberFormatException e){
            return "El saldo ingresado no se corresponde con un valor numérico.";
        }
 
        empleados.add( new Empleado(apellidos, nombres, DNI, sueldo, password, tipoTrabajador) );
        return null; // Si devuelve null es porque no hubo error.
    }
 
    public String modificarEmpleado(int posicion, String apellidos, String nombres, String DNI, String sueldoCadena, String password, boolean tipoTrabajador) {
 
        // Borramos espacios al inicio y al final con trim()
        apellidos = apellidos.trim();
        nombres = nombres.trim();
        DNI = DNI.trim();
 
        if(apellidos.isEmpty() || nombres.isEmpty() || DNI.isEmpty() || password.isEmpty())
            return "Se han encontrados datos vacíos o que sólo contienen espacios.";
 
        if(password.length()<6)
            return "La contraseña debe tener al menos 6 caracteres.";
 
        if(DNI.length() != 8)
            return "El DNI debe tener 8 dígitos.";
 
        if(buscarPorDNI(DNI) != -1)
            return "Ya existe un empleado registrado con este DNI.";
 
        Double sueldo;
        try{
            sueldo = Double.parseDouble(sueldoCadena);
        }catch(NumberFormatException e){
            return "El saldo ingresado no se corresponde con un valor numérico.";
        }
 
        empleados.set( posicion, new Empleado(apellidos, nombres, DNI, sueldo, password, tipoTrabajador) );
        return null; // Si devuelve null es porque no hubo error.
    }

Cuando se agregue, los datos serán enviados desde un formulario.
Cuando se modifique, será desde una tabla y aquí puede haber un ligero problema.

Lo malo es que, si el administrador modifica un empleado en la tabla (y le modifica todos sus atributos) yo no tendría como identificar a ese empleado en todo mi ArrayList, ya que la tabla no muestra todos los empleados, sólo los que son resultados de una búsqueda (haciendo imposible que coincida la posición del empleado en la lista con su posición en el ArrayList). Creo que tendré que poner que el código no sea modificable, así tendría cómo ubicarlo siempre.

En C++ no llegué a usar mucho clases y objetos, más que todo usaba funciones que se llamaban entre sí o que eran recursivas.

En Java, digamos que ya he usado la POO como tal. Entonces, en muchas ocasiones pude reutilizar código sin tantas complicaciones, a través de herencia y polimorfismo. Incluso creo que comencé a utilizar mejor los métodos, y a crearlos siempre que fuese conveniente.

Ahora me encuentro con una situación un tanto particular, en la que me he detenido por pensar qué es lo mejor que puede hacerse.

Tengo un método agregarProducto en una clase que gestiona un listado del mismo.
Aquí se tienen las restricciones para los atributos ingresados. Si hubo error, el producto no se agrega al listado y se devuelve una advertencia como String. Si no hubo error, el producto es agregado y se devuelve null.

Ahora he querido agregar un método modificarProducto. A éste se le pasa la posición del producto a modificar (existe un método que devuelve la posición de un producto buscándolo por su código) y los atributos que deben asignarse.

Creo que lo más correcto es copiar el código de agregarProducto pero cambiar las líneas en las que se agrega... es decir, cambiar el add por un set (el listado es un ArrayList). Así, modificar también devuelve una advertencia, y si no la hay, devuelve null.

Pero me pareció extraño copiar el código ya que no lo hacía por un buen tiempo, y pensé en lo siguiente:

1. Podría hacer que agregarProducto llame a modificarProducto y que en vez de pasarle una posición intermedia, le pase la última posición+1. Pero podría darse el caso de que no se haya reservado memoria para tal posición aún.

2. Podría hacer lo anterior pero en el método modificarProducto evaluar si la posición es mayor a la longitud actual del ArrayList. De ser así agregar (usar add), sino, modificar (usar set).

3. Que agregarProducto se mantenga tal cual pero modificarProducto llame a agregarProducto. En caso de que se haya agregado, pasar ese objeto a la posición que se quiere modificar y luego eliminar la última posición. Así modificar ya no tiene el mismo código (no tendría que copiarlo) y se modificaría la posición deseada con datos correctos. Lo malo es que estoy haciendo operaciones adicionales.

A fin de cuentas, es mejor a veces copiar el código que tratar de no hacerlo y complicarse en vano, ¿verdad?
Además, más líneas de código pueden estar más optimizadas que otras muy pocas.

A veces me pasa esto, que me lío en vano, pudiendo simplemente avanzar con el programa y no detenerme a pensarlo tanto.

Edit: Muchas gracias por su interés, espero que puedan ayudarme un poco comentando cómo creen que es conveniente hacerlo.

Muchas gracias.
Justo hace poco me dijeron en un grupo que el componente era JToolBar, pero creo que a fin de cuentas no lo usaré... es decir, lo estoy usando pero desactivé la propiedad de que sea flotante, ya que si es desplazado a otra posición dentro del JFrame al que pertenece se comienza a descuadrar todo.
Probablemente haya forma de adecuarlo mediante código para que esto no suceda, pero ahora estoy usando el asistente de Netbeans para crear la interfaz "más rápido".
Me di cuenta que incluso puedo usar los Layout...

A este componente le puedo agregar varios JMenu y a cada uno de estos sus correspondientes JMenuItem, pero si lo que deseo es agregarle botones al JMenuBar, ¿cómo puedo hacerlo?
Porque recuerdo haber visto un menú que además de tener opciones escritas en texto presentaba botones a modo de imágenes pequeñas (tampoco tan pequeñas como íconos, sino de 60px aproximadamente).

Gracias de antemano, espero que puedan ayudarme.

La verdad no creo que sea posible agregar un JFrame dentro de un JPanel, ya que los JFrame hacen que aparezca un botón adicional en la barra de tareas (aparece 1 por cada JFrame). Pero lo que sí, es que existen los JInternalFrame, que pueden agregarse a los JDesktopPane, que aunque no son JPanel pueden agregarse a los JFrame.

Acá un código ejemplo (extraído de chuidiang.org, sólo que le cambié un poco lo que decían los comentarios):

package Principal;
 
import java.awt.FlowLayout;
import javax.swing.JDesktopPane;
import javax.swing.JFrame;
import javax.swing.JInternalFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.WindowConstants;
 
/**
 * Se instancia un JFrame y un JDesktopPane,
 * y dentro de este último se agrega un JInternalFrame.
 */
 
public class Main {
 
        @SuppressWarnings("ResultOfObjectAllocationIgnored")
	public static void main(String[] args) {
		new Main();
	}
 
	public Main()
	{
		// Instanciación de JFrame y JDesktopPane.
		JFrame v = new JFrame("Soy un JFrame");
		JDesktopPane dp = new JDesktopPane();
		v.getContentPane().add(dp);
 
		// Panel que irá dentro del JInternalFrame.
		JPanel p = new JPanel();
		p.setLayout(new FlowLayout());
		p.add (new JLabel("Una etiqueta"));
		p.add (new JTextField(10));
 
		// Se construye el JInternalFrame y se le agrega el panel.
		JInternalFrame internal = new JInternalFrame("Soy un JInternalFrame");
		internal.add(p);
 
		// Podemos asignar el tamaño con setSize,
                // o usar pack para que se asigne el tamaño mínimo adecuado.
		internal.pack();
 
		// Por defecto un JInternalFrame no es redimensionable ni
		// tiene el botón de cerrar, así que se lo agregamos:
		internal.setResizable(true);
		internal.setClosable(true);
 
		// Se agrega el JInternalFrame en el JDesktopPane.
		dp.add(internal);
 
		// Asignamos tamaño al JFrame y lo hacemos visible.
		v.setSize(500,500);
		v.setVisible(true);
		v.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
 
		// Hacemos visible al JInternalFrame.
		internal.setVisible(true);
	}
 
}

La verdad no entiendo mucho la utilidad, tal vez puedas explicar un poco más de cómo es eso de localizar una página 

La verdad es que siempre tuve cierta duda sobre JavaFX (porque aparece entre las opciones cuando se va a crear un proyecto en Netbeans)... y no sabía que era más moderno que Java Swing. ¿JavaFX es entonces otro conjunto de métodos al que debería acostumbrarme?

De momento creo que continuaré usando Swing porque es lo que llevaré en el ciclo entrante. Y el tipo de tablas que buscaba crear aparece en la siguiente entrada:
http://foro.elhacker.net/java/como_crear_este_tipo_de_tablas-t408389.0.html

Ahora ya tiene color de fondo y ciertos bordes pero sigue sin verse como debería.

Muchas gracias por su ayuda.

Bueno, yo he creado un programa que resuelve cierto tipo de ejercicios de un curso que estoy llevando. Son operaciones básicas las que se realizan pero se realizan sobre una tabla y como el proceso es largo uno puede equivocarse fácilmente... por ello decidí hacerlo. El programa genera la tabla y opera sobre ella explicando paso a paso qué es lo que está haciendo.

Sólo que no he usado JTable, porque no comprendo muy bien cómo usar esta clase. Cuando busqué información, vi que había que usar otras clases como intermediario para pasarle los datos que debe llenar en cada celda. Además, necesitaba crear un cuadro de doble entrada y con JTable sólo se pueden poner encabezados en las columnas y no por filas (hay un modo, pero agrega más código aún).

La tabla que el programa crea puede tener más filas o más columnas dependiendo de los datos ingresados, y lo hice todo a puro GridLayout... incluyendo muchos paneles en el panel principal y que tengan FlowLayout para que aparezcan centrados.

Pero lo malo es que dicha tabla no se ve muy bien, en comparación de un JTable. Y estaba pensando si podría hacer que tome la misma apariencia que un JTable. Pero creo que eso no es puro color sino que incluye cierto estilo de sombreado o borde tal vez.

Gracias por su ayuda... tal vez usted conozca cómo copiar el estilo de un JTable jeje

He creado un programa con interfaz gráfica usando Netbeans pero sin usar el asistente para crear GUI.
En dicho programa (escrito a puro código) he usado colores que ya vienen predefinidos... como CYAN, BLACK, WHITE de clase Color. Pero recordé que hay otros tipos de colores que también están predefinidos, y como no sé cómo agregarlos, he creado un JFrame Form con el asistente para asignar tal color, luego ver el código y copiarlo a mi programa que está sin el asistente.

Lo malo es que, lo que se muestra en la vista de diseño no es lo mismo a lo que se ejecuta:



¿A qué podría deberse?

He buscado en el código, y lo que se ha autogenerado es: