la clase que he creado es:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class GUI extends JFrame implements ActionListener
{

//la clase GUI esta heredada de la clase JFrame, en caso de poner JFrame para definir un metodo, pondria this
 public void ventana()
 {
  
  JPanel panel=new JPanel();
  
  JButton b=new JButton();
  JPanel contentPane = (JPanel) this.getContentPane();
 

 //llamada al metodo de eventos para obtener la pulsación
  b.addActionListener(this);   
  panel.add(b);
  
  //contentPane.add(b,BorderLayout.CENTER);
   
  contentPane.add(panel); 
  
  setSize(500,300);
  setVisible(true);
  
 
 }
 //este metodo es obligatorio porque esta clase implementado de ActionListener
 public void actionPerformed(ActionEvent e)
 {
 System.out.println(“hola”);// evento de la pulsacion del boton
 }
public static void main(String args[])
{
 GUI g = new GUI();
 g.ventana();
}
}

El segundo ejercicio es crear una clase que contiene un boton y una etiqueta. cada vez cuando pulsa el boton, se cambia el color de la etiqueta. hemos estudiado en la practica 9, que utiliza el metolo getBackground(Color color) para definir el color de la etiqueta, miemtras  crear el metodo

setOpaque(boolean isOpaque).

En el metodo de actionPerformed hay que definir el evento, utilizamos un if()para el color se cambia cuando pulsando el boton.

CON LAS PRACTICAS DE SWING, YA TENGO LA ESTRUCTURA DE MI JUEGO TRES EN RAYA.

Escribiendo la clase de TresEnRaya, ayudando con APIs. He hecho la clase heredada de la clase JFrame, para facilitar de agregar los eventos. y con los paquetes de

import javax.swing.*;

import java.awt.*; 

para que no tengo que buscar todos paquetes de Layout y las clases de SWING,  como que este juego tiene una matriz de 3*3, utilizando

GridLayout(3,3)

busco por API, y con el metodo   setLayout(new GridLayout(3,3));   para la estructura de la ventana de juego.

luego para añadir el panel a la ventana, utilizo

JPanel contentPane = (JPanel) this.getContentPane();

en principio me sale error. porque use

JPanel contentPane = (JPanel) JFrame.getContentPane();

como que en esta clase he definido TresEnRaya heredada de la clase JFrame, en este caso no puede usar JFrame.getContentPane, sino con la palabra this.

despues del panel principal ,tengo que crear los botones, en mi caso, son 9 botones, y los añado al propio panel, luego me sale un error grave, el mismo error que pasó la practica anterior, porque no pongo esta panel a ContenPane, asi que no sale la pantalla con los botones. otro error que ocurre en esta clase es, pongo todas las estructuras en el metodo main, asi que no funciona, porque las interfaces no pueden estar en el metodo main. porque el metodo main solo ejecuta los metodos que implementan en la clase pero no puede implementar los en main. luego, creamos un constructor en main. TresEnRaya tr= new TresEnRaya(); y metemos todos los metodos en el constructor de la clase,mostrar(); el main llamará a este metodo, para que ejecute.  tr.mostrar(); .

compilo y ejecuto, aparece una ventana con 9 botones. despues de implementar esta ventana, tengo que implementar los eventos de los botones, las pulsaciones de botones. YA INTENTARÉ A RESOLVER TODOS…

import javax.swing.*;

import java.awt.*;

public class TresEnRaya extends JFrame
{

 public void mostrar()
 {
  JPanel campo = new JPanel();
  JLabel label = new JLabel();
  campo.setLayout(new GridLayout(3,3));
  JPanel contentPane = (JPanel) this.getContentPane();
  
  //botones
  JButton b1=new JButton();
  JButton b2=new JButton();
  JButton b3=new JButton();
  JButton b4=new JButton();
  JButton b5=new JButton();
  JButton b6=new JButton();

 JButton b7=new JButton();
  JButton b8=new JButton();
  JButton b9=new JButton();
  campo.add(b1);
  campo.add(b2);
  campo.add(b3);
  campo.add(b4);
  campo.add(b5);
  campo.add(b6);

  setSize(500,300);
  setVisible(true);
 
 }
 
