40
| Date post: | 06-Jun-2015 |
| Category: |
Education |
| Upload: | daniel-martinez |
| View: | 52 times |
| Download: | 3 times |
Section 1: Declarations, initialization and Scoping
3
SCJP: Section 1 Section 1: Declarations, Initialization and Scoping
Develop code that declares classes (including abstract and all forms of nested classes), interfaces, and enums, and includes the appropriate use of package and import statements (including static imports).
Develop code that declares an interface. Develop code that implements or extends one or more interfaces. Develop code that declares an abstract class. Develop code that extends an abstract class.
Develop code that declares, initializes, and uses primitives, arrays, enums, and objects as static, instance, and local variables. Also, use legal identifiers for variable names.
4
SCJP: Section 1 Section 1: Declarations, Initialization and Scoping (Continuación)
Develop code that declares both static and nonstatic methods, and if appropriate use method names that adhere to the JavaBeans naming standards. Also develop code that declares and uses a variablelength argument list.
Given a code example, determine if a method is correctly overriding or overloading another method, and identify legal return values (including covariant returns), for the method.
Given a set of classes and superclasses, develop constructors for one or more of the classes. Given a class declaration, determine if a default constructor will be created, and if so, determine the behavior of that constructor. Given a nested or nonnested class listing, write code to instantiate the class.
5
Modificadores en JavaEjercicio en grupo
Modifiers Top Class Inner Class Interface Top Enum Method Constructorprivatedefaultprotectedpublicstaticfinalabstracttransientvolatile
Instance Enum
Instance Variable
Local Variable
6
Modificadores en JavaSolución ejercicio en grupo
Modifiers Top Class Inner Class Interface Method Constructorprivate NO SI NO NO SI SI SI SI NOdefault SI SI SI SI SI SI SI SI NOprotected NO SI NO NO SI SI SI SI NOpublic SI SI SI SI SI SI SI SI NOstatic NO SI NO NO SI SI NO SI NOfinal SI SI NO NO NO SI NO SI SIabstract SI SI SI NO NO SI NO NO NOtransient NO NO NO NO NO NO NO SI NOvolatile NO NO NO NO NO NO NO SI NO
Top Enums
Instance Enum
Instance Variable
Local Variable
7
Declaración y control de accesoModificadores y declaración de clases.
Reglas básicas
Solo puede existir una clase “public” por archivo fuente.
El nombre del archivo deberá de coincidir con el nombre de la clase publica.
La sentencia “package” (si la hay) deberá colocarse en la primera línea.
Si existen instrucciones “import” estas deberán de situarse entre la instrucción “package” y la declaración de clase.
8
Sintaxis en ClasesRegla:
[ access modifier ] [modifier ]* class NameClass{
}
Ejemplos:
public abstract class Person{}
strictfp abstract class TaxesType{}
public class Vehicle{}
class public WrongExample{} //Error de Compilación
9
Sintaxis VariablesVariables de Instancia:
[ access modifier ] [modifier ]* type nameVariable [ = value] ;
Ejemplos:
public class Person{
String firstName ;
int age = 0;
public static final int idPerson;
//...
}
10
Sintaxis VariablesVariables Locales:
[modifier final] type nameVariable [ = value];
Ejemplos:
public void method(){
int a = 10;
final double interestRate = 0.05 ;
private int c = 100; //Error de Compilación
}
11
Sintaxis MétodosMétodos
[access modifier] [modifier]* returnType
nameMethod( [ arguments]*){ }
Ejemplos:
public void methodA(int a, float f){ }
public final int methodB(){ return 100;}
public static void main(String args[]){ }
public native void methodC();
public abstract void methodD();
12
Métodos static El modificador static es utilizado en declaración de: variables,
métodos, nested classes, y nested enum. Los miembros declarados con el modificador static existen para toda la clase, es decir NO se asocian a ninguna instancia / objeto en particular.
No necesario crear instancias para accesar miembros static.
Accesados por medio del nombre de la clase.
public class CasaGeo{
private static int noHabitaciones=1;
}
En otro código podemos usar:
System.out.println(CasaGeo.noHabitaciones);
Los Métodos static, solo pueden accesar a variables locales y variables static de la clase que lo define.
13
Identificadores Válidos
Identificador:
Nombre asignado a una variable, clase o método.
Reglas:
Caracter inicial: Letras, '_', '$'.
Subsecuentes caracteres pueden ser dígitos.
Sensibles a mayúsculas
No hay máximo en longitud
No utilizar palabras reservadas como identificadores.
14
Java BeansComponentes de sw reusables que pueden ser manejados por una herramienta de desarrollo.
Convención:
La clase debe ser serializable.
Constructor sin argumentos.
Propiedades accesibles por medio de los métodos:
getX()
setX()
isX(). Utilizado para valores booleano.
15
Sintaxis ConstructoresConstructores
[access modifier] NameClass ( [ arguments]*){ }
Ejemplos:
public class Account{
private double balance ;
public Account (){ }
protected Account(double pBalance){
balance = pBalance;
}
}
16
Constructor por defaultEn todas las clases SIEMPRE existe al menos un constructor
Si el programador no define un constructor, automáticamente Java genera un constructor por default
El constructor default tiene:
Mismo modificador de acceso que la clase
No define argumentos
Esta vacío
17
Ejemplo de constructor DefaultCódigo con constructor Default
import java.util.*;
public class Customer{
private String firstName;
private String lastName;
List accounts;
}
public class TestCustomer{
public static void main(String args[]){
Customer obj = new Customer();}
}
18
Estructura PackageSe utiliza para agrupar un conjunto de clases
Hace referencia de manera lógica a un directorio físico en el disco duro
Solamente puede existir una y solo una declaración de package por archivo .java
Si existe la declaración, debe ser la primer línea en el archivo, si se omite se usa el package default
19
Estructura ImportPermite indicar la ruta de paquetes en donde se encontraran las clases a utilizar
Puede utilizarse de dos maneras:
import packageNameA.pckageNameN.*;
o bien:
import packageNameA.packageNameN.NameClass;
Es utilizando a través del Dynamic Class Loader
20
Estructura de ClasesEjemplo de Clase Java
//Customer.java
package com.ses.scjp.domain;
import java.util.*;
import java.util.Locale;
public class Customer{
private String firstName ;
private String lastName;
List accounts;
//...
}
21
Statics ImportCaracterística de Java, agregada a la versión 1.5
Se utiliza para importar miembros estáticos
Útil para referencia miembros estáticos de clase, sin necesidad de utilizar su nombre completamente calificado
Solo importa los miembros estáticos de una clase
Si se usa debe usarse adicionalmente el import nostatic
Su sintaxis es:
import static package.subPackage.NameClase.*;
o bién:
import static package.subPackage.NameClase.memberStatic;
22
Ejemplo de Static ImportCódigo Java 1.6
import static java.lang.System.*;
import static java.lang.Math.*;
public class TestStaticImport{
public static void main(String args[]){
out.println("Numero aleatorio:" + random());
}
}
23
Clases AbstractasNO se puede crear instancias de clases abstractas
Pueden declarar 1 ó N métodos abstractos
Pueden declarar atributos y métodos concretos
Los constructores son permitidos pero no se pueden invocar directamente, es decir, se invocan desde los constructores de sus subclases.
24
Ejemplo de Clase Abstractapublic abstract class Figura{
protected double area;
protected abstract void calculaArea();}
public class Circulo extends Figura{
protected void calculaArea(){ System.out.println(“ PI * R2”);
}}
25
InterfacesPermite emular la herencia múltiple.
Solamente definen métodos abstractos y variables:
public static final type nameVarible = value;
No se permiten los constructores
Una Java interface puede extender a otras interfaces
Una clase puede implementar a 1 ó N interfaces
26
Ejemplo de InterfaceCódigo con Java Interface
public interface Flyer{
public void land();
public void takeOff();
public void fly();
}
public class Aircraft implements Flyer{
public void land(){ }
public void takeOff(){ }
public void fly(){ }
}
27
Ejemplo de InterfaceContinuación (1)...
public class Helicopter implements Flyer{
public void land(){ }
public void takeOff(){ }
public void fly(){ }
}
public class Bird extends Animal implements Flyer{
public void land(){ }
public void takeOff(){ }
public void fly(){ }
}
28
Ejemplo de InterfaceContinuación (2)...
public class ClassA extends SuperClassA implements
InterfaceA, InterfaceB{
}
public interface Remote{ }
public interface RemoteHandler extends Remote{
}
29
Nested ClasesClases declaradas dentro de la encapsulación de otra clase
Existen 3 tipos básicos de clases Nested
Clases Nested declaradas como variable de instancia
Clases Nested Locales declaradas dentro de un Método
Clases Nested Anónimas
30
Nested Clases Variable InstanciaLas clases Nested declaradas como variable de instancia, pueden tener cualquier modificador de acceso
Pueden utilizar las variables de instancia definidas en la clase wrapper
Fuera de la encapsulación de la clase externa, es posible crear instancias de una clase Nested, pero requiere una sintaxis especial.
31
Ejemplo Clase Nested InstanciaCódigo de Nested Class declarada como variable de instancia
public class OuterClass{
private int a = 10;protected class NestedClass{
public void metodo(){ System.out.println(“El valor de a=” + a);
}}
}
32
Ejemplo Clase Nested InstanciaCódigo continuación...
public class TestNested{
public static void main(String args[]){
OuterClass outer = new OuterClass(); OuterClass.NestedClass nested = outer.new
NestedClass();
nested.method();
}
}
33
Clases Nested LocalesDeclaradas dentro de un método
No pueden tener ningún modificador de acceso
Sólo pueden ser instanciadas dentro de la encapsulación del método
Si utilizan variables del método wrapper, éstas deben ser declaradas como final
34
Ejemplo clase Nested LocalCódigo Clase Nested Local
public class TestNestdLocal{
public static void main(String args[]){
final int a = 110;
class NestedClass{
public void method(){
System.out.println("El valor de a=" + a);
}
} NestedClass nested = new NestedClass();
nested.method();
} }
35
Clases Nested AnónimasDeclaradas al momento de invocar el constructor
No se define un nombre para la clase Nested, solamente se define el cuerpo de la clase seguido del constructor
No se puede reutilizar el código de una clase anónima, para crear múltiples instancias de la clase nested anónima
36
Ejemplo Clase Nested AnónimaCódigo Clase Nested Anónima
public class Main{
static Object obj = new Object(){
public String toString(){
return "Ejemplo de Clase Nested Anonima...";
}
};
public static void main(String args[]){
System.out.println(obj.toString());
}
}
37
Java EnumerationsCaracterística de Java, agregada a la versión 1.5
Permite definir conjuntos de elementos de manera typesafe
Pueden ser usadas para hacer referencia a conjuntos de elementos finitos
Pueden contener métodos
Pueden ser usadas como argumentos en estructuras de control switch
38
Java EnumerationsContinuación...
No se pueden instanciar
Si son públicas deben se declaradas en un archivo con el mismo nombre que la enum
No se permiten enums Locales a métodos
39
Ejemplo de EnumerationsCódigo que muestra una Enumeration
public class TestEnums{
enum Week{
MONDAY, TUESDAY, WEDNESDAY, THURSDAY,
FRIDAY, SATURDAY, SUNDAY
}
public static void main(String args[]){
Week today = Week.FRIDAY;
System.out.println("Hoy es:" + today);
}
}
40
Fin de Sección 1: Declarations, Initialization and Scoping
● Notas
