Resumen Capítulo 1 – Declaraciones y Control de Acceso Identificadores



Descargar 66,79 Kb.
Fecha de conversión07.05.2017
Tamaño66,79 Kb.

TMD


Resumen

Capítulo 1 – Declaraciones y Control de Acceso

Identificadores


  • Los identificadores pueden empezar con una letra o los caracteres "_" o "$".

  • Despues del primer caracter, los identificadores pueden incuir tambien digitos.

  • Los identificadores pueden ser de cualquier tamaño.

  • Los métodos JavaBeans deben ser llamados usando "camelCase" y dependiendo del tipo de método empezaran con get, set, is, add o remove.

Reglas de declaraciones



  • Un fichero con código puede tener solo una clase pública.

  • Si el fichero que contiene el código contiene una clase pública, el fichero debe llamarse igual que la clase pública.

  • Un fichero solo puede tener una sentencia "package", pero puede tener multiples "import".

  • La sentencia package debe ser la primera linea del fichero.

  • Las sentencias import deben ir despues de package y antes de la declaración de la clase.

  • Si no hay sentencia "package" las sentencias import deben ser las primeras lineas del fichero.

  • Las sentencias package e import son aplicadas a todas las clases del fichero.

  • Un fichero puede contener más de una clase no publica.

  • Los ficheros que no tienen clase publica no tienen restricciones con el nombre del fichero.

Modificadores de acceso a clase



  • Hay tres modificadores de acceso: public, protected y private.

  • Hay cuatro niveles de acceso: public, protected, default y private.

  • Las clases solo pueden tener acceso public o default.

  • Una clase declarada como default puede ser vista solo por las clases de su mismo paquete.

  • Una clase declarada publica puede ser vista por todas las clases de todos los paquetes.

  • La visibilidad de una clase gira en torno a si el código de una clase puede ...

  • Cear una instancia de otra clase.

  • Extender (o subclase) de otra clase.

  • Acceso a variables y métodos de otras clases.

Modificadores de clase (no acceso)



  • Las clases pueden tambien ser declaradas con final, abstract y strictfp.

  • Una clase no puede ser abstract y final a la vez.

  • Una clase final no puede ser sobrescrita por una subclase.

  • Una clase abstract no puede ser instanciada.

  • Un solo método abstracto en una clase obliga a la clase a ser declarada abstracta.

  • Una clase abstracta puede tener ambos tipos de métodos abstractos y no abstractos.

  • La primera clase concreta que extienda una clase abstracta debe implementar todos sus métodos astractos.

Implementación de interfaz

  • Las interfaces son contratos que una clase puede hacer, pero no dicen nada de la manera en la que la clase debre hacerlo.

  • Las interfaces pueden ser implementadas por cualquier clase, de cualquier arbol de herencia.

  • Una interfaz es como una clase abstracta 100% y es declarada implicitamente abstract aunque tu no lo declares así.

  • Una interfaz debe tener todos los métodos abstractos, no permite ningún método concreto.

  • Los métodos de una interfaz son por defecto "public abstract", la declaración explicita de estos modificadores es opcional.

  • Las interfaces pueden tener constantes, las cuales son implicitamente "public abstract final".

  • La declaración de public, static y final es opcional en las constantes.

  • La implementación legal de una clase no abstracta tiene las siguiente propiedades:

  • Proporciona implementaciones concretas de todos los métodos de la interfaz.

  • Debe seguir todas las reglas de sobrecritura para los métodos implementados.

  • No debe declarar ningúna nueva excepción chequeada para la implementación de un método.

  • No debes declarar ninguna excepción chequeada que sea más amplia que la declarada en el método de la interfaz.

  • Puedes declarar excepciones en tiempo de ejecución en cualquier implementación de un método de la interfaz independientemente de la declaracuión de la interfaz.

  • Debes mantener la nomenclatura y el tipo de devolución de los métodos implementados (pero no tienes que declarar las excepciones de la interfaz).

  • Una clase que implemente una interfaz puede ser abstracta.

  • La clase abstracta que implemente una interfaz no tiene que implementar los métodos de una interfaz (pero la primera subclase concreta si debe implementarlos).

  • Una clase puede extender de una sola clase (no hay herencia multiple), pero puedes implementar varias iterfaces.

  • Las interfaces pueden extender de una o mas interfaces.

  • Las interfaces no pueden extender de una clase o implementar una clase o interfaz.

  • Cuando estes en el examen, verifica que las declaraciones de interfaces y clases son legales, antes de verificar cualquier otra lógica del código.

