Mehrfache print ausgabe ohne Schleife oder Rekursiven aufruf?

Status
Nicht offen für weitere Antworten.

Erebos1988

Mitglied
Ich habe hier eine Aufgabe vor mir und weiß nicht weiter.
Es soll mehrmals der gleiche Satz ausgegeben werden zb 1000 mal und das ohne Schleife und ohne Rekursion.
Der Quelltext soll aber auch keine 1000 Zeilen lang sein.

Das einzige was mir dann noch einfällt wären 3 Methoden die jeweils 10 prints enthalten, die verknüpft man noch miteinander und dann hätte man 10x10x10.

Wäre das wirklich die Lösung oder gibts da noch was besseres?
 

Marco13

Top Contributor
Das mit den Methoden klingt in Ermangelung von Alternativen für mich im Moment nach der einzigen Lösung - aber nur für eine Feste Anzahl... Wie soll die Anzahl der Aufrufe angegeben werden?
 

Erebos1988

Mitglied
Ist in dem Fall auf 1000 festgelegt, es kann auch nur was ganz simples sein, weil die meisten Leute nicht Programmieren können.
Tja dann wirds wohl wirklich so sein. Muss man erstmal drauf kommen, weil man ja gleich an schleifen denkt.
 

Landei

Top Contributor
Ist das hier gemogelt?
Java:
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/**
 *
 * @author Gronau
 */
public class TimerTest {
   public static void main(String... args) {
       final int times = 1000;
       final Timer timer = new Timer();
       Timer stopper = new Timer(true);
       timer.schedule(new TimerTask(){
            @Override
            public void run() {
                timer.cancel();
            }
        }, new Date(System.currentTimeMillis() + (times-1)*1000));
       timer.schedule(new TimerTask(){
            @Override
            public void run() {
                System.out.println("Cheater!!!");
            }
        }, new Date(), 1000);
   }
}
 

0x7F800000

Top Contributor
Das einzige was mir dann noch einfällt wären 3 Methoden die jeweils 10 prints enthalten, die verknüpft man noch miteinander und dann hätte man 10x10x10.

Wäre das wirklich die Lösung oder gibts da noch was besseres?
Naja, die idee scheint (zumindest in diesem Knobelaufgaben-Kontext) richtig, nur hast du's schlecht faktorisiert^^

1000=5^3*2^3 , das ist weniger zu tippen, als zehnmal dasselbe^^
Java:
import static java.lang.System.*;

public class _ {
	private static Runnable twice(final Runnable r){
		return new Runnable(){@Override public void run(){r.run(); r.run();}};
	}
	private static Runnable fiveTimes(final Runnable r){
		return new Runnable(){
			@Override public void run(){
				twice(twice(r)).run();
				r.run();
			}
		};
	}
	private static Runnable tenTimes(final Runnable r){
		return twice(fiveTimes(r));
	}
	public static void main(String... args){
		tenTimes(tenTimes(tenTimes(new Runnable(){
			@Override public void run(){ out.println("rofl"); }
		}))).run();
	}
}
 

Marco13

Top Contributor
:D @Andrey: Sowas ähliches hatte ich bei meiner ersten Nachfrage schon im Hinterkopf - allerdings auf eine etwas ... "krampfige" Art "systematischer": Wenn die Anzahl der Aufrufe angegeben werden können soll, wäre das dann sowas wie
Java:
class Repeater
{
    public static void main(String args[])
    {
        //createCode();

        run(1);
        run(6);
        run(23);
        run(1000);

    }

    public static void run(int n)
    {
        System.out.println("Result for "+n+":");
        if ((n & (1<<0))!=0) run0001();
        if ((n & (1<<1))!=0) run0002();
        if ((n & (1<<2))!=0) run0004();
        if ((n & (1<<3))!=0) run0008();
        if ((n & (1<<4))!=0) run0016();
        if ((n & (1<<5))!=0) run0032();
        if ((n & (1<<6))!=0) run0064();
        if ((n & (1<<7))!=0) run0128();
        if ((n & (1<<8))!=0) run0256();
        if ((n & (1<<9))!=0) run0512();
    }
    public static void run0001() { System.out.println("run"); }
    public static void run0002() { run0001(); run0001(); }
    public static void run0004() { run0002(); run0002(); }
    public static void run0008() { run0004(); run0004(); }
    public static void run0016() { run0008(); run0008(); }
    public static void run0032() { run0016(); run0016(); }
    public static void run0064() { run0032(); run0032(); }
    public static void run0128() { run0064(); run0064(); }
    public static void run0256() { run0128(); run0128(); }
    public static void run0512() { run0256(); run0256(); }

