¿Podrías explicarte correctamente? ¿Qué tratas hacer y por qué, para obtener qué resultado? Porque no se te entiende absolutamente nada.

Si quieres guardar cambios, solo debes hacer:

btnSave.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        JPanel panel = (JPanel) tabs.getSelectedComponent();
        // 0 -> asume que el JTextArea es el unico hijo del JPanel
        JTextArea area = (JTextArea) panel.getComponent(0);
        String text = area.getText();
        try {
            Path path = Paths.get("ruta/a/tu/archivo");
            Files.write(path, text.getBytes("utf-8"));
        } catch(IOException e) {
            throw new RuntimeException("Ocurrió un error al guardar los cambios", e);
        }
    }
});

PD: Importar Path, Paths y Files del paquete java.nio.file.

Think in Java ya no es recomendado, trabaja con una API de Java vieja que en el desarrollo actual no te será de mucha ayuda.

Si bien es cierto que es bueno un entorno cómodo por defecto, tú como programador debes poderte adaptar. No creas que siempre vas a encontrar todo listo, y aquí te diferencias entre un novato y un programador que sabe lo que hace. Como programador debes de poder manejar las herramientas como Git, tu terminal (Win-GNU/Linux), Mercurial, etc. Es un hábito que debes adquirir.

Si quieres todo hecho, ve por .NET. En Java nos acostumbramos a aprender a manejar las cosas por nuestra cuenta también, como Maven por ejemplo. Si te refieres solo a instalamiento de entorno, en el caso de Java solo es Next, Next (tanto el JDK como IDEs, aunque siempre te permite la personalización de plugins por ejemplo).

En fin, tanto VS como NetBeans o IntelliJ IDEA, te permiten un manejo gráfico de Maven, Git, Mercurial, Subversion, etc.

No se de donde diablos sacó esa información, nunca lo he escuchado. Lo que NetBeans guarda son configuraciones del proyecto solamente. Decir que te dice cuánto tiempo demoró el proyecto, ¿cómo lo hace? ¿cómo hace para agregar minutos si el proyecto puede estar abierto pero no modificándose?

Hacer eso sería una pérdida de tiempo y recursos ya que el IDE tendría que estar escaneando el proyecto a cada instante, checkeando modificaciones para aumentar minutos, horas, etc.

Lo único que todos vemos que guarda NetBeans es el usuario del equipo pero como Javadoc (@author).

En resumen dudo muchísimo de la afirmación de tu amigo.

La clase Timer es una clase muy útil para situaciones particulares. Estas situaciones pueden ser por ejemplo, cuando necesitamos hacer algo cada X tiempo. Quizás hayas visto en algunas webs que aparecen ofertas o anuncios cada X tiempo, pues bien, esto se hace gracias a los Timers.

Vamos a realizar un pequeño timer que hace un conteo regresivo imprimiendo en pantalla la hora actual. Primero hagamos una clase que muestre la hora actual.

public class Display {
 
    public void printTime(int hour, int minute, int second) {
        String fullHour = "";
 
        fullHour += (hour > 9) ? ":" + hour : "0" + hour;
        fullHour += (minute > 9) ? ":" + minute : ":0" + minute;
        fullHour += (second > 9) ? ":" + second : ":0" + second;
 
        System.out.println(fullHour);
    }
}

Nada del otro mundo, solo le da formato a una hora recibida como 3 parámetros: hora, minuto y segundo. Esta clase la usaremos en el Timer para mostrar la hora actual.

import java.util.Timer;
import java.util.TimerTask;
 
public class Timeout {
 
    private int hour = 0;
    private int minute = 0;
    private int second = 11;
    private Timer timer;
    private boolean isTimerRunning;
    private Display display;
 
    public Timeout() {
        timer = new Timer();
        display = new Display();
    }
 
