Programación

Sobrecarga de métodos

Sobrecarga de métodos en Java

SOBRECARGA

Se denomina sobrecarga en Java al método duplicado en una clase, distinguidos mediante los parámetros incluidos. Es decir, son métodos que comparten el mismo nombre pero pueden realizar procesos distintos y que Java los identifica entre sí por el tipo de parámetro o por la cantidad de parámetros que incluye dicho método.

  1. package miclase;
  3. public class MiClase{
  4.     int numero = 2;
  5.     String cadena;
  6.     public void cambiar(){
  7.         numero = 10;
  8.     }
  9.     public void cambiar(String nombre){
  10.         cadena="Hola "+nombre;
  11.     }
  12.     public void cambiar(int num){
  13.         numero = numero + num;
  14.     }
  15.     public void cambiar(int num,int num2){
  16.         numero = numero + num+num2;
  17.     }
  18.     public static void main(String[] args){
  19.         MiClase miclase = new MiClase();
  20.         System.out.println(miclase.numero);
  21.         miclase.cambiar(20,10);
  22.         System.out.println("Java identifica el método por la cantidad de parámetros dados");
  23.         System.out.println(miclase.numero);
  24.         miclase.cambiar("Jose");
  25.         System.out.println(miclase.cadena);
  26.     }
  27. }

CONSTRUCTOR

El método constructor es un método inicializador que se ejecuta cada vez que se crea un objeto y es donde se deben asignar todos los valores iniciales. En Java es necesario que el constructor coincida con el nombre de la clase, y como cualquier otro método, admite la sobrecarga permitiendo que una clase contenga más de un constructor.

  1. package miclase;
  2. public class MiClase{
  3.     int numero;
  4.     String nombre;
  5.     
  6.     public MiClase(){
  7.         numero = 10;
  8.         nombre = "Jose";
  9.     }
  10.     public MiClase(String cadena){
  11.         nombre = cadena;
  12.     }    
  13.     public static void main(String[] args) {
  14.         MiClase miclase = new MiClase("María");
  15.         System.out.println(miclase.nombre);        
  16.     }
  17. }

HERENCIA

Java soporta herencia, concretamente herencia simple   que permite que una clase denominada hijo extienda de otra clase denominada padre. Para ello, es necesario indicar a continuación de la palabra reservada extends, el nombre de la clase de la que va a heredar y así cualquier otra clase disponer de las propiedades y métodos de esta clase. Por defecto la clase hijo toma el constructor del padre si no dispone de uno propio.

clase Padre

  1. package miclase;
  3. public class MiClase{
  4.     int numero;
  5.     String nombre;    
  6.     public MiClase(){
  7.         numero = 10;
  8.     }
  9.     
  10.     public static void main(String[] args) {
  11.         Hija hija = new Hija();
  12.         System.out.println(hija.numero);
  13.         Hijo hijo = new Hijo();
  14.         System.out.println(hijo.numero);        
  15.     }
  16. }

clase Hijo

  1. package miclase;
  3. public class Hija extends MiClase {
  4.     
  5.     String cadena;        
  6. }

clase Hijo

  1. package miclase;
  3. public class Hijo extends MiClase {
  4.     int numero = 100;
  5. }

POLIMORFISMO

El polimorfismo en Java indica que un mismo método puede tener distintos comportamientos según la clase desde la que es llamado. Para poder entenderlo mejor y manteniendo la estructura del ejemplo anterior es necesario analizar el siguiente código.

La clase MiClase (clase padre) es una clase abstracta que debe estar compuesta por lo menos por un método abstracto obligando a toda clase que extienda de ella a incluir ese método.

clase padre

  1. package miclase;
  3. public abstract class MiClase {
  4.     
  5.     int numero;
  6.     String cadena;
  7.     
  8.     public abstract void metodoAbstracto();
  9.     
  10.     public static void main(String[] args) {
  11.         Hijo hijo = new Hijo();
  12.         Hija hija = new Hija();
  13.         
  14.         hijo.metodoAbstracto();
  15.         hija.metodoAbstracto();
  16.     }
  17. }

Esta clase abstracta permite a sus clases hijas definir la funcionalidad de dicho método. 

clase hijo

  1. package miclase;
  3. public class Hijo extends MiClase {
  4.     
  5.     @Override
  6.     public void metodoAbstracto(){
  7.         System.out.println("método desde Hijo");
  8.     }
  9. }

clase hija 

  1. package miclase;
  3. public class Hija extends MiClase {
  4.     
  5.     @Override
  6.     public void metodoAbstracto(){
  7.         System.out.println("método desde Hija");
  8.     }        
  9. }

