1.3 Definición de clases - ajpaez/OCA GitHub Wiki

(OCA Objectives 1.2, 1.3, 1.4, 6.6, and 7.6)

Para estos objetivos, vamos a estudiar las formas en las que se pueden declarar y modificar ( o no) las clases.

Reglas de declaración para archivos de código

Antes de profundizar en las declaraciones de clase, vamos a hacer una revisión rápida de las reglas asociadas con la declaración de clases, declaraciones de import y las declaraciones de los packages en un archivo de código:

  • Sólo puede haber una clase pública por archivo de código fuente.
  • Los comentarios pueden aparecer al principio o al final de cualquier línea en el código fuente; ya que son independientes de cualquiera de las reglas de posicionamiento discutidos aquí.
  • Si hay una clase pública en un archivo, el nombre del archivo debe coincidir con el nombre de la clase pública. Por ejemplo, una clase declarada como Dog public class {} debe estar en un archivo llamado Dog.java.
  • Si la clase es parte de un package, la sentencia del package debe ser la primera línea en el archivo, antes de cualquier declaración de importación que puedan existir.
  • Si hay declaraciones de import, deben estar entre la sentencia de package (si lo hay) y la declaración de clase. Si no hay una sentencia de package, entonces la declaración de import debe ser la primera línea en el archivo de código fuente. Si no hay sentencias de package o de import, la declaración de la clase debe ser la primera línea del archivo de código fuente.
  • declaraciones de import y de package se aplican a todas las clases dentro de un archivo de código fuente. En otras palabras, no hay manera de declarar varias clases en un archivo y que tengan diferentes paquetes o utilizar diferentes import.
  • Un archivo puede tener más de una clase no pública.
  • Los archivos sin clases públicas pueden tener un nombre que no coincide con ninguna de las clases del archivo.

Usando javac y comandos java

Compilando con javac

El comando javac es usado para invocar el compilador de Java, Tu puedes especificar muchas opciones cuando ejecutes javac. Por ejemplo, opciones para generar información de debugg o warnings del compilador. Esta es su estructura para invocarlo:

javac [options] [sourcefile.java]

Cuenta con comandos adicionales llamados @argfiles.

Lanzando aplicaciones con java

El comando java es usado para invocar a la maquina virtual de java (JVM). Esta es la estructura básica del comando:

java [options] class [args]

Las partes de options y args son opcionales, y pueden tener varios valores. Se debe especificar exactamente un fichero de que contenga la clase a ejecutar, y el comando java asume que tu estas pasando un fichero .class. Ejemplo:

public class MyClass {
  public static void main(String[] args) {
    System.out.println(args[0] + " " + args[1]);
  }
}

java -version MyClass x 1

Este comando es interpretado como "muéstrame la versión de JVM usada y después lanza el fichero llamado MyClass.class y pasarle dos argumentos String cuyos valores son x y 1.

Si no se pasan argumentos en la parte de args, se recibe un array de string con longitud cero en el método main. Por tanto, no se produce un NullPointerException cuando se accede a args cuando no se pasan argumentos.

Usando public static void main(String[] args)

El uso del método main esta implicado en la mayoría de las preguntas del examen. No cualquier metodo llamado main() tendrá los mismo efectos que el main original, para que sea el verdadero main que busca JVM debe tener la firma:

public static void main(String[] args)

Otras versión de main con distinta firma son legales, pero son tratados como métodos normales. Hay cierta flexibilidad en la declaración del main original, el orden de sus modificadores puede ser alterado, el array de String no tiene que llamarse args y desde Java 5 puede ser declarado usando sintaxis de var-args. Las siguientes firmas son legales:

static public void main(String[] args)

public static void main(String... x)

static public void main(String bang_a_gong[])

Sentencia import y la API de Java

Concepto: Nombre completamente calificado (fully qualified name), nombre de una clase que incluye su paquete, ejemplo: java.util.ArrayList. Para evitar tener que indicar el fqn cada vez que se quiera usar ArrayList, tenemos la sentencia import:

import java.util.ArrayList;

También podemos usar varias clases del mismo paquete y hacer el import a la vez de todas ellas con *.

import java.util.*;

import estáticos

Pueden hacerse de dos formas distintas:

  • Integer.MAX_VALUE, sin import
  • añadiendo la clase que contiene el miembro estático, import static java.lang.Integer.*; y posteriormente llamando a MAX_VALUE.

Reglas para el uso de import estáticos:

  • Se debe escribir import static, NO static import.
  • Tener cuidado con los miembros estáticos que tengan nombre ambiguos entre distintas clases, no es lo mismo MAX_VALUE de Integer que de Double.
  • Se pueden hacer importaciones estáticas tanto de constantes como métodos.

#Declaración de clases y modificadores En este aparatado solo se verán las clases de alto nivel (las clases anidadas o inner class) se verán mas adelante. Declaración de clase:

class MyClass{ }

A la declaración anterior se le puede añadir un modificar antes de la palabra class, estos modificadores se clasifican en dos grupos:

  • Modificadores de acceso: public, protected, private
  • Modificaciones de no acceso: strictfp, final, abstract

##Modificadores de acceso ¿Qué significa tener acceso o visibilidad a una clase? Cuando decimos que una clase (A) tiene acceso a otra clase (B), significa que la clase A puede realizar tres operaciones sobre la clase B:

  • Crear una instancia de la clase B.
  • Extender la clase B.
  • Acceder a ciertos métodos y variables dentro de la clase B.

###Default Access Una clase con modificador por defecto (no tiene modificador que preceda a class en la declaración). Este acceso es un acceso a nivel de paquete, ya que solo las clases dentro del mismo paquete podrán ver/usar/instanciar dicha clase. ###Public Access Una clase con modificador public permite el acceso desde cualquier clase.

###Otros modificadores (no acceso) strictfp, final, abstract

Estos modificadores son un añadido a los modificadores de acceso, puede existir una clase public y final. Pero no se pueden mezclar modificadores de no acceso entre ellos.

####Strictfp Se puede usar en clases o métodos, pero nunca en variables. Indica que una clase o un método va a respetar las reglas del estándar IEEE 754 para los datos en punto flotante, sin este modificar los métodos que usen datos en punto flotante su representación dependerá de la plataforma donde se ejecute.

####Final Indica que una otras clases no podrán extender o heredar de ella. Haremos una clase final si tenemos absoluta garantía de que no se va a necesitar sobrescribir ninguno de sus métodos. Ejemplo de clase final:

public final class Beverage {
  public void importantMethod() { }
}

####Abstract Una clase abstracta nunca puede ser instanciada. Solo tiene un propósito, ser heredada. En ella se pueden especificar los métodos que implementaran las subclases, así como, variables comunes a todas ellas. Ejemplo de clase abstracta:

abstract class Car {
   private double price;
   private String model;
   private String year;
   public abstract void goFast();
   public abstract void goUpHill();
   public abstract void impressNeighbors();
   public void methodNonAbstract(){
     int i = 123; // permitido
   }
   // Additional, important, and serious code goes here
}

NOTA: los métodos marcados como abstract deben acabar en punto y coma (;)

Si una clase tiene métodos abstractos, la clase debe ser marcada como abstracta también. Los métodos no marcados con abstract son accesibles para todas las sublcases por herencia e implementar solo los métodos que necesiten redefinir su comportamiento. NO se pueden marcar una clase como abstracta y final, tiene significados opuestos (y no compila)