    /*
    private static String pad(String s, int n)
    {
        while (s.length()<n) s = "0"+s;
        return s;
    }
    private static void createCode()
    {
        System.out.println("public static void run0001() { System.out.println(\"run\"); }");
        for (int i=1; i<=9; i++)
        {
            String n1 = pad(String.valueOf(1<<i), 4);
            String n0 = pad(String.valueOf(1<<(i-1)), 4);
            String s = "public static void run"+n1+"() { run"+n0+"(); run"+n0+"(); }";
            System.out.println(s);
        }
    }
    */

}

:smoke: ;)
 

Marco13

Top Contributor
:D Ich wollte ja gewappnet sein, wenn er sich drüber beschwert, dass das nicht für 1 Milliarde Wiederholngen funktioniert --->

Java:
class Repeater
{
    public static void main(String args[])
    {
        //createCode();

        run(1);
        run(6);
        run(23);
        run(1000);

    }

    public static void run(int n)
    {
        System.out.println("Result for "+n+":");
        if ((n & (1<<0))!=0) run0000000001();
        if ((n & (1<<1))!=0) run0000000002();
        if ((n & (1<<2))!=0) run0000000004();
        if ((n & (1<<3))!=0) run0000000008();
        if ((n & (1<<4))!=0) run0000000016();
        if ((n & (1<<5))!=0) run0000000032();
        if ((n & (1<<6))!=0) run0000000064();
        if ((n & (1<<7))!=0) run0000000128();
        if ((n & (1<<8))!=0) run0000000256();
        if ((n & (1<<9))!=0) run0000000512();
        if ((n & (1<<10))!=0) run0000001024();
        if ((n & (1<<11))!=0) run0000002048();
        if ((n & (1<<12))!=0) run0000004096();
        if ((n & (1<<13))!=0) run0000008192();
        if ((n & (1<<14))!=0) run0000016384();
        if ((n & (1<<15))!=0) run0000032768();
        if ((n & (1<<16))!=0) run0000065536();
        if ((n & (1<<17))!=0) run0000131072();
        if ((n & (1<<18))!=0) run0000262144();
        if ((n & (1<<19))!=0) run0000524288();
        if ((n & (1<<20))!=0) run0001048576();
        if ((n & (1<<21))!=0) run0002097152();
        if ((n & (1<<22))!=0) run0004194304();
        if ((n & (1<<23))!=0) run0008388608();
        if ((n & (1<<24))!=0) run0016777216();
        if ((n & (1<<25))!=0) run0033554432();
        if ((n & (1<<26))!=0) run0067108864();
        if ((n & (1<<27))!=0) run0134217728();
        if ((n & (1<<28))!=0) run0268435456();
        if ((n & (1<<29))!=0) run0536870912();
        if ((n & (1<<30))!=0) run1073741824();
    }

