Certificación java 6 cap 2

Realizado por: Raúl Ernesto Triviño Alvarado

Certificación Java 6
Capítulo 2 – Orientación de
objetos

Cubre el objetivo 5.1

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

Encapsulación
• Para mantener la encapsulación de una clase se debe entonces:
▫ Mantener las variables protegidas (con modificadores de acceso como private)
▫ Hacer métodos de acceso a las variables, estos deben ser públicos
▫ Estos métodos deben tener notación de JavaBean, uso de getters y setters


5.5 Develop code that implements "is-a" and/or "has-a" relationships.

Herencia
• La herencia se usa en todos los estamentos de
Java pues todas las clases heredan de la clase
Object. Por este motivo todas las clases tienen
los métodos toString, equals, clone, notify y
notifyAll entre otros.
• La herencia por lo general se usa para dos
propositos:
▫ Para reusar el código
▫ Para usar el poliformismo

Herencia
• Reuso de código: El reuso se ve en el momento que todas las clases
hijas tienen todos los métodos y atributos de las clases padres
(siempre y cuando lo permitan los modificadores de acceso)

Herencia
• Poliformismo: se hace presente cuando una clase hija
puede pasar en un método como una clase padre.

Relación “es un”
• La relación “es un” está basada en términos de herencia ya sea
de una clase o una interface.
• Palabras clave: extends o implements
Código •Relaciones es un
• Vehicle es la superclase de Car.
• Car es una subclase de Vehicle.
• Car es una superclase de Subaru.
• Subaru es una subclase de Vehicle.
• Car hereda de Vehicle.
• Subaru hereda de Vehicle y Car.
• Subaru es una derivación de Car.
• Car es un derivado de Vehicle.
• Subaru es un derivado de Vehicle.
• Subaru es un subtipo de Vehicle y Car.

Relación “tiene un”
• Esta relación esta basada en términos de uso, en otras palabras si la
clase A tiene una instancia de la clase B, entonces A tiene a B.

Código Relaciones

• Un Horse es un Animal.
• Un Horse tiene un Halter.


5.2 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.

Reglas sobre variables de referencias
• Una variable de referencia solo puede ser de un tipo, y
una vez declarada, ese tipo nunca puede ser cambiado.
public class clase1{ …. }
Error de compilación,
Una vez declarada no
public class ejemplo{
clase1 elemento = new clase2();
se puede cambiar
}

Una referencia es una variable, por lo tanto puede ser reasignada
a otros objetos (a menos que sea declarada como final)

public class ejemplo{
clase1 elemento1 = new clase1();
public void metodoEjemplo(){
Se puede reasignar a otros
clase1 elemento2 = new clase1(); objetos del mismo tipo.
elemento1 = elemento2;
}
}

Reglas sobre variables de referencias
• El tipo de una variable de referencia determina los métodos
que pueden ser invocados en el objeto que la variable esta
referenciando.
public interface Animatable {
public void animate();
}
class PlayerPiece implements Animatable { Animable animacion = new PlayerPiece();
public void movePiece() {
System.out.println("moving game piece");
}
public void animate() {
System.out.println("animating...");
}
}

Objeto que la variable
Tipo de variable referencia
de referencia
• El ejemplo anterior muestra entonces que el objeto animación solo puede hacer uso del
método de la interface, es decir animate, y tiene el comportamiento que le da la clase
PlayerPiece. Si llegarse a hacer uso del método movePiece, erroja un error de
compilación.

Reglas sobre variables de referencia

• Una variable de referencia puede referirse a
cualquier objeto del mismo tipo, esto incluye a
cualquier objeto que herede la clase de
referencia.

• Una variable de referencia puede ser declarada
de una clase o una interface, si es de una
interface entonces, se puede referir a cualquier
clase que implementa la interface.

Cubre los objetivos 1.5 y 5.4

1.5 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.

5.4 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.

Métodos sobrescritos
• Cada vez que se realiza una herencia se tiene la
posibilidad de realizar una sobrescritura, exceptuando
los métodos cargados con final.
• El beneficio de hacer eso es lograr crear métodos mucho
más especializados sin afectar la lógica de la clase padre.


• En este ejemplo también podemos claramente que en el
caso del objeto b, no puede implementar el método buck,
pues es un objeto tipo Animal con implementación
Horse, y el método buck no hace parte de la clase
Animal. Arrojará un error de compilación.


Este código arroja error en tiempo de
ejecución, porque el método es privado
y no se puede invocar desde una clase
externa.

Reglas de los métodos sobrescritos
• La lista de los argumentos debe coincidir que el
método que se quiere sobrescribir.

• El retorno del método debe ser exactamente igual
del método original de la superclase.

• El nivel de acceso no puede ser más restrictivo que
el método original, por ejemplo si el método originar
es public, el método sobrescrito no puede ser
protected, por defecto o privado, mientras que si el
método original es private, si puede ser el método
sobrescrito public.