 public static void main(String args[])
 {
  
  TresEnRaya tr = new TresEnRaya();
  tr.mostrar();
 }

} 

El ejericio1 nos da una clase y tenemos que responder unas preguntas,son sencillas. En este ejercicio he encontrado unos “obstaculos”.

Nos pide crear una etiqueta con el color de fondo azul.Intentamos a buscar en API el metodo que puedo utilizar, en la clase JLabel,  no encuentro ninguno metodo sobre color. Como que la clase JLabel heredada de JComponent, buscamos los metodos de esta clase,

Luego en el metodo color para definir el color,

La clase color esta es el paquete java.awt.Color, hay que importar en principio.

Import. java.awt.Color;

Luego en la clase   label.setForeground(Color.BLUE);

Compilamos la clase, aparece una ventana con texto en color azul.

Si queremos que la ventana aparece con color rosa, hay que definir un metodo 

setBackground(Color bg); lo hacemos igual que el de color de letras. Compila, pero no funciona.  Buscamos otro metodo     setOpaque(boolean isOpaque). Porque el fondo de ventana esta transparente, llamamos este metodo a true, (porque es de tipo boolean), y luego define setBackground(Color.PINK); compila y ejecuta, si que aparece una ventana con color de fondo rosa, y color de letras azul.

El ejercicio2 nos piden crear una ventana que ignore el mensaje de cierre del manejador de ventanas.

buscamos en API, encuentramos setDefaultCloseOperation(int operation); pero no entendia que el tipo de operation es int,luego probamos con un numero 5, frame.setDefaultCloseOperation(5);

********.

public void setDefaultCloseOperation(int operation)

Sets the operation that will happen by default when the user initiates a “close” on this frame. You must specify one of the following choices:  

 

 

 

 

 

• DO_NOTHING_ON_CLOSE (defined in WindowConstants): Don’t do anything; require the program to handle the operation in the windowClosing method of a registered WindowListener object.
• HIDE_ON_CLOSE (defined in WindowConstants): Automatically hide the frame after invoking any registered WindowListener objects.
• DISPOSE_ON_CLOSE (defined in WindowConstants): Automatically hide and dispose the frame after invoking any registered WindowListener objects.
• EXIT_ON_CLOSE (defined in JFrame): Exit the application using the System exit method. Use this only in applications.

The value is set to HIDE_ON_CLOSE by default. Changes to the value of this property cause the firing of a property change event, with property name “defaultCloseOperation”.

es decir que el parametodo operation hay que tomar el valor uno de los cuatros que aparece anterior.

luego lo hacemos con frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); compila y ejecuta, funciona! aparece una ventana igual que antes, pero cuando pulse el boton cerrar, la ventana no cierre, esto es lo que funciona este metodo.

Ejercicio 3

Crear una ventana no solo con textos , sino con los botones. En este ejercicio tenemos que crear 2 paneles mas, uno contiene 2 botones, y otro 5 botones colocado en posiciones norte, sur, est, oest y centro.

una ventana tiene un frame, ea la forma de ventana que aparece, dentro de frame son paneles, uno principal, sobre el podemos modificar los botones, textos, etcs, pero tambien podemos añadir unos paneles dentro de este principal. Para esto tenemos que utilizar Layout para colocar los diferentes componentes , todo esto se implementan mediante las clases derivadas de java.awt.LayoutManager.

El prof nos dar varios tipos de Layout, Flowlayout, que coloca los botones en fila, Borderlayout coloca los botones en 4 posiciones y el centro, Girdlayout

En este ejercicico vamos a utilizar Flowlayout y Borderlayout.

Primero creamos un panel y añade un layout. 

  JPanel panel=new JPanel();
  panel.setLayout(new BoxLayout(panel,BoxLayout.Y_AXIS));

 luego creamos panel p1 y p2,necesitamos definir BorderLayout y FlowLayout y 2 botones en clase JButton.buscamos en API, y lo tenemos:

import java.awt.BorderLayout;
import javax.swing.BoxLayout;
import java.awt.FlowLayout;
import javax.swing.JButton;

en el panel p1,necesita 2 botones,b1 y b2.en panel p2,necesita 5 botones, cada uno definido por posiciones, luego añaden los botones a su propio panel:

