inicio
colores inicio colores libro W3c ColorPicker
#7c16cb #f6b33d #d29105 #a53df6 #fc8d83 #f2ab1e #f0c911 #8cb82b #005200 #9dce2c #378de5 #79bbff #e4685d silver #495252 khaki gold blue
iconos inicio iconos libro
myHTML inicio HTML libro
myCSS inicio CSS libro
myAJAX inicio AJAX libro
myPHP inicio PHP libro
myJavaScript inicio JavaScript libro
aviso de depuración:
	//aviso de depuración
	function jsaviso(aviso) {
	alert(aviso);
	}		
	
myJava inicio Java libro
myMySQL inicio MySQL libro
				Puesta en marcha:
				Añadir alias para acceder a Mywww
				c:/users/miguel/documents/Mywww/
				
				en my.ini (configuración PHP), modificar el valor de datadir:
				#Path to the database root
				#datadir = "${path}/binaries/mysql/data/"
				datadir = "c:/users/miguel/documents/MyBBDD/"

				#innodb_data_home_dir = "C:/Program Files (x86)/EasyPHP-DevServer-14.1VC11/binaries/mysql/data/"
				innodb_data_home_dir = "c:/users/miguel/documents/MyBBDD/"
				datadir = "c:/users/miguel/documents/MyBBDD/"
				innodb_data_file_path = ibdata1:10M:autoextend
				#innodb_log_group_home_dir = "C:/Program Files (x86)/EasyPHP-DevServer-14.1VC11/binaries/mysql/data/"
				innodb_log_group_home_dir = "c:/users/miguel/documents/MyBBDD/"
			
En config.inc.php, modificar:
				/*
				 * Directories for saving/loading files from server
				 */
				$cfg['UploadDir'] = 'C:\Users\Miguel\Documents\MyBBDD'; 	//'../../data/databases';
				$cfg['SaveDir'] = 'C:\Users\Miguel\Documents\MyBBDD';		//'../../data/databases';
			
