Duda principiante funcion (THIS) java

[ARAPSPGON]

Saludos.

el tema es que he comenzado a practicar el tema de cual es la funcion de la palabra reservada This en java para el tema de las variables. y me estoy haciendo un lio con lo que dicen las definiciones y con lo que me muestran los ejemplos que voy practicando.

las definiciones me dicen principalmente que :
-la referencia this siempre apunta al objeto sobre el que se ejecuta un metodo.
-this permite especificar que la variable que señala (y la señala haciendo this.nombreVariable) es de la misma clase en la que se usa.

pues bien yo tengo este ejemplo que me he hecho para intentar comprenderlo pero me contradice la definicion:

Código:

class RGB {
  int red=1;
  int green=2;
  int blue=3;

  void RGBB(int red, int green, int blue) {//metodo
   
 this.green = green;
 this.blue = blue;
   // con (this.nombreVAr=nombreVAr hago que la referencia this 
   // que apunta a la variable 
   // de la clase  coja el valor de la variable que apunta al objeto
   // sobre el que se ejecuta el metodo
   // aunque si no lo pusiese el programa seguiria haciendo la 
   // misma funcion
   
System.out.println( "valor de rojo "+ this.red );
   // en este caso this.red hace que se apunte al valor de la variable
   // de la clase ...red=1
   
System.out.println( "valor verde "+ green );
System.out.println( "valor azul "+ blue );
   //tanto green como blue apuntan al objeto
   // sobre el que se ejecuta el metodo
  }
  
  public static void main( String args[] ) { 
      
      RGB obj = new RGB();
      
      obj.RGBB( 10,12,13 ); 
      }
}

por que me salen definiciones diciendome
la referencia this siempre apunta al objeto sobre el que se ejecuta un metodo.
si cuando aplico this.red me apunta al valor de la variable de la clase??

el resultado al compilar es :
valor de rojo 1
valor verde 12
valor azul 13

otro ejemplo que tengo es este:

Código:

class MiClase {
    
    int miVariable;  // Variable de instancia-> int MiClase.miVariable
    
   
    public MiClase() {//Constructor de la clase : MiClase.MiClase()
        miVariable = 5;
        }
    
   
    void miMetodo(int miVariable) {  // Metodo con argumentos->void MiClase.miMetodo(int miVariable)
    	
    	System.out.println( "La variable Local miVariable contiene "
            + miVariable );//int miVariable -> MiClase.miMetodo(int)
        
        System.out.println( 
            "La variable de Instancia miVariable contiene " 
            + this.miVariable );//int MiClase.miVariable
        //La palabra reservada this permite especificar que 
        //la variable que señala (y la señala haciendo this.nombreVariable) 
        //es de la misma clase en la que se usa.
        }
    
    public static void main( String args[] ) { 
        // Instanciamos un objeto del tipo de la clase
        MiClase obj = new MiClase();
        // que utilizamos para llamar a su unico metodo
        obj.miMetodo( 10 ); //void MiClase.miMetodo(int miVariable)
        }
    }

otra duda es el tema del contructor de la clase ..¿el constructor de la clase es el metodo que inicializa las varibles de la clase ?

gracias y perdonad por si mis preguntas son de risa pero me estoy haciendo un lio con todo esto. gracias de antemano

[akiles83]

Buenas, es tan sencillo como que this hace referencia a los atributos propias de la clase, es decir, te lo explico con un ejemplo como el que tienes,

Código:

public class ElementoThis{
    int red;
    int green;
    int black;

    // Contructuro de la clase
    public ElementoThis(int red, int green, int black){
       this.red = red; // la variable local del metodo contructor seria red y this.red hace referencia al atributo de la clase ElementoThis
       this.green = black; 
       this.blaci = black;
    }

    public int getRed(){
       return this.red;
    }
    
    .......
}

En definitiva, this, hace referencia a todos aquellos atributos propios de la clase, diferencias los atributos de la clase con los del metodo.

Espero que te haya quedado mas claro.

Un saludo