// panel p1
  JPanel p1 = new JPanel();
  FlowLayout f=new FlowLayout();
  p1.setLayout(f);
  JButton b1=new JButton();
  JButton b2=new JButton();
  p1.add(b1);
  p1.add(b2);
  //panel p2
  JPanel p2 = new JPanel();
  BorderLayout b=new BorderLayout();
  p2.setLayout(b);
  JButton bNorte=new JButton();
  JButton bSur=new JButton();
  JButton bOeste=new JButton();
  JButton bEste=new JButton();
  p2.add(bNorte,BorderLayout.NORTH);
  p2.add(bSur,BorderLayout.SOUTH);
  p2.add(bOeste,BorderLayout.WEST);
  p2.add(bEste,BorderLayout.EAST);

*****************************************************************************************************************

*****************************************************************************************************************

COMPILA Y EJECUTA, FUNCIONA, PERO SOLO APARECE LA VENTANA, NO LOS BOTONES. ME ALEGRO SI ALGUIEN ME PUEDE AYUDAR PARA RESOLVER LA.

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JLabel;
import java.awt.Color;
import java.awt.BorderLayout;
import javax.swing.BoxLayout;
import java.awt.FlowLayout;
import javax.swing.JButton;

 

class CompassSimple {
    public static void main(String args[]) {
  
        JFrame frame = new JFrame();
  //panel
        JPanel panel=new JPanel();
       panel.setLayout(new BoxLayout(panel,BoxLayout.Y_AXIS));
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
       JPanel contentPane = (JPanel) frame.getContentPane();
       JLabel label = new JLabel();
  
  
  // panel p1
  JPanel p1 = new JPanel();
  FlowLayout f=new FlowLayout();
  p1.setLayout(f);
  JButton b1=new JButton();
  JButton b2=new JButton();
  p1.add(b1);
  p1.add(b2);
  //panel p2
  JPanel p2 = new JPanel();
  BorderLayout b=new BorderLayout();
  p2.setLayout(b);
  JButton bNorte=new JButton();
  JButton bSur=new JButton();
  JButton bOeste=new JButton();
  JButton bEste=new JButton();
  p2.add(bNorte,BorderLayout.NORTH);
  p2.add(bSur,BorderLayout.SOUTH);
  p2.add(bOeste,BorderLayout.WEST);
  p2.add(bEste,BorderLayout.EAST);
  
  // añadir todos paneles a un panel principal
  
  panel.add(p1);
  panel.add(p2);
  frame.pack();
  
  label.setOpaque (true);
        label.setBackground(Color.BLACK);
  label.setForeground(Color.WHITE);
  contentPane.add(label);  

  frame.setSize(1500,800);
   frame.setVisible(true);
    }
}

 

Tetris es un videojuego de puzzle, y contiene varios piezas bidimensionales de cuatro bloques en distintas disposiciones caen de la parte superior de la pantalla, el jugador  puede decidir la rotación de la pieza (0°, 90°, 180°, 270°) y en que lugar debe caer. estas piezas forma  “L”,”z”,”I”,y  un cuadrado, primero crear una clase para definir estas piezas y conocerlos.luego para estas piezas que se muevan creamos una clase Cola utilizando la estructura de datos Cola, y las operaciones básicas que se pueden realizar con esta estructura de datos, Encolar(insertar un elemento en la cola) y Desencolar(Eliminar el elemento en la cola), así que tambien hay que crear los metodos de la cola cuando esta vacia o esta llena.

El sobrecarga de metodos se produce cuando tenemos varias implementaciones de un mismo método pero con distintos parámetros.y el sobreescritura de metodos se produce cuando la subclase es la que implementa el método heredado de la superclase.

descargamos las soluciones de practica 4, vemos que en la clase base CLASE MIEMBRO contiene un metodo toString

public String toString() {
        String str = “”;
            str += “NOMBRE = ” + nombre+”, MODIFICADOR = “+ Modificador.toString(modificadores);
        return str;
    }

primero define el valor inicial del parametro str, es de tipo String, su valor inicial es vacio,definido por “” .  luego utilizado “+” para definir el valor de str, significa que str es igual a su valor inicial mas el valor que define. de tipo retorno. este proceso llamamos sobrecarga de metodos.