Modificadores de acceso Miembros



  • Los métodos y las variables de instancia (no variables locales) de una clase son conocidos como miembros.

  • Los miembros pueden usar los cuatro niveles de acceso: public, protected, default y private.

  • Hay dos maneras de acceder a los miembros:

  • El código de una clase puede acceder a un miembro de otra clase.

  • Una subclase puede heredar un miembro de su superclase.

  • Si una clase no puede ser accedida, tampoco se puede acceder a sus miembros.

  • Determina antes la visibilidad de la clase antes que la de los miembros.

  • Los miembros public pueden ser accedidos por cualquier clase, incluso de otro paquete.

  • Si un miembro de la superclase es public, la subclase lo heredara (independientemente del paquete).

  • Para acceder a un miembro sin el operador (.) debemos estar en la misma clase.

  • this. Siempre se refiere al actual objeto en ejecución.

  • this.aMethod() es lo mismo que ejecutar aMethod().

  • Los miembros private pueden ser accedidos solo desde la misma clase.

  • Los miembros private no son accesibles a las subclases, así que los miembros private no se heredan.

  • Los miembros default o protected solo difieren en el caso de las subclases:

  • Los miebros default pueden ser accedidos solo por clases de su mismo paquete.

  • Los miembros protected pueden ser accedidos por clases de su mismo paquete, mas las subclases de diferente paquete.

  • protected = paquete + hijos(subclases).

  • Para las subclases fuera del paquete, el miembro portected puede ser accedido solo a traves de herencia; una subclase fuera del paquete de la clase del miembro no puede acceder al miembro protected usando una referencia de la instancia de la superclase.

  • Un miembro protected de una superclase heredado por una subclase de un paquete diferente al de la superclase no es accesible por otras clases del mismo paquete que la subclase, excepcto las propias subclases de la subclase.

Variables locales



  • Las declaraciones de una variable local no pueden tener modificadores de acceso.

  • final es el único permitido.

  • Las variables locales no obtienen valores por defecto, asi que hay que inicializarlas antes de ser usadas.

Otros Modificadores miembros



  • Los métodos final no pueden ser sobrescritos por una subclase.

  • Los métodos abstract son declarados con un nombre, un tipo de devolución y una clausula throws opcional, pero no son implementados.

  • Los métodos abstractos terminan en ; y no llevan {}.

  • Hay tres maneras de reconocer que un método no es abstract:

  • El método no esta marcado abstract.

  • El método tiene {}.

  • El método tiene código entre las llaves.

  • La primera clase concreta (no abstracta) que extienda de una clase abstracta debe implementar todos los métodos abstract de la clase abstracta.

  • El modificador syncronized se usa solo en métodos y bloques de código.

  • Los métodos syncronized pueden tener cualquier control de acceso y tambien pueden ser marcados final.

  • Los métodos abstractos deben ser implementados por la subclase, así que deben ser heredables.

  • Un método abstracto no puede ser private.

  • Un método abstracto no puede ser final.

  • El modificador native se aplica solo a métodos.

  • El modificador strictfp es aplicable solo a clases y métodos.

Métodos con var-args



  • Despues de Java 5, los métodos pueden aceptar un parametro que acepta de cero a muchos argumentos, así que son llamados métodos var-arg.

  • Un parametro var-arg es declarado con la sintaxis "tipo... nombre".

  • Un método var-arg puede tener un solo paramtero var-arg.

  • Un método con parametros normales y un var-arg, el var-arg se declarara al final.

Declaraciones de variables



  • Las variables instancia pueden:

  • Tener cualquier control de acceso.

  • Ser marcadas final o transient.

  • Las variables de instancia no pueden ser abstract, syncronized, native ni strictfp.

  • Es legal declarar una variable local con el mismo nombre que una variable de instancia, esto se conoce como shadowing.

  • Las variables final tienen las siguientes propiedades:

  • Las variables final no pueden ser reinicializadas una vez tengan asignado un valor.

  • Las variables de referencia final no pueden referirse a un objeto diferente una vez el objeto haya sido asignado a la variable final.

  • Las variables de referencia final deben ser inicializadas antes que el constructor acabe.

  • Un objeto referenciado marcado como final no significa que el objeto en si sea inmutable.

  • El modificador transient solo se aplica a variables de instancia.

  • El modificador volatile se aplica solo a variables de instancia.

Declaraciones de Array



  • Los arrays pueden almacenar primitivos o objetos, pero el array en si es siempre un objeto.

  • Cuando declaras un array, los [] pueden estar a la izquierda o a la derecha del nombre de la variable.

  • Nunca es legal incluir el tamaño del array en la declaración.

  • Un array de objetos puede almacenar a cualquier objeto que pase el test IS-A (o instanceof) con el tipo declarado en el array.

