Forum Mjukvara Programmering och digitalt skapande Tråd

Java metoder, komma åt variabler, kod

1
Skriv svar
Permalänk
Medlem
●

Java metoder, komma åt variabler, kod

Hej!
Jag försöker använda mig utav metoder som sköter uträkningar, sen vill jag kunna anropa metoderna och plocka ut vissa delar för att kunna använda i andra metoder men det funkar inte!
Jag vet inte hur man på enklast sätt kan ta de 3 olika summorna från metoden som summerar till utskrift metoden.?
är det någon som kan hjälpa mig?
Vill inte använda globala variabler.
Det är alltså :
summa_v1
summa_v2
summa_v3
som jag vill ha i utskift metoden

import java.util.Scanner;


public class test2 {
	

	public static void main(String[] args)  // MAIN METOD
	{
		int[] v1 = {3, 4, 2};
		int[] v2 = {6, 8, 9};
		int[] v3 = {1, 3, 5};
		
		utskrift(v1, v2, v3); //Anropp metod UTSKRIFT
		
			
	}
	
	public static void utskrift(int[] v1, int[] v2, int[] v3) 
	{
		Summa(v1, v2, v3); //Anropp metod SUMMA, Vet inte exakt hur jag ska göra här...
		System.out.println("\t" + v1[0] + "\t" + v1[1] + "\t" + v1[2] + "\t" + summa_v1 ); //Här vill jag kunna ta den uträknade summan från metod summa istället för att räkna ut här. 
		System.out.println("\t" + v2[0] + "\t" + v2[1] + "\t" + v2[2] + "\t" + summa_v2 );
		System.out.println("\t" + v3[0] + "\t" + v3[1] + "\t" + v3[2] + "\t" + summa_v3 );                     
		 
	}
	
	public static int Summa(int[] r1, int[] r2, int[] r3) 
	{
		int summa_v1 = v1[0] + v1[1] + v1[2];
		int summa_v2 = v2[0] + v2[1] + v2[2];
		int summa_v3 = v3[0] + v3[1] + v3[2];
		return summa_v1, summa_v2, summa_v3; //Hur ska jag kunna få dessa värden till metoden ovan, antar att det inte går att göra såhär...
	}
}
Senast redigerat
Redigera
Citera flera Citera
Permalänk
Medlem
●

inte den snyggaste lösningen men det kommer att lösa ditt problem

import java.util.Scanner;



public class test2 {
	private static int  summa_r1;
        private static int  summa_r2;
        private static int  summa_r3;

	public static void main(String[] args)  // main
	{
		int[] v1 = {3, 4, 2};
		int[] v2 = {6, 8, 9};
		int[] v3 = {1, 3, 5};
		
		utskrift(v1, v2, v3); //Anropp metod UTSKRIFT
		
			
	}
	
	public static void utskrift(int[] v1, int[] v2, int[] v3) 
	{
		Summa(v1, v2, v3); //Anropp metod SUMMA, trodde man fick tillgång till variablerna när man anroppar metoden.. ?
		System.out.println("\t" + v1[0] + "\t" + v1[1] + "\t" + v1[2] + "\t" + summa_r1 ); //Här vill jag kunna ta den uträknade summan från metod summa istället för att räkna ut här. Men
		                                                                                   //Men summa_r1 ger felmeddelande: "summa_r1 cannot be resolved to a variable"
		 
	}
	
	public static void Summa(int[] r1, int[] r2, int[] r3) 
	{
		summa_r1 = r1[0] + r1[1] + r1[2];
		summa_r2 = r2[0] + r2[1] + r2[2];
		summa_r3 = r3[0] + r3[1] + r3[2];
		
	}
}

för övrigt brukar man vilja undvika statiska metoder och variabler, detta kan lösas snyggare objektorienterat

Redigera
Citera flera Citera
Permalänk
Medlem
●

Hej Bruum, tack för svaret. Men tyvärr så vill jag försöka utan globala variabler.
Jag har uppdaterat koden lite.
Kan jag returnera 3 värden? Kan jag göra på något enklare sätt?