Luego definimos el mismo metodo en las clases derivadas

public String toString() {
        String str = “”;        
        str += “\nATRIBUTO\t”;
        str +=super.toString();
        str += ” TIPO =”+tipo;
        return str;
    }

aqui utiliza SUPER para heredar el metodo de la clase base, este proceso es sobreescribe de metodo.

Pero como que la clase Construtor es la clase derivada de la clase Metodo, y la Metodo es la derivada de  la Miembro, para heredar el mismo metodo,utilizamos un metodo REPLACEALL. es sustituye en caso de una variable por otra en una clase

public String toString() {
        String str = “”;            
            str += super.toString().replaceAll(“CONSTRUCTOR”, “METODO”);
            return str;
    }

en este caso, si solo hacemos str +=super.toString(); se va a heredar el metodo desde la clase Miembro, no Metodo.  es decir que en su clase base,Metodo es la derivada de la Miembro, lo que queremos hacer es sustituir la clase Constructor en lugar de Metodo,  definido Metodo como la clase base, y lo que va a heredar el metodo toString es lo de la clase Metodo no la Miembro.

Una vez hacemos esto, compilar todos las clases a la vez, utilizado javac *.java .

En el ejercicio 2, nos dar 3 clase. una clase base ComponenteGrafico, esta casi implementado todo, falta el constructor. como ya sabemos que el constructor es para definir valor inicial de los parametros de la clase.

public ComponenteGrafico(int x, int y, int ancho, int alto, Color colorFondo, Color colorBorde ) {
  this.x=x;
  this.y=y;
  this.ancho=ancho;
  this.alto=alto;
  this.colorFondo=colorFondo;
  this.colorBorde=colorBorde;
    }

Luego, dos clases derivadas, Boton y Menu. es tambien pide la implementacion de constructores. como que sabemos estas dos clases son heredadas de la clase ComponenteGrafico. y los parametros que utilizan tambien lo son. utilizamos la palabra super.

public Boton( int x, int y, int ancho, int alto, Color colorFondo, Color colorBorde, Color colorTexto, String texto ) {
  super(x,y,ancho,alto,colorFondo,colorBorde);
  colorTexto=colorTexto;
  this.texto=texto;
    }

**************************************
    public Menu( int x, int y, int ancho, int alto, Color colorFondo, Color colorBorde, Color colorTexto, String[] opciones  ) {
  super(x,y,ancho,alto,colorFondo,colorBorde);
  this.colorTexto=colorTexto;
  this.opciones=opciones;
    }

************************************

una vez implementamos el constructor de cada clase, compila con la consola, y no hay errores. lo ejecuta, con java ComponenteGrafic 50 50 100 50 , salta una pantalla, con los medidas que da..  luego, ejecuta java Boton 50 50 100 boton , salta una pantalla con un boton  que escribe “boton” . si ejecuta javac Menu 50 50 100 50 menu. salta una pantalla  con un boton que pone menu.

ES LA PRIMERA PRACTICA CON  PRESENTACION DE GRAFICAS. AUNQUE LA CLASE NO IMPLEMENTAMOS NOSOTROS, PERO NOS AYUDA MUCHO PARA EL TRABAJO DE VIDEOJUEGO.

En la herencia hay dos tipos de clases,la clase base o superclase,que  dar la herencia, y las clases derivadas, que  reciben la herencia.

supongamos hay una clase Personas como clase base, y las clases Ingeniero y Deportista como clases derivadas. la clase Ingeniero contiene siguiente informaciones: nombre, apellidos,DNI,profesion…. y la clase Deportista tiene las informaciones : nombre,apellidos,DNI,deporte…   

vemos que las clases derivadas contienen las siguientes informaciones comunes: nombre, apellidos, DNI.  para que no sea complicados a definir las cada clase,creamos una clase base y definir las una vez solo.

public class Personas
{
 private String nombre;
 private String apellidos;
 privete String DNI;
 
 public Personas(String nombre,Atring apellidos,String DNI)
 {
 this.nombre=nombre;
 this.apellidos=apellidos;
 this.DNI=DNI;
 }
 public void imprimir()
 {
 System.out.println(“Nombre=”+this.nombre);
 System.out.println(“Apellidos=”+this.apellidos);
 System.out.println(“DNI=”+this.DNI);
 }
}// Personas