    public static void run0000000001() { System.out.println("run"); }
    public static void run0000000002() { run0000000001(); run0000000001(); }
    public static void run0000000004() { run0000000002(); run0000000002(); }
    public static void run0000000008() { run0000000004(); run0000000004(); }
    public static void run0000000016() { run0000000008(); run0000000008(); }
    public static void run0000000032() { run0000000016(); run0000000016(); }
    public static void run0000000064() { run0000000032(); run0000000032(); }
    public static void run0000000128() { run0000000064(); run0000000064(); }
    public static void run0000000256() { run0000000128(); run0000000128(); }
    public static void run0000000512() { run0000000256(); run0000000256(); }
    public static void run0000001024() { run0000000512(); run0000000512(); }
    public static void run0000002048() { run0000001024(); run0000001024(); }
    public static void run0000004096() { run0000002048(); run0000002048(); }
    public static void run0000008192() { run0000004096(); run0000004096(); }
    public static void run0000016384() { run0000008192(); run0000008192(); }
    public static void run0000032768() { run0000016384(); run0000016384(); }
    public static void run0000065536() { run0000032768(); run0000032768(); }
    public static void run0000131072() { run0000065536(); run0000065536(); }
    public static void run0000262144() { run0000131072(); run0000131072(); }
    public static void run0000524288() { run0000262144(); run0000262144(); }
    public static void run0001048576() { run0000524288(); run0000524288(); }
    public static void run0002097152() { run0001048576(); run0001048576(); }
    public static void run0004194304() { run0002097152(); run0002097152(); }
    public static void run0008388608() { run0004194304(); run0004194304(); }
    public static void run0016777216() { run0008388608(); run0008388608(); }
    public static void run0033554432() { run0016777216(); run0016777216(); }
    public static void run0067108864() { run0033554432(); run0033554432(); }
    public static void run0134217728() { run0067108864(); run0067108864(); }
    public static void run0268435456() { run0134217728(); run0134217728(); }
    public static void run0536870912() { run0268435456(); run0268435456(); }
    public static void run1073741824() { run0536870912(); run0536870912(); }

    /*
    private static String pad(String s, int n)
    {
        while (s.length()<n) s = "0"+s;
        return s;
    }
    private static void createCode()
    {
        int padding = 10;
        System.out.println("public static void run0000000001() { System.out.println(\"run\"); }");
        for (int i=1; i<=30; i++)
        {
            String n1 = pad(String.valueOf(1<<i), padding);
            String n0 = pad(String.valueOf(1<<(i-1)), padding);
            String s = "public static void run"+n1+"() { run"+n0+"(); run"+n0+"(); }";
            System.out.println(s);
        }
        for (int i=1; i<=30; i++)
        {
            System.out.println("if ((n & (1<<"+i+"))!=0) run"+pad(String.valueOf(1<<i), padding)+"();");
        }

    }
    //*/

}

:D

Keine Schleifen, keine Rekursion....
 

cfcnigel

Mitglied
Hallo,

ich habe die gleiche Aufgabe wie der Themenstarter,
nur das wir in der FH noch nicht wirklich etwas der gleichen durchgenommen haben.
Da ich schon andre Programmiersprachen kenne, hätte ich die Aufgabe mit einer Schleife gelöst, leider darf ich dies aber nicht.

Da ich bisher nur ein HelloWord Programm geschrieben habe, habe ich leider keine Ahnung wie sich das lösen lässt.

Hier die Aufgabe:

A.1.f Eine Nachricht 1000 Mal ausgeben (5 Punkte)
Schreiben Sie ein Java-Programm, das folgende Nachricht von Immanuel Kant 1000 Mal ausgibt:
Habe Mut dich deines eigenen Verstandes zu bedienen!
Ihr Programm sollte nicht 1000 Zeilen lang sein. Benutzen Sie Methoden, um das Programm zu kürzen.
Benutzen Sie keine Schleifen und keine Rekursion (kommt später in der Vorlesung), nur den einfachen
Methodenaufruf.

Gibt es dafür den keine einfach simple Lösung, die oben geposteten Vorschläge erscheinen mir recht kompliziert.

Hoffe auf Hilfe, Danke und Gruß
 

Leroy42

Top Contributor
Ihr Programm sollte nicht 1000 Zeilen lang sein....Gibt es dafür den keine einfach simple Lösung

Nicht 1000 Zeilen lang. Mehr Zeilen oder weniger Zeilen?

Wenn's weniger Zeilen sein sollen, dann schreib doch einfach eine Methode mit
kurzen Namen von der du in einer Zeile mehrere aufrufen kannst.

Etwa so:

Java:
...
public static x() {System.out.print("Habe Mut dich deines eigenen Verstandes zu bedienen!")}
...
public static void main(String[] args) {
    x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();
    x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();
    ...
}

Und das ganze jetzt sooft bis die 1000 Ausgaben erreicht werden. :D