Variables y métodos static



  • No esta atada a cualquier instancia particular de una clase.

  • No son necesarias instancias de una clase para usar sus miembro static.

  • Solo hay una copia de una variable static por clase y todas las instancias la comparten.

  • Los métodos static no tiene acceso directo a miembros no static.

Enums



  • Un enum especifica una lista de valores constantes que pueden ser asignados a un tipo particular.

  • Un enum no es un String o un int; un tipo de enumerado constante es un tipo enum.

  • Un enum se puede declarar dentro o fuera de una clase, pero no en un método.

  • Un enum declarado fuera de una clase no debe ser marcado static, final, abstract, protected o private.

  • Los enums pueden contener constructores, métodos, variables y constantes.

  • Las constantes enum pueden enviasr arguemntos al constructor enum, usando la sintaxis BIG(8), donde el entero literal 8 es pasado al constructor enum.

  • Los constructores enum pueden tener argumentos y pueden ser sobrecargados.

  • Los constructores enum no pueden ser invocados directamente desde el código. Son llamados automaticamente cuando el enum es inicializado.

  • El ; al final de una declaración enum es opcional.

Capítulo 2 – Orientación a Objetos



Encapsulación IA-A, HAS-A

  • La encapsulación te ayuda a esconder la implementación detras de una interfaz (o API).

  • Un código encapsulado tiene dos caracteristicas:

  • Las variables instancia estan protegidas (normalmente con el modificador private).

  • Los métodos Getter y Setter proporcionan acceso a las variables de instancia.

  • IS-A se refiere a herencia.

  • IS-A es expresado con la palabras clave extends.

  • IS-A, hereda de... y "es un subtipo de ..." son expresiones equivalentes.

  • HAS-A significa que una instancia de una clase tiene una referencia a una instancia de otra clase o una instancia de la misma clase.

Herencia



  • La herencia permite a una clase ser subclase de una superclase y de este modo hereda hereda variables y métodos declarados protected o public en la superclase.

  • La herencia es un concepto clave que subyace de IS-A, polimorfismo, sobrescritura, sobrecarga y casting.

  • Todas las clases (excepto la clase Object) son subclases de tipo Object y heredan los métodos de Object.

Polimorfismo



  • Polimorfismo significa muchas formas.

  • Una variable de referencia es siempre se un solo tipo, pero puede referirse a objetos de un subtipo.

  • Un solo objeto puede ser referenciado por varias variables de referencia de diferentes tipos, que serian del mismo tipo o de un subtipo del objeto.

  • El tipo de variable de referencia (no el tipo del objeto) determina que método puede ser llamado.

  • Las invocaciones de un método polimorfico se aplican solo a métodos de instancia sobrescritos.

Sobrescritura y sobrecarga



  • Los métodos pueden ser sobrescritos o sobrecargados, los constructores pueden ser sobrecargados pero no sobrescritos.

  • Los métodos abstractos deben ser sobrescritos por la primera subclase concreta (no abstracta).

  • Con respecto a la sobrescritura de métodos:

  • Deben tener la misma lista de argumentos.

  • Deben devolver el mismo tipo, excepto despues de Java 5 que el tipo devuelto puede ser una subclase, esto es conocido como return covariante.

  • Puedes tener un modificador de acceso menos restrictivo.

  • No debes lanzar nuevas o ampliadas excepciones chequeadas.

  • Puedes lanzar cualquier excepción no chequeada.

  • Los métodos final no pueden ser sobrescritos.

  • Solo los métodos heredados pueden ser sobrescritos y recordar que los métodos private no son heredados.

  • Una subclase usa super.overridenMethodName() para llamar a la versión de la superclase de un método sobrescrito.

  • Sobrecarga significa reusar el nombre de un método, cambiandole la lista de argumentos.

  • Métodos sobrecargados:

  • Deben tener listas de argumentos diferentes.

  • Pueden tener diferentes tipos de devolución, si la lista de argumentos tambien es diferente.

  • Puedes tener diferentes modificadores de acceso.

  • Puedes lanzar diferentes excepciones.

  • Los métodos de una superclase pueden ser sobrecargados en una subclase.

  • El polimorfismo se usa para sobrescribir no para sobrecargar.

  • Un tipo de Objeto (no el tipo de la variable de referencia) que método sobrescrito esta usando en tiempo de ejecución.

  • El tipo de referencia determina que método sobrecargado sera usado en tiempo de compilación.