[ARAPSPGON]

gracias por contestar ....

mas o menos como tu lo has puesto es como yo lo entiendo ....pero lo que no entiendo es por que en las definicines de la referencia this pone lo contrario:


"la referencia this siempre apunta al objeto sobre el que se ejecuta un metodo."


tendria que ser al reves....que this apunta a las variables de la clase en vez de apuntar a las variables locales generadas por un metodo al que apunta un objeto...no?

[GreenEyed]

Lo que tienes es un problema de "imprecision sintactica" . Lo que tu llamas "variables de la clase" no existen, son variables de instancia (no son estaticas) y por tanto pertenecen a un objeto... que es el objeto sobre el que ejecutas el metodo.

Cuando usas "this", estas llamando al objeto sobre el que se esta ejecutando el metodo, y por eso al hacer this.variable accedes directamente a las variables de ese objeto y no a las variables locales del metodo.

"This" no apunta a variables, apunta a un objeto. Si ese objeto tiene variables, pues se pueden acceder a traves del objeto, pero si no tiene variables "this" tambien funciona.

S!

[ARAPSPGON]

Iniciado por GreenEyed

Lo que tienes es un problema de "imprecision sintactica" . Lo que tu llamas "variables de la clase" no existen, son variables de instancia (no son estaticas) y por tanto pertenecen a un objeto... que es el objeto sobre el que ejecutas el metodo.

Cuando usas "this", estas llamando al objeto sobre el que se esta ejecutando el metodo, y por eso al hacer this.variable accedes directamente a las variables de ese objeto y no a las variables locales del metodo.

"This" no apunta a variables, apunta a un objeto. Si ese objeto tiene variables, pues se pueden acceder a traves del objeto, pero si no tiene variables "this" tambien funciona.

S!

gracias por contestar pero podrias aclararmelo en el ejemplo siguiente?
me estoy haciendo un lio monumental.

Código:

class RGB {
  int red=1;//variables objeto???
  int green=2;
  int blue=3;

void RGBB(int red, int green, int blue) {
//metodo y en sus argumentos variables locales??
  
   System.out.println( "valor de rojo "+ this.red );
   // this.red apunta al objeto??? no entiendo ya que me imprimirá 
   //valor de rojo=1(this.red)
   System.out.println( "valor verde "+ green );
   System.out.println( "valor azul "+ blue );
   //tanto green como blue apuntan a las variables locales del metodo???
  }
  
public static void main( String args[] ) { 
      RGB obj = new RGB();//objeto de la clase RGB
      obj.RGBB( 10,12,13 ); 
      //con el objeto mando ejecutar el metodo RGBB poniendo los valores a los 
      //argumentos del metodo
      }
}

[GreenEyed]

Lo primero son miembros de instancia, si.

Lo segundo no son variables locales en argumento, son argumentos y punto.

this.red es el valor del miembro red de la instancia que esta llamando al metodo (this), por eso imprime un 1 ya que se inicializa a ese valor.

green y blue apuntan a los argumentos, si, ya que al no poner "this", tienen preferencia los argumentos por ser de un ambito más "cercano".

[ARAPSPGON]

ok ya lo voy pillando

todo esto sera por que no tenia muy claro la diferencia entre :
-variables de instancia o miembros dato
-variables de clase o miembros dato estaticos
-variables locales

Las variables de instancia o miembros dato se usan para guardar los atributos de un objeto particular.

Las variables de clase o miembros dato estáticos son similares a las variables de instancia, con la excepción de que los valores que guardan son los mismos para todos los objetos de una determinada clase. En el siguiente ejemplo, PI es una variable de clase y radio es una variable de instancia. PI guarda el mismo valor para todos los objetos de la clase Circulo, pero el radio de cada círculo puede ser diferente

Código:

class Circulo{
	static final double PI=3.1416;//variable de clase o miembro dato estatico
	double radio;//variables de instancia o miembro dato
                             //con this se apunta a este tipo de variables(de instancia)
//...
}