Zwar bei weitem nicht so elegant wie die Lösungen meiner Vorredner aber wenn die
Aufgabe so gestellt wurde, würde ich diese Lösung mit Absicht so abgeben. :noe: :)D)
 

eRaaaa

Top Contributor
hmm, was ist mit indirekten schleifen? die sind doch wohl erlaubt oder? :oops:

Java:
String[] s = new String[1000];
		Arrays.fill(s, "Habe Mut dich deines eigenen Verstandes zu bedienen!");
		System.out.println(Arrays.toString(s));

:bae:
 

eRaaaa

Top Contributor
denke aber trotzdem nicht, dass das, das gewollte ergebnis des aufgabenstellers war, deshalb würd emich mal die musterlösung dazu interessieren.

@cfcnigel, wär cool wenn du die hier veröffentlichen könntest (oder halt per pn), wenn du mehr weisst :>
 

cfcnigel

Mitglied
Also meine Klassenkollegen machen das mit 3 Mal ne Methode aufrufen, den wie der Threadstarter schon schreibt 10x10x10... allerdings ist mir nicht klar wie.
Die Kollegen von mir verraten natürlich auch nichts.
 
S

SlaterB

Gast
du hast eine Methode A, die 10x was ausgibt,
an anderer Stelle rufst du A zweimal auf, mit diesen zwei Aufrufen erzeugst du insgesamt 20 Ausgaben
 

cfcnigel

Mitglied
könnt ihr mir bitte dazu den kompletten code posten, ich blicke da nämlich noch nicht so wirklich durch
wenn ich es so schreibe wie eRaaaa dann bekomme ich eine fehlermeldung: can not found symbol

[Java]
class tausend2
{
public static void main(String[] args )
{
String[] s = new String[1000];
Arrays.fill(s,"Habe Mut dich deines eigenen Verstandes zu bedienen!");
System.out.println(Arrays.toString(s));
}
}
[/code]
 

eRaaaa

Top Contributor
Java:
import java.util.Arrays;
fehlt bei dir wohl :D

wegen der 3 methoden-geschichte: versuchs doch vllt erstmal mit 2 und 100 mal den string ausgeben oder ähnlich.
 
Zuletzt bearbeitet:

ARadauer

Top Contributor
wenn du keine Schleifen und keine Rekursion verwenden darfst, da du das erst lerns. Dann wirst du 100%ig auch kein Arrays.fill verwenden dürfen!

Die Kollegen von mir verraten natürlich auch nichts.
mimimi.jpg


Was wird wohl der Lehrer erwarten? Sowas oder?
Java:
public class TausendNachrichten {

	public static void main(String[] args) {
		print1000Messages();
	}
	
	public static void print1000Messages(){
		print100Messages();
		print100Messages();
		print100Messages();
		print100Messages();
		print100Messages();
		print100Messages();
		print100Messages();
		print100Messages();
		print100Messages();
		print100Messages();
	}

	public static void print100Messages(){
		print10Messages();
		print10Messages();
		print10Messages();
		print10Messages();
		print10Messages();
		print10Messages();
		print10Messages();
		print10Messages();
		print10Messages();
		print10Messages();
	}

	public static void print10Messages(){
		print1Message();
		print1Message();
		print1Message();
		print1Message();
		print1Message();
		print1Message();
		print1Message();
		print1Message();
		print1Message();
		print1Message();		
	}

	public static void print1Message(){
		System.out.println("Die ersten Beispiele im Studium sind nur der Anfang... Es wird noch viel schwerer ;-)");		
	}

}

Ist ja ganz einfach oder? Und was ist der Sinn? Wiederholt sich ja immer alles... mhn vielleicht wären da Schleifen besser... und somit haben wir die Überleitung zum nächsten Kapitel...

ich finde diese Art zu unterichten wirklich super, das bring die Studenten wirklich an die Materie heran.

mah sorry das war ja genau deine idee: *selbst schäm* das hab ich jetzt gar nicht mehr gelesen...
 
Zuletzt bearbeitet:

0x7F800000

Top Contributor
hmm, was ist mit indirekten schleifen? die sind doch wohl erlaubt oder? :oops:

ja gut, wenn schon, dann schon:
Java:
import javax.script.*;

