Section5 scjp6.0

PCG SG CampusSun Certified Java Programmer [email protected]

Sun Educación

mailto:manuel.contreras@sun

Descripción del Examen

3

Sun Certified Java Programmer 6.0

Requisitos previos: 6 – 12 meses experiencia

Tipo de Examen: Opción Múltiple, y respuesta corta

Número de preguntas: 60

Porcentaje mínimo: 58.33 % (35 / 60 preguntas)

Tiempo Limite: 180 minutos

Lenguajes disponibles: Ingles / Español

4

Sun Certified Java Programmer 6.0

Centro Prometric

En equipo PC

Solo papel, lápiz

Encuesta Inicial

Información para estadísticas

Costo del voucher: 300 USD por intento ( PCG retries número ilimitados)

El examen contiene 7 secciones como objetivos

Contenido del Examen

6

Sun Certified Java Programmer 6.0 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.

7

Descripción de Secciones SCJP 6.0 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.

8

Descripción de Secciones SCJP 6.0 Section 2: Flow Control

Develop code that implements an if or switch statement; and identify legal argument types for these statements.

Develop code that implements all forms of loops and iterators, including the use of for, the enhanced for loop (foreach), do, while, labels, break, and continue; and explain the values taken by loop counter variables during and after loop execution.

Develop code that makes use of assertions, and distinguish appropriate from inappropriate uses of assertions.

Develop code that makes use of exceptions and exception handling clauses (try, catch, finally), and declares methods and overriding methods that throw exceptions.

9

Descripción de Secciones SCJP 6.0 Section 2: Flow Control (Continuación)

Recognize the effect of an exception arising at a specified point in a code fragment. Note that the exception may be a runtime exception, a checked exception, or an error

Recognize situations that will result in any of the following being thrown: ArrayIndexOutOfBoundsException,ClassCastException, IllegalArgumentException, IllegalStateException, NullPointerException, NumberFormatException, AssertionError, ExceptionInInitializerError, StackOverflowError or NoClassDefFoundError. Understand which of these are thrown by the virtual machine and recognize situations in which others should be thrown programatically.

10

Descripción de Secciones SCJP 6.0 Section 3: API Contents

Develop code that uses the primitive wrapper classes (such as Boolean, Character, Double, Integer, etc.), and/or autoboxing & unboxing. Discuss the differences between the String, StringBuilder, and StringBuffer classes.

Given a scenario involving navigating file systems, reading from files, or writing to files, develop the correct solution using the following classes (sometimes in combination), from java.io: BufferedReader,BufferedWriter, File, FileReader, FileWriter and PrintWriter.

Develop code that serializes and/or deserializes objects using the following APIs from java.io: DataInputStream, DataOutputStream, FileInputStream, FileOutputStream, ObjectInputStream, ObjectOutputStream and Serializable.

11

Descripción de Secciones SCJP 6.0 Section 3: API Contents (Continuación 1)

Write code that uses standard J2SE APIs in the java.util and java.util.regex packages to format or parse strings or streams. For strings, write code that uses the Pattern and Matcher classes and the String.split method. Recognize and use regular expression patterns for matching (limited to: . (dot), * (star), + (plus), ?, \d, \s, \w, [], ()). The use of *, +, and ? will be limited to greedy quantifiers, and the parenthesis operator will only be used as a grouping mechanism, not for capturing content during matching. For streams, write code using the Formatter and Scanner classes and the PrintWriter.format/printf methods. Recognize and use formatting parameters (limited to: %b, %c, %d, %f, %s) in format strings.

12

Descripción de Secciones SCJP 6.0 Section 3: API Contents (Continuación 2)

Use standard J2SE APIs in the java.text package to correctly format or parse dates, numbers, and currency values for a specific locale; and, given a scenario, determine the appropriate methods to use if you want to use the default locale or a specific locale. Describe the purpose and use of the java.util.Locale class.

13

Descripción de Secciones SCJP 6.0 Section 4: Concurrency

Write code to define, instantiate, and start new threads using both java.lang.Thread and java.lang.Runnable.

Recognize the states in which a thread can exist, and identify ways in which a thread can transition from one state to another.

Given a scenario, write code that makes appropriate use of object locking to protect static or instance variables from concurrent access problems.

Given a scenario, write code that makes appropriate use of wait, notify, or notifyAll.

14

Descripción de Secciones SCJP 6.0 Section 5: OO Concepts

Develop code that implements tight encapsulation, loose coupling, and high cohesion in classes, and describe the benefits.