********************************

public class Deportista extends Personas
{ // para heredar de la clase Personas,utilizamos la palabra extends
 private String deporte;
 public Deportista(String nombre,String apellidos,String DNI,String deporte)
 {
  this.deporte=deporte;
  super(nombre,apellidos,DNI);//estos atributos heredan de la clase Presona.utilizamos la palabra super
 }
 public void imprimir()
 {
 super.imprimir(); //hereda un metodo
 System.out.println(“Deporte=”+this.deporte);
 
 }

}

*****************************

EMPIEZAMOS A HACER LA PRACTICA.

Creamos una clase Miembro, que recupera la practica 3. es decir la clase Miembro como clase base, y las clase derivadas son las que hemos hecho en la practica3. la clase Miembro es una generalización de Atributo, Método y Constructor y contiene las características comunes: el nombre y los modificadores de acceso . Podemos comprobar que, tanto un Atributo, un Constructor o un Metodo son “tipos” de Miembro. 

las clases Atributo y Metodo son clases derivadas de la clase Miembro,Perola clase Constructor es un “tipo especial” de Metodo que no tiene tipo de retorno asociado. Esdecir para la clase Constructor, su clase base es Metodo.

Ahora creamos las clases.

public class Miembro {
   
    protected String  nombre;
    protected int modificadores = 0;
   
    /** Constructor de la clase. */
    public Miembro(String nombre, int modificadores ) {
  // A IMPLEMENTAR         
  this.nombre=nombre;
  this.modificadores=modificadores;
    }
   
     /**
     * Devuelve una cadena de caracteres (String) con una descripci髇
     * literal del objeto y los valores de sus atributos.
     *
     */
    public String toString() {    
        return “Nombre=”+nombre+”;”+”Modoficador=”+Modificador.toString(modificadores);
    }
   
}

Vemos que esta clase tiene un metodo toString, de tipo retorno,el método toString() no imprime nada por pantalla y lo único que hace es devolver una cadena de caracteres formateada con una descripción literal del objeto y los valores de sus atributos.

public class Atributo extends Miembro{
    public String  nombre = null;
    public String tipo = null;
    public int modificadores = 0;
  
    public Atributo(String nombre, String tipo, int modificadores )
 {
  super(nombre,modificadores);
  this.tipo=tipo;
 }
  
  public String toString()
 {
  String resultado=null;
  resultado+=super.toString();
  resultado+= “Tipo:”+this.tipo;
  return resultado;
 }

}

utilizamos la palabra “extends”para heredar desde clase Miembro. la palabra”super” para heredar los atributos y metodos.

En esta metodo toString,definimos un atributo resultado, porque en la clase base, el metodo toString solo devuelve nombre y modificadores, pero la clase Atributo se devuelve tambien el tipo. resultado+ significa resultado es igual a su valor inicail mas valor actual.

public class Metodo extends Miembro {
   
    String tipoRetorno = null;
    Parametro[] parametros = null;
 
   
    /** Constructor de Metodo */
    public Metodo(String nombre, int modificadores, String tipoRetorno, Parametro[] parametros) {
   // A IMPLEMENTAR     
  super(nombre,modificadores);
  this.tipoRetorno=tipoRetorno;
  this.parametros=parametros;
    }
   
    /**
     * Devuelve una cadena de caracteres (String) con una descripci髇
     * literal del objeto y los valores de sus atributos.
     *
     */
    public String toString() {
  // A IMPLEMENTAR       
  String resultado=null;
        resultado+=super.toString();
  resultado+=”TIPO RETORNO=”+tipoRetorno;
  for(int i=0; i<parametros.length;i++){
  resultado+= “PARAMETRO["+i+"]=”+parametros[i];
  
  
  }
  return resultado;
  
    }

}

En esta clase vemos que hay un atributo array. Parametro[] parametros,  de tipo Parametro.que se quiere devolver

TIPO RETORNO = <tipoRetorno> PARAMETRO(0) TIPO= <tipo> PARAMETRO(1) TIPO= <tipo1>……PARAMETRO(n) TIPO= <tipoN>