public class _ {
	public static void main(String[] args)throws Exception{
		new ScriptEngineManager().
			getEngineByName("JavaScript").
			eval("for(i=0;i<1000;i=i+1) print(\""
				+"Habe Mut dich deines eigenen Verstandes zu bedienen!"
				+"\\n\")");
	}
}
Keine schleifen, keine Rekursionen, keine zusätzliche methoden. Eine einzige Anweisung mit einem String-Literal als Argument :bae:

@cfcnigel: nicht nur dass du an der trivialsten Aufgabe hängen bleibst: da stehen schon 5 Lösungen und Vorschläge zur exakt der selben Aufgabe, und du kannst nicht mal irgendwas kopieren oder nachahmen? Bist du dir sicher, dass bei dir der Spruch vom Kant angekommen ist? ???:L
 
Zuletzt bearbeitet:

Landei

Top Contributor
Java:
import java.util.Arrays;
import java.util.Comparator;

public class Thousand {

    private static int X = 1000;
    private int x = X--;

    public static void main(String... args) {
        Thousand[] array = new Thousand[]{
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
        };
        TC tc =  new TC();
        Arrays.sort(array, tc);
        tc.compare(array[1], array[1]);
    }

    static class TC implements Comparator<Thousand> {

        public int compare(Thousand o1, Thousand o2) {
            say(); say(); say(); say(); say();
            return o1.x - o2.x;
        }
        private void say() {
            System.out.println("Habe Mut dich deines eigenen Verstandes zu bedienen!");
        }
    }
}
 

0x7F800000

Top Contributor
naja, wenn man weiß dass da ein ganz bestimmter nicht randomisierter Merge-Sort algo zum einsatz kommt, hätte man es prinzipiell ausrechnen können^^ ;)
 

cfcnigel

Mitglied
Hallo,

erst mal vielen Dank an alle für ihre vielen Antworten. Ich habe Abgabe-Termin am Montag werde euch dann hier die Musterlösung präsentieren.

Da wir ja eigentlich beim Thema Schleifen sind, ich hätte das einfach so gelöst.

[Java]
class tausend
{
public static void main ( String[] args )

{
int zaehler = 0;

while (zaehler <= 1000 )
{
System.out.println("Habe Mutig dich deines Eigenen verstandes zu bedienen!");
zaehler = zaehler + 1;
}
}
}
[/code]
 

cfcnigel

Mitglied
Ja das wird wohl so sein, aber wenn wir uns mal die andren Lösungen ansehen ist das doch alles totaler quatsch :oops: (nicht persönlich gemeint, die lösungen sind ja alle sehr gut). ich meine das alles macht es aber nur unnötig kompliziert und den quelltext sehr lange.
 

Opnox

Mitglied
Und deine "Lösung" geht einfach an der Aufgabenstellung vorbei. Was das für eine Punktzahl gibt kannst du dir ja dann in etwa vorstellen.
 
B

Beni

Gast
Wie wäre es einen grossen String mit 1000 Zeilen zu erzeugen?
Java:
String x = "Das ist der Satz.\n";
String x2 = x+x;  // * 2
String x4 = x2+x2;  // * 4
String x8 = x4+x4;  //  *8
...
 
Zuletzt bearbeitet von einem Moderator:
S

SlaterB

Gast
hmm, da kam ja noch keiner drauf, leider auch nicht der Aufgabe entsprechend:
> Benutzen Sie Methoden, um das Programm zu kürzen.
 

Landei

Top Contributor
Ja das wird wohl so sein, aber wenn wir uns mal die andren Lösungen ansehen ist das doch alles totaler quatsch :oops: (nicht persönlich gemeint, die lösungen sind ja alle sehr gut). ich meine das alles macht es aber nur unnötig kompliziert und den quelltext sehr lange.

Es sind natürlich einige lustige Lösungen dabei (u.a. meine), aber die am Anfang genannte mit den Methoden für 10, 100 und 1000 Sätze, oder Beni's Vorschlag sehen doch sehr vernünftig aus.