Las variables locales se utilizan dentro de las funciones miembro (métodos).
En el siguiente ejemplo area es una variable local a la función calcularArea en la que se guarda el valor del área de un objeto de la clase Circulo.
al no usar this se apunta a variables locales o argumentos.

Código:

class Circulo{
//...
  	double calcularArea(){//funcion miembro(metodo)
		double area=PI*radio*radio;//variable local
		return area;//se guarda el valor de area que puede servir para 
                                   //un objeto de la clase Circulo
  	}
}

bueno mas o menos lo he asimilado de esta manera...
muchas gracias a todos

[GreenEyed]

Sólo un par de apuntes para acabar de refinarlo.

.- Si no tienes variables locales o argumentos con el mismo nombre, no hace falta usar "this" para acceder a los miembros de instancia, ya que como no hay conflicto de nombres no hace falta. Sin embargo, es buena practica ponerlo para dejarlo bien claro.

.- De igual forma, muchas veces no es necesario poner el nombre de la clase para acceder a un miembro estatico, Circulo.PI en tu ejemplo, pero es buena practica siempre poner el nombre de clase para dejarlo claro.

.- Las variables o miembros estaticos no son exactamente "parecidos a las de instancia pero en todas el mismo valor", es que solo hay una variable que comparten todos los miembros de la clase, y aun es mas, no hace falta que exista ninguna instancia de la clase para poder acceder a esas variables. Es importante saber que solo hay una variable por que si le cambias el valor, todo el mundo vera el cambio, que no es lo mismo que si todos tuvieran una copia con el mismo valor.

S!

[ARAPSPGON]

muchas gracias por las anotaciones las tendré en cuenta.

y muchas a gracias a los demas por la ayuda.y por hacer de este foro uno de los mas completos y utiles.

[skay]

Hola compañeros, yo también tengo dudas con la función THIS.

Una vez aclarada la utilización anterior del THIS, me gustaria que alguien me despejara la duda de que funcion hace el this en esta expresion:

.
.
.


botonEjemplo.addActionListener(this);

public void actionPerformed(ActionEvent e)

{

System.out.println("HOLA")
}

.
.
.

He creado un boton y aora le estoy añadiendo la acción a realizar pulsando el boton.

Lo que necesito saber es teoricamente que hace este codigo elemento a elemento.

Si alguien me pudiera explicarlo, me ayudaria a ser ingeniero puesto que es la ultima asignatura que me falta, y si no se esto para realizar una practica no apruebo.

MUCHAS GRACIAS COMPAÑEROS.

[ARAPSPGON]

Saludos
te voy a ayudar ya que soy quien inició este post y creo que esto te puede ayudar

hay va la leccion ..leee atento

Realizar una acción al pulsar un botón

Las aplicaciones han de responder a las acciones que realiza el usuario, por ejemplo: cerrar la ventana al pulsar un botón. Es necesario poder detectar las acciones de usuario y convertirlas en acciones de programa. Java dispone de varias formas de implementar este funcionamiento. En este ejercicio se mostrarán algunas de ellas. Todas se basan en este mecanismo básico:

Las Interfaces son clases "prefabricadas" con propósitos definidos. Cada Interface contiene declaraciones de métodos (nombre del método, lista de argumentos y tipo de retorno) pero estos métodos no están implementados (carecen de cuerpo); todos los métodos de las Interfaces son public. Las Interfaces también pueden declarar constantes (public final static).

En Java no existe la herencia múltiple como tal: una clase no puede heredar (extends) de más de una clase. Pero una clase puede implementar más de una Interface, ésta es una manera de tener herencia múltiple. En la clase que implementa una Interface han de ser sobrescritos (override) todos los métodos declarados en la Interface. La clase que implementa una Interface es la Interface.

ActionListener es una Interface del grupo de los Listeners (escuchadores). ActionListener tiene un sólo método: void actionPerformed(ActionEvent e). ActionListener se usa para detectar y manejar eventos de acción (ActionEvent): los que tienen lugar cuando se produce una acción sobre un elemento del programa.