• Los métodos pueden ser sobrescritos, solo si son heredados a la subclase. Es
decir si la subclase esta en el mismo método que la superclase se puede
sobreescribir cualquier método que no sea private o final. Y si están en
diferente paquete entonces solo puede sobrescribir los métodos que son
como public o protectec, y que no sean final.

• En cuanto al manejo de excepciones si el método original lanza (throw) una
excepción, el método sobrescrito la debe lanzar también, o en su defecto
uno que sea un subtipo del método original
Correcto Incorrecto
public class claseA{ public class claseA{
public void metodo1() throws public void metodo1() throws nullPointerException{
nullPointerException{ …..
….. }
} }
}
public class claseB extends claseA{
public class claseB extends claseA{ public void metodo1() throws IOException{
public void metodo1() throws …..
nullPointerException{ }
….. }
}
}


El compilador cree que se
esta tratando de invocar el
método de animal y no el de Dog2
tocaría colocar un try – catch,
para solucionar el error

• Si un método esta sobrescrito pero usa polimorfismo para referirse
al método de la clase hija el compilador asume que se esta es
llamando a la versión original de la clase padre. En este caso como a
clase padre lanza una excepción entonces va a arrojar error de
compilación, pidiendo que se implemente un try – catch.

• Un método sobrescrito puede lanzar una excepción si el método original no las lanza.

• No se puede sobrescribir un método marcado como final.

• No se puede sobrescribir un método marcado como static.

• Si un método no puede ser heredado, no puede ser sobrescrito, pues la sobrescritura se
basa en la herencia

Ojo el método es privado no se
puede heredar y por ende no se
puede sobrescribir

Ejemplos de sobrescritura ilegales
• Si se tiene la siguiente clase
public class Animal {
public void eat() { }
}

Entonces podemos decir que:
Llamado Explicación del error
private void eat() { } El modificador de acceso no puede ser más restrictivo,
si es public no puede declararse como private
public void eat() throws El método está lanzando una excepción que el método
IOException { } original no tiene
public void eat(String Esto no es una sobrescritura es una sobrecarga de
food) { } métodos
public String eat() { } El método retorna un tipo de variable diferente al
propuesto

Sobrecarga de métodos
• La sobrecarga de métodos dice que pueden haber
uno o más métodos con el mismo nombre en la
misma clase, o en sus hijas pero deben cumplir con
las siguientes características.
▫ Tienen que cambiar la lista de argumentos
▫ Pueden cambiar el tipo de retorno
▫ Pueden cambiar el modificador de acceso
▫ Pueden declarar nuevas excepciones para lanzar o no
tienen que ser subtipo del método original
▫ La sobrecarga no se da solamente en la misma clase,
puede darse entre dos o más clases siempre y cuando
estén ligadas por la herencia, y cumpla con las reglas
anteriores.

Sobrecarga de métodos
• ¿El siguiente código es sobrescritura o sobrecarga?
Un método trabaja
int y String y otro int
y long

• A simple vista uno creería que es sobrescritura, y
que además no cumple con las reglas vistas
anteriormente, pero no es así, es una sobrecarga
porque los parámetros de entrada del método son
distintos. De esta forma se puede identificar
facilmente cual mecanismo se esta usando.

Ejemplos de sobrecarga legales
• Si una clase tiene un método que dice así:
public void changeSize(int size, String name, float pattern) { }

• Entonces se puede sobrecargar de las siguientes
maneras:
public void changeSize(int size, String name) { }
public int changeSize(int size, float pattern) { }
public void changeSize(float pattern, String name) throws
IOException { }

Invocando un método sobrecargado

• En la sobrecarga entonces el compilador siempre le asigna
prioridad al método que coincide con los atributos sin
castearlos, por eso el primero va al método que recibe las dos
variables enteras y el segundo al que recibe las dos variables
double.


• Aquí se aplica el mismo principio del caso anterior,
el sistema siempre busca primero los métodos con
atributo igual al mismo presentado, si se pasa un
objeto animal, buscará el método que usa Animal
como atributo


Qué pasa si en el
main se llama?

Si se tiene el mismo ejemplo de la diapositiva pasada pero en el
método main se hace un llamado con un objeto que usa
polimorfismo tal como se ve, entonces el sistema se va por el método
que implementa el objeto declarado en este caso Animal.

Polimorfismo en métodos sobrescritos y sobrecargados

Si se tiene el anterior bloque de código
entonces podríamos decir lo siguiente

