Para modificar una tabla en SQL, nos ayudamos del comando ALTER TABLE . El formato general será el siguiente:

es decir , ALTER TABLE seguido del nombre de la tabla a modificar y a continuación acciones que irán enfocadas a modificar una columna, añadir y/o modificar restricciones o modificar una tabla.

Las acciones destinadas a modificar columnas son las siguientes:

• Añadir columnas : ADD (columna def_columnas [, columna2 def_columnas …] ).
  • Ejemplo: ALTER TABLE COCHE ADD (caballos NUMBER(3))
• Borrar columnas: DROP (columna [, columna2 def_columnas, …] )
  • Ejemplo: ALTER TABLE COCHE DROP (motor NUMBER(20))
• Modificar columnas: MODIFY (columna def_columnas [, columna2 def_columnas …] )
  • Ejemplo: ALTER TABLE COCHE MODIFY (motor NUMBER(20)) .
  • Lógicamente la columna ha de estar creada con anterioridad, las opciones que Oracle nos permite modificar son:
    • Incrementar la precisión o anchura de los tipos de datos
    • Sólo se puede reducir la anchura, si esa columna posee nulo en todos los registros, todos los valores son tan pequeños como la nueva anchura o no hay registros.
• Renombrar columnas: RENAME COLUMN nombreAntiguo TO nombreNuevo .                                                                        Ejemplo:  ALTER TABLE COCHE RENAME COLUMN combustible TO tipoCombustible.

Las acciones enfocadas a modificar las restricciones son las siguientes:

• Añadir restricciones: ADD [CONSTRAINT nombre] tipoDeRestricción(columnas)
  • Ejemplo:  ALTER TABLE COCHE ADD CONSTRAINT COCHE_PK PRIMARY KEY (matricula). Añadiría a la tabla Coche la restricción de nombre COCHE_PK ,de tipo PRIMARY KEY referente a la columna matrícula.
  • El tipo de Restricción puede ser:
    • CHECK : Para restringir los valores de la columna a los que definamos nosotros.
    • PRIMARY KEY: Para indicar que es clave primaria.
    • FOREIGN KEY: Para indicar que es clave ajena.
• Borrar restricciones:  DROP PRIMARY KEY | UNIQUE (campos) | CONSTRAINT nombreRestricción. Es decir DROP seguido de PRIMARY KEY para borrar una clave primaria , UNIQUE con los campos que deseemos o CONSTRAINT y nombre de restricción para borrar una restricción en concreto.
  • Ejemplo: ALTER TABLE COCHE DROP PRIMARY KEY
  • Ejemplo: ALTER TABLE COCHE DROP CONSTRAINT COCHE_CHK
• Desactivar restricciones: DISABLE CONSTRAINT nombre Para desactivar restricciones previamente creadas.
  • Ejemplo: ALTER TABLE COCHE DISABLE CONSTRAINT COCHE_CHK .
• Activar restricciones: ENABLE CONSTRAINT nombre . Para activar restricciones previamente creadas y desactivadas.
  • Ejemplo: ALTER TABLE COCHE ENABLE CONSTRAINT COCHE_CHK
• Renombrar restricciones: RENAME CONSTRAINT nombreViejo TO nombreNuevo. Para cambiar el nombre de una restricción previamente creada.
  • Ejemplo: ALTER TABLE COCHE RENAME CONSTRAINT COCHE_CHK TO COMBUSTIBLE_CHK

Las acciones destinadas a modificar una tabla son las siguientes:

• Borrar una tabla: DROP TABLE nombre_tabla. Al borrar una tabla tenemos que tener en cuenta que el borrado es irreversible, desapareciendo los datos que tenía, aunque prevalecen las vistas y los sinónimos referentes a esa tabla, siendo conveniente eliminarlos posteriormente. Lógicamente sólo podremos borrar tablas si tenemos permisos para ello.
  • Ejemplo: DROP TABLE conductor.
• Renombrar una tabla: RENAME nombreViejo TO nombreNuevo. Cambia el nombre de una tabla previamente creada de un nombre antiguo a uno nuevo.
  • Ejemplo: RENAME conductor TO conductores.
• Borrar el contenido de una tabla: TRUNCATE TABLE nombreTabla. Borra los datos de la tabla sin borrar la tabla.
  • Ejemplo: TRUNCATE TABLE conductores.