con esta informacion,utilizamos un bucle for, y creamos un atributo resultado , lo implementamos como la clase anterior

Ahora implementamos la clase Constructor, que recibe la herencia de la clase Metodo.

import java.lang.reflect.*; 
public class Constructor extends Metodo {
   
    
    /** Constructor de la Constrctor, valga la redundancia.*/
    public Constructor(String nombre, int modificadores, Parametro[] parametros ) {

  super(nombre,modificadores,”",parametros);
    }
   
  /**
     * Devuelve una cadena de caracteres (String) con una descripci髇
     * literal del objeto y los valores de sus atributos.
     *
   */ 
    public String toString() {     
  String resultado=null;
  resultado+=super.toString();
  return resultado;

 }
   
}

 En el constructor, definimos los valores iniciales, en este caso, no asociado el tipo retorno, lo definimos como vacio.

FIN DE PRACTICA.

YA VEMOS LA HERENCIA ES BASICAMENTE SABER COMO VA A HEREDAR UNA CLASE DESDE OTRO, PARA CUAL UTILIZAMOS LA PALABRA”EXTENDS’. PARA HEREDAR UN METODO O UN ATRIBUTU, UTILIZAMOS LA PALABRA “SUPER”.  LE HERENCIA ES PARA FACILITAR NUESTRO PROGRAMA.

En esta practica, primero repasamos de Objetos, nos dar una clase  Punto,y tenemos que responder unas  preguntas basicas de esta clase. por ejemplo “cuantos metodos hay en la clase”,”cuantos constructures en la clase”,”cuantos atributos en la clase”, etc.
public class Punto {
  private double x;
  private double y;
 
  public static int contador = 0;

  // Constructor
  public Punto(double x, double y) {
    this.x = x;
    this.y = y;
 contador++;
  }

  // toString: devuelve una cadena con la representación del objeto
  public String toString() {
    // el signo + para cadenas no significa “suma matemática” sino concatenación
    return “(“+x+”, “+y+”)”;
  }

  // devuelve la distancia al origen
  // NOTA: se podría haber hecho con la distancia a (0,0):
  //   return calcularDistancia(new Punto(0,0));
  public double distanciaAlOrigen() {
    return Math.sqrt(x*x+ y*y);
  }

  // métodos de acceso
  public double getX() {
    return x;
  }
  public double getY() {
   return y;
  }

  // devuelve la distancia a otro punto
  public double calcularDistancia(Punto otroPunto) {
    double x1;
    double y1;
   
    x1 = x-otroPunto.getX();
    y1 = y-otroPunto.getY();
 
    return Math.sqrt(x1*x1+y1*y1);
  }

}

 **************************************************************

con esta clase tenemos que crear una clase PruebaPunto, que contiene metodo main, y los valores que hay que calcular en esta clase.

**************************************************************

public class PruebaPunto{

 public static void main(String args[]){
  Punto p1;
  p1=new Punto(2,2);
   
  Punto p2;
  p2=new Punto(1,1);
  
  System.out.println(p1.toString());
  System.out.println(p1.distanciaAlOrigen);

  System.out.println(p1);
  System.out.println(p1.calcularDistancia(p2));
  System.out.println(Punto.contador);
 }

}

************************************************************

Una vez creado esta clase, lo compilo en modo Consola, y salió un error con

System.out.println(p1.distanciaAlOrigen);

******

distanciaAlOrigen es un metodo en la clase Punto, para definir la distancia entre  punto p1 al origen, hay que hacer una llamada a este metodo, para llamar a metodo lo que he hecho p1.distanciaAlOrigen. pero lo que he hecho es una llamada a un atributo, no un metodo, por tanto salió un error. la forma correcta es hacer

 p1.distanciaAlOrigen();

**************************************************

Luego. hacemos el ejercicio 1, la clase Modificador

import java.lang.reflect.Modifier;

public class Modificador {

    public static final int PUBLIC = 1;
    public static final int PRIVATE = 2;
    public static final int PROTECTED = 4;
    public static final int STATIC = 8;
    public static final int FINAL = 16;
    public static final int SYNCHRONIZED = 32;
    public static final int VOLATILE = 64;
    public static final int TRANSIENT = 128;
    public static final int NATIVE = 256;
    public static final int INTERFACE = 512;
    public static final int ABSTRACT = 1024;
    public static final int STRICT = 2048;
   