Método de invocación usado Resultado
Animal a = new Animal(); Generic Animal Eating Generically
a.eat();
Horse h = new Horse(); Horse eating hay
h.eat();
Animal ah = new Horse(); Horse eating hay, en la sobrescritura el que determina
ah.eat(); que método usar es el tipo del objeto (Horse) y no la
referencia (Animal)
Horse he = new Horse(); Horse eating Apples, aquí se aplican los métodos
he.eat("Apples"); básicos de la sobrecarga de métodos.
Animal a2 = new Animal(); Error de compilación, la clase Animal no tiene un método
a2.eat("treats"); eat que reciba un String
Animal ah2 = new Horse(); Error de compilación, el objeto es de el tipo Horse y
ah2.eat("Carrots"); referencia Animal, entonces el compilador busca el método
en la referencia y lo ejecuta como el tipo, al buscar el método
eat que recibe un string en la clase Animal, no lo encuentra y
arroja error de compilación.

Diferencias entre la sobrecarga y la
sobrescritura
Métodos sobrecargados Métodos sobrescritos
Argumentos Deben ser diferentes No deben cambiar

Tipo de retorno Pueden cambiar No pueden cambiar exceptuando que
sea un objeto que quepa, por ejemplo
un int en una variable double, o un
hijo dentro de una clase padre
Excepciones Pueden cambiar Se pueden reducir o eliminar, no se
pueden lanzar excepciones nuevas o
no relacionadas
Accesos Pueden cambiar No puede ser más restrictivo, solo
igual o menos restrictivo
Invocación La referencia del objeto indica cual es la El tipo de objeto determina cual es el
versión que se debe usar, y las variables de método que se debe usar. Esto
acceso del método. Esto ocurre en tiempo de también se determina en tiempo de
compilación. compilación

Animal animalRefToHorse = new Horse();

Referencia del objeto Tipo del objeto


5.2 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.

Casteo de variables
• Existen dos tipos de casteo:

▫ Upcast: Es implícito y es cuando uno coloca una variable de
menor tamaño dentro de una más grande. Por ejemplo se
puede meter una variable byte dentro de un char, un char
dentro de un int, y un int dentro de un double. Lo mismo se
puede colocar una clase hija dentro de una clase padre.

▫ Downcast: Debe ser explicito, y se hace cuando es necesario
hacer un casteo de una variable de mayor tamaño a uno
más pequeño, ya sea por ejemplo de un double a un int, o
de un int a un char, o de un char a un byte, o de una clase
padre a un hijo. La sintaxis es así:

Clase hijo variable = (ClaseHijo) variableClasePadre

Aplicación del casteo
Aquí el sistema crea una instancia
implícita como la siguiente,
para la primera pasada:

Animal animal = new Animal()

Pero para la segunda pasada
declara algo así:

Animal animal = new Dog()

Por reglas de poliformismo ya se sabe que esto arrojaría un error, y en este
caso viene a salvarnos el casteo explicito, si se coloca la siguiente línea
entonces ya no hay ningún error en tiempo de ejecución.

if(animal instanceof Dog) {
Dog d = (Dog) animal; // casting the ref. var.
d.playDead();
}

Riesgos del casteo
• Cuando se hace un casteo sobretodo explícito el compilador confía
en que se sabe que el casteo se hace sin ningún inconveniente, por lo
tanto en los casos de download que los objetos tengan una relación
de herencia no arroja un error de conexión, pero no garantiza que
no halla un error de ejecución.

En ejecución java.lang.ClassCastException

• Existen otros casos como en los que la clase de casteo no hace parte
de la línea de herencia, en este caso el compilador si puede detectar
que hay un error.

En inconvertible types
compilación


1.2 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.

Reglas para implementar una interface

• Proveer una implementación concreta (no abstracta) de
todos los métodos de la interface declarada.

• Seguir todos los pasos para la sobrescritura legal

• No declarar excepciones o métodos diferentes a los
declarados por la interface

• Mantener la firma de los métodos de la interface, y el
tipo de retorno o un subtipo de este.

Reglas para implementar una interface
• Se puede implementar una interface con una clase
abstracta, claro esta que esta clase debe ser
implementada a su vez por una clase concreta. Esto
implica que una clase abstracta no necesita
implementar todos los métodos de la interface si no
que puede delegar esta tarea a sus hijos.

Reglas para implementar una interfaz
• Una clase puede implementar más de una interfaz, sin embargo solo
puede extender de una clase.

• Una clase puede heredar de otra interface, pero nunca puede
implementar nada, por lo tanto la clase que implemente esta clase
deberá implementar los métodos de la interface y de la que hereda

Usos legales e ilegales de extends e
implements
Declaración Resultado
class Foo { } Ok
class Bar implements Foo { } Error, Foo no es una interface, no se puede implementar
de esta
interface Baz { } Ok
interface Fi { } Ok
interface Fee implements Baz { } Error, una interface no puede implementar otra interface,
solo heredar
interface Zee implements Foo { } Error, una interface tampoco puede implementar una
clase, ni siquiera heredar de esta.
interface Zoo extends Foo { } Error, una interface no puede heredar de una clase, solo
de interfaces
interface Boo extends Fi { } Ok
class Toon extends Foo, Button { } Error, una clase solo puede heredar de una clase, no de
varias
class Zoom implements Fi, Baz { } Ok, una clase puede implementar varias interfaces
interface Vroom extends Fi, Baz { } Ok, una interface puede heredar de varias interfaces
class Yow extends Foo implements Fi { } Ok, una clase puede heredar de una clase e implementar
una interface al mismo tiempo