myEasyPHP inicio EasyPHP libro
myJQuery inicio JQuery libro
colores inicio colores libro
iconos inicio iconos libro
HTML inicio HTML libro
background-color padding border margin
Sirve para mantener el formato original
CSS inicio CSS libro
visibilityvisible / hidden letter-spacing 'normal'/ tamaño @import url(http://fonts.googleapis.com/css?family=Open+Sans:800); @import url(http://fonts.googleapis.com/css?family=Open+Sans:800&;effect=3d;
AJAX inicio AJAX libro
PHP inicio PHP libro
JavaScript inicio JavaScript libro
Java inicio Java libro
MySQL inicio MySQL libro
EasyPHP inicio EasyPHP libro
JQuery inicio JQuery libro
==========================================================================================================================================

HTML Índice

Form. Envío por botones. Función JavaScript.
==========================================================================================================================================

CSS Índice

NOTAS:
idx puede ser cualquier identificador: id :(etiqueta) .id :(clase) #id :(elemento del DOM))
id1 id2 { ...} Afecta a id2 dentro de id1
==========================================================================================================================================

AJAX Índice

==========================================================================================================================================

PHP Índice

==========================================================================================================================================

JavaScript Índice

==========================================================================================================================================

Java Índice

package org.upv.cursoandroid.unidad0;

import android.app.Activity;
import android.content.BroadcastReceiver;
import …
	
Definición de clase:
class <'Clase'>  {
   //declaración de atributos
  [visibilidad] [modificadores] <'tipo'> <'atributo'> [= valor];
  ...
 
  //declaración de constructor
  public <'Clase'>(<'argumentos'>) {
	<'instrucciones'>;
  }
  //declaración de métodos
  [visibilidad] [modificadores] <'tipo'> <'método'>(<'argumentos'>) {
	<'instrucciones'>;
  }
  ...
}	 

donde:       [visibilidad] = public, protected o private
			[modificadores] = final, static y abstract
	
main class: La clase Principal es algo atípica, no tiene atributos ni constructor, únicamente el método main.
Cuando en un proyecto existe una clase que tiene un método con este perfil, es el que se llama para comenzar la ejecución.
class Principal {
	public static void main(String[] main) {
		Complejo z, w;
		z = new Complejo(-1.5, 3.0);
		w = new Complejo(-1.2, 2.4);
		-o-
		<'Clase'> <'objeto'> = new <'Clase'>(<'parámetros'>);
		Complejo z = new Complejo(-1.5, 3.0);
		z.suma(w);
		System.out.println("Complejo: " + z.toString());
	}
}
	
En Java si añadimos cualquier objeto a una expresión de texto, se utilizará el método toString() para convertir el objeto a texto. Visibilidad:
public: accesibles desde cualquier clase.
private: sólo son accesibles por la clase actual.
protected: sólo por la clase actual, sus descendientes y clases de nuestro paquete.

 sólo son accesibles por clases de nuestro paquete.	

public double getReal() {
   return real;
}

public void setReal(double real) {
   this.real = real;
} 			
	
Herencia:
extends : Indica clase de la que hereda. Clase padre.
super: Se refiere a los atributos y métodos 'public' de la clase padre.
También se pueden definir en la clase padre como 'protected', para no tener que utilizar get.
@Override : redefinición de una clase del padre. No es obligatorio, pero sí conveniente.
class ComplejoAmpliado extends Complejo {

  private boolean esReal;

  public ComplejoAmpliado(double re, double im) {
	super(re, im);
	esReal = im ==0;
  }

  public ComplejoAmpliado(double re) {
	super(re, 0);
	esReal= true;
  }

  @Override
  public void suma(Complejo v) {
	esReal = getImaginario() == - v.getImaginario();
	super.suma(v);
  }

  @Override
  public String toString() {
	if(esReal) {
	  return getReal() + " ¡real!";
	} else{
	  return super.toString();
	}
  }

  public boolean esReal(){
	return esReal;
  }

}
		
La clase Object Es la raíz del arbol de clases en Java.
Dispone de métodos predefinidos: toString(), getClass()o equals(Object o)...
Polimorfismo: El polimorfismo consiste en declarar un objeto de una clase, pero instanciarlo como un descendiente de dicha clase (lo contrario no es posible). Es decir, utilizaremos la siguiente expresión:
	 <'Clase_padre'> <'objeto'> = new <'Clase_hija'>(<'parámetros'>);
		
Conversión de tipos: Declarado un objeto de una clase pero lo hemos construido utilizando un constructor de una clase descendiente.
Vamos a poder utilizar cualquier método de c definido en la clase Complejo o cualquiera de sus descendientes.
<'Clase'> <'objeto'>

A partir de este momento será considerado de la clase <'Clase'>. Aunque no no haya sido declarada de esta clase
Complejo c = new ComplejoAmpliado(12.4);
 
c.toString();
c.getClass();

((ComplejoAmpliado)c).esReal()
instanceof: Podemos averiguar si un objeto es de una determinada clase usando la siguiente expresión:
<'objeto'> instanceof <'Clase'>
Complejo c = new ComplejoAmpliado(12.4);
if (c instanceof Object)… //siempre true
if (c instanceof Complejo)… //true
if (c instanceof ComplejoAmpliado)… //true
if (((ComplejoAmpliado)c).esReal())…
Tipos enumerados en Java : Se trata de un tipo de dato que solo puede tomar como valores los definidos en una lista.
Un enum se declara de la siguiente forma:
	[visibilidad][modificadores] enum <'Nombre> {VALOR1, VALOR2, VALOR3, ...}

dónde:      [visibilidad] = public, protected o private
			[modificadores] = static
se suelen escribir en nombre del enum comenzando por mayúscula y sus posibles valores todo en mayúsculas al tratarse de constantes.

Ejemplo:
   public enum Dia {LUNES, MARTES, MIÉRCOLES, JUEVES, VIERNES, SABADO, DOMINGO}

Una vez creado el tipo enum ya podemos declarar variables y asignarles valores:

   Dia dia;
   dia = Dia.JUEVES;
nueva clase descendiente de la clase Enum(java.lang.Enum)
Se pueden declarar el enum dentro o fuera de una clase, pero nunca dentro de un método. Si quieres que esté disponible en todo el proyecto, lo ideal es declararlo de forma pública en un fichero separado con el mismo nombre que el enum y extensión .java.
		
Veamos un ejemplo de uso de algunos métodos disponibles:

Dia dia = Dia.JUEVES;
dia.name()  →  "JUEVES"
dia.ordinal()  →  3
dia.compareTo(Dia.MARTES)  →  1-3 = 2
Dia.valueOf("JUEVES")  →  Dia.JUEVES
for (Dia d: Dia.values()){
     System.out.print(d+ ",");  →  "LUNES, MARTES, MIERCOLES,…"	
un enum en Java puede contener atributos y métodos. Estos atributos y métodos suelen utilizarse para asociar valores a cada una de las constantes de un enum
public enum VersionAndroid {
   CUPCAKE(3), DONUT(4), ECLAIR(5), FROYO(8), GINGERBREAD(9),
   HONEYCOMB(11), ICE_CREAM(14), JELLY_BEAN(16), KITKAT(19);

   private int nivelAPI;

   private VersionAndroid(int nivelAPI){
		 this.nivelAPI = nivelAPI;
   }

   int getNivelAPI(){
		 return nivelAPI;
   }
}
Las colecciones en Java estructuras de datos para almacenar y recuperar objetos de cualquier clase
son clases definidas en el paquete java.util
 Coleccion<'Clase> nombre = new Coleccion<'Clase>();
Donde Coleccion es una clase de este framework que queramos utilizar según la estructura de almacenamiento que nos interese y Clase representa el tipo de datos a almacenar.

Por ejemplo, para crear una lista ordenada de objetos de la clase String escribiríamos:
ArrayList<'String> listaNombres = new ArrayList<'String>();
...
Hay tres tipos de colecciones, cada uno con un interfaz común y diferentes implementaciones.
Las diferentes implementaciones de un mismo interfaz realizan la misma tarea aunque la diferencia está en que unas implementaciones son más rápidas en algunas operaciones y más lentas en otras:

Conjunto –
los elementos no tienen un orden y no se permiten duplicados.Se define el interfaz Set<'E>.
Podemos utilizar las siguientes implementaciones:
HashSet<'E> (implementación con tabla hash),
LinkedHashSet<'E> (tabla hash +doble lista enlazada),
TreeSet<'E> (implementación con árbol)

Listas –
estructura secuencial, donde cada elemento tiene un índice o posición. Se utiliza el interfaz List<'E>.
Podemos utilizar las siguientes implementaciones:
ArrayList<'E> (acceso rápido),
LinkedList<'E>(inserciones/borrado rápidas),
Stack<'E> (pila),
Vector<'E> (obsoleto)

Diccionario o Matriz asociativa –
cada elemento tiene asociado una clave que usaremos para recuperarlo. Se utiliza el interfaz Map<'K,V>.
Podemos utilizar las siguientes implementaciones:
HashMap<'K,V>, TreeMap<'K,V>, LinkedHashMap<'K,V>
		
 los interfaces List<'E> y Set<'E> heredan del interface Collection<'E>. 
 
A continuación se enumeran los métodos comunes a los interfaces List<'E> y Set<'E>, que son recogidos en el interface Collection. Supondremos que el elemento e es un objeto de la clase E:
boolean add(E e): Añade un nuevo elemento al final de la lista.
boolean remove(E e): Elimina la primera ocurrencia del elemento indicado.
boolean contains(E e): Comprueba si el elemento especificado está en la colección.

void clear(): Elimina todos los elementos de la colección.
int size(): Devuelve el número de elementos en la colección.
boolean isEmpty(Collection<'?> c): Comprueba si la colección está vacía.
Los siguientes métodos combinan dos colecciones:
boolean addAll(Collection<'?> c) : Añade todos los elementos de la colección c.
boolean removeAll(Collection<'?> c): Elimina todos los elementos de c.
boolean containsAll(Collection<'?> c): Comprueba si coinciden las colecciones.
boolean retainAll(Collection<'?> c): Elimina todos los elementos a no ser que estén en c. (obtiene la  intersección).
Conjuntos Los conjuntos son estructuras de datos donde los elementos no tienen un orden y no se permiten duplicados. Para definirlos se utiliza la interfaz Set<'E'>,
 : El siguiente ejemplo muestra cómo crear un conjunto de Strings y luego recorrerlo para mostrarlo en consola:

Set<'String'> conjunto = new HashSet(); conjunto.add("manzana");
conjunto.add("pera");
conjunto.add("fresa");
conjunto.add("naranja");
conjunto.remove("pera");
for(String s : conjunto) {
     System.out.println(s);
}
Listas Una lista es una estructura secuencial, donde cada elemento tiene un índice o posición. También recibe el nombre de array o vector unidimensional. El índice de una lista es siempre un entero y el primer elemento ocupa la posición 0.
Para trabajar con ellas se utiliza el interfaz List<'E'>. Las implementaciones más recomendables son: ArrayList<'E'> si queremos acceder a una posición de forma muy rápida o LinkedList<'E'> si queremos inserciones y borrado muy rápidos.
La interfaz List<'E'> hereda todos los métodos de Collection<'E'> y añade los siguientes:
boolean add(int indice, E e): Inserta un nuevo elemento en una posición.
El elemento que estaba en esta posición y los siguientes pararán a la siguiente.
E get(int indice): Devuelve el elemento en la posición especificada.
int indexOf(E e): Primera posición en la que se encuentra un elemento; -1 si no está.
int lastIndexOf(E e): Última posición del el elemento especificado; o -1 si no está.
E remove(int indice): Elimina el elemento de la posición indicada.
E set(int indice, E e): Pone un nuevo elemento en la posición indicada. Devuelve el elemento que se encontraba en dicha posición anteriormente.

 El siguiente ejemplo muestro como crear una lista de complejos y luego recorrerla:

List<'Complejo'> lista = new ArrayList<'Complejo'>();     lista.add( new Complejo(1.0, 5.0) );
lista.add( new Complejo(2.0, 4.2) );
lista.add(1, new Complejo(3.0, 0.0) );lista.remove(0);
for(Complejo c: lista) {
    System.out.println(c);
}
==========================================================================================================================================

MySQL Índice

Fechas:
			$ssql="select *, DATE_FORMAT(dn_mov_date,'%d/%m/%Y') as vdn_mov_date  from ".DINEROS.".dn_movs where " .$ssql;		
		
==========================================================================================================================================

EasyPHP Índice

==========================================================================================================================================

JQuery Índice

==========================================================================================================================================

BBcode Índice

http://es.wikipedia.org/wiki/BBCode http://pear.php.net/manual/en/installation.shared.php ==========================================================================================================================================