Given a scenario, develop code that demonstrates the use of polymorphism. Further, determine when casting will be necessary and recognize compiler vs. runtime errors related to object reference casting.

Explain the effect of modifiers on inheritance with respect to constructors, instance or static variables, and instance or static methods.

15

Descripción de Secciones SCJP 6.0 Section 5: OO Concepts (Continuación)

Given a scenario, develop code that declares and/or invokes overridden or overloaded methods and code that declares and/or invokes superclass, overridden, or overloaded constructors.

Develop code that implements "isa" and/or "hasa" relationships.

16

Descripción de Secciones SCJP 6.0 Section 6: Collections / Generics

Given a design scenario, determine which collection classes and/or interfaces should be used to properly implement that design, including the use of the Comparable interface.

Write code that uses the generic versions of the Collections API, in particular, the Set, List, and Map interfaces and implementation classes. Recognize the limitations of the nongeneric Collections API.

Develop code that makes proper use of type parameters in class/interface declarations, instance variables, method arguments, and return types; and write generic methods or methods that make use of wildcard types and understand the similarities and differences between these two approaches.

17

Descripción de Secciones SCJP 6.0 Section 6: Collections / Generics (Continuación)

Distinguish between correct and incorrect overrides of corresponding hashCode and equals methods, and explain the difference between == and the equals method.

Use capabilities in the java.util package to write code to manipulate a list by sorting, performing a binary search, or converting the list to an array. Use capabilities in the java.util package to write code to manipulate an array by sorting, performing a binary search, or converting the array to a list. Use the java.util.Comparator and java.lang.Comparable interfaces to affect the sorting of lists and arrays. Furthermore, recognize the effect of the "natural ordering" of primitive wrapper classes and java.lang.String on sorting.

18

Section 7: Fundamentals

Given a code example and a scenario, write code that uses the appropriate access modifiers, package declarations, and import statements to interact with (through access or inheritance) the code in the example.

Given an example of a class and a commandline, determine the expected runtime behavior.

Determine the effect upon object references and primitive values when they are passed into methods that perform assignments or other modifying operations on the parameters.

Descripción de Secciones SCJP 6.0

19

Section 7: Fundamentals (Continuación 1)

Given a code example, recognize the point at which an object becomes eligible for garbage collection, and determine what is and is not guaranteed by the garbage collection system. Recognize the behaviors of System.gc and finalization.

Write code that correctly applies the appropriate operators including assignment operators (limited to: =, +=, =), arithmetic operators (limited to: +, , *, /, %, ++, ), relational operators (limited to: <, <=, >, >=, ==, !=), the instanceof operator, logical operators (limited to: &, |, ^, !, &&, ||), and the conditional operator ( ? : ), to produce a desired result. Write code that determines the equality of two objects or two primitives.


20

Section 7: Fundamentals (Continuación 2)

Given the fullyqualified name of a class that is deployed inside and/or outside a JAR file, construct the appropriate directory structure for that class. Given a code example and a classpath, determine whether the classpath will allow the code to compile successfully.


21

Modificadores en JavaRepaso

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

22

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.

23

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

24

Sintaxis VariablesVariables de Instancia:

[ access modifier ] [modifier ]* type nameVariable [ = value] ;

Ejemplos:

public class Person{

String firstName ;

int age = 0;

public static final int idPerson;

//...

}

25

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

}

26

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();

Section 5: OO Concepts

28

SCJP: Section 5 Section 5: OO Concepts

Develop code that implements tight encapsulation, loose coupling, and high cohesion in classes, and describe the benefits.

Given a scenario, develop code that demonstrates the use of polymorphism. Further, determine when casting will be necessary and recognize compiler vs. runtime errors related to object reference casting.

Explain the effect of modifiers on inheritance with respect to constructors, instance or static variables, and instance or static methods.

29

SCJP: Section 5 Section 5: OO Concepts (Continuación)

Given a scenario, develop code that declares and/or invokes overridden or overloaded methods and code that declares and/or invokes superclass, overridden, or overloaded constructors.

Develop code that implements "isa" and/or "hasa" relationships.

30

Definición de EncapsulaciónMecanismo de la POO, que permite ocultar y proteger los detalles de la implementación de una clase

Los cambios de implementación de una clase no afectan a las clases cliente de ésta

La clase encapsulada expone sus variables de instancia privadas,a través de métodos públicos

31

Ejemplo de Encapsulación: El problema public class MyDate{

public int day;

public int month;

public int year;

public MyDate(){ . . . }

public MyDate(int day, int month, int year){ . . . }

}