1.5 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.

Reglas en retornos
• Se puede retornar null en un método que devuelve un objeto

• Un método puede retornar un Array sin problema

• En un método que retorna un primitivo, se puede retornar sin problema un valor que
pueda convertirse implícitamente en el tipo de retorno esperado, o en caso contrarío hay
que hacer previamente un casteo explicito

Casteo explícito
Casteo implícito

Reglas en retornos
• Cuando se tiene un void no se debe retornar nada

• En los métodos que retornan un objeto, se puede colocar cualquier objeto
que implícitamente castee dentro del objeto de retorno

Tipos de retorno en métodos
sobrecargados
• Con la sobrecarga toca tener cuidado es en identificar
que sea efectivamente una sobrecarga de métodos, pues
la sobrecarga no exige que los retornos tengan algo que
ver, pueden ser de diferentes tipos, sin ningún tipo de
restricción

Efectivamente es una sobrecarga de Esto no es una sobrecarga, por lo
métodos, por lo tanto pueden los tanto no puede retornar cualquier
dos métodos retornar cosas distintas cosa

Tipos de retorno en métodos
sobrescritos
• Los métodos sobrescritos son diferentes, aquí es necesario que el
retorno del método sobrescrito quepa dentro de la variable del
método original, es decir en el caso de clases puede el método
sobrescrito puede retornar una clase hija del retorno del método
original. Esto aplica solo de la versión Java 1.5 o superior

Beta es una clase hija
De Alpha

Cubre los objetivos 1.6, 5.3 y 5.4
1.6 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.3 Explain the effect of modifiers on inheritance with respect to constructors, instance or static variables, and instance or static
methods.

5.4 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.

Principios de los constructores
• Los principios fundamentales en la creación e identificación de los
constructores:
▫ Todas las clases deben tener un constructor, inclusive las clases
abstractas, es posible que al momento de crear una clase no exista un
constructor explicito, sin embargo el compilador le asigna uno implícito.
Una explicación sobre esto se verá más adelante.
▫ Los constructores no retornan nada. Nada de nada, si siquiera un
void, debe ir en su firma el tipo de acceso, el nombre del constructor, y
los parámetros que recibe.
▫ Un constructor debe llamarse exactamente igual a la clase.
▫ El fin de un constructor es inicializar el estado del objeto al momento
que se construye un objeto.

Cadena de construcción
1. En el método principal se crea un objeto Horse.
Object() 2. Entonces el compilador lo que hace es ir al constructor
de la clase horse, aquí implicitamente, antes de todo
llama al constructor de la clase padre, en este caso
Animal 3 Animal
4 llama 3. Animal Repite el proceso, invoca a su constructor,
new
super() y llama implicitamente a su padre, en este caso Object
4. Object completa su constructor, y vuelve a la clase
Animal.
5 2
Horse
llama
5. Animal completa su constructor y vuelve a la clase
super() Horse.
6. Horse completa su constructor, inicializa el estado de
Main 1
sus variables, y retorna un objeto de tipo Horse.
6 llama 7. El método main obtiene un objeto de la clase Horse,
new
Horse() con las clases inicializadas y lo puede usar.

Reglas de los constructores
• Los constructores pueden usar cualquier modificador de acceso,
aunque es algo muy bobo poner un constructor private, pero se
puede hacer y funciona.

• El nombre del constructor tiene que ser exactamente igual al
nombre de la clase.

• Los constructores no deben retornar nada, ni siquiera void.

• Puede existir un método con el mismo nombre de la clase, este no es
considerado como constructor si retorna algo.

• Si un constructor no esta creado explícitamente en la clase entonces
el compilador automáticamente generara uno por defecto.

• El constructor por defecto nunca trae argumentos.

• La única forma de tener un constructor con argumentos es creando uno
explícitamente, es decir escribiéndolo en la clase.

• Cada constructor tiene, como su primera declaración, ya sea una llamada a
un constructor sobrecargado (this()) o una llamada al constructor de la
superclase (super ()), esta llamada puede ser insertado por el compilador.

• Si se crea explícitamente un constructor y no se escribe como primera
sentencia la línea super(), el compilador lo hace automáticamente por
usted.

• Si se llama automáticamente la sentencia super(), entonces el compilador
busca el contructor sin argumentos de la clase padre. Por eso es importante
tener cuidado cuando se tiene un constructor explícito creado, pues si no
existe el constructor sin argumentos, el sistema arroja error de compilación.

• El constructor por defecto no es el que no tiene argumentos, el
constructor por defecto es el creado por el compilador.

• No se puede hacer llamado de un método, o acceder a una
variable de instancia solo hasta que el constructor corra.