Ohne Schleife und Rekursion heisst eben genau das: Ohne Schleife und Rekursion. Und ich denke alle Lösungen, die nicht auf eine "versteckte" Schleife zugreifen (wie bei Arrays.fill) oder auf speziellen Sprachfeatures beruhen (Timer oder Arrays.sort-Implementierung) sind im Sinne der Aufgabenstellung korrekt.
 

ARadauer

Top Contributor
Code:
  while (zaehler <= 1000 )
generell kann man sagen, wenn man weiß wie viele iterationen eher for nehmen...
 
B

bygones

Gast
alles unschoen, dabei doch so einfach :lol:

[groovy]println 'Habe Mutig dich deines Eigenen verstandes zu bedienen!\n' * 1000[/groovy]

oh man... jetzt habe ich einfach mal copy und paste gemacht... ich hoffe mal instaendig der Satz ist ironischerweise von dir verfremdet worden...
 

0x7F800000

Top Contributor
was du hir wollen mit groovy code? ???:L Wenn du schon dabei bist, andere Sprachen zu verwurschten, dann kannst du auch gleich mal eine spezialisierte Version von HQ9+ für cfcnigel schreiben, wo er nur einen einzigen buchstaben als quellcode anzugeben hat^^
 
Zuletzt bearbeitet:

Terrestrex

Mitglied
Tach,

ist so etwas auch Rekursiv?:

