1: // Capítulo 4: Flujo de control. Pág 83.

   2: /************************* Ejercicio 9 ****************************

   3: * Una secuencia Fibonacci es la secuencia de números 1, 1, 2, 3, 5,

   4: * 8, 13, 21, 34, etc., donde cada número (a partir del tercero) es 

   5: * la suma de los dos anteriores. Cree un método que tome un entero 

   6: * como argumento y muestre esa cantidad de números de Fibonacci co-

   7: * menzando por el principio de la secuencia; por ejemlo, si ejecuta 

   8: * java Fibonacci 5 (donde Fibonacci es el nombre de la clase) la 

   9: * salida sería: 1, 1, 2, 3, 5.

  10: ******************************************************************/

  11: import static net.mindview.util.Print.*;

  12: public class E09_Fibonacci {

  13:     public static void imprimir(int cantidad) {

  14:         int f;

  15:         int a1 = 0;

  16:         int a2 = 1;

  17:         printnb(a2 + ", ");

  18:         for(int i = 1; i < cantidad; i++) {

  19:             f = a1 + a2;            

  20:             a1 = a2;

  21:             a2 = f;

  22:             printnb(f + ", ");

  23:         }

  24:     }

  25:     public static void main(String[] args) {

  26:         int cantidad = Integer.parseInt(args[0]);

  27:         if(cantidad > 0)

  28:             imprimir(cantidad);

  29:         else 

  30:             print("La cantidad debe ser mayor a 0");

  31:         /*print();

  32:         imprimir(1);

  33:         print();

  34:         imprimir(2);

  35:         print();

  36:         imprimir(3);*/

  37:     }

  38: }

Existe varias maneras de hacerlo: Recursiva, Iterativa y Divide y vencerás. El método iterativo que emplee es más rápido que el recursivo pero más lento que la versión de divide y vencerás. La solución en Java empleando recursión, se puede checar en este link. La descripción de cada uno de los algoritmos se puede ver en la Wikipedia.

¡Saludos!" y hasta la otra.

Me despido no sin antes compartir con ustedes una frase que me guiará este año (tomado en pensamientosyreflexionessobrelavida) y desearles un mejor año, acompañado de ¡mucha felicidad!.

MAMERTO MENAPACE

No pierdas mucho tiempo pensando en el problema. Dedica toda tu energía y sapiencia en buscar soluciones.