    TimerTask task = new TimerTask() {
        @Override
        public void run() {
            isTimerRunning = true;
            if(second > 0) {
                second--;
            } else {
                second = 59;
                if(minute > 0) minute--;
                else {
                    minute = 59;
                    if(hour > 0) hour--;
                    // si segundo = 0, minuto = 0 y hora = 0,
                    // cancelamos el timer
                    else {
                        isTimerRunning = false;
                        timer.cancel();
                        timer.purge();
                    }
                }
            }
            if(isTimerRunning)
                display.printTime(hour, minute, second);
        }
    }; // fin timertask
 
    public void start(int timeout, int interval) {
        timer.schedule(task, timeout, interval);
    }
 
} // fin clase

El código es autoexplicado. En lo que debemos de fijarnos es el TimerTask. La TimerTask nos permite realizar tareas en un thread separado. Esto es así, porque por lo general, cuando usamos un Timer es para que se esté ejecutando cada cierto tiempo un código de forma paralela, esto eso, multithreading programming (programación multi hilo). El código del TimerTask solo hace una serie de comprobaciones para disminuir la hora, minuto y segundo. Luego, llama al método printTime del objeto Display, pasándole la hora, minuto y segundo y que este método dará forma e imprimirá.

Para empezar un timer, debemos de llamar al método schedule el cual recibe 3 parámetros:

• Un objeto TimerTask
• Un timeout (tiempo de espera para que empiece a ejecutarse)
• Un intervalo (la tarea se ejecutará cada X tiempo)

Los dos últimos parámetros se debe especificar en milisegundos, así, 1000 es equivalente a 1 segundo. Por último, hagamos nuestra clase principal.

public class TimerTest {
 
    public static void main(String[] args) {
        Timeout timeout = new Timeout();
        timeout.start(0, 1000);
    }
}

En la clase principal decimos que el timer tendrá un delay de 0s y un intervalo de 1s. Si compilamos y corremos:

javac Display.java
javac Timeout.java
javac TimerTest.java
 
java TimerTest

Obtendremos lo siguiente:


¿Posibilidades? La que puedas imaginar, así que piensa como sacarle provecho en tu próximo proyecto.

Te agradecería si marcas los temas como solucionados (ícono check verde al tema) para mantener el orden.

1. Overloading (sobrecarga)

La sobrecarga es cuando en una misma clase redefines un mismo método. Esta técnica tiene una restricción y es:

• Un método sobrecargado debe tener diferentes parámetros (tipos de dato)

Así, lo siguiente es correcto:

public int multiplicar(int x, int y) {
	return x * y;
}
 
public int multiplicar(float x, float y) {
	return x * y;
}

Pero esto es incorrecto:

public int multiplicar(int x, int y) {
	return x;
}
 
public float multiplicar(int x, int y) {
	return new Float(String.valueOf(x));
}

A pesar que el tipo de retorno es diferente, los parámetros son iguales, por lo que el compilador lo detectará como el mismo método.

2. Overriding (sobreescritura)

La sobreescritura sucede cuando tu heredas una clase o cuando implementas una interfaz. En el caso de herencia, es obligatorio sobreescribir los métodos de una superclase si estos son abstractos, si no son abstractos, es opcional sobreescribirlos; pero generalmente así sucede para dar un comportamiento polimórfico.

public abstract class Persona {
 
		// obligatorio sobreescribir en subclases
		public abstract void lenguaje();
 
		// no es obligatorio, ya que no es abstracto
		public void caracteristicas() {
			System.out.println("dos ojos, una nariz y una boca");
		}
 
}

public class Canadiense extends Persona {
 
	@Override // indica que se sobreescribe
	public void lenguaje() {
		System.out.println("Inglés");
	}
 
	// método caracteristicas heredado
 
}

En el caso de una clase que implemente una interfaz, es obligatorio sobreescribir los métodos  de la interfaz, siempre y cuando estos no sean default, ya que por defecto, los métodos  de una interfaz son públicos y abstractos.

public interface Construccion {
 
	// necesita ser sobreescrito
	int cantidadColumnas();
 
	// necesita ser sobreescrito
	int cantidadPisos();
 
