Resumen Android Studio (Java)
TIPS
* static NO es igual que en VB (ver en 'Definiciones')
* Los argumentos que sean variables primitivas no se pueden pasar por referencia. Se
deben crear objetos/estructuras para este fin, ya que estos sí pasan por referencia.
* Las variables propias de cada método no van con private, sino que van directas.
DEFINICIONES
VariablesMiembros : Propiedades de una clase
constructor base : el que no llama a otro constructor.
ELEMENTOS PROPIOS DE ANDROID
activity : son contenedores de elementos, son entidades de ejecución. Generalmente
ocupan toda la pantalla pero no es necesario.
ELEMENTOS PROPIOS DE JAVA
paquete : son contenedores de clases que permiten delimitar el espacio en el cual una
clase existe.
this : referencia a la clase actual (VB 'Me')
super : referencia a la superclase (VB 'MyBase')
static : común a toda la clase (VB Shared)
tipo de dato primitivo (de valor) : enteros, doble, caracter, buleano
tipo de dato de referencia : objetos, estructuras (array y otros)
Garbage Collector : proceso que recoge y elimina toda la memoria que fue
desreferenciada. Es decir, si a una referencia se le asignó un Array y a la línea
siguiente se le asigna NULL, como ese Array no posee nadie que lo referencie (quedó
huérfano) es ELIMINADO!
REFERENCIAR
int casa;
casa = auto.cantidad_puertas; // miembro static (común a toda la clase)
Especificadores de Acceso
* public : cualquier parte del programa.
* protected : solo se tiene acceso desde la clase misma y las que la hereden, siendo en
este caso tratada como privada (private).
* private : solo se tiene acceso en la clase misma.
* (default) : en caso de no poner especificador alguno. Solo se tiene acceso público,
pero dentro del mismo paquete.
Alcance de Especificadores de Acceso PUBLIC PROTECTED DEFAULT PRIVATE
Misma clase X X X X
Subclase en el mismo paquete X X X -
Otra clase en el mismo paquete X X X -
Subclase en otro paquete X X - -
Otra clase en otro paquete X - - -
Declaracion variables
[especificadordeAcceso] [static] [final] [transient] [volatile] TIPO IDVARIABLE
¡Atención! Se requiere inicializar todas las variables antes de usarlas, si no el compilador genera un error y aborta la
compilación.
* static : indica que la variable es una variable miembro de la clase en oposición a
una variable miembro del ejemplar. Se puede utilizar static para declarar métodos de
clase. Miembros de Clase y de Ejemplar explica la declaración de variables de clase y
de ejemplar y escribir métodos de ejemplar o de clase.
* final : indica que la variable es una constante. Debe ser inicializada in-situ.
Generalmente su id se escribe en MAYUSCULA.
* transient : la variable no es una parte persistente del estado del objeto
* volatile : significa que la variable es modificada de forma asíncrona.(en distintos
threads)
Declaración de clases
[public][final(no heredable)][abstract(no instanciable)] class IDCLASE [extends CLASE]
[implements INTERFAZ-1,INTERFAZ-N] {}
* final : indica que esta clase NO es heredable.
* abstract : indica que esta clase NO es instanciable (no se puede hacer un New de la
misma). Está pensada para ser heredada, y definir algún método que desde la subclase
será invocado.
* extends : palabra clave que indica la CLASE de la que se heredarán variables y
funciones miembros (ya que los constructores no se heredan).
* implements : palabra clave que indica la o las INTERFACES que se implementarán en
esta clase; es decir, las clases cuyas declaraciones DEBEN ESTAR DEFINIDAS en esta
clase. Si alguna función de la interfaz faltara definir, el programa no compilará.
Declaración de subclases
Son clases anidadas que pueden tener definición completa o ser una clase anónima (es
decir, una clase sin nombre).
Su aplicación principal es en el manejo de eventos
Declaración de interfaces
[public] interface ID{}
Declaración de funciones
[especificadordeAcceso] [static] [abstract] [final] [native] [synchronized] TIPO
IDMETODO([listadeparámetros]) [throws listadeExcepciones] {}
* static : indica que es común de toda la clase
* abstract : indica una función abstracta; quiere decir que no servirá su declaración,
sino que DEBE SER SOBREESCRITA por las subclases. Al ser abstracta, la clase entera
debe ser abstracta.
* final : indica que no puede ser sobreescrita por ninguna subclase.
* native :
* synchronized :
- listadeparámetros : en Java, lo que se pasa por parámetro es SIEMPRE una COPIA de la
referencia al objeto que se pase por el parámetro
* throws : indica que dentro de la misma se podrá lanzar determinada lista de
Excepciones (se separan con “,”). También se puede indicar una Superclase de las
mismas.
Declaración de Constructores
[public] IDCLASE([listadeparametros]) {
super([listadeparametros2]); // debe ser la PRIMER LINEA del constructor base
// puede llamar a otro constructor
}
* super() : llamada al constructor de la Superclase
Paquetes: Pertenencia de la clase a uno
Los paquetes pueden organizarse como una jerarquía. Para esto, se separa el nombre de
cada paquete por medio de un punto:
package paq1.paq2.paq3;
Para indicar que una clase pertenece a un cierto paquete, se utiliza la palabra clave
package,como PRIMER LINEA del archivo .java:
package [Link];
…
public class bla {
…
}
Instanciación de un objeto
IDVARIABLE = New IDCLASE;
Toma de Decisiones
* if() {}
else if() {}
else {}
* switch(){
case 8: blah
case 9.
blah
break;
default:
}
Bucles: for, while, do-while (como en C)
Excepciones: try-catch-finally, throw
Miscelaneas: break ETIQUETA; , continue ETIQUETA; , LABEL: , return VALOR;
----------------------------------------------------------
Estructuras:
Array:
TIPO[][] ID = new int[10][5]; (es un objeto)
Funciones: [Link]
Manejo: ID[dim1][dim2] = blah....
Garbage Collector (se ejecuta de vez en cuando)
[Link]()
Finalize()
El método finalize() es un miembro de la clase [Link]. Una clase debe
sobreescribir el método finalize() para realizar cualquier finalización necesaria para
los objetos de ese tipo.
----------------------------------------------------------
TIPOS DE DATO PRIMITIVOS
Tipo Tipo Tamaño (bytes) Rango
Entero byte 1 -128 a 127
Entero short 2 -32768 a 32767
Entero int 4 -2147483648 a 2147483647
Entero long 8 -9223372036854775808 a 9223372036854775807 ;Ej: 9022L
Real float 4 - 3.40282347E+38 a + 3.40282347E+38 ;Ej: 90,22F
Real double 8 - 179769313486231570E+308 a + 179769313486231570E+308
Texto char X ‘a’ o ‘+’ o “sin” o “ataque específico”
Lógico boolean true o false
Reglas de conversión entre Tipos
Prioridad en Numéricos:
- Si algún operando es … , todos se convertirán a …
double <- float <-long <- int <- short <- byte
Particularidad de Char:
- Si se concatena a un objeto String, SE CONVIERTE a String.
- Si se asigna a un objeto String, NO SE CONVIERTE!! ¿Qué hago?
char caracter = ‘a’;
String aux = “” + caracter;
----------------------------------------------------------
OPERADORES
Aritméticos:
+ (suma), - (resta), * (producto), / (división), % (resto división entera), -- (decrementi), ++ (incremento)
Relacionales:
==, !=, <, >, <=, >=
Lógicos:
! (negación), && (conjunción), || (adición)
----------------------------------------------------------
Objetos Particulares
Random(): Genera números aleatorios
----------------------------------------------------------
Manejo/Control de Errores
* try {}
catch([clase que herede de Exception] idError)
----------------------------------------------------------
----------------------------------------------------------
----------------------------------------------------------
----------------------------------------------------------