Un evento ActionEvent se produce:

* al pulsar un botón (Button)
* al hacer doble clic en un elemento de lista (List)
* al pulsar INTRO en una caja de texto (TextFiel)
* al elegir un menú (MenuItem)

Los distintos elementos del programa (botones, etc...) están vigilados por Listeners que detectan las acciones que tienen lugar sobre el elemento vigilado. Cuando ActionListener detecta una acción (por ejemplo: pulsar sobre un botón) se genera un evento de acción (ActionEvent) en el elemento (botón). Los ActionEvent invocan el método actionPerformed(ActionEvent e) que realiza las acciones programadas ante ese evento. La clase que implementa ActionListener ha de importar el paquete java.awt.event.*.

De manera que cuando el usuario pulsa un botón:

1. el botón sobre el que se produce una acción y genera un evento (event source, este dato se puede obtener con el método getSource) ha de estar previamente registrado con algún objeto que gestione el evento (ActionListener en este caso) mediante el método:

boton.addActionListener(ActionListener nombre_de_actionListener)

2. el botón genera un ActionEvent (clase del paquete java.awt.event)

3. ActionEvent invoca al método actionPerformed que realiza las acciones programadas

4. si la clase implementa ActionListener, el método public void actionPerformed(ActionEvent e) ha de ser sobreescrito (override)

A continuación se muestran los aspectos más destacados del código en 4 versiones diferentes:

* la clase pricipal implementa ActionListener; el registro del botón con ActionListener es:

boton.addActionListener(this);
//
public void actionPerformed(ActionEvent e) {
... código ... ;
}

* la clase principal no implementa ActionListener pero sí lo hace otra clase; el botón es registrado con ActionListener asociándolo a una nueva instancia de esta clase:

boton.addActionListener(new ClaseClicEnBoton());
//
class ClaseClicEnBoton implements ActionListener {
public void actionPerformed(ActionEvent e) {
... código ... ;
}
}

* la clase principal no implementa ActionListener; el botón es registrado con ActionListener asociándolo a una nueva instancia de la clase ActionListener:

boton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
clicEnBoton(e); }
});

private void clicEnBoton(ActionEvent e) {
... código ... ;
}

* en caso de tener que detectar el botón que origina un evento (event source) entre varios botones registrados con un ActionListener, puede ser útil recurrir al método setActionCommand, que establece un nombre, independiente de su etiqueta, para el botón:

boton1.setActionCommand ("nombre_ActionCommand1");
boton2.setActionCommand ("nombre_ActionCommand2");

posteriormente se emplea una estructura condicional para elegir la acción dependiendo del botón origen del evento:

public void actionPerformed(ActionEvent e) {
//si se ha pulsado en el botón 1 (si ActionCommand es nombre_ActionCommand1)
if ("nombre_ActionCommand1".equals(e.getActionCommand ())) {
... código ... ; }
//si se ha pulsado en el botón 2 (si ActionCommand es nombre_ActionCommand2)
else if ("nombre_ActionCommand2".equals(e.getActionCommand ())) {
... código ... ; }
}

Código 1: la clase principal implementa ActionListener

* Declarar la clase principal del programa (esta clase sí implementa la interfaz ActionListener):

class action_Listener1 implements ActionListener { ... }

* Registrar el botón con la propia clase a que pertenece (ya que implementa ActionListener):

boton1.addActionListener(this);

* El método actionPerformed contiene las instrucciones que ejecutan la acción deseada:

// LO QUE SUCEDE AL PULSAR EL BOTÓN
public void actionPerformed(ActionEvent e) {
... código ... ;
}

Código 2: la clase principal no implementa ActionListener

* Declarar la clase principal del programa (esta clase no implementa la interfaz ActionListener):

class action_Listener1 { ... }

* Registrar el botón con una instancia de la Interface ActionListener:

boton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
clicEnBoton(e); }
});

* El método clicEnBoton contiene las instrucciones que ejecutan la acción deseada:

private void clicEnBoton(ActionEvent evt) {
... código ... ;
}