Para ilustrar ésto, en el siguiente ejemplo tenemos la clase Conductor dentro de la clase Coche, ambas dentro del paquete cursojava.Coche:

package cursojava;
public class Coche {

private String marca;
private String modelo;
private Conductor conductor;
public Coche(String marca, String modelo) {
this.marca = marca;
this.modelo = modelo;
conductor = new Conductor("Fernando Alonso");
}
public Conductor getConductor() {
return conductor;
}
public String getMarca() {
return marca;
}
public String getModelo() {
return modelo;
}

// la clase conductor solo tiene accesibilidad en clases que estén en el mismo paquete
class Conductor{
private String nombre;
public Conductor(String nombre) {
this.nombre = nombre;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
}

Desde la clase Principal, ubicada en el paquete cursojava.principal, no podemos acceder al método getNombre de la clase conductor dado que no es accesible al estar en paquetes distintos.

package cursojava.principal;
import cursojava.Coche;
public class Principal {
public static void main(String[] args) {
Coche coche = new Coche("Ferrari", "F10");
//Tanto si intentamos acceder a getConductor creando un nuevo objeto
//de la clase conductor
Conductor conductor = coche.getConductor();
//Como  si lo hacemos llamando al atributo conductor de coche
String nombre = coche.getConductor().getNombre();
//nos será imposible acceder al método getnombre
System.out.println(conductor.getNombre());
}
}

Para solucionar este problema nos ayudaremos de un interfaz, que podemos definir en cualquier paquete, teniendo que importarlo si lo definiéramos en otro. Por ejemplo, en nuestro caso crearemos un Interfaz llamado IConductor ubicado en el paquete cursojava.interfaz y lo importaremos en los otros paquetes.

El interfaz lo definiremos de la siguiente forma:

package cursojava.interfaz;
public interface IConductor {
public String getNombre();
}

Y el resto de clases quedarán como sigue (observar los comentarios):

package cursojava;
import cursojava.interfaz.IConductor;
public class Coche {
private String marca;
private String modelo;
private Conductor conductor;

public Coche(String marca, String modelo) {
this.marca = marca;
this.modelo = modelo;
conductor = new Conductor("Fernando Alonso");
}

public Conductor getConductor() {
return conductor;
}

public String getMarca() {
return marca;
}

public String getModelo() {
return modelo;
}
}

// Ahora la clase Conductor implementa al Interface IConductor

class Conductor implements IConductor{
private String nombre;

public Conductor(String nombre) {
this.nombre = nombre;
}

//Debemos de implementar el método getNombre del Interfaz

public String getNombre() {
return nombre;
}

public void setNombre(String nombre) {
this.nombre = nombre;
}

}

package cursojava.principal;
import cursojava.Coche;
import cursojava.interfaz.IConductor;

public class Principal {

public static void main(String[] args) {
Coche coche = new Coche("Ferrari", "F10");
//Ahora accedemos por medio del Interfaz IConductor al método getConductor
IConductor conductor = coche.getConductor();
System.out.println(conductor.getNombre());
}
}

Para ello crearemos las tablas necesarias para modelizar el siguiente diagrama entidad-relación básico para una empresa de una empresa mayorista:

CREATE TABLE CLIENTE (
DNI VARCHAR2(10),
&lNOMBRE VARCHAR2(20),
FECHA_NAC DATE NOT NULL,
TFNO VARCHAR2(10),
APELLIDOS VARCHAR2(100),
CONSTRAINT CLIENTE_PK PRIMARY KEY (DNI)
)
CREATE TABLE PROVEEDOR(
NIF VARCHAR2(10),
NOMBRE VARCHAR2(20),
DIRECCION VARCHAR2(200),
CONSTRAINT PROVEEDOR_PK PRIMARY KEY (NIF)

)

CREATE TABLE PRODUCTO(
NOMBRE VARCHAR2(50),
CODIGO VARCHAR2(50),
PRECIO NUMBER(10) NOT NULL,
PRV_NIF VARCHAR2(10),
CONSTRAINT PRODUCTO_PK PRIMARY KEY (CODIGO),
CONSTRAINT PROVEEDOR_FK FOREIGN KEY(PRV_NIF) REFERENCES PROVEEDOR (NIF)
)

CREATE TABLE CLIENTE_PRODUCTO(
PRD_CODIGO VARCHAR(50),
CLN_DNI VARCHAR(10),
CONSTRAINT CLIENTE_PRODUCTO_PK PRIMARY KEY (PRD_CODIGO, CLN_DNI),
CONSTRAINT PRODUCTOCP_FK FOREIGN KEY (PRD_CODIGO) REFERENCES PRODUCTO(CODIGO),
CONSTRAINT CLIENTECP_FK FOREIGN KEY (CLN_DNI) REFERENCES CLIENTE(DNI)
)

CREATE TABLE nombre_tabla(
definición_columna
[, definición_columna...]
[, restricciones_tabla]);

nombre_columna {tipo_datos} [def_defecto] [restric_col]

Los tipos de datos que se pueden utilizar son:

La opción def_defecto nos permite especificar qué nomenclatura queremos dar a nuestros valores por omisión.

Por ejemplo, para un empleado que todavía no se ha decidido cuánto ganará, podemos elegir que, de momento, tenga un sueldo de 0 euros (DEFAULT 0.0), o bien que tenga un sueldo con un valor nulo (DEFAULT NULL).

Sin embargo, hay que tener en cuenta que si elegimos la opción DEFAULT NULL, la columna para la que daremos la definición por defecto de valor nulo debería admitir valores nulos.

La opción DEFAULT tiene el siguiente formato:

DEFAULT (literal|null)

Las restricciones que se pueden dar son las que aparecen en la tabla que tenemos a continuación:

• Una vez definidas las columnas, sólo nos quedará dar las restricciones de tabla, según la tabla que se muestra a continuación:

Los métodos pueden declararse con la palabra reservada “abstract” y éstos metodos se caracterizan porque no pueden tener cuerpo.

public abstract void metodo();

Además de métodos abstractos una clase puede contener otro tipo de métodos, eso sí una clase con al menos un método abstracto, debe declararse abstracta.

Un posible ejemplo podría ser:

public abstract class Geometria{
private Color color;
/**Se define un metodo abstracto sin cuerpo, posteriormente
son implementados gracias al polimorfismo en las clases derivadas**/
public abstract double perimetro();  
public abstract double area();
//Puede contener métodos no abstractos como getColor
public Color getColor() { return color; } 
} 

public class Cuadrado extends Geometria{ 
private float lado; 
public Cuadrado(float lado) { this.lado = lado; }
/**para cada instanciación se define el método 
abstracto de la clase super**/
public double area() {  return lado*lado; }
/**para cada instanciación se define el método 
abstracto de la clase super**/
public double perimetro() {  return 4*lado; } }  
public class Lienzo{  public static void main(String[] args) { 
Cuadrado cuadrado = new Cuadrado(4.52); 
System.out.println("Area: " + cuadrado.area()); 
System.out.println("Perimetro: " + cuadrado.perimetro());   
} 
} 

Se puede redefinir cualquier método salvo aquellos que sean “final” o “static”.

Se puede acceder a un método de la superclase que haya sido redefinido utilizando la palabra super.

// Método clase base
public int funcion()
// Método redefinido en la clase derivada
public int funcion()
// Acceso al método de la clase base
super.funcion()

Un ejemplo de polimorfismo podría ser:

//Clase super
public class Empleado
{
protected int sueldoBase = 700;
public int getSueldo() {
return sueldoBase;
}
}
//La clase Analista hereda a Empleado
public class Analista extends Empleado
{
//Y "polimorfea" getSueldo
public int getSueldo() {
return sueldoBase + 500;
}
}

//La clase Programador hereda a Empleado
public class Programador extends Empleado
{
//Y "polimorfea" getSueldo de forma distinta a Analista
public int getSueldo() {
return sueldoBase + 70;
}
}

Como sabemos cualquier clase que creamos en Java se hereda de la clase Object. De esta clase, los métodos que pueden ser redefinidos son:

• clone():  crea un objeto a partir de otro objeto de la misma clase.
• 
  equals(object):  indica si dos objetos son o no iguales. Devuelve true si son iguales.
• 
  toString():  devuelve un String conteniendo una representación del objeto como cadena de caracteres.

Por último comentar que el atributo “final” , si se indica en un método, no se podrá “polimorfear” ese método en clases derivadas:

class MiClase
{

public final void metodoNoPolimorfeable()
{ ...

Y si se indica en una clase, no se podrá heredar de dicha clase.

final class ClaseNoHeredable
{ ...

Por ejemplo, los tipos de datos básicos mapeados en clases son de tipo final.