Curso de nivelación Primer parte. Conceptos generales del lenguaje

Sección 1 Declaración y Control de Acceso

Objetivos – part. 1 Desarrollar código donde se declaren clases, interfaces, y enumeraciones, e inclusive el uso apropiado de las declaraciones “pakage” y “import”, inclusive las importaciones estáticas (static import). Desarrollar código donde se declare una interfaz. Desarrollar código que implemente o se extienda de una o más interfaces. Realizar declaraciones de clases abstractas y desarrollar código donde se extienda de una clase abstracta.

Objetivos – part. 2 Desarrollar código en donde se declaren, inicialicen, y usasen, tipos primitivos, arrays, enumeraciones, y objetos de forma estática, instancias, y variables locales. Además, el uso legal de los identificadores para nombres de variables. Desarrollar código donde se declaren métodos tanto estáticos y no estáticos, y -si es apropiado- utilizar nombres de métodos que se adhieren a las normas de denominación JavaBeans. Asimismo, elaborar el código que declara y usa una lista de longitud variable de argumentos.

Identificadores y palabras reservadas Los tres tipos de identificadores Java: Identificadores permitidos Convenciones de codificación de Sun’s Convención de nombres JavaBeans Palabras reservadas del lenguaje:

Identificadores permitidos Reglas del compilador usadas para determinar cuales son los identificadores permitidos. Los identificadores deben comenzar con una letra, un símbolo de pesos ($), o un carácter de conexión tal como es el guión bajo ( _ ). Después del primer caracter, los identificadores pueden contener cualquier combinación de letras, carácter de moneda, caracteres de conexión, o números. No se pueden usar las palabras claves de Java como identificadores. Los identificadores en java son “case-sensitive” sensibles a mayúsculas y minúsculas.

Convenciones de codificación de Sun Clases e interfaces: Dog, Account, PrintWriter, Runnable, Serializable Métodos getBalance, doCalculation, setCustomerName Variables buttonWidth, accountBalance, myString Constantes MIN_HEIGHT

Reglas de propiedades de JavaBean Reglas de nombre de propiedades: public int getSize(); public void setSize(int size); public boolean isConnected() or getConnected(); Regla de nombres para Listener: public void addActionListener(ActionListener a); public void removeMyListener(MyListener list);

1.int.f; 2.int _a; 3.int :b; 4.int -d; 5.int $c; 6.int ______2_w; 7.int e#; 8.int _$; 9.int this_is_a_very_detailed_name_for_an_identifier; 10.int 7g; Identificadores

Puede haber solo una clase publica por archivo. Si hay una clase publica en un archivo, el nombre del archivo debe coincidir con el nombre de la clase publica. Si la clase es parte de un paquete, la sentencia “package” debe ser la primer línea en el archivo, antes de cualquier sentencia “import” que pueda haber. Si hay sentencias “import”, deben ir entre la sentencia “package” (si es que hay una) y la declaración de la clase. Un archivo puede tener mas de una clase que no se publica. Los archivos con clases que no son publicas pueden tener un nombre que no coincida con ninguna de las clases en el archivo Reglas de declaración de archivos de código

Declaraciones de clases y modificadores Modificadores de acceso: public, protected, private. Modificadores que no son de acceso: strictfp, final y abstract. ¿Que significa acceso a una clase? Crear una instancia de la clase B. Extender la clase B (en otras palabras, crear una subclase de la clase B). Acceder a ciertos métodos y variables dentro de la clase B, dependiendo del control de acceso de los estos métodos y variables.

Modificadores de clase Default: Pensemos en acceso “default” como acceso a nivel de paquete. Public: Todas las clases en el Universo Java tienen acceso a las clases publicas. Final (no es de acceso) La palabra reservada “final” significa que la clase no puede ser heredada. Abstract (no es de acceso) Su único propósito es ser extendida (sub-clase). Strictfp (no es de acceso) El código de un método en la clase estará conforme a la IEEE 754.

Declaración de interfaces Todos los métodos de una interfaz son implícitamente públicos y abstractos. Todas las variables definidas en una interfaz deben ser publicas, estáticas y finales. Los métodos de una interfaz no deben ser estáticos. Debido a que los métodos de una “interface” son abstractos, estos no pueden ser declarados como “final”, “strictfp”, “native”. Una “interface” puede extender de una o mas interfaces. Una “interface” no puede extender de otra cosa que no sea otra “interface”. Una “interface” no puede implementar una “interface” o una “clase”. Los tipos “Interface” pueden ser usados poliformicamente

Declaring Interfaces (2) ‏ public interface Ordenable { void ordenar(); void setOrden(int orden); int MAX_SIZE = 42; } Es requerido si queremos una visibilidad publica Implícitamente “public” y “abstract” Implícitamente “public”, “static” y “final” Cualquier combinación de los modificadores requeridos (pero implícitos) es correcta.

Modificadores de miembros de clase Mientras que una clase puede usar sólo dos de los cuatro niveles de control de acceso (“default” o “public”), los miembros pueden usar todos los cuatro public protected default private (no permite sobre escritura)

Miembros de clase “Protected” y “Default”

From any non-subclass class outside the package From a subclass outside the same package From a subclass in the same package From any class in the same package From the same class PrivateDefaultProtectedPublicVisibility Visibilidad de los miembros de una clase

Modificadores que no son de acceso para Miembros de clase (part. 1) Métodos Final La palabra reservada “final” permite que un método no sea sobre escrito en una subclase. Argumentos Final Los argumentos de los métodos son esencialmente lo mismo que las variables locales. Métodos Abstract Debemos marcar un método “abstract” cuando queremos hacer que las subclases provean una implementación de este método. Es ilegal tener una método “abstract” en una clase que no se haya declarado explícitamente abstracta. La primer subclase concreta de una clase abstracta debe implementar todos los métodos abstractos de la clase padre.