Código cliente:

MyDate date = new MyDate();

date.day = 32; //Error de implementación

date.month = 2; date.day = 31; //Error de implementación

date.day = date.day + 1; //posible error de implementación

32

Ejemplo de Encapsulación: La solución public class MyDate{

private int day;private int month;private int year;public MyDate(){...}public boolean setDay(int day){...}public int getDay(){...}public boolean setMonth(int month){...}public int getMonth(){...}public boolean setYear(int year){...}public int getYear(){...}public boolean addDay(int day){...}

}

33

Ejemplo de Encapsulación: La soluciónSolución:

Definir una encapsulación en la clase MyDate

Declarar las variables de instancia con el modificador

privado

Definir métodos públicos de acceso a las variables

privadas

Cada método Internamente valida el uso de las variables

de instancia

34

Coupling & CohesionCoupling:

Grado de dependencia entre 2 ó más clases

Entre menor sea el grado de Coupling, mayor es la independencia de componentes

No Coupling Loose Coupling

Tight Coupling

A B A B

A B

35

Coupling & CohesionCohesion:

Grado de especialización de un componente / clase.

Los componentes de cada clase deben modelar reglas altamente relacionadas entre sí

Entre mas alto sea el grado de Cohesion , mayor especialización del componente y mayor facilidad de mantenimiento.

Ejemplo: Clase coche:

Debe ocuparse de frenar, acelerar.

Es decir define los comportamientos propios de un coche.

Nota. Crear un comportamiento que verifique el seguro del coche. No es parte del alcance o funcionalidad para la que fue creada la clase coche.

36

Diseño de Clases en Java

Java Herencia simple

En Java podemos heredar de una y sólo una Super Clase

Herencia múltiple emulada a través de las Interfaces

Podemos implementar más de una interface y combinarla con herencia con una clase

37

Modificadores de AccesoModificadores que permite o no, el uso de algún recurso

Se pueden aplicar a variables de instancia, métodos y clases (nested y top level)

En el caso de clases top level, sólo se pueden usar los modificadores public y default

38

HerenciaMecanismo de la POO que permite reutilizar código

Permite definir a partir de una clase ya existente (super clase), una nueva clase (subclase) que reutilice la definición de métodos y variables definidos por su super clase

39

Ejemplo de herencia public class Employee{

public String name;public double salary;public Date birthDate;public String getDetails(){...}

}

public class Manager extends Employee{

public String department;}

40

Ejemplo de HerenciaLa subclase Manager hereda todos los miembros de su super clase declarados con el modificador: protected ó public.

El modificador de acceso private no permite el acceso a miembros heredados.

41

Relaciones “is a” vs “has a”La relación “es un” es definida a través de una jerarquía de herencia

La relación “tiene un” es definida cuando una ClaseA tiene una referencia de una ClaseB

Manager “is a” Employee Customer “has a” Account

class Customer{

private String firstName; private String lastName;

private Account account;

}

class Account{ private double balance; private double interestRate;

}

42

Sobre Escritura de MétodosUna subclase puede modificar el comportamiento de

algún método heredado de su super clase

La sobre escritura de métodos permite definir una

nueva implementación para un método heredado,

respetando:

Mismo nombre de método

Mismo tipo de retorno, o su covariant

Mismo tipo y lista de argumentos

43

Sobre Escritura de Métodos

44

Sobre Escritura de Métodos1. class Mama{2. public void bailar(){ System.out.println("baila: Rock & Roll"); }3. }4. 5. class HijoA extends Mama{6. public void bailar(){ System.out.println("baila: Jazz"); }7. }8. 9. class HijoB extends Mama{10. public void bailar(){ System.out.println("baila: Tango"); }11. }12. 13. class HijoC extends Mama{14. public void bailar(){ System.out.println("baila: Danzon"); }15. }16. 17. class HijoD extends Mama{}

45