Código 3: la clase principal no implementa ActionListener

* Declarar la clase principal del programa (esta clase no implementa la interfaz ActionListener):

class action_Listener1 { ... }

* Crear una nueva clase implementando ActionListener:

class ClaseClicEnBoton implements ActionListener {
public void actionPerformed(ActionEvent evt) {
... código ...; }
}

* Registrar el botón con una instancia de la clase ClaseClicEnBoton:

boton.addActionListener(new ClaseClicEnBoton());

Código 4: detectar qué botón ha generado el evento

* Declarar la clase principal del programa (esta clase sí implementa la interfaz ActionListener):

class action_Listener1 implements ActionListener { ... }

* Configurar la propiedad ActionCommand de los botones:

boton1.setActionCommand ("nombre_ActionCommand1");
boton2.setActionCommand ("nombre_ActionCommand2");

* Registrar los botones con la propia clase a que pertenecen (ya que implementa ActionListener):

boton1.addActionListener(this);
boton2.addActionListener(this);

* Recuperar el valor de la propiedad ActionCommand para saber cuál es el botón que ha generado el evento:

public void actionPerformed(ActionEvent e) {
//si se ha pulsado en el botón 1 (si ActionCommand es nombre_ActionCommand1)
if ("nombre_ActionCommand1".equals(e.getActionCommand ())) {
... código ... ; }
//si se ha pulsado en el botón 2 (si ActionCommand es nombre_ActionCommand2)
else if ("nombre_ActionCommand2".equals(e.getActionCommand ())) {
... código ... ; }
}

Código común

* Es necesario importar los paquetes requeridos para el manejo de eventos:

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

* Al crear y mostrar la ventana es posible configurar la posición centrada en la pantalla. setLocationRelativeTo(null) ha de ir colocado cuando ya se ha configurado adecuadamente el tamaño de la ventana:

ventana.setSize(220,100);
ventana.setLocationRelativeTo(null); //centrar el formulario en la pantalla
ventana.setResizable(false);
ventana.setVisible(true);

* Todos los métodos de las Intefaces son públicos, por lo que al sobrescribir el método actionPerformed hay que declararlo como public:

public void actionPerformed(ActionEvent e) {
... código ... ; }
}

[ARAPSPGON]

Aplicación de ejemplo

Se trata de una ventana con una etiqueta para mostrar un número y 4 botones de comando; cada botón,al ser pulsado, implementa la acción de forma diferente, según lo referido más arriba; todos ellos suman una cifra al número mostrado.

codigo fuente

Código:

/* CAPTURA DE EVENTOS DE ACCIÓN USANDO 
* CLASES DERIVADAS DE LA INTERFAZ ActionListener Y EVENTOS DE TIPO ActionEvent.
* ActionListener GENERA EVENTOS ActionEvent CUANDO OCURRE UNA ACCIÓN SOBRE EL ELEMENTO
* Y MEDIANTE SU MÉTODO ActionPerformed(ActionEvent e) REALIZA LAS ACCIONES PREVISTAS */

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