Métodos Synchronized La palabra clave synchronized indica que un método puede ser accedido por un thread (hilo) a la vez. Métodos Native El modificador “native” indica que un método es implementado para una plataforma especifica, al igual que C. Métodos Strictfp strictfp obliga que los punto flotante (y cualquier operación de puntos flotantes) adhieran al estandar IEEE 754. Modificadores que no son de acceso para Miembros de clase (part. 2)

Métodos con parámetros var-arg Tipo var-arg: Cuando declaramos un parámetro var-arg, debemos especificar que tipo de dato será este argumento(s). (Puede ser de tipos primitivos o un tipo de objetos). Sintaxis básica: Para declarar un método usando parámetros var-arg, debemos poner después del tipo puntos suspensivos (...), un espacio, y luego el nombre del array que contendrá los parámetros recibidos. Otros parámetros: Esta permitido tener otros parámetros en un método que usa var-arg. Restricciones de Var-args: El parámetro var-arg debe estar al final de todos los parámetros en la firma del método, y solo podemos tener un var-arg en un método. EJ: public void doStuff(char c, int... x)

Declaración de constructores (part.1) Un constructor nunca pero nunca debe tener un “return”. La declaración de un constructor puede tener todos los modificadores de acceso normales, y puede tomar argumentos (incluido var-args), al igual que los métodos. Los constructores deben tener el mismo nombre que la clase en la cual este, esté declarado. Los constructores no pueden ser marcados como “static” (están asociados a la creación del objeto), no pueden ser marcados como “final” o “abstract” (debido a que no pueden ser sobre escritos).

class Foo2 { Foo2() { } abstract Foo2(char c) { } Foo() { } Foo2(short s); static Foo2(float f) { } private Foo2(byte b) { } Foo2(int... x, int t) { } Foo2(int x) { } Foo2(int x, int... y) { } void Foo2() { } final Foo2(long x) { } } // no puede ser abstract // debe llamarse igual que la clase que lo contiene // no puede ser “static” // está mal la sintaxis de var-arg // los constructores no tienen retorno // no puede ser Final Declaración de constructores (part.2)

Declaración de variables Variables de instancia Las variables de instancia son definidas dentro de la clase, pero fuera de los métodos, y son solo inicializadas cuando la clase es instanciada. Variables Locales Las variables locales son declaradas dentro de un método. Las variables locales pueden ser marcadas como “final”. Es posible declarar variables locales con el mismo nombre que las variables de instancia; esto se conoce como “shadowing”

Declaración de variables (Primitivas) (part. 1) Una variable primitiva puede tener asociado uno de los siguientes ocho tipos: char, boolean, byte, short, int, long, double, o float. EJ: byte b; boolean myBooleanPrimitive; int x, y, z; Los seis tipos de números en Java tienen un cierto numero de bytes (8-bit) y permiten números negativos.

Declaración de variables (Primitivas) (part. 2) Las variables de tipo “boolean” no tienen un rango; un “boolean” solo puede tener el valor “true” o “false”. Las variables de tipo “char” son iguales a las de tipo “int”, a esta se le puede asignar cualquier numero entre 0 y

Variables de referencia Una variable de referencia es usada para referirse (o acceder) a un objeto. Una variable de referencia puede ser usada para referirse a un objeto del tipo declarado o de un subtipo del tipo declarado. EJ: Perro a; a = new Doberman(); String s1, s2, s3; // declaracion de 3 variables String.

Declaración de variables (Arrays) En java los array son objetos que almacenan multiples variables del mismo tipo, o variables que son subclases del mismo tipo. EJ: int[ ] key; // Corchetes antes del nombre (recomendado) int key [ ]; // Corchetes después del nombre (permitido pero menos legible) Thread[ ] threads; Thread threads [ ]; String[ ][ ][ ] occupantName; String[ ] ManagerName [ ]; // Permitido pero poco legible.

Declaración de variables Variables Final Declarando una variable con la palabra reservada “final” hacemos que sea imposible reinicializarla, esta variable puede tener un único valor. Variables Transient Si marcamos una variable de instancia como “transient”, estamos indicándole a la JVM que no tome en cuenta esta variable cuando realice la serialización del objeto que la contiene. Variables Volatile El modificador “volatile” le indica a la JVM que siempre que vaya a ser usada la variable la debe leer de memoria aunque tenga una copia.”Volatile” se usa con variables en las que no se sabe con certeza cuándo se va a modificar su contenido.

El modificador “static” es usada para crear variables y métodos que podrán existir independientemente de cualquier instancia creada para esa clase. Se puede marcar como estático: Métodos. Variables. Una clase anidada dentro de otra clase, pero no dentro de un método. Boques de inicialización. Variables y Métodos “Static“

Comparación de modificadores de variables y métodos

Declaración de enumeraciones enum CoffeeSize { BIG, HUGE, OVERWHELMING }; // el punto y coma es opcional enum Son realmente es un tipo especial de la clase. enum puede ser declarada como una clase, o dentro de otra clase. Cada uno de los tipos enumerados en CoffeeSize son en realidad instancias de CoffeeSize.

Enumeraciones: Declaración de Constructores, Métodos y Variables Podemos añadir constructores, variables de instancia, métodos, y algo realmente extraño conocido como “constant specific class body” enum CoffeeSize { BIG(8), HUGE(10), OVERWHELMING(16); // los argumentos después de cada valor de la enumeración son // pasados como valores al constructor CoffeeSize(int ounces) { this.ounces = ounces; // asigna el valor a una variable de instancia } // variable de instancia que cada valor de la enumeración tiene private int ounces public int getOunces() { return ounces; }