A continuación adjunto cuatro pruebas que se han hecho en el optativo de certificación para java, el cual nos ha ido a todos como las #$%&”#$%& y ahora espero mejoremos en estas cuatro pruebas que faltan.
se que a mas de alguno les servirá pues cada prueba viene con sus respuestas pero la idea sería que las respondan a consciencia, sin nada mas que decir, a estudiar se ha dicho 
Prueba1
Prueba2
Prueba3
Prueba4
Prueba5
Prueba6
by AngerRising
Hoy he tenido que recurrir a la biblioteca a retirar algun librito que me permita poder estudiar java mas profundamente, porque la verdad este asunto de la certificacion está muy complicado, son tantos los detalles que como programadores se nos escapan que el tema es bastante serio … jajaja te reirás de mi pero ponte a hacer alguna que otra pregunta de certificacion y mas de alguna te dejará pillo, bueno que mas dá, el tema es que he tenido que volver a repasar desde lo mas básico como lo son las variables, y es por ello el siguiente post … siento latearlos con tanto java, pero creo que estaré hablando de esto por lo menos un mes y medio mas, vamos al grano mejor.
Las variables son espacios de memoria donde almacenar datos que son manipulados por el programa durante su ejecución, por ende los datos que hay en ellas pueden ir variando en el transcurso de tiempo y es por ello el nombre que llevan.
Para clasificar las variables tenemos dos categorías, variables primitivas y variables de instancia, las cuales serán explicadas a continuación:
a) variables primitivas: Las variables primitivas son aquellas que podemos encontrar en cualquier otro lenguaje de programación y su objetivo es almacenar un dato simple, a su vez están deben estar declaradas con anticipación.
b) variables de instancia: Las variables de instancia son todas aquellas que hacen referencia a un objeto de una clase, estas tienen una complejidad mas grande que las variables primitivas puesto que su comportamiento puede variar dependiendo de lo que permita realizar con ellas.
A continuación se explicará todo lo que concierne a las variables primitivas, puesto que las variables de instancia abarca mucho mas que a un capitulo.
Los números ordinales son aquellos que nos permiten contar cosas, osea asignarles un numero de orden, en la siguiente tabla se describe los tipos de variables que permiten identificar este tipo de números.
+---------------------------------------------------------+ | Tipo | Byetes | Nombre | Rango de Valores | + --------------------------------------------------------+ | byte | 1 | byte | -128 a 127 | | short | 2 | entero corto | -32768 a 32767 | | int | 4 | entero | -2^31 a 2^31-1 | | long | 8 | entero largo | -2^63 a 2^63-1 | +---------------------------------------------------------+
A continuación se muestra un programa donde se declaran y asignan valores a las variables primitivas correspondientes a números enteros u ordinales en java.
public class Asigna{
public static void main(String [] args){
byte mini;
short enteroCorto;
int entero;
long enteroLargo;
mini = (byte)87; // no es necesario el casting
enteroCorto = 23000;
entero = 2300000;
enteroLargo = 109999915;
System.out.println(“Entero mini: “+mini);
System.out.println(“Entero corto: “+enteroCorto);
System.out.println(“Entero Normal: “+entero);
System.out.println(“Entero Largo: “+enteroLargo);
}
}
Mostrando como salida lo siguiente:
bastian@Error-5500:~$ java Asigna
Entero mini: 87
Entero corto: 23000
Entero Normal: 2300000
Entero Largo: 109999915
Los datos de números reales son todos aquellos que poseen decimales como por ejemplo 123.45E+12 que significa que su valor es 123.45 multiplicado por 10 elevado a 12 (ya que los números reales están almacenados en potencias de 10).
La siguiente tabla muestra la lista de tipos de variables reales
+----------------------------------------------------------------------------+ | Tipo | Byetes | Nombre | Rango de Valores | + ---------------------------------------------------------------------------+ | float | 4 | real simple precisión | -3.4X10^38 a -1.4X10^-45 | | | | | 1.4^-45X10^-45 a 3.4X10^38 | | double | 8 | real doble precisión | -1.8X10^308 a -4.9X10^-324 | | | | |4.9X10^-324 a 1.8X10^308 | + ---------------------------------------------------------------------------+
A continuación se presenta un programa que muestra como usar las variables de reales o de coma flotante.
public class AsignaReales{
public static void main(String [] args){
float interes;
double capital;
interes = 6.2F;
capital = 3.7E+9D;
System.out.println(“Interés = “+interes);
System.out.println(“Capital = “+capital);
}
}
Dando como salida lo siguiente:
bastian@Error-5500:~$ java AsignaReales
Interés = 6.2
Capital = 3.7E9
Finalmente, completando la lista de tipos de variables primitivas estas son las variables boolean (logicas) y las variables char (caracteres). Las variables boolean pueden contener solo 2 valores true o false y utilizan para su almacenamiento un bit. En java no se pueden interpretar las variables enteras ni de ningún tipo como tipo boolean y viceversa.
En cuanto a las variables char utilizan 16 bits y codifican caracteres según el formato unicode
La siguiente tabla muestra algunos de los caracteres especiales mas utilizados.
+--------------------------------------------------+ | Caracter | Denominación | + -------------------------------------------------+ | '\n' | salto de linea | | '\t' | tabulador | | '\r' | retorno del carro | | '\'' | comillas simples | | '\\' | contra-barra (backslash) | | '\"' | doble comillas | | '\xxx' | caracter en octal | | '' | caracter nulo (null) | | '\uxxxx' | caracter en hexadecimal unicode | + -------------------------------------------------+
A continuación se mostrará un ejemplo de como declarar y asignar valores a variables boolean y de tipo char.
public class AsignaOtras{
public static void main(String [] args){
boolean esCierto;
char letra;
esCierto = false;
letra = ‘a’;
System.out.println(“Es cierto = “+esCierto);
System.out.println(“Letra = “+letra);
letra = ‘\r’;
System.out.println(“Este texto\n se ve en \ntres lineas”);
}
}
y su salida seria la siguiente:
bastian@Error-5500:~$ java AsignaOtras
Es cierto = false
Letra = a
Este texto
se ve en
tres lineas
continuará …
by AngerRising
Tanto darle y darle a java, y ver los pésimos resultados 
no quiero perder la adoración por mi lenguaje de programación preferido, y en honor a él he aquí la preparación del café que le dió origen a su nombre … JAVA.
Receta Café Java
Disfruta de esta combinación de café y chocolate.
1. Prepara un café solo.
2. Aparte, en un cazo, prepara el chocolate caliente.
3. Después, mezcla el café con el chocolate sin que llegue a hervir.
4. Sírvelo en un tazón.
Ingredientes
(1 persona)
café molido Marcilla (para 1 taza)
chocolate en polvo (1 taza)
Fuente: Aquí
by AngerRising
Revisando los foros de la Comunidad de Dragonjar me metí a la sección de programación en Java y por casualidad encontré unos materiales y un simulador para la certificación SCJA donde a pesar que quiero certificarme para SCJP nos puede servir de todas maneras, los enlaces son los siguientes:
Aquí está el enlace del material
http://www.megaupload.com/?d=2RHQE4LJ
Aquí viene el temario con el simulador
http://www.megaupload.com/?d=9UT38HQX
Se que les agradará, aprovechenlo, salu2
Fuente: Aquí
by AngerRising
Mientras estudiaba las preguntas para la certificación de java, se me presentó un caso de clases anidadas conocidas como nested classes o clases internas también conocidas como inner classes, el asunto es que me he visto obligado a averiguar sobre ellas puesto que no manejo muy bien sus detalles y pillé el siguiente slide que quiero compartir con ustedes, está muy bueno y está compuesto por 11 diapositivas muy bién explicadas asi que aprovechenlo 
by AngerRising
Glossary
Aquí les dejo un glosario de Java2 bien bueno, está en idioma ingles pero se los recomiendo, saludos.
Archivo: Glosario.pdf
Tamaño: 168 kb
by AngerRising
java
Aserciones (assert)
Las aserciones son introducidas en la versión 1.4 de Java, y sirven para establecer cómo se comportará el flujo de la información (etapa de prueba). No es para detectar errores en la entrada de datos.
Para colocar una aserción se utiliza la palabra clave assert; esto es,
assert expresión1 [: expresión2];
Donde,
Expresión1: define la aserción que se desea controlar
Expresión2: Es opcional, sirve para que en caso de no cumplirse la expresión1, pasarle un valor concreto al error que se produce. Este valor puede ser el valor de una variable o un String.
Ejemplo:
class Aser
{
public static void main(String[]arg)
{
int a=10;
assert a>=0 &&a<=5 : metodo();
System.out.println(“todo bien”);
}
static String metodo()
{
return “Se sale del rango especificado”;
}
}
Java lo que hace es no chequear las aserciones salvo que le indiquemos explícitamente que queremos que lo haga:
java -ea miPrograma //activa las aserciones de mi programa
java -da miPrograma //las desactiva
java -ea:class miPrograma //activa las aserciones de mi programa; pero sólo en la clase class
java -da:class miPrograma //desactiva las aserciones de la clase class
java -ea:package… miPrograma //activa las aserciones de mi programa; pero sólo en el paquete package
java -da:package… miPrograma //desactiva las aserciones del paquete package
Criterios
Son las aserciones un arma poderosa para detectar errores antes de perder el control del programa; pero hay que usarla con prudencia y sabiduría.
NO se deben usar a la entrada de métodos públicos
NO se deben usar para detectar errores en los datos de entrada al programa
SI se deben usar a la entrada de métodos privados
SI se deben usar a la salida de métodos públicos o privados
SI se deben usar para chequear cómo suponemos que están las variables y estructuras de datos internas
SI se deben usar en la clausula else de construcciones switch cuando todos los casos correctos están explícitos (es decir, cuando la rama else no debería tomarse jamás)
SI se deben usar en el último else de cadenas if … else if … switch cuando todos los casos correctos están explicitados (es decir, cuando el último else no debería tomarse jamás)
SI se deben usarse en bucles largos (siguiendo el concepto de invariantes de bucle)
Documento hecho por Sonia Arriagada
by AngerRising
java
Tipos enumerados
Los tipos enumerados permiten definir nuevos tipos de datos cuyos posibles valores están limitados a un determinado conjunto dado.
El formato para definir un tipo enumerado es:
[public] enum NombreTipo {VALOR1, VALOR2,…}
Donde:
NombreTipo: es el identificador que se va asignar al tipo enumerado
VALORN: son los posibles valores que puede tomar
La declaración de un tipo enumerado puede estar en el interior de una clase o en el exterior, pero nunca en el interior de un método
Ejemplo:
Se puede colocar al final de la declaración del enum un punto y como
Constructores y métodos de una enumeración
Un enum es un tipo de dato (clase), por lo tanto, se pueden definir constructores y métodos, los cuales deben estar declarados después de la lista de valores de la enumeración
El enum puede estar declarado fuera o dentro de una clase. Si está declarado fuera, NUNCA se declarará static; en cambio si está dentro, si puede ser static
Ejemplo:
Donde:
System.out.println(maq.venta()); // Mostrará: Retire su cafe
System.out.println(maq.name()); // Mostrará: NORMAL
System.out.println(maq.getCantidad()); // Mostrará: 2
System.out.println(maq.ordinal()); // Mostrará: 2 (se refiere al elemento)
maq.values() // devuleve un array con todos los objetos
Documento hecho por Sonia Arriagada.
by AngerRising
Por fin he logrado hacer que desaparezca el segmento index.php de la url de mi servidor apache bajo el frameword CodeIgniter, si antes la URL se veía:
http://localhost/MundoPatitas/index.php/crear_cuenta
ahora a quedado en esto
http://localhost/MundoPatitas/crear_cuenta
Mucho mas vistoso si se podrán haber dado cuenta, para ello debemos hacer modificaciones tanto a nivel servidor (apache) y a nivel de framework, para ello debemos hacer lo siguiente:
1.- Primero habilitamos el Mod_Rewrite escribiendo en consola:
$sudo a2enmod rewrite
2.- Debemos modificar todos los campos que dicen “AllowOverride None” por “AllowOverride All” del siguiente documento:
$sudo gedit /etc/apache2/site-enable/000-default
3.- Reiniciamos apache
$sudo /etc/init.d/apache2 restart
Ahora que tenemos activado el Mod_Rewrite tenemos que hacer las configuraciones que respectan a nuestro framework.
1.- Nos vamos al archivo de configuración que se encuentra ubicado en el directorio “application/config/config.php” y cambiamos los siguientes campos:
$config['index_page'] = “index.php”;
El cual debería quedarnos así:
$config['index_page'] = “”;
2.- Y finalmente en el directorio raíz, que en mi caso es “/var/www/MundoPatitas” debemos crear un archivo llamado “.htaccess” el cual debe tener el siguiente contenido:
# Customized error messages.
ErrorDocument 404 /index.php
# Set the default handler.
DirectoryIndex index.php
# Various rewrite rules.
<IfModule mod_rewrite.c>
RewriteEngine on
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php/$1 [L,QSA]
</IfModule>
Con esto ya deberíamos tener habilitado el sistema para poder sacar el TÓXICO index.php de nuestra URL, espero les sirva pues me costó su buenas horas en pillar la solución, saludos 
PD: si por alguna razón, al levantar apache les arroja lo siguiente:
apache2: Could not reliably determine the server’s fully qualified domain name, using 127.0.1.1 for ServerName
La solución está en agregar al documento apache2.conf la siguiente línea al principio del documento:
ServerName localhost
Fuentes:
by AngerRising
El día miércoles 2 de septiembre se realizó en DuocUC una charla sobre como certificarse en SCJP y sus beneficios en comparación de los programadores no certificados. Los siguientes apuntes fueron tomados por mi y los encontré bastante buenos como para compartirlos con ustedes, saludos.
¿Que es una certificación?
SCJP
Beneficios
¿Que debo saber?
Objetivos del examen SCJP
¿Donde me inscribo?
¿Donde me preparo?
¿Donde puedo conseguir ayuda?
by AngerRising
Estas viendo los archivos de la categoría Programación.
RSS