// CLASE PRINCIPAL DEL PROGRAMA (implementa ActionListener)
public class Action_listener extends JFrame implements ActionListener {

// variables a nivel de clase
private JLabel contador;
private JButton bt1, bt2, bt3, bt4, bt5, bt6;
private int cuenta = 0; 
private JPanel p1, p2;

//  MÉTODO DE ENTRADA AL PROGRAMA
public static void main(String[] args) {
   // instancia de la clase principal
   new Action_listener();
}

// MÉTODO CONSTRUCTOR QUE CREA Y MUESTRA LA INTERFAZ
   public Action_listener() {
   // decoración de Java
   JFrame.setDefaultLookAndFeelDecorated(true);

   /* la variable especial this se usa en métodos de instancia
   * para hacer referencia al objeto que contiene al método,
   * aquí equivale a JFrame */

   // acción por defecto al cerrar la ventana: salir del programa
   this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     
   /* paneles de disposición: por defecto, los paneles se crean con diseño FlowLayout
   * por ello es preferible definir el Layout en el constructor del panel, para crearlo
   * desde el principio con ese diseño y evitar la creación de un FlowLayout temporal;
   * es preferible hacer:
   * p1 = new JPanel(new BorderLayout());
   * mejor que hacer ésto otro:
   * p1 = new JPanel();
   * p1.setLayout(new BorderLayout()); */
   p1 = new JPanel(new BorderLayout());
   //  borde del panel: vacío, 10px por cada lado
   p1.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
   // panel para ocupar BorderLayout.SOUTH
   p2 = new JPanel();
   p2.setLayout(new GridLayout(1,4,10,10));

   //  configurar fuente y convertir número a String para JLabel
   contador = new JLabel(Integer.toString(cuenta), JLabel.CENTER);
   Font letra1 = new Font("Arial", Font.BOLD, 12);
   contador.setFont(letra1);
   //  configurar fuente para los botones
   Font letra2 = new Font("Arial", Font.PLAIN, 12);
   bt1 = new JButton("De 1 en 1");
   bt1.setFont(letra2);
   bt2 = new JButton("De 2 en 2");
   bt2.setFont(letra2);
   bt3 = new JButton("De 3 en 3");
   bt3.setFont(letra2);
   bt4 = new JButton("De 4 en 4");
   bt4.setFont(letra2);

   // tooltips para los botones
   bt1.setToolTipText("Contar de 1 en 1");
   bt2.setToolTipText("Contar de 2 en 2");
   bt3.setToolTipText("Contar de 3 en 3");
   bt4.setToolTipText("Contar de 4 en 4");

   /* acción por defecto ante los eventos de bt1 y bt3,
   * para poder diferenciar más tarde cuál de los 2 botones
   * ha generado el evento */
   bt1.setActionCommand ("Contar1");
   bt3.setActionCommand ("Contar3");

   /*colocar los componentes en los paneles;
   * para añadir un componente a un JFrame es preferible
   * frame.getContentPane().add(p1);
   * en lugar de
   * frame.add(p1);*/
   this.getContentPane().add(p1);
   p1.add(contador, BorderLayout.NORTH);
   p1.add(p2, BorderLayout.SOUTH);
   p2.add(bt1);
   p2.add(bt2);
   p2.add(bt3);
   p2.add(bt4);

   // crear y mostrar la ventana
   this.setTitle("ActionListener");
   this.setSize(500,100);
   this.setLocationRelativeTo(null); // centrar el formulario en la pantalla
   this.setResizable(false);
   this.setVisible(true);

   /*la clase principal implementa la interfaz ActionListener
   * por ello se pueden emplear sus métodos directamente.
   * aquí se detectan las acciones sobre los botones bt1 y bt3: */
   bt1.addActionListener(this);
   bt3.addActionListener(this);

   /*Botón bt2: se asocia con una instancia de la clase Contar,
   * la clase Contar también implementa ActionListener por lo que 
   * este método podría usarse aunque la clase principal no fuese ActionListener */
   bt2.addActionListener(new Contar());

   /* si la clase principal no implementa la interfaz ActionListener
   * se puede asociar el botón con una instancia de ActionListener;
   * su método actionPerformed() enlaza con el método clicEnBoton2() que 
   * se ejecuta cuando se detectan acciones sobre el botón */
   bt4.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
     clicEnBoton2(e); }
   });

}

  //  LO QUE SUCEDE AL PULSAR LOS BOTONES 1 y 3 
  public void actionPerformed(ActionEvent e) {
    // si se ha pulsado en el botón bt1 (si ActionCommand es Contar1)
   if ("Contar1".equals(e.getActionCommand())) {
    cuenta ++; // contar 1
    contador.setText(Integer.toString(cuenta)); }
    // si se ha pulsado en el botón bt3 (si ActionCommand es Contar3)
   else if ("Contar3".equals(e.getActionCommand())) {
    cuenta +=3; // contar 3
    contador.setText(Integer.toString(cuenta)); }
   }

 //  LO QUE SUCEDE AL PULSAR EL BOTON 2
 class Contar implements ActionListener {
   public void actionPerformed(ActionEvent evt) {
    cuenta +=2; // contar 3
    contador.setText(Integer.toString(cuenta)); }
   }

 //  LO QUE SUCEDE AL PULSAR EL BOTON 4 