• Solo las variables y los métodos estáticos pueden ser
accedidos como parte de los métodos this() y super().

• Las clases abstractas tienen constructores y estos
constructores son llamados cuando una clase hija concreta la
instacia.

• Las interfaces no tienen constructores, porque no hacen parte
del árbol de herencia de los objetos.

¿Cuándo se crea un constructor por
defecto?

Se crea un constructor por
No tiene un constructor por defecto, ya se crearon defecto, pues no hay
explícitamente. ninguno creado
explícitamente

Entonces para que un
constructor por defecto
este creado no deben haber
constructores explícitos
Se crea un constructor por defecto, pues lo que muestra creados
este ejemplo es un método no un constructor, los
constructores no devuelven nada

¿Qué pasa cuando la clase padre tiene
un constructor con atributos?
Este constructor
no existe
Esto ve el
compilador

• El anterior código es un claro ejemplo de errores de los
constructores, como bien se dijo antes el sistema llama un
constructor por defecto, el problema es que no encuentra una
implementación en la clase padre de este constructor, porque
ya existe un constructor explícito, la solución es crearlo
manualmente también.

Sobrecarga de constructores

El ejemplo muestra
que el
comportamiento de
la sobrecarga de
constructores tiene
los mismos
principios de la
sobrecarga de
métodos


1.3 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.

Variables y métodos estáticos
• El principio fundamental de un método o una
variable marcadas con acceso estático es que se
le esta diciendo al compilador “Esto no hace
parte de la clase únicamente hace parte de un
entorno global a todo el programa que se esta
desarrollando”, por lo tanto tiene una serie de
especificaciones y tratamiento especial, tanto al
desarrollarlo como al ejecutarlo por el
compilador.

frogCount = 1

frogCount = 2

frogCount = 3

Frog count is now 3

• Del código anterior se puede ver varias cosas:
▫ Obviamente la variable flogCount es static
▫ El método main puede acceder a ella sin necesidad de usar la clase Flog, si no
directamente, si no estuviera marcada como static pues arroja error de
compilación.
▫ El constructor aumenta el valor que tiene en 1, pero aunque se crean 3 objetos
distintos el valor de frogCount cambia

• Entonces se puede concluir que flogCount al ser marcada como static se
vuelve una variable global.

• Del ejemplo anterior vemos que el método main puede
acceder directamente a la variable frogCount, esto es porque
los métodos static pueden entrar directamente a las variables
static.
• Por otro lado no pueden acceder a los métodos ni variables no
estaticos. Es por esto que siempre en el método main no
puede acceder a el resto de la clase que lo contiene y toca
construirlo
Error de compilación,
Esta variable no es static, por lo
tanto el método main
no puede acceder a este
directamente

Acceder a variables y métodos
estáticos
Un método estático no puede
acceder a una variable no estática

Un método estático tampoco puede
acceder a un método no estático

Un método estático si puede acceder a
variables y métodos estáticos

Sobrescritura en los métodos estáticos
• Los métodos estáticos no pueden ser sobrescritos, el
compilador no arroja error, y la aplicación funciona, pero
siempre se llama al método estático, el método sobrescrito no
es tenido en cuenta por el compilador

Esto demuestra que los métodos y
variables estáticas tienen más
importancia para el compilador que un
método o variable no estática

a a a

Pregunta 1
public abstract interface Frobnicate { public void twiddle(String s); }

Which is a correct class? (Choose all that apply.)

• A. public abstract class Frob implements Frobnicate {
public abstract void twiddle(String s) { }
}

• B. public abstract class Frob implements Frobnicate { }

• C. public class Frob extends Frobnicate {
public void twiddle(Integer i) { }
}

• D. public class Frob implements Frobnicate {
public void twiddle(Integer i) { }
}

• E. public class Frob implements Frobnicate {
public void twiddle(String i) { }
public void twiddle(Integer s) { }
}

Respuesta 1
• La A es incorrecta, pues un método abstracto no puede
implementarse, o se implementa o es abstracto pero no
ambos.
• La B es correcta, al decir que la clase Forb es
abstracta, entonces la clase que implementa a Forb
implementa el método.
• La C es incorrecta, una interface no usa extends si no
implements.
• La D es incorrecta, pues la clase no implementa el método de
la interface.
• La E es correcta, la clase implementa el método
correctamente, y fuera de eso usa sobrecarga de métodos

Esta pregunta cubre el objetivo 5.4

Pregunta 2
class Top {
public Top(String s) { System.out.print("B"); }
}
public class Bottom2 extends Top {
public Bottom2(String s) { System.out.print("D"); }
public static void main(String [] args) {
new Bottom2("C");
System.out.println(" ");
}
}

What is the result?
• A. BD
• B. DB
• C. BDC
• D. DBC
• E. Compilation fails

Respuesta 2
• La respuesta correcta es la E, puesto que no compila,
pues el constructor de la clase padre que en este
caso es Top(), no esta implementado.