Variable de referencia Casting



  • Hay dos tipos de variable de referencia casting: downcasting o upcasting.

  • Downcasting: Si tienes una variable de referencia que se refiere a un objeto subtipo, tu puedes asignarlo a una variable de referencia del subtipo. Tu debes hacer un casting para hacer esto y el resultado es que puedes acceder a los miembros del subtipo son esta nueva variable de referencia.

  • Upcasting: Tu puedes asignar una variable de referencia a una variable de referencia de un supertipo explictamente o implicitamente. Esto es una operación segura ya que la asignación restringe el acceso a las capacidades de la nueva variable.

Implementando una interfaz



  • Cuando implementas una interfaz, tu estas cumpliendo su contrato.

  • Tu implementas una interfaz sobrescribiendo todos los métodos definidos en la interfaz.

  • Una sola clase puede implementar muchas interfaces.

Tipos devueltos



  • Los métodos sobrecargados pueden cambiar el tipo de devolución, los métodos sobrescritos no pueden excepto en el caso de return covariantes.

  • Un array es un legal tipo de devolución.

  • Para los métodos que devuelven tipos primitivos, cualquier valor que pueda ser implicitamente convertido al tipo de devolución puede ser devuelto.

  • Nada puede ser devuelto de un void.

  • Los métodos que devuelven un tipo de objeto, pueden devolver un subtipo de el.

  • Los métodos que devuelven una interfaz, pueden devolver cualquier implementación.

Constructores e Instanciación



  • Un constructor es siemrpes llamado cuando un nuevo objeto es creado.

  • Cada superclase en un arbol de herencia de objetos tendra un constructor llamado.

  • Todas las clases, incluso las abstractas, tienen al menos un constructor.

  • Los constructores no devuelven nada. Si ves un método que devuelve algo con el mismo nombre que la clase no es un constructor.

  • La ejecución tipica de un constructor ocurre como veremos ahora:

  • El constructor llama al constructor de la superclase, el cual llama al constructor de su superclase y asi sucesivamente hasta llegar al constructor de Object.

  • El constructor de Object se ejecuta y entonces vuelve al constructor que lo llamo y asi sucesivamente hasta llegar al constructor de la actual instancia que se esta creando.

  • Los constructores pueden usar cualquier modificador de acceso (incluso private).

  • El compilador creara un constructor por defecto si no creas ningún constructor en la clase.

  • El constructor por defecto es un constructor sin argumentos con una llamada al constructor padre sin parametros super().

  • La primera sentencia de un constructor debe ser this() o super().

  • El compilador añadira una llamada a super() a menos que ya hayas puesto this() o super().

  • Los miembros de instancia son accesibles solo despues de la ejecución del constructor super.

  • Las clases abstractas tienen constructores que son llamados cuando se esta instanciando una subclase concreta.

  • Las interfaces no tienen constructores.

  • Si tu superclase no tiene un constructor sin argumentos, tu debes crear un constructor e insertar una llamada super().

  • Los constructores nunca son heredados, entonces no pueden ser sobrescritos.

  • Un constructor puede ser invocado directamente solo por otro constructor (usando una llamada a super() o this()).

  • this() solo puede aparecer en la primera sentencia en un constructor.

  • La lista de argumentos indica que constructor sobrecargado es llamado.

  • Tu puedes tener las llamadas this() o super() en un constructor, pero nunca ambas.

Statics



  • Usa métodos static para imnplementar caracteristicas que no afecten al estado de la instancia.

  • Usa variables estaticas para almacenar datos que son especificos de la clase pero no de las instancias.

  • Todos los miembros static pertenecen a la clase no a la instancia.

  • Un método static no puede acceder directamente a una variable de instancia.

  • Usa el operador (.) para acceder a miembros static.

  • Los métodos static no pueden ser sobrescritos pero si redefinidos.

Acoplamiento y cohesión



  • Acoplamiento: se refiere al grado en el que una clase conoce o usa los miembros de otra clase.

  • Bajo acoplamiento es el estado deseado, significa tener las clases bien encapsuladas.

  • Alto acoplamiento es el estado no deseado, significa no cumplir las reglas de bajo acoplamiento.

  • Cohesión: se refiere al hecho de que una clase tenga un único y buen definido papel o responsabilidad.

  • Alta cohesión es el estado deseable de una clase, cuyos miembros tiene un único y bien definido su papel o responsabilidad.

  • La baja cohesión es el estaod no deseable de una clase, cuyos miembros tienen multiples papeles o responsabilidades.




La base de datos está protegida por derechos de autor ©absta.info 2016
enviar mensaje

    Página principal