Ejemplo 2: Sobre Escritura1. class Object{2. public String toString(){3. }4. }5. class Employee extends Object{6. private String name; 7. private Date birthDate;8. private double salary;9. 10. public String toString(){11. return " El empleado :" + this.getName() +12. " recibe un sueldo de:" + this.getSalary() + 13. "fecha denaciemiento:" + this.getBirthDate();14. }15. //getters & setters16. }

46

Sobre Escritura: Covariants1. class SuperType{}2. class SubType extends SuperType{}3. 4. class ClassA{5. public SuperType method(){6. return null;7. }8. }9. 10. class ClassB extends ClassA{11. public SubType method(){12. return null;13. }14. }

47

Continuación: Reglas Sobre Escritura El método sobre escrito debe respetar las siguientes reglas, con respecto a su super método:

Mismo nombre


Misma lista y tipo de argumentos

El modificador de acceso del método de la subclase no puede ser más restrictivo que el de la super clase

Las excepciones que lanza el método sobre escrito, no pueden ser de mayor jerarquía que las excepciones lanzadas por el método en la super clase

48

Regla: Modificador de acceso

49

Continuación: Reglas Sobre Escritura El método sobre escrito debe respetar las siguientes reglas, con respecto a su super método:

Mismo nombre


Misma lista y tipo de argumentos

El modificador de acceso del método de la subclase no puede ser más restrictivo que el de la super clase

Las excepciones que lanza el método sobre escrito, no pueden ser de mayor jerarquía que las excepciones lanzadas por el método en la super clase

50

Regla: Sobre Escritura y Exceptions

51

Repaso: Categorías de Excepciones

52

Sobre Escritura método staticEn la invocación de métodos static sobre escritos, tiene prioridad el método de la clase padre.

public class A{

public static void metodo(){ System.out.println(“Clase A”); }}

public class B extends A{

public static void metodo(){System.out.println(“Clase B”); }}

public class TestA{

public static void main(String []args){

A a = new B();a.metodo(); //Invocara el método de la clase padre “Clase A”}

}

53

PolimorfísmoCaracterística de los lenguajes OO que permiten definir diferentes implementaciones de un mismo método

En Java existe:

Polimorfísmo en métodos

Requiere: Herencia y sobre escritura de métodos

Polimorfísmo en Argumentos

El argumento de un método es polimorfo

54

Polimorfismo en Métodos class Animal{

public void eat(){

System.out.println(“Generic Animal eating...”);}

}

class Horse extends Animal{

public void eat(){

System.out.println(“Horse eating...”);}

}

public class TestAnimal{

public static void main(String args[]){

Animal a = new Animal();

Animal b = new Horse();

a.eat(); //method eat() version Animal Class

b.eat(); //method eat() version Horse Class

}

}

55

Polimorfismo en Argumentosclass Figura{ }class Circulo extends Figura{}class Triangulo extends Figura{}class Rectangulo extends Figura{}

// Otro código... public void calculaArea(Figura f){ if(f instanceof Circulo){ // PI * R 2 }else if(f instanceof Triangulo){ // B * H /2 }else if(f instanceof Rectangulo){ // B * H } }

56

Sobrecarga de MétodosSobre cargar un método se refiere a declarar 2 ó varios métodos en la misma clase con el mismo nombre pero siguiendo las siguientes reglas:

Deben tener diferente lista y tipo de argumentos

Pueden tener diferente tipo de retorno

Pueden tener diferente modificador de acceso

Pueden lanzar Excepciones

El método a sobre cargar puede ser definido en la misma clase o bien en la super clase

57

Ejemplos válidos de sobre carga de métodospublic class TestOverloaded {

public void method(){}

public void method(int a){}

public void method(double d){}

private void method(long i){}

public boolean method(String s){

return false;

}

public void method(char c) throws RuntimeException{

}

}

58

Sobrecarga vs Sobre escritura

59

Concepto de ConstructorSimilar a un método pero con las siguientes reglas:

Mismo nombre de clase

No define tipo de Retorno

Utilizado para crea una nueva instancia de Clase en el Heap

Referencia en Stack, Objeto en el Heap

Si no se define un constructor, Java genera el constructor por default

60

Sobre carga de constructoresTodas las clases cuentan con un constructor por default

Cualquier definición explícita de un constructor elimina la existencia del constructor por default

Una clase Java permite definir 2 ó más constructores en la misma clase (sobre carga de constructores)

Un constructor puede invocar a otros constructores de la misma clase a través de this()

Desde un constructor se puede invocar el constructor de su super clase a través de super()

61

Invocación automática de Constructoresclass Abuelo extends Object{ public Abuelo(){ System.out.println("Constructor de Abuelo()"); } }class Papa extends Abuelo{ public Papa(){ System.out.println("Constructor de Papa()"); } }class Hijo extends Papa{ public Hijo(){ System.out.println("Constructor de Hijo()"); } }

public class TestConstructors { public static void main(String[] args) { Abuelo obj = new Hijo(); } }

62

Fin de Sección 5: OO Concepts

● Notas

● Trabajo en casa

Asesoría SCJP: Sun Certified Java Programmer 6.0

Sun Educational Services