STATIC

Definir una variable como estática permite acceder a esa variable sin necesidad de crear un objeto.

  1. package miclase;
  3. public abstract class MiClase {
  4.         
  5.     static String cadena;
  6.     
  7.     public static void main(String[] args) {        
  8.         System.out.println(MiClase.cadena);        
  9.     }
  10. }

FINAL

La palabra final es el equivalente a una constante (const) en PHP, es decir, indica que una variable no puede ser modificada.

  1. final int numero = 10;

CASTING

  1. package miclase;
  2. public abstract class MiClase {
  3.     
  4.     public static void main(String[] args) {        
  5.         double num = 10000.00000;
  6.         int numI = (int) num;
  7.         System.out.println(numI);        
  8.     }
  9. }

JDBC

JDBC es considerado un tipo de conexión en Java. Para poder utilizarlo es necesario descargarlo desde la página oficial de MySQL para después desde el propio IDE importarlo  al proyecto. 

SONIDOS

Java dispone de la clase AudioSystem que permite trabajar con archivos de audio. A continuación un ejemplo básico de la reproducción de un sonido. 

  1. package Multimedia;
  3. import java.awt.event.ActionEvent;
  4. import java.awt.event.ActionListener;
  5. import java.io.File;
  6. import java.io.IOException;
  7. import javax.sound.sampled.AudioSystem;
  8. import javax.sound.sampled.Clip;
  9. import javax.sound.sampled.LineUnavailableException;
  10. import javax.sound.sampled.UnsupportedAudioFileException;
  11. import javax.swing.BoxLayout;
  12. import javax.swing.JButton;
  13. import javax.swing.JFrame;
  14. import javax.swing.JPanel;
  16. public class Sonido implements ActionListener{
  18.     JFrame ventana;
  19.     JPanel panel;
  20.     JButton botonPlay;
  21.     Clip sonido;
  22.     
  23.     public Sonido(){
  24.         addPanel();
  25.         addFrame();
  26.     }
  27.     
  28.     public void addPanel(){
  29.         panel = new JPanel();
  30.         panel.setSize(120,120);
  31.         panel.setLayout(new BoxLayout(panel,BoxLayout.X_AXIS));
  32.         botonPlay = new JButton();
  33.         botonPlay.setSize(100,100);
  34.         botonPlay.setText("Play");
  35.         panel.add(botonPlay);
  36.     }    
  37.     public void addFrame(){
  38.         ventana = new JFrame();
  39.         ventana.setLayout(new BoxLayout(ventana.getContentPane(),BoxLayout.Y_AXIS));
  40.         ventana.setTitle("Ventana");
  41.         ventana.setSize(600,600);
  42.         botonPlay.addActionListener(this);
  43.         ventana.add(panel);
  44.         ventana.setDefaultCloseOperation(ventana.EXIT_ON_CLOSE);
  45.         ventana.setVisible(true);        
  46.     }
  47.     
  48.     public void actionPerformed(ActionEvent e){
  49.         if(e.getSource()==botonPlay){
  50.             try{
  51.                 playAudio();
  52.             }catch(IOException | UnsupportedAudioFileException el){
  53.                 el.printStackTrace();
  54.             }catch(InterruptedException el){
  55.                 el.printStackTrace();
  56.             }
  57.         }
  58.     }
  59.     
  60.     public void playAudio() throws IOException, UnsupportedAudioFileException, InterruptedException{
  61.         try{
  62.             sonido = AudioSystem.getClip();
  63.             File archivo = new File("sonido2.wav");
  64.             sonido.open(AudioSystem.getAudioInputStream(archivo));
  65.             sonido.start();
  66.             Thread.sleep(1000);
  67.             sonido.close();            
  68.         }catch(LineUnavailableException ex){
  69.             ex.printStackTrace();
  70.         }
  71.     }
  72.     
  73.     public static void main(String[] args) {
  74.         Sonido ventana = new Sonido();
  75.     }
  76. }

DIBUJAR IMÁGENES 

Las imágenes pueden dibujarse sobreescribiendo el método paintComponent() o el método paint(). Según si la clase extiende de un JFrame o un JPanel se sobreescribirá un método u otro.

paintComponent()