Recuerde que lo
class Top { primero que llama el
public Top(String s) { System.out.print("B"); } compilador en este
} punto es el constructor
public class Bottom2 extends Top { super(), y top no tiene
public Bottom2(String s) { System.out.print("D"); } El constructor Top(),
public static void main(String [] args) { se podría corregir colocando
new Bottom2("C"); un super(s), al inicio del
System.out.println(" "); constructor.
}
}


Pregunta 3
class Clidder {
private final void flipper() { System.out.println("Clidder"); }
}
public class Clidlet extends Clidder {
public final void flipper() { System.out.println("Clidlet"); }
public static void main(String [] args) {
new Clidlet().flipper();
}
}

What is the result?

• A. Clidlet

• B. Clidder

• C. Clidder
Clidlet

• D. Clidlet
Clidder


Respuesta 3
• A es correcta, la sobrescritura de métodos en métodos
final no es muy efectiva, el método final no hereda a la
clase hija, por lo tanto si esta usa un método con el
mismo nombre pues no tiene en cuenta el método de la
clase padre.
• B es incorrecta porque no es posible la sobrescritura
• C y D no es posible porque no se comporta como un
constructor, son métodos sobrescritos.
• E no es correcta, porque no hay errores de compilación,
puede haber un método igual en la clase padre e hija con
el mismo nombre y marcados con final.


Pregunta 4
Using the fragments below, complete the following code
so it compiles. Note, you may not have to fill all of the slots.
class AgedP {
__________ __________ __________ __________ __________
public AgedP(int x) {
__________ __________ __________ __________ __________
}
}
public class Kinder extends AgedP {
__________ __________ __________ _________ ________ __________
public Kinder(int x) {
__________ __________ __________ __________ __________ ();
}
}

Respuesta 4
class AgedP {
__ AgedP _ __(_ ___)______ ___{______ ___}____
public AgedP(int x) {
___this_____ __(__ __)_ __; _ __________
}
}
public class Kinder extends AgedP {
__________ __________ __________ _________ ________ __________
public Kinder(int x) {
_super__ ();
}
}

Esta línea es opcional


Pregunta 5
Which statement(s) are true? (Choose all that apply.)
• A. Cohesion is the OO principle most closely associated with
hiding implementation details

• B. Cohesion is the OO principle most closely associated with
making sure that classes know about other classes only
through their APIs

• C. Cohesion is the OO principle most closely associated with
making sure that a class is designed with a single, well-
focused purpose

• D. Cohesion is the OO principle most closely associated with
allowing a single object to be seen as having many types

Respuesta 5
• La opción A es incorrecta porque se esta refiriendo a
la encapsulación. Con encapsulación no se puede
acceder directamente a los atributos de la clase, es
decir los oculta.
• La opción B es incorrecta porque se refiere a la
coherencia, que corresponde que una clase solo debe
hacer lo que le corresponde, no tener tareas ajenas a
su naturaleza.
• La opción C es la correcta.
• La opción D es incorrecta, porque se refiere al
polimorfismo, una misma clase puede ser vista de
diferentes formas por diferentes clases.


Pregunta 6
1. class X { void do1() { } }
2. class Y extends X { void do2() { } }
3.
4. class Chrome {
5. public static void main(String [] args) {
6. X x1 = new X();
7. X x2 = new Y();
8. Y y1 = new Y();
9. // insert code here
10. } }

Which, inserted at line 9, will compile? (Choose all
that apply.)

• A. x2.do2();
• B. (Y)x2.do2();
• C. ((Y)x2).do2();
• D. None of the above statements will compile

Respuesta 6
• A es incorrecta porque el polimorfismo no permite
que se invoque el método do2, recuerde como esta
llamado el objeto x2 se comporta como la clase Y,
pero solo son válidos los métodos de la clase X.
• B es incorrecta, el casteo el compilador cree que el
casteo es incorrecto.
• C es correcta, antes de invocar el método do2 de Y,
hay que castear el objeto a X.
• D es incorrecta, porque la respuesta C compila.


Pregunta 7
1. ClassA has a ClassD
2. Methods in ClassA use public methods in ClassB
3. Methods in ClassC use public methods in ClassA
4. Methods in ClassA use public variables in ClassB

Which is most likely true? (Choose the most likely.)

• A. ClassD has low cohesion
• B. ClassA has weak encapsulation
• C. ClassB has weak encapsulation
• D. ClassB has strong encapsulation
• E. ClassC is tightly coupled to ClassA

Respuesta 7
• A es incorrecta, porque classD solo es accedida por
classA.
• B es incorrecta, pues solo pueden acceder las demás
clases los método públicos de classA
• C es correcta, pues classA puede acceder
directamente a los atributos de classB
• D es incorrecta, por el mismo motivo del punto
anterior.
• E es incorrecta pues classC solo accede a los
métodos públicos de classA