    public static String toString( int modificador ) {
  // ESTE MÉTODO YA ESTÁ IMPLEMENTADO.
  return Modifier.toString( modificador );
    }

   public static void main( String args[] ) {
  // ESTE MÉTODO YA ESTÁ IMPLEMENTADO.
       int modificador = Integer.parseInt(args[0]);

       System.out.println(” El modificador de acceso de ” + modificador  +” es “+ Modificador.toString(modificador) );

   }
   
}Este ejercicio no tenemos que implementar la clase, sólo para saber como funcionarla.

A cada una de las constantes se le asocia la cadena de caracteres con el literal correspondiente de la siguiente lista de modificadores de Java:

abstract, final, interface, native, private, protected, public, static, strict, synchronized, transient, volatile.

Los modificadores de acceso se identifican con un número entero que representa una combinación de las estas constantes.

Creamos una clase PruebaModificadores

public class PruebaModificador
{
 public static void main(String args[])
 {
 
  System.out.println(Modificador.toString(3));
 
 
 }

}

La clase PruebaModificadores se imprima por pantalla todos los posibles valores de salida del método toString() que ha definido en la clase Modificadores.

lo que he hecho con un numero entero de modificadores igual a 3. cuando ejecutamos esta clase, se imprima: public, private

Como ya hemos visto en la clase, el atributo PUBLIC es igual a 1, y el atributo PRIVATE es igual a 2, la suma de estos dos valores es 3, por tanto se imprima por pantalla los valores posibles de del metodo toString() son PUBLIC Y PRIVATE.

*****************************************************

En el ejercicio 2, la clase Atributo.

nos dar siguiente informacion de la clase.

public class Atributo {
   
    public String  nombre = null;
    public String tipo = null;
    public int modificadores = 0;
   
    public Atributo(String nombre, String tipo, int modificadores ) { /*…*/}
   
    public String toString() {/*…*/}
}

****************

Esta clase tiene declarados los siguientes métodos que permiten crear e imprimir las instancias de Atributo:           

-        Un constructor de Atributo con los parámetros adecuados.

-        Un método públic String toString() que permite obtener una cadena de caracteres con una descripción literal del atributo correspondiente mostrando los siguientes datos del mismo: el nombre, el tipo y el modificador de acceso. Un formato de ejemplo puede ser el siguiente: 

   ATRIBUTO : NOMBRE=<nombre_Atributo> TIPO =java.lang.String MODIFICADOR ACCESO = public

**************************************

completamos  la clase anterior. 

 import java.lang.reflect.Modifier;
 

public class Atributo {
   
   
public String  nombre = null;
   
public String  tipo= null;
   
public int modificadores = 0;
   
   
/**   Crea una instancia de Atributo   */
   
public Atributo(String nombre, String tipo, int modificadores ) {
       
// A IMPLEMENTAR. 
  
this.nombre=nombre;
  
this.tipo=tipo;
  
this.modificadores=modificadores;
   
}
   
   
public String toString() {
      
 // A IMPLEMENTAR. 
  
return “Atributo”+nombre+”,”+tipo+”,”+Modificador.toString(modificadores);
  
    }
}

*************************************

una vez completado la clase,creamos una clase PruebaArticulo,

public class PruebaAtributo{

 public static void main(String args[]){

Atributo a=new Atributo(“nombre”,”String”,54);

 System.out.println(a.toString());
 }
}

definimos los valores de los atributos de la clase Atributo, e imprima el metodo toString, en la clase Atrubuto, el metodo toString(),contiene siguiente codigo

return “Atributo”+nombre+”,”+tipo+”,”+Modificador.toString(modificadores);

 lo que hace es va a llamar el metodo toString de Modificador, y lo que hace es igual que la clase Modificador.

     Año pasado utilizamos”SETPATH=%PATH%;”mas el fichero donde esta “java” y “javac”.y cada vez cuando ejecutamos la consola, hay que definirlo. Hoy hemos cambiado la forma de emplearlo,utilizamos “C:>mkdir” + el directorio donde estan “java ” y “javac”. y añade el path de este directorio en la variable CLASSPATH ,

C:\set CLASSPATH=C:\TEMP\TSIOCA;%CLASSPATH%

para fijar este CLASSPATH,asi que no hay que definir el directoria cada vez cuando ejecutamos la  consola.