El código siguiente consta de una clase (Dibujar) que crea una ventana y añade esta ventana un elemento de tipo Panel.

  1. package Multimedia;
  2. import java.awt.Toolkit;
  3. import javax.swing.JFrame;
  5. public class Dibujar extends JFrame{    
  6.     Panel panel;    
  7.     
  8.     public Dibujar(){
  9.         this.setTitle("Imagen");
  10.         this.setSize(300,300);
  11.         this.setDefaultCloseOperation(EXIT_ON_CLOSE);
  12.         panel= new Panel(); 
  13.         this.add(panel);
  14.     }
  15.     
  16.     public static void main(String[] args) {
  17.         Dibujar ima = new Dibujar();
  18.         ima.setVisible(true);        
  19.     }
  20. }

La clase Panel que extiende de JPanel es la que junto a los métodos de la clase Graphics2D sobreescribe el método paintComponent() permitiendo dibujar la imagen.

  1. package Multimedia;
  2. import java.awt.Color;
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import java.awt.Image;
  6. import java.awt.Toolkit;
  7. import javax.swing.JPanel;
  9. public class Panel extends JPanel{
  10.     
  11.     Toolkit toolkit = Toolkit.getDefaultToolkit();
  12.     public Panel(){
  13.         this.setBackground(Color.red);
  14.         this.setSize(300,300);        
  15.     }    
  16.     @Override
  17.     public void paintComponent(Graphics g){
  18.         Graphics2D g2d = (Graphics2D) g;
  19.         g2d.setBackground(Color.white);
  20.         g2d.clearRect(0, 0, 300, 300);
  21.         Image imagen = toolkit.getImage("angular_logo.png");
  22.         g2d.drawImage(imagen,0,0,250,250,this);
  23.     }
  24. }

paint()

El ejemplo siguiente es idéntico al anterior pero realizándose todo desde un mismo archivo, extendiendo solamente de la clase JFrame. Para sobreescribir desde el JFrame se llama al método paint() de la misma forma que si fuera paintComponent().

  1. package Multimedia;
  2. import java.awt.Color;
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import java.awt.Image;
  6. import java.awt.Toolkit;
  7. import javax.swing.JFrame;
  9. public class DrawImage extends JFrame{    
  10.     JPanel panel;
  11.     Toolkit toolkit = Toolkit.getDefaultToolkit();
  12.     
  13.     public DrawImage(){
  14.         this.setTitle("Imagen");
  15.         this.setSize(300,300);
  16.         this.setDefaultCloseOperation(EXIT_ON_CLOSE);
  17.         panel= new JPanel(); 
  18.         panel.setSize(300,300);
  19.         panel.setBackground(Color.red);
  20.         this.add(panel);        
  21.     }  
  22.     
  23.     @Override
  24.     public void paint(Graphics g){
  25.         Graphics2D g2d = (Graphics2D) g;
  26.         Image imagen = toolkit.getImage("angular_logo.png");
  27.         g2d.drawImage(imagen,10,10,280,280,this);
  28.     }
  29.     
  30.     public static void main(String[] args) {
  31.         DrawImage ima = new DrawImage();
  32.         ima.setVisible(true);        
  33.     }
  34. }

Además de dibujar la imagen es posible realizar algunas transformaciones a dicha imagen mediante la clase AffineTransform(). 

  1. package Multimedia;
  2. import java.awt.Graphics;
  3. import java.awt.Graphics2D;
  4. import java.awt.geom.AffineTransform;
  5. import javax.swing.ImageIcon;
  6. import javax.swing.JComponent;
  7. import javax.swing.JFrame;
  8. public class TransformImage {
  9.     Dibujo draw;
  10.     
  11.     public TransformImage(){
  12.         JFrame frame = new JFrame();
  13.         draw=new DrawImg();
  14.         frame.add(draw);
  15.         frame.setSize(300,300);
  16.         frame.setVisible(true);        
  17.     }
  18.     
  19.     class DrawImg extends JComponent {
  20.         @Override
  21.         public void paint (Graphics g){
  22.             Graphics2D g2d = (Graphics2D) g;
  23.             AffineTransform at = new AffineTransform();            
  24.             double x =120;
  25.             double y =320;            
  26.             at.translate(x,y);
  27.             at.rotate(180);
  28.             g2d.setTransform(at);
  29.             g2d.drawImage(new ImageIcon("angular_logo.png").getImage(),at,this);
  30.         }
  31.     }
  32.     
  33.     public static void main(String[] args) {
  34.         TransformImage edit = new TransformImage();
  35.         
  36.     }
  37. }

La acción de dibujar se lleva a cabo mediante la clase Graphics2D con su método drawImage(), pero es importante destacar que mientras en los ejemplos anteriores se obtiene la imagen mediante la clase Image y se indica la ruta mediante clase Toolkit, en éste, se realiza la conversión mediante la clase ImageIcon y su método getImage().

ESCRIBIR ARCHIVOS 