Java:
int i = 0;
	public void printSatz(){
		if (i <1000){
			System.out.println(i + " Satz");
			i++;
			printSatz();
		}

In meine Naivität würde ich sagen, das ist ziemlich einfach, oder?
 

0x7F800000

Top Contributor
oh verzeih, dass einer eine Frage stellt und es nicht weiss... ja schlimme welt nicht... oh man
Ne, etwas nicht zu wissen und Fragen zu stellen ist völlig in Ordnung.
Aber da kommt einer ausgerechnet in diesem Thread vorbei, und stellt nach 20 Beiträgen verwundert fest, dass es mit einer Rekursion ja viel leichter ist: was? neeee? wirklich jetzt? Wieso sind wir hier bloß zu zehnt drei Tage lang nicht drauf gekommen^^ :autsch:
 

Terrestrex

Mitglied
@0x7F800000

ja, du hast recht. Ich habe bei Wiki gelesen, was alles unter Rekursion zu verstehen ist, und ich muss sagen, die Frage hätte ich mir ersparen können.
Es ist leider so, dass ich teilweise, die Threads lese (aus Interesse) und manchmal ne Idee habe wie man etwas lösen könnte. Dass hier Leute mit viel mehr Erfahrung (und Wissen) gibt, weiß ich.

Also, Entschuldigung für die Betriebsstörungen.

Grüße

Terrex
 
Status
Nicht offen für weitere Antworten.
Ähnliche Java Themen
  Titel Forum Antworten Datum
O Mehrfache Scanner-Eingabe durch Komma getrennt Java Basics - Anfänger-Themen 6
S mehrfache if-Abfragen - beste Lösung Java Basics - Anfänger-Themen 1
G mehrfache If-Abfrage Java Basics - Anfänger-Themen 8
H Print und Println Java Basics - Anfänger-Themen 13
123456789sssssaaaa Which is the best way to Print Fibonacci Series in Java? Java Basics - Anfänger-Themen 3
H awt.print. Java Basics - Anfänger-Themen 0
Kotelettklopfer Stringbuilder mit print ausgeben Java Basics - Anfänger-Themen 83
paulen1 Methoden Unerwünschte Ausgabe bei System.out.print in For-Schleife Java Basics - Anfänger-Themen 8
Y Wie kann man überprüfen, ob bei einem Print Befehl tatsächlich etwas geprintet wurde? Java Basics - Anfänger-Themen 4
S Anweisungen verstehen System.out.print/println Java Basics - Anfänger-Themen 2
B Input/Output System.out.print mit und ohne "" Java Basics - Anfänger-Themen 5
Ghostman1711 Itext PDF print File gelockt by Java Java Basics - Anfänger-Themen 15
L system.print.out geht nicht Java Basics - Anfänger-Themen 11
B Print Service Java Basics - Anfänger-Themen 5
I Print Client -> Server -> Client? Java Basics - Anfänger-Themen 1
I Print Monitor Java Basics - Anfänger-Themen 0
I Drucken (Print) monitoren Java Basics - Anfänger-Themen 0
S Unterschied print() und println() Java Basics - Anfänger-Themen 3
J Umgang mit System.out.println() und .print() Java Basics - Anfänger-Themen 6
C Kleines Problem mit System.out.print Java Basics - Anfänger-Themen 1
R Char wird in System.out.print(); nicht ausgegeben Java Basics - Anfänger-Themen 6
T System.out.print : Frage zu Aufbau Java Basics - Anfänger-Themen 4
J Erste Schritte System.out.print (Fehlermeldung) Java Basics - Anfänger-Themen 14
X Eclipse System.out.print fehler Java Basics - Anfänger-Themen 5
K char-int-Addition in System.out.print Java Basics - Anfänger-Themen 3
A Feststellen ob Desktop.print("*.pdf") fertig ist Java Basics - Anfänger-Themen 6
Junb Sys.Out.Print - aus Methode zugreifen Java Basics - Anfänger-Themen 6
G DRUCKEN von z.B. eines JFrame über print(Graphics g) Java Basics - Anfänger-Themen 9
S [JUnit] Print Results while running Java Basics - Anfänger-Themen 6
J print button Java Basics - Anfänger-Themen 2
T Dezimaltrennzeichen bei Ausgabe mit print ändern Java Basics - Anfänger-Themen 4
ruutaiokwu System.err.print(ln) macht ein durcheinander??! Java Basics - Anfänger-Themen 8
J print-Anweisung verschluckt Java Basics - Anfänger-Themen 3
S Print Methode zweier "Classes" kombinieren Java Basics - Anfänger-Themen 2
O Drucker: print methode wird 2 mal aufgerufen nachfrage Java Basics - Anfänger-Themen 4
J Fragen zu System.out.print und charAt Java Basics - Anfänger-Themen 3
S 2 kleine Methoden negieren und print Java Basics - Anfänger-Themen 8
D System.out.print(0101); =65. Warum? Java Basics - Anfänger-Themen 3
M to pdf print process starten Java Basics - Anfänger-Themen 4
C javax.print.DocPrintJob Java Basics - Anfänger-Themen 17
F print in java Java Basics - Anfänger-Themen 3
W Die Methode print() wird 2 mal für jede Seite aufgerufen Java Basics - Anfänger-Themen 9
B Objekt Orintiertes Programmieren ausgabe Fehler mit Print() Java Basics - Anfänger-Themen 4
S print()! Java Basics - Anfänger-Themen 2
L PrintWriter autoflush: println funktioniert, print nicht Java Basics - Anfänger-Themen 3
G Auswahl:in File schreiben, oder System.out.print Java Basics - Anfänger-Themen 4
J System.out.print Java Basics - Anfänger-Themen 5
S Listen - insert - print etc. Dringend! Bitte! Java Basics - Anfänger-Themen 6
H Print Methode Java Basics - Anfänger-Themen 6
C System.out.print oder println ? Java Basics - Anfänger-Themen 2
M Ausgabe einer ArrayList ensteht nur als Hashcode, nicht als Objekt Java Basics - Anfänger-Themen 16
M Methode zielnah zeigt das gewünschte Ausgabe nicht an Java Basics - Anfänger-Themen 3
M Ausgabe beim Overloading Java Basics - Anfänger-Themen 3
H Frage zur Ausgabe Java Basics - Anfänger-Themen 4
H Java-Programm zur Ausgabe von Zuständen Java Basics - Anfänger-Themen 80
S Einfach-Verkettete-Listen Ausgabe zeigt nur 1. und letzte instanz Java Basics - Anfänger-Themen 2
T float soll durch schleife die größte mögliche Zahl herausfinden, Ausgabe ist aber "Infinity" Java Basics - Anfänger-Themen 1
B Binärzahlen auflisten, falsche Ausgabe? Java Basics - Anfänger-Themen 1
M Java Ausgabe der höchsten Zahl Java Basics - Anfänger-Themen 14
M Erste Schritte While Schleife / Ausgabe von buchstabe & ASCII Wert Java Basics - Anfänger-Themen 4
nelsonmandela Problem bei Ausgabe einer Switch - Case Funktion Java Basics - Anfänger-Themen 5
W Streams in Java und was bedeutet meine Konsolen-Ausgabe? Java Basics - Anfänger-Themen 4
B Automatisierte Ausgabe (Schleife, If-Abfrage?) Java Basics - Anfänger-Themen 24
C 2D Array Ausgabe mit for-Schleife i,j Java Basics - Anfänger-Themen 4
B Deadlock verstehen der Ausgabe! Java Basics - Anfänger-Themen 12
Lion.King Ausgabe mit Eigenschaften Java Basics - Anfänger-Themen 4
D Java Pattern mit X Ausgabe Stern Java Basics - Anfänger-Themen 4
J In der Ausgabe wird ohne Eingabe in den else Block gesprungen. Java Basics - Anfänger-Themen 0
J In der Ausgabe wird ohne Eingabe in den else Block gesprungen. Java Basics - Anfänger-Themen 5
Xaver code Tastatur ausgabe Java Basics - Anfänger-Themen 4
R Anfänger: Ausgabe kommt minus raus? Java Basics - Anfänger-Themen 6
K Leerzeile in Konsolen-Ausgabe Java Basics - Anfänger-Themen 4
K Zweite Ausgabe von vererbten Klassen Java Basics - Anfänger-Themen 3
Q return Ausgabe Java Basics - Anfänger-Themen 4
C Java Arrays - Ausgabe in Methode Java Basics - Anfänger-Themen 12
D Best Practice Ausgabe über direkte Ausgabe oder try-catch? Java Basics - Anfänger-Themen 13
S Ausgabe des Variablenwerts Java Basics - Anfänger-Themen 10
I Ausgabe nicht nur senkrecht sondern auch waagerecht. Java Basics - Anfänger-Themen 2
C Ausgabe boolean return ((n==9)||(n==0)); Java Basics - Anfänger-Themen 13
F Double Ausgabe nicht wissenschaftlich Java Basics - Anfänger-Themen 16
danieldemetry Java - Graph Komponenten - Ausgabe Java Basics - Anfänger-Themen 0
S Fragen zu Ausgabe double und float Java Basics - Anfänger-Themen 3
B Ausgabe in TextArea funktioniert nicht Java Basics - Anfänger-Themen 2
D BigDecimal Ausgabe sehr lang. Java Basics - Anfänger-Themen 2
J String Ausgabe Java Basics - Anfänger-Themen 2
TimoN11 IntelliJ , Ausgabe von einem Quellcode in Eingabe eines Quellcodes Java Basics - Anfänger-Themen 1
Kalibru Problem bei Ausgabe von Objekt Java Basics - Anfänger-Themen 1
KogoroMori21 Array-Ausgabe Java Basics - Anfänger-Themen 6
JaVaN0oB Wörterraten - Falsche Ausgabe, String/Chars vergleichen Java Basics - Anfänger-Themen 2
E Ausgabe überschreiben Java Basics - Anfänger-Themen 15
D Ausgabe von Array Java Basics - Anfänger-Themen 2
U Ausgabe Java Basics - Anfänger-Themen 4
J Buchstabenhäufigkeit mit Array und Ausgabe des häufigsten Buchstaben Java Basics - Anfänger-Themen 25
V Multiplikationstafel - Ausgabe Java Basics - Anfänger-Themen 4
L Warum ist die Ausgabe anders als das was im Bezeichner steht? Java Basics - Anfänger-Themen 4
M In gleicher zeile hinter ausgabe noch etwas ausgeben Java Basics - Anfänger-Themen 1
newcomerJava Nach doppelter Zahl eine Ausgabe Java Basics - Anfänger-Themen 10
H Falsche Ausgabe Java Basics - Anfänger-Themen 2
P Klassenübergreifende Ausgabe mittels "getter" nicht möglich Java Basics - Anfänger-Themen 21
R Call-by-Value, Call-by-Reference, Call-by-Name Ausgabe Java Basics - Anfänger-Themen 1

Ähnliche Java Themen

Neue Themen


Oben