Pregunta 8
3. class Dog {
4. public void bark() { System.out.print("woof "); }
5. }
6. class Hound extends Dog {
7. public void sniff() { System.out.print("sniff "); }
8. public void bark() { System.out.print("howl "); }
9. }
10. public class DogShow {
11. public static void main(String[] args) { new DogShow().go(); }
12. void go() {
13. new Hound().bark();
14. ((Dog) new Hound()).bark();
15. ((Dog) new Hound()).sniff();
16. }
17. }

• What is the result? (Choose all that apply.)

• A. howl howl sniff
• B. howl woof sniff
• C. howl howl followed by an exception
• D. howl woof followed by an exception
• E. Compilation fails with an error at line 14
• F. Compilation fails with an error at line 15

Respuesta 8

• A, B, C y D son incorrectas, porque el código
propuesto presenta un error de compilación.
• E es incorrecta, pues las clases Dog y Hound tienen
el método bark(), aquí se aplican los principios de la
sobrescritura.
• F es correcta, se presenta un error de compilación,
porque al momento de hacer el casteo entre Hound
y Dog, se pierde la posibilidad de usar el método
sniff().


Pregunta 9

3. public class Redwood extends Tree { What is the result? (Choose all that apply.)
4. public static void main(String[] args) {
5. new Redwood().go(); • A. An exception is thrown at runtime
6. } • B. The code compiles and runs with no output
7. void go() { • C. Compilation fails with an error at line 8
• D. Compilation fails with an error at line 9
8. go2(new Tree(), new Redwood());
• E. Compilation fails with an error at line 12
9. go2((Redwood) new Tree(), new Redwood());
• F. Compilation fails with an error at line 13
10. }
11. void go2(Tree t1, Redwood r1) {
12. Redwood r2 = (Redwood)t1;
13. Tree t2 = (Tree)r1;
14. }
15. }
16. class Tree { }

Respuesta 9
• A es incorrecta, pues aparece un error de
ejecución tratando de hacer un downcast de la
clase tree a Redwood.
• Las demás son incorrectas, por lo mencionado
anteriormente.

Pregunta 10
3. public class Tenor extends Singer {
4. public static String sing() { return "fa"; }
6. Tenor t = new Tenor();
7. Singer s = new Tenor();
8. System.out.println(t.sing() + " " + s.sing());
9. }
10. }
11. class Singer { public static String sing() { return "la"; } }

What is the result?

• A. fa fa
• B. fa la
• C. la la
• D. Compilation fails
• E. An exception is thrown at runtime

Respuesta 10
• A y C es incorrecta porque no hay polimorfismo,
y ambos métodos son estáticos y se esta
accediendo por medio del objeto.
• B es correcta, por los motivos anteriores.
• D es incorrecta, porque no existe ningún motivo
de implementación.
• E es incorrecta, no hay ningún motivo para
arrojar un error en tiempo de ejecución.


Pregunta 11
3. class Alpha {
4. static String s = " ";
5. protected Alpha() { s += "alpha "; }
6. }
7. class SubAlpha extends Alpha {
8. private SubAlpha() { s += "sub "; }
9. }
10. public class SubSubAlpha extends Alpha {
11. private SubSubAlpha() { s += "subsub "; }
13. new SubSubAlpha();
14. System.out.println(s);
15. }
16. }

What is the result?

• A. subsub
• B. sub subsub
• C. alpha subsub
• D. alpha sub subsub
• F. An exception is thrown at runtime

Respuesta 11
• A es incorrecta, pues acuérdese que se llama primero el constructor del padre.
• B es incorrecta, pues SubSubAlpha no hereda de SubAlpha.
• C es correcta, SubSubAlpha hereda de Alpha.
• D es incorrecta por el mismo motivo de la respuesta B.
• E y F es incorrecta, pues compila sin ningun problema.

3. class Alpha {
4. static String s = " ";
5. protected Alpha() { s += "alpha "; }
6. }
7. class SubAlpha extends Alpha {
8. private SubAlpha() { s += "sub "; }
9. } alpha subsub
10. public class SubSubAlpha extends Alpha {
11. private SubSubAlpha() { s += "subsub "; }
13. new SubSubAlpha();
15. }
16. }

Pregunta 12
3. class Building {
4. Building() { System.out.print("b "); }
5. Building(String name) {
6. this(); System.out.print("bn " + name);
7. }
8. }
9. public class House extends Building {
10. House() { System.out.print("h "); }
11. House(String name) {
12. this(); System.out.print("hn " + name);
13. }
14. public static void main(String[] args) { new House("x "); }
15. }

What is the result?

• A. h hn x
• B. hn x h
• C. b h hn x
• D. b hn x h
• E. bn x h hn x
• F. b bn x h hn x
• G. bn x b h hn x
• H. Compilation fails

Respuesta 12
• La opción correcta es la C, por el llamado de los
constructores padres.