	// no es necesario sobreescribir
	default boolean tieneAsensor() {
		return true;
	}
 
}

public class Edicio implements Construccion {
 
	@Override
	public int cantidadColumnas() {
		return 20;
	}
 
	@Override
	public int cantidadPisos() {
		return 10;
	}
 
}
 

Hay bastantes, pero personalmente te puedo recomendar Java 7 los fundamentos del lenguaje de programación y Cómo programar en Java de Deitel & Deitel. Ambos los leí cuando empezaba y me ayudaron mucho. Si no se te dificulta el inglés, lee todo lo que puedas en inglés que hay muchísimo material bueno en ese idoma.

PD: Siempre mira con que versión de Java trabaja el libro. Adquiere los que sean Java 7+.


Saludos.

Yo hice lo mismo para un amigo pero en Java. Te dejo el gist para que lo veas y lo traduzcas a C: Números primos con criba de eratóstenes

Es sencillo, solo hay que pensar un poco.

import java.util.Scanner;
 
public class SerieUtil {
	public static void main(String[] args) {
		Integer[] serie;
		Integer[] even;
		Integer[] odd;
		final Scanner READER = new Scanner(System.in);
 
		System.out.print("Ingrese el límite de la serie impar: ");
		byte limit = READER.nextByte();
 
		serie = new Integer[Math.round((float) limit/2)];
		even = new Integer[serie.length/2];
		odd = new Integer[Math.round((float) serie.length/2)];
 
		// llena los arreglos
		int serieValue = 1;
		for(byte i=0; i<serie.length; i++) {
			serie[i] = serieValue;
 
			// empieza a contar en el indice 1, no 0:
			// 1, 3, 5, 7, 9, 11, 13 -> 1 es indice 1,
			// 3 es indice 2, 5 es indice 3, etc...
			int aux = i+1;
			if(aux % 2 == 0) {
				int evenIndex = getIndexToFill(even);
				even[evenIndex] = serieValue;
			}
			else {
				int oddIndex = getIndexToFill(odd);
				odd[oddIndex] = serieValue;
			}
 
			serieValue += 2; // va de 2 en 2, 1-3-5-7...
		}
 
		for(byte i=0; i<serie.length; i++) {
			if(i < even.length)
				System.out.println(even[i]);
			// si i es mayor quel tamaño de even
			// entonces, se debe empezar a imprimir
			// el arreglo odd, por lo tanto, la forma
			// de acceder al valor actual de odd
			// es restando i (indice de serie) - el
			// tamaño de even. Por ejemplo, even tiene
			// un  tamaño de 3 y odd de 4. Cuando i
			// vale 3 (supera el tamaño de even), se de
			// be entonces empezar a imprimir odd. Entonces,
			// i(3) - even.length(3) = 0 -> odd[0],
			// i(4) - even.length(3) = 1 -> odd[1],
			// i(5) - even.length(3) = 2 -> odd[2],
			// i(6) - even.length(3) = 2 -> odd[3]
			else {
				System.out.println(odd[i - even.length]);
			}
		}
 
	}
 
	// Obtiene el primer índice null para establecer un
  // número de la serie
	public static int getIndexToFill(Integer[] array) {
		// if array is fill, the last index fill is the last index
		int indexToFill = array.length - 1;
 
		for(int i=0; i<array.length; i++) {
			if(array[i] == null) {
				indexToFill = i;
				break;
			}
		}
 
		return indexToFill;
	}
 
}
 

PD: Los códigos deben ir entre etiquetas GeSHi (leer reglas del foro).

A mí me suena más a un bug con el tipo de dispositivo. Lo que no entiendo, es por qué cuando especificas un constructor vacío no sucede. De alguna manera, ese super() hace algo en el constructor de BroadcasterReceiver o el runtime instancia internamente a las subclases de BroadcasterReceiver y al no encontrar un constructor vacío, lanza excepción. Es raro, trata de reportarlo como bug a ver qué te dicen xD.