La clase BufferedWriter y la clase PrintWriter permiten la escritura de archivos. BufferedWriter es más eficiente mientras que PrintWriter tiene acceso a métodos basados en print como println(). Los dos prescinden de la clase FileWriter para el proceso de escritura y los dos disponen de métodos similares.

Para crear un archivo con PrintWriter son necesarios tres pasos. Un primer paso que consiste en abrir el archivo, un segundo paso basado en escribir los datos y el tercero y último que cierra el archivo.

El código siguiente realiza este proceso de escritura de archivos mediante la clase PrintWriter. Básicamente se basa en la creación de un archivo (mediante la clase File), donde se escribe una línea con una cadena predefinida y otra línea con los datos introducidos en el campo de texto de la ventana. El proceso de escritura se genera  mediante un evento que se activa cuando se pulsa el botón Guardar.

  1. package Archivos;
  2. import java.awt.BorderLayout;
  3. import java.awt.Container;
  4. import java.awt.event.ActionEvent;
  5. import java.awt.event.ActionListener;
  6. import java.io.File;
  7. import java.io.FileWriter;
  8. import java.io.PrintWriter;
  9. import javax.swing.JButton;
  10. import javax.swing.JFrame;
  11. import javax.swing.JTextField;
  12. public class writeFile extends JFrame implements ActionListener {
  13.     
  14.     JTextField inputText;
  15.     File file;
  16.     JButton button;
  17.     
  18.     public writeFile(){
  19.         inputText = new JTextField("Escribir");
  20.         button = new JButton("Guardar");
  21.         add(inputText);
  22.         add(button);
  23.         button.addActionListener(this);        
  24.         Container contenedor = getContentPane();        
  25.         contenedor.add(inputText,BorderLayout.NORTH);        
  26.         setSize(400,400);
  27.         setDefaultCloseOperation(EXIT_ON_CLOSE);
  28.         setVisible(true);
  29.     }    
  30.     @Override
  31.     public void actionPerformed(ActionEvent e) {
  32.         String text = inputText.getText();
  33.         if(e.getSource() == button){
  34.             file = new File("archivo.txt");            
  35.             try{
  36.                 FileWriter writer = new FileWriter(file);                
  37.                 PrintWriter printwriter = new PrintWriter(writer);
  38.                 printwriter.append("Hola");
  39.                 printwriter.println();
  40.                 printwriter.append(text);
  41.                 printwriter.close();
  42.             }catch(Exception ex){
  43.                 ex.printStackTrace();
  44.             }
  45.         }
  46.     }
  47.     
  48.     public static void main(String[] args){
  49.         writeFile esc = new writeFile();        
  50.     }
  51. }

El código siguiente es similar al ejemplo anterior pero utilizando BufferedWriter, con la opción añadida de que en lugar de crear un archivo nuevo cada vez que se pulsa el botón Guardar, añade datos a continuación de los datos existentes sin sobrescribir el archivo y solo lo crea si no existe.

  1. package Archivos;
  2. import java.awt.BorderLayout;
  3. import java.awt.Container;
  4. import java.awt.event.ActionEvent;
  5. import java.awt.event.ActionListener;
  6. import java.io.BufferedWriter;
  7. import java.io.File;
  8. import java.io.FileWriter;
  9. import javax.swing.JButton;
  10. import javax.swing.JFrame;
  11. import javax.swing.JTextField;
  12. public class writeFile extends JFrame implements ActionListener {
  13.     
  14.     JTextField inputText;
  15.     File file;
  16.     JButton button;
  17.     
  18.     public writeFile(){
  19.         inputText = new JTextField("Escribir");
  20.         button = new JButton("Guardar");
  21.         add(inputText);
  22.         add(button);
  23.         button.addActionListener(this);        
  24.         Container contenedor = getContentPane();        
  25.         contenedor.add(inputText,BorderLayout.NORTH);        
  26.         setSize(400,400);
  27.         setDefaultCloseOperation(EXIT_ON_CLOSE);
  28.         setVisible(true);
  29.     }    
  30.     @Override
  31.     public void actionPerformed(ActionEvent e) {
  32.         String text = inputText.getText();
  33.         if(e.getSource() == button){
  34.             file = new File("archivo.txt");            
  35.             try{
  36.                 BufferedWriter writer =new BufferedWriter(new FileWriter(file.getAbsoluteFile(),true));                
  37.                 writer.write("hola");
  38.                 writer.newLine();
  39.                 writer.write("otra línea");
  40.                 writer.newLine();
  41.                 writer.write(text);
  42.                 writer.flush();
  43.             }catch(Exception ex){
  44.                 ex.printStackTrace();
  45.             }
  46.         }
  47.     }
  48.     
  49.     public static void main(String[] args){
  50.         writeFile esc = new writeFile();        
  51.     }
  52. }