3. class Building {
4. Building() { System.out.print("b "); }
5. Building(String name) {
6. this(); System.out.print("bn " + name);
7. }
8. }
9. public class House extends Building { b h hn x
10. House() { System.out.print("h "); }
11. House(String name) {
12. this(); System.out.print("hn " + name);
13. }
new House("x "); }
15. }

Pregunta 13
3. class Mammal {
4. String name = "furry ";
5. String makeNoise() { return "generic noise"; }
6. }
7. class Zebra extends Mammal {
8. String name = "stripes ";
9. String makeNoise() { return "bray"; }
10. }
11. public class ZooKeeper {
12. public static void main(String[] args) { new ZooKeeper().go(); }
13. void go() {
14. Mammal m = new Zebra();
15. System.out.println(m.name + m.makeNoise());
16. }
17. }

What is the result?

• A. furry bray
• B. stripes bray
• C. furry generic noise
• D. stripes generic noise
• F. An exception is thrown at runtime

Respuesta 13
• A es correcta, pues los atributos se toman del tipo de
objeto, pero el comportamiento de los métodos de la
clase de los métodos.

3. class Mammal {
4. String name = "furry ";
5. String makeNoise() { return "generic
noise"; }
6. } furry bray
7. class Zebra extends Mammal {
8. String name = "stripes ";
9. String makeNoise() { return "bray"; }
10. }
11. public class ZooKeeper {
new ZooKeeper().go(); }
Concluyendo podemos decir que en
13. void go() { aspecto de atributos hay que tomar la
14. Mammal m = new Zebra();
15. System.out.println(m.name +
referencia del objeto y en caso de
m.makeNoise()); métodos se mira si la referencia tiene
16. }
17. }
el método como tal pero ejecuta el
método del tipo del objeto.

Pregunta 14
• You’re designing a new online board game in which Floozels are a type of Jammers,
Jammers can have Quizels, Quizels are a type of Klakker, and Floozels can have several
Floozets. Which of the following fragments represent this design? (Choose all that apply.)

import java.util.*;
import java.util.*;
A interface Klakker { }
class Jammer { Set<Quizel> q; } B class Klakker { Set<Quizel> q; }
class Quizel extends Klakker { }
class Quizel implements Klakker { }
class Jammer { List<Floozel> f; }
public class Floozel extends Jammer {
class Floozet extends Floozel { }
List<Floozet> f; }
public class Floozel { Set<Klakker> k; }
interface Floozet { }

import java.util.*; import java.util.*;
C class Floozet { }
class Quizel implements Klakker { }
D interface Jammer extends Quizel { }
interface Klakker { }
class Jammer { List<Quizel> q; } interface Quizel extends Klakker { }
interface Klakker { } interface Floozel extends Jammer,
class Floozel extends Jammer { Floozet { }
List<Floozet> f; } interface Floozet { }

Respuesta 14
• A y C es correcta, puesto que cuando se dice “es un”
entonces se aplica a herencia. Cuando se dice “tiene
un”, es porque hay una relación de atributos de una
clase con otra. La diferencia entre A y C es que una
usa interfaces y la otra clases, pero aplican ambas a
las condiciones del enunciado.
• B es incorrecta, porque el enunciado dice que
Floozels es de tipo Jammers, y Floozet aquí hereda
de Floozel.
• D es incorrecta, porque porque el enunciado dice
que Floozels es solamente de tipo Jammers, y
Floozet aquí hereda de Floozel y de Jammer.

Pregunta 15
3. class A { }
4. class B extends A { } What is the result?
5. public class ComingThru {
6. static String s = "-";
8. A[] aa = new A[2];
• A. -124
9. B[] ba = new B[2]; • B. -134
10. sifter(aa);
11. sifter(ba); • C. -424
12. sifter(7);
13. System.out.println(s); • D. -434
14. }
15. static void sifter(A[]... a2) { s += "1"; }
• E. -444
16. static void sifter(B[]... b1) { s += "2"; }
17. static void sifter(B[] b1) { s += "3"; }
• F. Compilation fails
18. static void sifter(Object o) { s += "4"; }
19. }

Respuesta 15
• La correcta es la D, siempre el último en
seleccionarse es el var-arg , entonces como el array
cabe en el Object, el compilador se va por ahí.
3. class A { }
4. class B extends A { }
5. public class ComingThru {
6. static String s = "-";
8. A[] aa = new A[2];
9. B[] ba = new B[2];
10. sifter(aa); -434
11. sifter(ba);
12. sifter(7);
14. }
15. static void sifter(A[]... a2) { s += "1"; }
16. static void sifter(B[]... b1) { s += "2"; }
17. static void sifter(B[] b1) { s += "3"; }
18. static void sifter(Object o) { s += "4"; }
19. }

Certificación java 6 cap 2

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Certificación java 6 cap 2

Similar a Certificación java 6 cap 2 (20)

Último

Último (20)

Certificación java 6 cap 2