referencja jako parametr

0

Troszkę szukałem na ten temat? czy jest w ogóle możliwe podanie referencji do globalnej zmiennej i by na niej operowane było?

import javax.swing.JApplet;

public class test55 extends JApplet {
    int c=44;

    @Override public void init(){
       fukncja(22,33);
       fukncja2(c);
    }
    public void fukncja(int a, int b){
       System.out.println("a="+a + " b="+b);
    }
    public void fukncja2(int *c){
       c++; 
       System.out.println("c="+c);
    }

}
0

Po pierwsze, nie nazywaj "test55", tylko "Test55".

Tą gwiazdką przy c to ja nie wiem co chcesz osiągnąć, bo w Javie wskaźniki nie występują...
c++;tutaj odwołujesz się do zmiennej lokalnej c. Jeśli chcesz się odwołać do pola obiektu, nie możesz tego robić w ten sposób, bo jest ono przesłonięte... możesz za to zrobićthis.c++wtedy na pewno odwołasz się do pola obiektu.

0

no tak ale mi zależy by jako parametr podawać różne zmienne c,d,e więc this.c++; mnie nie ratuje bo odwoła się tylko do jednej zmiennej

0

W Javie
1) wszystkie argumenty do funkcji są przekazywane przez wartość
2) wartością może być prymityw lub referencja do obiektu
Masz do wyboru:
1) zwracać zmodyfikowaną liczbę jako wynik funkcji
2) opakować argument w obiekt
Generalnie chyba robisz coś nie tak(a przy najmniej nie w duchu Javy), skoro koniecznie potrzebujesz wskaźników ;)

0

W Javie funkcjonalnym odpowiednikiem wskaźnika (void*) jest referencja do Object. Nie możesz jednak wykonywać na tym żadnych operacji arytmetycznych, a jedynie skonwertować na referencje do innych obiektów (każdy obiekt dziedziczy po Object). No i oczywiście od razu zapominasz o wszelkich typach prostych - nawet jeżeli chciałbyś użyć typu int, to musisz posłużyć się obiektem klasy Integer (lub pochodnej od niej).
Krótko mówiąc referencja każdego obiektu jest automatycznie konwertowana do referencji Object, więc jako argument dowolnej metody każde referencja będzie formalnie ok. Następnie konwertujesz taką referencję na referencję do obiektu jaki wg Twojego mniemania powinien się tam znajdować i przeprowadzasz na nim operacje (zwykle za pomocą jego metod). Nie potrzebujesz zwracać tej referencji ponieważ i tak nie może się ona zmienić (przekazywanie zawsze przez wartość), chyba, że zwrócisz referencję do innego obiektu, który ma coś wspólnego z tym pierwszym.

Można w pewnym stopniu zasymulować arytmetykę wskaźników przez przekazywanie jako argument referencji do tablicy wraz z indeksem. Ewentualnie tablica może być polem klasy do którego ma się dostęp. Wtedy indeks zadziała bardzo podobnie do wskaźnika tyle, że będzie działał wyłącznie w ramach pamięci tablicy i ewentualnie jej obiektów. Przy każdym wychyleniu poza ten obszar będzie wyjątek. Co akurat jest bardzo przydatną funkcjonalnością.

0

No własnie, w C++ można zwrócić referencję w parametrze funkcji.
np:

void funkcja(int &c, int &d);

a jak jest z Javą?

public class Test {

    public static void main(String[] args){
        int c = 0;
        int d = 0;
        Util u = new Util();
        u.funkcja(c, d);

        System.out.println("c="+c + ",d="+ d);
    }
}

class Util {
        public Util() {
        }

        public int funkcja(int c, int d){
            c = 1;
            d = 1;
            return c;
        }
}

output:
c=0,d=0

0

W tym temacie napisałem kiedyś odpowiedź na podobny problem:
http://4programmers.net/Forum/503371?h=Pointer#id503371

Masz tam gotowy kod klasy wskaźnika w Javie, a poniżej przykład przekazywania argumentu przez zmienną

package Testy;
import Olamagato.Pointer;

class Typ
{
    public int val;
}

public class TestPointer
{
    public static void main(String[] args)
    {
        Typ x = new Typ();
        x.val = 100;
        System.out.printf("x = %d\n", x.val);

        zmien(new Pointer(x), +10); //utworzenie referencji/wskaźnika i podanie go jako argument

        System.out.printf("x = %d\n", x.val);
    }

    public static void zmien(Pointer arg, int dx)
    {
        Object o = arg.get();
        if(o instanceof Typ)
            ((Typ)o).val += dx;
        else
            System.out.println("Nieznany Typ wskaźnika");
    }
}
/*
run:
x = 100
x = 110
*/

Oczywiście zamiast tworzyć w klasie Typ operacje get i set (lub assign) posłużyłem się polem publicznym.
Gdyby Java miała możliwość definiowania operatorów, to zapis nie różniłby się od użycia referencji w C/C++.

Wszystko sprowadza się po prostu do modyfikacji zmiennej x typu Typ za pomocą wywołania funkcji zmień i jej argumentu wskaźnikowego. Jak widać zmienna x nie została bezpośrednio nawet dotknięta, lecz jej wartość została zmodyfikowana.

0

dziękuje za wypowiedzi faktycznie nie należy używać typów prostych :)

a chciałem uzyskać mniej więcej taki efekt dla zainteresowanych:

import javax.swing.JApplet;

public class Test55 extends JApplet {
    jakisObiekt t=new jakisObiekt("przyklad1");
    jakisObiekt t2=new jakisObiekt("przyklad2");

    @Override public void init(){
        przerobic(t);
        przerobic(t);
        przerobic(t);
        przerobic(t);
        przerobic(t2);
        przerobic(t2);
        przerobic(t2);
    }
    void przerobic(jakisObiekt nazwa){
        nazwa.podniesX();
        nazwa.wyswietl();
    }
}

class jakisObiekt {
  jakisObiekt(String nazwa){
      this.nazwa=nazwa;
  }
  String nazwa="";
  int x=0;
  public void wyswietl(){
     System.out.println(nazwa+" x = "+x);
  }
  public void podniesX(){
     x++;
  }
}
0

Tak właściwie, to nie musisz w ogóle kombinować. W Javie wszystkie obiekty przekazywane są przez referencję (ale sama referencja podobnie jak typy proste zawsze przez wartość). Tym samym metoda, która otrzyma referencję obiektu zachowuje się zawsze tak jakby otrzymała argument obiektowy przez zmienną. Taka metoda jest w stanie zawsze zmodyfikować otrzymany obiekt, chyba że argument referencyjny będzie typu final (co można obejść).

Nie potrzebujesz więc żadnego symulowania referencji, wskaźnika jeżeli masz zamiar operować w metodzie tylko na obiekcie - bo jest to podstawowa własność Javy.
To co podałem wyżej, to sposób na modyfikowania samej referencji do takiego obiektu (inaczej mówiąc przekazywanie referencji lub opakowanych typów prostych poprzez zmienną).

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0