private void clicEnBoton2(ActionEvent evt) {
    cuenta +=4; // contar 4
    contador.setText(Integer.toString(cuenta));
   }

}

[jhwhprincess]

El error que tienes aqui es que los atributos que tienes declarados no son objetos son variables tipo int, para que sea un objeto debe estar declarado del tipo de la clase o en dado caso para decalrarlo de tipo int debes declararlo asi: Integer red= 1; puesto que asi lo toma como si fuera objeto, de esta manera si saldra el resultado que quieres:

debera quedar asi:

class RGB {
Integer red=1;// objeto tipo Integer
Integer green=2;
Integer blue=3;

void RGBB(Integer red, Integer green, Integer blue) { //--- aqui tmb debes declaralo asi


System.out.println( "valor de rojo "+ this.red );
System.out.println( "valor verde "+ green );
System.out.println( "valor azul "+ blue );

}

De esta manera es correcto :aplauso

Iniciado por ARAPSPGON

gracias por contestar pero podrias aclararmelo en el ejemplo siguiente?
me estoy haciendo un lio monumental.

Código:

class RGB {
  int red=1;//variables objeto???
  int green=2;
  int blue=3;

void RGBB(int red, int green, int blue) {
//metodo y en sus argumentos variables locales??
  
   System.out.println( "valor de rojo "+ this.red );
   // this.red apunta al objeto??? no entiendo ya que me imprimirá 
   //valor de rojo=1(this.red)
   System.out.println( "valor verde "+ green );
   System.out.println( "valor azul "+ blue );
   //tanto green como blue apuntan a las variables locales del metodo???
  }
  
public static void main( String args[] ) { 
      RGB obj = new RGB();//objeto de la clase RGB
      obj.RGBB( 10,12,13 ); 
      //con el objeto mando ejecutar el metodo RGBB poniendo los valores a los 
      //argumentos del metodo
      }
}

[GreenEyed]

Acceder con this o sin this y si a través de eso accedes a variables locales o de instancia no tiene nada que ver con si las variables son int o son Integer.

S!

[Pedrazass]

Wenas! tengo un pequeño problema con saber que tipo de dato y funcion es "this".
Concretamente de esta liena de programa b.addActionListener(this); b es un boton que tengo implementado dentro de un frame. Gracias!

[martinartaza]

Hola comunidad, tengo una duda con THIS.
Parecido a todo lo planteado en este hilo en este momento estoy haciendo una calculadora, que tiene un JTextField y los botones de los numero, hago que cuando se presione el uno el siguiente código y lo quiero cambiar.

jTFCalculo.setText(jTFCalculo.getText() + jButton1.getText() )

En vez de usar para cada boton, el mismo código pero cambiando el jbutton, me gustaría usar el método this y no logro eh probado lo siguiente y no a compilado.

jTFCalculo.setText(jTFCalculo.getText() + this.getText() )

Bueno en definitiva quiero hacer algo parecido que postee con monodevelop en
http://www.kubuntu-es.org/foro/200901/realizar-calculadora-monodevelop-c-v-10
ahí uso self, no se como hacerlo con java.
Desde ya muchas gracias.

[Xerelo]

This se usa para referirse a un objeto, dentro de ese mismo objeto, tú lo que quieres hacer es sustituir una referencia a un objeto por this, como si fuera una referencia genérica, lo cual no es correcto.

Para las siguientes veces, no hagas preguntas en temas antiguos (este empezó en el 2007), crea uno nuevo. Los temas viejos está bien que los leas por si ya tienen la solución a tu duda, pero ten en cuenta que los mensajes anteriores, no aportan nada a tu pregunta.