Redigera
Citera flera Citera
Permalänk
Medlem
●

Ifall jag inte är helt ute och cyklar stödjer inte java returnering av flera variabler.
Returnera istället en array av ints eller en lista eller vad som nu passar dig bäst.

Redigera
Citera flera Citera
Permalänk
Medlem ★
●
Skrivet av JungelTarzan:

Hej Bruum, tack för svaret. Men tyvärr så vill jag försöka utan globala variabler.
Jag har uppdaterat koden lite.
Kan jag returnera 3 värden? Kan jag göra på något enklare sätt?

Gå till inlägget

Det finns ett annat sätt som ur ren ett objektorienterat synsätt är bättre på alla vis: returnera ett objekt.

Den enklare varianten här är att du bestämmer att ditt program alltid kommer returnera tre summor och bygger utifrån det. Här är exempelkod:

public class Resultat3 {
    private final int summa1;
    private final int summa2;
    private final int summa3;

    public Resultat3(int summa1, int summa2, int summa3) {
        this.summa1 = summa1;
        this.summa2 = summa2;
        this.summa3 = summa3;
    }

    public int getSumma1() { return summa1; } 
    public int getSumma2() { return summa2; } 
    public int getSumma3() { return summa3; } 
}

låt Summa returnerar en instans av denna klass:

...
        int s1 = v1[0] + v1[1] + v1[2];
        int s2 = v2[0] + v2[1] + v2[2];
        int s3 = v3[0] + v3[1] + v3[2];

        return new Resultat3(s1, s2, s3);

Detta har fördelar då det kommer till bland annat typsäkerhet: Det går exempelvis inte att försöka komma åt ett resultat som inte finns; koden kompilerar inte om du försöker nå resultat.getSumma4().

En nackdel är att du måste definiera en separat klass beroende på antalet resultat du vill returnera.

Du kan förlänga detta koncept genom att skapa en specifik typ för inmatningsvärden också:

public class Rad3(int värde1, int värde2, int värde3) { ... }

samt

public class Matris3(Rad3 rad1, Rad3 rad2, Rad3 rad3) { ... }

Genom att arbeta med dessa istället för vektorer har du nu effektivt flyttat ett potentiellt problem från runtime till compile time; det vill säga, du kan garantera att ditt program fungerar om det går att kompilera.

Om du är intresserad av typsäkerhet och renhet i kod rekommenderar jag dig att titta på Scala, ett programmeringsspråk som kompilerar till Java-bytekod. Scala har inbyggt stöd för vad som kallas "tuplar" vilket är precis vad du är ute efter. Koden skulle då se ut så här (rakt översatt, det går att skära ner en hel del i den):

object test2 extends App {
    def utskrift(rad1: (Int, Int, Int),
                 rad2: (Int, Int, Int),
                 rad3: (Int, Int, Int)) {
        val (summa1, summa2, summa3) = Summa(rad1, rad2, rad3)
        println(s"\t${rad1._1}\t${rad1._2}\t${rad1._3}\t$summa1")
        println(s"\t${rad2._1}\t${rad2._2}\t${rad2._3}\t$summa1")
        println(s"\t${rad3._1}\t${rad3._2}\t${rad3._3}\t$summa1")
    }

    def Summa(rad1: (Int, Int, Int),
              rad2: (Int, Int, Int),
              rad3: (Int, Int, Int)) = {
        val s1 = rad1._1 + rad1._2 + rad1._3
        val s2 = rad2._1 + rad2._2 + rad2._3
        val s3 = rad3._1 + rad3._2 + rad3._3

        (s1, s2, s3)
    }

    utskrift((3, 4, 2),
             (6, 8, 9),
             (1, 3, 5))
}
Senast redigerat
Visa signatur

Kom-pa-TI-bilitet

Redigera
Citera flera Citera
1
Skriv svar
Senaste nyheterna
Hårdvara
Mjukvara
Övrigt
Nytt i forumet
Datorkomponenter
System
Ljud, bild och kommunikation
Spel och mjukvara