    Hay otra forma para hacerlo es a traves de la propieded de MI PC, donde  estan opciones avanzadas y modificar el directorio de CLASSPATH del propio ordenador.

   En el ejercicio 2 , estudiamos la depuracion de errores como ASERCIONES y las TRAZAS DE DEPURACION.

Una aserción es una condición que necesariamente se debe cumplir en un determinado segmento de código para que pueda considerarse que el código es correcto.  Habia intentado escribir un programa para comprobar el funcionamiento de System.exit(1); que significa la salida directa del programa. utilizamos siguiete class:

public class Numero
{
 private int numero;
 
 public int dameNumero()
 {
  return numero;
 } 
 
 public void actualizarNumero(int x)
 {
  numero = x;
 }
 
 public static void main(String args[])
 {
  
  Numero n = new Numero();
  n.actualizarNumero(Integer.parseInt(args[0]));
  
  if (n.dameNumero()<0)
  {
   System.out.println(“Error: valor negativo de numero”);
   System.exit(1);  //salida directa
  }

else
  {
   System.out.println(“vamos a ver si este texto aparece”);
  }
   }
 

}

con este programa habiamos comprobado que si el numero  introcido es positivo , el programa va a seguir ejecutando hasta fin de proceso, pero cuando es un numero negativo, va a llegar Sytem.exit, que se salta directamente del programa sin ejecucion de los restos condiciones.

Las trazas de depuración son mensajes añadidos al código que nos informan del funcionamiento del mismo. Un ejemplo de trazas de depuración:

public class ErrorDivisión {         
public static void main(String[] args) {         
boolean continuar=true;         
int a=3;         
int b=3;         
int c=4;         
int d=0;         
System.err.println("Empezando la depuración");         
a+=b;         
System.err.println("Vamos a ver si el programa divide bien");         
b+=c/d;         
System.err.println("El programa funciona bien");         
} }

En este programa ,nos explica la funcionamiento de Las trazas de depuración  ,que nos permite saber donde estan los errores, aunque es muy molestas en una aplicacion finalizada. Ejecutamos este progragrama, la ultima condicion no habia ejecutado debido a un fallo de una operacion aritmetica que no esta grave de llega hacer un error, sino una exception.

En esta practica nos dar cuenta de que las aplicaciones de conocimientos que habiamos estudiado en el primer cutrimestre son fundamentales.

Esta practica hay 7 ejercicios

El primero se dedica a unas preguntas teoricas.

El segundo ejercicio es para imprimir en la pantalla 200 Hello World, he utilizado un bucle “for” para resolver el problema.

for(int i=0;i<args.length;i++)

     System.out.println(“Hello World!!”);

que no hay ningun problema.

El tercer ejercicio veo que es poco mas complicado.

nos dado un programa y escribimos el resultado que hay que imprimir por la pantalla cuando ejecutamos el programa,y ademas tenemos  que crear un programa a base de programa anterior, el resultado sea el inverso de los datos que nos dan. el problema que he ocurrido es que cuando pongo ” args[args.length-i] ” para que el resultado sea inverso, por ejemplo, cuando i=0,args.length=4,args[4]. me ha producido un error.que args[4] no existe. la posicion de un array empieza por 0, aun asi ,su longitud (args.length) es  1. por lo tanto, en este problema tiene que ser ” args[args.length-i-1] “

al final, que resolví este problema.

 El ejercicio 4, utilizando “System.read()” para escribir sobre la pantalla. y “System.write” para copiar los que he escrito en la pantalla, dicho programa tiene un bucle infinito. para finalizar  este  programa Control + C

para este programa, tenemos que entrar a la pagina web de : 

java.sun.com/api

para encontrar y resolver las dudas que tengo.(Busca en el API el porqué de la comparación de b con -1.)etc….

BIENVENIDO A MI BLOG.

AQUI ES DONDE VOY A ESCRIBIR MI DIARIO DE TRABAJO DURANTE TODO EL CURSO.

AZA AZA FIGHTING!!