JM.

   1: // Programa de ejemplo donde se le pasa desde la línea de comandos, 

   2: // argumentos que son recibidos en el programa y se imprimen en la consola.

   3:  

   4: class ImprimeArgumentos {

   5:     public static void main(String[] args) {

   6:         System.out.println("Argumento 1 = " + args[0]);

   7:         System.out.println("Argumento 2 = " = " + args[1]);

   8:         System.out.println("Argumento 3 = " = " + args[2]);

   8:     }

   9: } 

Para esto una vez el código en el editor, nos vamos en Construir de la barra de menú, enseguida se abre una nueva ventana como esta:

Nos vamos en la sección Ejecutar comandos y ponemos delante de java "%e" los argumentos que queremos que reciba nuestro programa, en este caso he colocado : a b c (antes de cada espacio es recibida como una cadena de caracteres en un arreglo de Strings). Una vez hecho esto damos Aceptar y listo ya podemos ejecutar nuestro programa, solo hay que tener cuidado con insertar el numero correcto de argumentos pues el programa no válida que se reciban argumentos, en este caso causaría error en tiempo de ejecución.

Como salida nos debe imprimir:

a

b

b

Esto sería todo, espero  le pueda servir a alguien más, me despido hasta la próxima.

Ejercicio 1: (2) Cree una clase con un método main() que genere un objeto de la clase Exception dentro de un bloque try. Proporcione al constructor de Exception un argumento String. Capture la excepción dentro de una cláusula catch e imprima el argumento String. Añada una clausula finally e imprima un mensaje para demostrar que pasó por allí.

   1: public class ClaseGeneraExcepciones  {

   2:     public static void main(String[] args){

   3:         try {

   4:             throw new Exception("Esto es una Excepción");

   5:         } catch(Exception e) {

   6:             System.out.println("Se produjo un excepción: " + e.getMessage());

   7:         } finally {

   8:             System.out.println("Esto se ejecuta sin importar si se presentan errores");

   9:         }

  10:     }

  11: }

salida del programa:

Se produjo una excepción: Esto es una Excepción
Esto se ejecuta sin importar si se presentan errores

Después, iré actualizando el post con las demás soluciones de los restantes ejercicios del tema de Excepciones, hasta pronto.

Actualización [15/11/2010]

Aquí están las siguientes soluciones:

Ejercicio 2: (1) Defina una referencia a un objeto e inicializela a null. Trate de invocar un método a través de esta referencia. Ahora rodee el código con una clausula try-catch para probar la nueva excepción.

   1: // Ejercicio 2

   2:  

   3: class ExcepcionNull {

   4:     String s = "ejercico 2 sobre Excepciones";

   5:     String getString() {

   6:         return s;

   7:     }

   8:     

   9:     public static void main(String[] args) {

  10:         ExcepcionNull en = null;

  11:         try {

  12:             en.getString();

  13:         } catch (Exception e){

  14:             System.out.println("Se produjo una expción. " + e.getMessage());

  15:         }

  16:     }

  17: }

Salida: Se produjo una expción. null

Ejercicio 3: Escriba código para generar y capturar una excepción ArrayIndexOutOfBoundsException (Índice de matriz fuera de límites).

   1: public class ExcepcionEnArray {

   2:     int[] array = {0, 1, 2, 3, 4, 5};

   3:     int getValor(int indice) {

   4:         return array[indice];

   5:     }

   6:     

   7:     public static void main(String[] args) {

   8:         ExcepcionEnArray ea = new ExcepcionEnArray();

   9:         try {

  10:             ea.getValor(6);

  11:         } catch (ArrayIndexOutOfBoundsException e) {

  12:             System.out.println("Excepción: indice de array fuera de limites" + e.getMessage());

  13:         }

  14:     }

  15: }

salida: Excepción: indice de array fuera de limites 6

Actualización [16/11/2010]

Continuó con las soluciones a los ejercicios, si detectarán alguna barbaridad, les agradecería corregirme.

Ejercicio 4: (2) Cree su propia clase de excepción utilizando la palabra clave extends. Escriba un constructor para dicha clase que tome un argumento String y lo almacene dentro del objeto como una referencia de tipo String. Escriba un método que muestre la cadena de caracteres almacenada. Cree una cláusula try-catch para probar la nueva excepción.

   1: class MiExcepcion extends Exception {

   2:     String mensaje;

   3:     public MiExcepcion(String mensaje) {

   4:         this.mensaje = mensaje;

   5:     }

   6:     public String getMensaje() {

   7:         return mensaje;

   8:     }

   9: }

  10:  

  11: public class PropiaClaseExcepcion {

  12:     public static void main(String[] args) {

  13:         try {

  14:             throw new MiExcepcion("mi propia Excepción");

  15:         } catch(MiExcepcion e) {

  16:             System.out.println("excepción: " + e.getMensaje());

  17:         }        

  18:     }

  19: }

  20:  

Salida: Excepción generada: mi propia Excepción

Ejercicio 5: (3) Defina un comportamiento de tipo reanudación utilizando un bucle while que se repita hasta que se deje de generar una excepción.

   1: import java.io.*;

   2:  

   3: public class ExcepcionConReanudacion {

   4:    

   5:    public static void main(String[] args) {

   6:         boolean continuar = true; 

   7:         while(continuar) {        

   8:             try {                

   9:                 System.out.print("Introduce un número entero: ");

  10:                 InputStreamReader datosInsertados = new InputStreamReader(System.in);

  11:                 BufferedReader datos = new BufferedReader(datosInsertados);

  12:                 String cadenaDatos = datos.readLine();

  13:                 int numero = Integer.parseInt(cadenaDatos);

  14:                 int cuadrado = numero * numero;

  15:                 System.out.println("El cuadrado de " + numero + " = " + cuadrado);

  16:                 continuar = false;

  17:             } catch(Exception e) {

  18:                 System.out.println(e.getMessage());                

  19:             }            

  20:         };           

  21:     }

  22: }

Salida:

Introduce un número entero: r
For input string: “r”
Introduce un número entero: t
For input string: “t”
Introduce un número entero: 3
El cuadrado de 3 = 9

Este ejercicio lo pude terminar gracias al apoyo de un tutorial en  la parte de la entrada de datos por el teclado.

La palabra clave final

Se emplea final para impedir cambios tanto para elementos de datos, métodos y clases. Se puede querer evitar cambios debido a nuestro diseño o la búsqueda de eficiencia.

Datos final

En los datos se pueden tener constantes de tiempo de compilación (valor que definimos de antemano y nunca va a cambiar) y de tiempo de ejecución (valor calculado). Estos tipos de constantes deben ser de tipos primitivos que se definen con la palabra final al momento de definirlos, hacerlo implica indicar su valor. Si se antepone la palabra static a final lo que sucedería es que el valor constante existirá en un único espacio de almacenamiento que no se podrá cambiar.

Usar final en referencias a objetos hace que sean constantes las referencias no los objetos. No se podrá hacer que la referencia apunte a otro objeto, pero el objeto si podrá modificarse.Lo mismo sucede con las matrices pues también son objetos.

Un ejemplo que nos propone Bruce Eckel es el siguiente, donde se describe el comportamiento de los elementos de datos de una clase utilizando final y static:

//: reusing/FinalData.java
//Efecto de final sobre los campos.
import java.util.*;
import static access.net.mindview.util.Print.*;

class Value {
 int i; // Acceso de paquete
 public Value(int i) { this.i = i; }
}

public class FinalData {
 private static Random rand = new Random(47);
 private String id;
 public FinalData(String id) { this.id = id; }
 // Pueden ser constantes de compilación:
 private final int valueOne = 9;
 private static final int VALUE_TWO = 99;
 // Constante pública típica:
 public static final int VALUE_THREE = 39;
 // No pueden ser constantes de tiempo de compilación:
 private final int i4 = rand.nextInt(20);
 static final int INT_5 = rand.nextInt(20);
 private Value v1 = new Value(11);
 private final Value v2 = new Value(22);
 private static final Value VAL_3 = new Value(33);
 // Matrices:
 private final int[] a = { 1, 2, 3, 4, 5, 6 };
 public String toString() {
  return id + ": " + "i4 = " + i4 + ", INT_5 = " + INT_5 + " a[0] = " + a[0] ;
 }
 public static void main(String[] args) {
  FinalData fd1 = new FinalData("fd1");
  //! fd1.valueOne++; //Error: no se puede modificar el valor
  fd1.v2.i++; // EL objeto no es constante
  fd1.v1 = new Value(9); // Ok -- no es final
  for(int i = 0; i < fd1.a.length; i++)
   fd1.a[i]++; // ¡El objeto no es constante!
  //! fd1.v2 = new Value(0); // Error: no se puede cambiar la referencia
  //! fd1.VAL_3 = new Value(1);
  //! fd1.a = new int[3];
  print(fd1);
  print("Creating new FinalData");
  FinalData fd2 = new FinalData("fd2");
  print(fd1);
  print(fd2);
 }
}

Espero pronto agregar otros temas que vaya viendo, ¡hasta pronto!

Conocí a Java, en la universidad, tocamos algo de Java, una pequeña introducción, después he hido aprendiendo otros temas por mi cuenta. Hasta ahora sólo sé temas básicos como: Operadores, Control de Flujo, Matrices y ultimamente he estado estudiando sobre el tema de la Inicialización de Objetos y de tipos primitivos. Conocer un poco de POO (Programación Orientada a Objetos) y algo de Java me ayudo a cursar la materia de POO en la maestria en la que ahora estoy, sin tantos problemas.

He decidio crear una serie de post que serán parte de éste, que los iré añadiendolos conforme los vaya aprendiendo. El orden de los temas  de los que tratare, es de acuerdo a la organización de los capitulos y subtemas del libro que tengo (Piensa en Java, de Bruce Eckel, 4ta edición), empezaré en el capitulo 3 ya que ahi se inicia la enseñanza de la sintaxís del lenguaje (los primeros capitulos es una introducción a la POO). Espero lograr mi objetivo y tener esta información, como una referencia de todo lo que me encuentre en el camino de mi aprendizaje de este lenguaje, ¡haya vamos!.

• 3 Operadores
• 4 Control de ejecución
• 5 Inicialización y limpieza
• 6 Control de acceso
• 7 Polimorfismo
• 9 Interfaces
• 10 Clases Internas
• 11 Almacenamiento de objetos
• 12 Tratamiento de errores mediante excepciones
• 13 Cadenas de caracteres
• 14 Información de tipos
• 15 Genéricos
• 16 Matrices
• 17 Análisis detallado de los contenedores
• 18 Entrada/Salida
• 19 Tipos enumerados
• 20 Anotaciones
• 21 Concurrencia
• 22 Interfaces gráficas de usuario

Observando la lista puedo decir que es una manera de ver mis avences. Espero que  alguien más le sirva

¡Saludos! nos leemos pronto…

Actualización (25/Enero/10):

• Todo es un objeto
  • Los objetos son manejados por referencias

Olvide colocar este capítulo, que es de suma importancia, que nos introduce temas básicos para construir nuestras aplicaciones.

1. Regla del producto
2. Regla de la suma
3. Permutaciones
4. Factorial de un entero no negativo
5. Permutaciones con objetos iguales
6. Permutaciones parciales
7. Variaciones con repetición
   
8. Combinaciones
9. Coeficientes binomiales
10. Triangulo de Pascal
11. Subconjuntos de un conjunto
12. Combinaciones con repetición

Este es el documento de donde se pueden ver una descripción de cada tema Combinatoria, ahora estoy revisando unas copias que tengo desde la universidad que no recuerdo de que autor es, pero creo que se titulo Matemáticas Discretas. Tengo la intención de postear en que consiste cada tema, algunos ejemplos y ejercicios. Todo esto con el objetivo de autoobligarme a estudiar, aprender y tener unos apuntes para donde estudiar. Eso es lo que muchos hacen y dicen que es bueno.

Por cierto la pagina oficial de la materia es: http://posgradomm.googlepages.com

Por ahora no me ha parecido difícil comprender estos temas, basta con unas lecturas de que trata cada tema, checar los ejemplos y resolver los ejercicios. Pasado será mi segunda clase, espero me vaya bien. bueno es todo por ahora. Nos vemos luego.

¡Saludos!

PD: Desgraciadamente no pude insertar una imagen para hacer más ilustrativo este post, pero bueno ya será después.

Sin embargo, ahora estoy más decidido ha aprender a usarlo, he ido aprendiendo poco a poco, en estas últimas semanas. Ya me canse de tanto virus y tener que estar  formateando Windows. Revisado la web, rápidamente uno se puede dar cuenta que muchos hablan de las bondades del mismo. Pero también no se puede negar que cada usuario se topa con problemas diferentes y es aquí donde la migración se vuelve frustrante, como consecuencia viene el arrepentimiento en algunos (a mi me paso), pero ahora no me importa, estoy mejor que antes. Para no darle más vuelta al asunto, enseguida les comento los problemas que he tenido:

Problemas con Aplicaciones

• Mi impresora HP no funciona. Instale el driver de Hplip siguiendo la misma guia de HP.

• Mi reproductor de sonido Creative Zen por Genomad 2 me manda el siguiente mensaje

• Sound Juicer no extrae los cd de audio, al dar clic en el botón extraer, enseguida se cierra la ventana , sólo lo hace si encuentra el album en la base de datos (no recuerdo cuál es) y eso casi nunca sucede.

Es bien sabido que no todo es perfecto, pero a mi me pasan estos problemitas y otros que no recuerdo, me queda claro que en estas cosas hay que buscarle, cómo solucionarlos, así que, lo único que he hecho es googlear, no me he ido en foros, sólo lo he intentado en ubuntu-es pero nomas no entra o tarda una eternidad en abrirse. Hace unas semanas me uní a la comunidad de Ubuntu México, y les puedo decir que me ha hido mejor, espero ir solucionado y apoyando a otros en este camino.

No todo es malo en Ubuntu. Creo que muchos hubieran escrito las cosas buenas al principio y no al final, pero ya no podía resistirme a decirlas.

Beneficios

• Tengo el sistema siempre actualizado.
• Libre de virus
• No tengo que pagar ni un solo centavo.
• Es más veloz, que antes mi equipo
• Dispongo de cientos sino miles de programas
• No tengo que estar instalando drivers
• Puedo personalizar mi sistema a mi gusto
• Dispongo de un montón de documentación para aprender a utilizarlo
• etc., etc..

Bueno finalmente, espero ir paso a paso aprendiendo de este maravillo SO. e ir invitando a otras personas a usarlo. No me queda más que agradecer haber leído estás palabras, espero cualquier comentario que ayude a comprender mejor estos temas y por cualquier tonteria que este diciendo me corrijan, por favor.

¡Saludos!

Instalación de Java en Ubuntu

Primeramente, buscando por la red, cómo instalar Java en Ubuntu, para programar me encontré con varios tutos, pero este me pareció más simple y entendible, en seguida los pasos que son copy & paste del mismo:

1. Antes que nada, debemos descargar el binario para Linux de JDK. Lo puedes descargar desde aquí, seleccionando la plataforma Linux y en la página posterior haciendo click en el segundo enlace de descarga (el primero es de arquitectura RPM). Una vez descargado, guardamos el archivo .bin en nuestra carpeta personal (/home/nombredeusuario).

2. Abrimos una terminal y nos logueamos como root (usando el comando su). Procedemos a crear el directorio de la instalación:

mkdir /usr/java

3. Le asignamos permisos de propietario a tu usuario (que es el que va a ejecutar JDK posteriormente), con el comando (ojo, cambiar tu_usuario por el de tu sesion en Debian o Ubuntu):

chown -R tu_usuario /usr/java

4. Copiamos el binario que descargamos anteriormente (JDK 6 update 11) al directorio que creamos (/usr/java) y le damos persmisos de ejecución:

cp /home/tu_usuario/jdk-6u11-linux-i586.bin  /usr/java

chmod a+x /usr/java/jdk-6u11-linux-i586.bin

5. Lanzamos la instalación del binario de JDK:

./jdk-6u11-linux-i586.bin

6. Aceptamos la licencia y procedemos con la instalación. Una vez concluída, debemos asignar permisos de propietario para nuestro usuario en la carpeta que se creó durante la instalación:

chown  -R tu_usuario  /usr/java/jdk1.6.0_11

7. Para ejecutar los comandos “java” y javac” desde cualquier ubicación hace falta editar el archivo .bashrc del superusuario (root) y de tu propio usuario. Para ello, debemos editar el archivo correspondiente para cada usuario con las siguientes lineas, mismas que se agregarán al final:

export JAVA_HOME=/usr/java/jdk1.6.0_05
export PATH=$JAVA_HOME/bin:$PATH

Para acceder a editar el archivo del usuario root:

nano /root/.bashrc

Para tu usuario:

nano /home/tu_usuario/.bashrc

8. Al terminar de añadir las líneas a ambos archivos, guardamos los cambio y cerramos la consola. JDK está instalado, con los permisos suficientes y listo para programar en Java.

En los pasos anteriores lo que hice diferente o pasos adicionales fue:

• Loguearse como root en ubuntu no fué posible ya que hasta donde recuerdo, viene desactivada, así que tuve que activarlo con las siguintes instrucciones que no recuerdo donde tome:

1. sudo passwd
2. introducimos la contraseña del actual usuario.
3. metemos la nueva contrasea del usuario root.
4. de nuevo metemos la contraseña del usuario root y listo ya podemos loguearnos como root.

• En el paso 7 en lugar de utilizar nano yo utilize gedit, ya que se me hace más fácil.

Tal como lo menciona Alan,  ya podemos programar. Esto si decidimos utilizar un editor sencillo, como gedit que viene prehinstalado en Ubuntu, para después compilar y ejecutar manualmente desde la consola. Sin embargo como queremos hacerlo con la ayuda de Geany como editor, procedemos a su instalación.

Instalación de Geany

Vamos a instalarlo enseguida desde Aplicaciones->Añadir y quitar… (seleccionando todas las aplicaciones libres o disponibles, aparece) buscamos Geany y los instalamos, una imagen a continuación del editor:

Ahora el nuevo programa nos aparecerá en una nueva categoría en Aplicaciones->Programación, luego, ya podemos teclear el siguiente código* en el archivo nuevo que aparece por default o desde una plantilla Java en Archivo-> :

//: object/HelloDate.java
 import java.util.*;

/** The first Thinking in Java example program.
 * Displays a string and today's date.
 * @author Bruce Eckel
 * @author www.MindView.net
 * @version 4.0
 */
 public class HelloDate {
 /** Entry point to class & application.
 * @param args array of string arguments
 * @throws exceptions No exceptions thrown
 */
 public static void main(String[] args) {
 System.out.println("Hello, it's: ");
 System.out.println(new Date());
 }
 } /* Output: (55% match)
 Hello, it's:
 Wed Oct 05 14:39:36 MDT 2005
 *///:~

A continuación tenemos que hacer lo siguiente para poder compilar y ejecutar desde el editor.

Intrucciones para hacer funcionar correctamente Geany

Si intentamos compilar y ejecutar desde el editor, nos mandará un mensaje indicando que no encuentra javac o java. Buscando de nuevo por la red me tope con la guía de ubuntu, donde pude darme cuenta que las instrucciones que resuelven este problema son las siguientes:

(He decidido editarlo, para adaptarlo a la instalación que se sigue, para evitar equivocaciones)

1. Setear javac de JDK como una "alternativa" (todo en la misma linea), ya que el sistema no lo reconoce:

$  sudo update-alternatives --install "/usr/bin/javac" "javac" "/usr/lib/jvm/jdk1.6.0_XX/bin/javac" 1 (XX la vesion del JDK que se descargo)

$  sudo update-alternatives --install "/usr/bin/javac" "javac" "/usr/java/jdk1.6.0_XX/bin/javac" 1 (XX la vesion del JDK que se descargo)

Seteamos el nuevo Java como una de las "alternativas de java":

$ sudo update-alternatives --install "/usr/bin/java" "java" "/usr/lib/jvm/jre1.6.0/bin/java" 1

$ sudo update-alternatives --install "/usr/bin/java" "java" "/usr/java/jdk1.6.0_XX/bin/java" 1

aquí las ejecute en orden inverso a como aparece en la guía, por qué primero necesitamos compilar y luego ejecutar, de esta forma se puede comprobar que efectivamente ejecutando ambas ordenes nos permiten ya compilar y ejecutar.

Configuración de la variable de entorno ClASSPATH

Ahora, para programar en ocasiones necesitamos importar paquetes, clases o archivos jar, creadas anteriormente para eso es necesario configurar la variable CLASSPATH, de acuerdo a la información que revise aquí, existen dos formas: la primera que sólo es funcional mientras este prendida la pc y que se hace desde la consola y la segunda que se queda lista de forma permanente, en seguida lo que hice:

En Ubuntu lo solucionamos modificando el archivo /etc/profile, recuerda hacerlo como root.

# vim /etc/profile

(e igual aqui utilize gedit, puede ser cualquier editor). A continuación se agrega la siguiente linea, donde indicamos el directorio donde podra encontrar los arhichos para su uso en nuestros programas.

CLASSPATH=/directorio/

Para establecer mas de un directorio los separamos con dos puntos ":".

CLASSPATH=/directorio1/:/diretorio2/

Hasta aquí todo hiba bien, pero luego tenia problemas al ejecutar; fue luego que mrcomputer en un comentario daba la solución e indica el por qué:

Lo qu haces es añadir el directorio actual para que a la hora de ejecutar una aplicacion busque los .class también en el directorio actual.

, quedando de la siguiente forma, con un directorio:

CLASSPATH =/directorio/:./

pero si quiero un directorio más, ¿cómo?, no encontraba cómo, pero, siendo un poquito observador fue fácil:

CLASSPATH =/directorio1/:./:/directorio2/:./

bueno solo guardamos los cambios y listo ya podemos programar, con la ayuda del editor e importar otras clases indicadas en los directorios en nuestros programas.

Finalmente, espero que ha alguien más le sirva esto que probe para programar en Ubuntu, es una forma de no perderme para después. Por cualquier duda, critica constructiva, o algún error mio, comenten por favor.

Saludos!

JM.

*Código extraido del libro Piensa en Java de Bruce Eckel, 4ta edición.

Para darse una idea, es como tener un cochecito (sería el objeto) que dispone de un control remoto (la referencia), donde siempre que contemos con la referencia mantendremos comunicación con el cochecito, si alguna persona nos pide, haz avanzar el coche, frenar, acelerar, todo esto lo haremos desde la referencia e inmediatamente, éste lo hará sobre el objeto. Teniendo el control (referencia) en mano, podemos movernos de un lugar a otro, sin necesidad de llevar con nosotros el cochecito y seguiremos manejándolo.

Otra cosa interesante, es que no necesitamos del cochecito para que exista el control remoto, éste puede existir de forma autónoma.  Es decir que podemos crear una referencia sin necesariamente asociarla a un objeto. Por poner un ejemplo si necesitamos guardar alguna palabra u oración lo que hacemos es crear una nueva  referencia de  tipo String.

String miPalabra;
String miOracion;

En este momento, unicamente tenemos la referencia al objeto, si se nos ocurrierá mandar algún mensaje a alguna de las referencias anteriores, nos devolvería error, ya que aún no existe un objeto (no tenemos cochecito) asociado a éstos.  Una recomendación que nos hacen es que al momentos de crear referencias tenemos que inicializarlas, para evitar problemas posteriores.

String miPalabra = "abcde";

String miOracion = "Aprendiendo a programar en Java";

Aqui hay que resaltar que se esta inicializando las cadenas de una forma no genérica de Objetos,  sino con textos entre comillas “”,  mismo que el lenguaje permite, pero es indispensable usar un tipo genérico en adelante.

Bueno, ya para concluir, espero haber comprendido y poder explicarme en este tema fundamental del Lenguaje Java, nos vemos la próxima, cualquier duda o comentario que ayude a entender mejor estos conceptos, son bienvenidos.