LEER ARCHIVOS

Para leer archivos Java dispone de la clase BufferedReader, que a diferencia de FileReader, permite leer línea por línea y devuelve null cuando finaliza la lectura.  El código que sigue a continuación permite introducir la ruta de un archivo y mediante un evento identifica si los datos introducidos pertenecen a la ruta de un archivo o de un directorio. En caso de un directorio muestra en el textarea el contenido del directorio en forma de lista, mientras que en caso de un archivo realiza el proceso de escritura y muestra en el textarea el contenido del archivo.

 

  1. package Archivos;
  3. import java.awt.BorderLayout;
  4. import java.awt.Container;
  5. import java.awt.ScrollPane;
  6. import java.awt.event.ActionEvent;
  7. import java.awt.event.ActionListener;
  8. import java.awt.event.MouseEvent;
  9. import java.awt.event.MouseListener;
  10. import java.io.BufferedReader;
  11. import java.io.BufferedWriter;
  12. import java.io.File;
  13. import java.io.FileReader;
  14. import java.io.FileWriter;
  15. import javax.swing.JFrame;
  16. import javax.swing.JOptionPane;
  17. import javax.swing.JTextArea;
  18. import javax.swing.JTextField;
  20. public class ReadFile extends JFrame implements ActionListener, MouseListener {
  21.     JTextArea text;
  22.     JTextField input;
  23.     boolean focus;
  24.     
  25.     public ReadFile(){
  26.         focus = false;
  27.         input = new JTextField("Escribir la ruta del archivo");
  28.         input.addActionListener(this);
  29.         input.addMouseListener(this);
  30.         
  31.         text = new JTextArea();
  32.         ScrollPane scroll = new ScrollPane();
  33.         scroll.add(text);
  34.         
  35.         Container container = getContentPane();
  36.         container.add(input,BorderLayout.NORTH);
  37.         container.add(scroll, BorderLayout.CENTER);
  38.         setSize(400,400);
  39.         setDefaultCloseOperation(EXIT_ON_CLOSE);
  40.     }
  42.     @Override
  43.     public void actionPerformed(ActionEvent e) {
  44.         File file = new File(e.getActionCommand());
  45.         //File file2 = new File("archivo.txt");
  46.         System.out.println(e.getActionCommand());
  47.         if(file.exists()){
  48.             text.setText("El dato "+file.getName()+ " existe en la ruta especificada\n");
  49.             if(file.isFile()){
  50.                 text.append("Es un archivo\n");
  51.                 try{
  52.                     BufferedReader read = new BufferedReader(new FileReader(file));                    
  53.                     StringBuffer buffer = new StringBuffer();
  54.                     String st;
  55.                     text.append("\n");
  56.                     while((st = read.readLine())!=null){
  57.                         buffer.append(st+"\n");
  58.                     }
  59.                     text.append(buffer.toString());
  60.                 }catch(Exception ex){
  61.                     JOptionPane.showMessageDialog(this, "ERROR LEYENDO ARCHIVO", "Error", JOptionPane.ERROR_MESSAGE);
  62.                 }
  63.                 
  64.             }else{
  65.                 if(file.isDirectory()){
  66.                     String dir[]=file.list();
  67.                     text.append("Es un directorio \n");
  68.                     text.append("El contenido a continuación en forma de lista \n");
  69.                     for(int i=0;i<dir.length;i++){                        
  70.                         text.append(dir[i]+"\n");
  71.                     }
  72.                 }
  73.                 
  74.             }
  75.         }
  76.         
  77.     }
  78.     public static void main(String[] args) {
  79.         ReadFile readfile = new ReadFile();
  80.         readfile.setVisible(true);
  81.     }
  83.     @Override
  84.     public void mouseClicked(MouseEvent e) {
  85.         input.setText("");
  86.     }
  87.     @Override
  88.     public void mousePressed(MouseEvent e) {
  89.     }
  90.     @Override
  91.     public void mouseReleased(MouseEvent e) {
  92.     }
  93.     @Override
  94.     public void mouseEntered(MouseEvent e) {        
  95.     }
  96.     @Override
  97.     public void mouseExited(MouseEvent e) {     
  98.     }
  99. }


Comentarios: 0

Para poder comentar es necesario iniciar sesión


Este dominio utiliza cookies de terceros para crear estadísticas y publicidad personalizada. Si continúa navegando está aceptando su uso