Java-Code, Array?

Kann jemand mir die Methoden, heller, spot, weichzeichnen, horizontalspieglung, punktSpieglung erklären?

* SWBild ist eine Klasse, die Graustufenbilder repraesentiert und

 * manipuliert. Die Implementierung erfolgt durch ein einfaches
 * Bildformat: Die Bildpunkte werden in einem zweidimensionalen
 * Array von 'short'-Werten gehalten. Jeder Feldeintrag kann einen
 * Wert zwischen 0 und 255 annehmen. Andere Werte sind unzulaessig.
 * Der Wertebereich [0..255] repraesentiert den Graustufenbereich:
 * 0 fuer Schwarz, 255 fuer Weiss und dazwischenliegende Werte fuer die Grauabstufungen.
 */

class SWBild
{
     

    /**
     * Dieses Bild weichzeichnen.
     */
    public void weichzeichnen()
    {
        for (int y = 0; y < _hoehe; y++)
        {
            for (int x = 0; x < _breite; x++)
            {
                int _nebenBildpunkte = 0; 
                int anzahlPiksel=0;          
                _nebenBildpunkte += weichzeichnen(y+1, x);
                _nebenBildpunkte += weichzeichnen(y+1, x+1);
                _nebenBildpunkte += weichzeichnen(y+1, x-1);
                _nebenBildpunkte += weichzeichnen(y, x+1);
                _nebenBildpunkte += weichzeichnen(y, x-1);
                _nebenBildpunkte += weichzeichnen(y-1, x+1);
                _nebenBildpunkte += weichzeichnen(y-1, x);
                _nebenBildpunkte += weichzeichnen(y-1, x-1);
                _nebenBildpunkte = _nebenBildpunkte/anzahlPiksel;
                _bilddaten[y][x] = (short) _nebenBildpunkte;
            }
        }
        zeichneBild();
    }

    public int weichzeichnen(int y, int x) {
        if (x >= 0 && x < _breite && y >= 0 && y < _hoehe) {
            anzahlPiksel++;
            return _bilddaten[y][x];
        }
        else
        {
            return 0;
        }
    }

    /**
     * Erzeuge bei diesem Bild einen Spot mit Radius r, Mittelpunkt x0,y0 und Beleuchtungsintensitaet i. Ausserhalb von r nimmt die Ausleuchtung linear ab.
     * Wie im wirklichen Leben...
     * @param xo
     *            x-Koordinate des Mittelpunktes
     * @param yo
     *            y-Koordinate des Mittelpunktes
     * @param r
     *            Radius
     * @param i
     *            Beleuchtungsintesitaet
     */
    public void spot(int x0, int y0, int r, short i)
    {
        short i0 = 0;
        for (int k = _breite/2; k >= r; k--) {
            for (int y=0; y<_hoehe; y++){
                for (int x=0; x<_breite;x++){
                    if(((x-x0)*(x-x0))+((y-y0)*(y-y0))<=k*k){ 
                        if (_bilddaten[y][x] + i0 > 255) {
                            _bilddaten[y][x] = 255;
                        } else if (_bilddaten[y][x] + i0 < 0) {
                            _bilddaten[y][x] = 0;
                        } else {
                            _bilddaten[y][x] = (short) (_bilddaten[y][x] + i0);
                         
                        }
                    }
                    if (i > i0){
                        i0++;
                    }
                }
            }
        }
        zeichneBild();
    }

1 Antwort

DasZitrone

Von gutefrage auf Grund seines Wissens auf einem Fachgebiet ausgezeichneter Nutzer

Computer

19.12.2022, 18:15

Die Methode "heller" fügt dem Wert jedes Bildpunkts einen bestimmten Betrag hinzu. Dies wird im Code wie folgt implementiert:

for (int y=0; y<_hoehe; y++){
    for (int x=0; x<_breite; x++){
        if (_bilddaten[y][x] + betrag > 255) {
            _bilddaten[y][x] = 255;
        } else if (_bilddaten[y][x] + betrag < 0) {
            _bilddaten[y][x] = 0;
        } else {
            _bilddaten[y][x] = (short) (_bilddaten[y][x] + betrag);
        }
    }
}

Die Methode "spot" erzeugt einen Spot-Effekt auf dem Bild, indem sie eine Beleuchtungsintensität in einem bestimmten Radius um einen Mittelpunkt herum anwendet. Die Ausleuchtung nimmt außerhalb dieses Radius linear ab. Dies wird im Code wie folgt implementiert:

short i0 = 0;
for (int k = _breite/2; k >= r; k--) {
    for (int y=0; y<_hoehe; y++){
        for (int x=0; x<_breite;x++){
            if(((x-x0)*(x-x0))+((y-y0)*(y-y0))<=k*k){ 
                if (_bilddaten[y][x] + i0 > 255) {
                    _bilddaten[y][x] = 255;
                } else if (_bilddaten[y][x] + i0 < 0) {
                    _bilddaten[y][x] = 0;
                } else {
                    _bilddaten[y][x] = (short) (_bilddaten[y][x] + i0);
                }
            }
            if (i > i0){
                i0++;
            }
        }
    }
}

Und so weiter und so fort...:

Die Methode "weichzeichnen" dient dazu, das Bild zu glätten, indem sie den Durchschnittswert der benachbarten Bildpunkte jedes Bildpunkts berechnet und diesen Wert als neuen Wert für den Bildpunkt verwendet.

Die Methode "horizontalspiegelung" spiegelt das Bild horizontal, indem sie die Bildpunkte auf der linken Seite des Bildes mit denen auf der rechten Seite vertauscht.

Die Methode "punktspiegelung" spiegelt das Bild um einen bestimmten Punkt herum, indem sie die Entfernungen von allen Bildpunkten zu diesem Punkt berechnet und die Bildpunkte an den entsprechenden symmetrischen Positionen des Bildes platziert.

Woher ich das weiß:Studium / Ausbildung – Hochschulabschluss in Informatik (MSc)

Mathematik2000

Fragesteller

19.12.2022, 18:36

Ich weiß schon, was jede Methode macht. Ich verstehe den Code nicht, welche Zeile was sagt und warum?

DasZitrone

19.12.2022, 18:37

@Mathematik2000

Dann verstehst du aber die Grundlagen des Programmierens nicht... Da solltest du nicht mit soetwas anfangen sondern mit einfacheren Sachen.

Ähnliche Fragen

Java-Code?

Wie sieht die Methode Punktspiegelung und horizonalspieglung aus?

Implementieren Sie die Operation punktSpiegeln, die alle Punkte am Mittelpunkt des Bildes spiegelt.

Implementieren Sie in SWBild die Operation horizontalSpiegeln, die das Bild an der horizontalen Achse spiegelt.Für die Lösung zu dieser Operation ist kein zusätzliches Array-Objekt zugelassen, sie muss also „in place“ erfolgen

/**
 * SWBild ist eine Klasse, die Graustufenbilder repraesentiert und
 * manipuliert. Die Implementierung erfolgt durch ein einfaches
 * Bildformat: Die Bildpunkte werden in einem zweidimensionalen
 * Array von 'short'-Werten gehalten. Jeder Feldeintrag kann einen
 * Wert zwischen 0 und 255 annehmen. Andere Werte sind unzulaessig.
 * Der Wertebereich [0..255] repraesentiert den Graustufenbereich:
 * 0 fuer Schwarz, 255 fuer Weiss und dazwischenliegende Werte fuer
 * die Grauabstufungen.
 * 
 * Beispielmethode 'dunkler': Ein geladenes Bild kann um
 * ein gegebenes 'delta' abgedunkelt werden.
 * 
 */
class SWBild
{
    private int anzahlPiksel=0;


    // die Bilddaten dieses Bildes
    private short[][] _bilddaten;


    // die Breite dieses Bildes
    private int _breite;


    // die Hoehe dieses Bildes
    private int _hoehe;


    // Leinwand zur Anzeige
    private Leinwand _leinwand;


    /**
     * Initialisiert ein Bild mit einer Bilddatei. Der Benutzer kann interaktiv mit
     * Hilfe eines Dateidialogs die zu ladende Datei auswaehlen.
     */
    public SWBild()
    {
        _bilddaten = BildEinleser.liesBilddaten();
        if (_bilddaten != null)
        {
            aktualisiereBildgroesse(_bilddaten);
            erzeugeLeinwand();
        }
    }


    /**
     * Initialisiert ein Bild mit einer Bilddatei. Der Dateiname kann als absoluter
     * oder relativer Pfad uebergeben werden.
     * 
     * @param bilddateiName
     *            der Name der Bilddatei
     */
    public SWBild(String bilddateiName)
    {
        _bilddaten = BildEinleser.liesBilddaten(bilddateiName);
        aktualisiereBildgroesse(_bilddaten);
        erzeugeLeinwand();
    }

/**
     * Erzeuge bei diesem Bild einen Spot mit Radius r, Mittelpunkt x0,y0 und
     * Beleuchtungsintensitaet i. Ausserhalb von r nimmt die Ausleuchtung linear ab.
     * Wie im wirklichen Leben...
     * 
     * @param xo
     *            x-Koordinate des Mittelpunktes
     * @param yo
     *            y-Koordinate des Mittelpunktes
     * @param r
     *            Radius
     * @param i
     *            Beleuchtungsintesitaet
     */
    public void spot(int x0, int y0, int r, short i)
}

...zur Frage

Java-Code? Array?

Wie wird das Array verwendet? Was befindet sich in dem Array? kann jemand mir den Code und die Methode dunkler erklären?

* SWBild ist eine Klasse, die Graustufenbilder repraesentiert und
 * manipuliert. Die Implementierung erfolgt durch ein einfaches
 * Bildformat: Die Bildpunkte werden in einem zweidimensionalen
 * Array von 'short'-Werten gehalten. Jeder Feldeintrag kann einen
 * Wert zwischen 0 und 255 annehmen. Andere Werte sind unzulaessig.
 * Der Wertebereich [0..255] repraesentiert den Graustufenbereich:
 * 0 fuer Schwarz, 255 fuer Weiss und dazwischenliegende Werte fuer
 * die Grauabstufungen.
 * 
 * Beispielmethode 'dunkler': Ein geladenes Bild kann um
 * ein gegebenes 'delta' abgedunkelt werden.
class SWBild
{


    // die Bilddaten dieses Bildes
    private short[][] _bilddaten;


    // die Breite dieses Bildes
    private int _breite;


    // die Hoehe dieses Bildes
    private int _hoehe;


    // Leinwand zur Anzeige
    private Leinwand _leinwand;


    /**
     * Initialisiert ein Bild mit einer Bilddatei. Der Benutzer kann interaktiv mit
     * Hilfe eines Dateidialogs die zu ladende Datei auswaehlen.
     */
    public SWBild()
    {
        _bilddaten = BildEinleser.liesBilddaten();
        if (_bilddaten != null)
        {
            aktualisiereBildgroesse(_bilddaten);
            erzeugeLeinwand();
        }
    }


    /**
     * Initialisiert ein Bild mit einer Bilddatei. Der Dateiname kann als absoluter
     * oder relativer Pfad uebergeben werden.
     * 
     * @param bilddateiName
     *            der Name der Bilddatei
     */
    public SWBild(String bilddateiName)
    {
        _bilddaten = BildEinleser.liesBilddaten(bilddateiName);
        aktualisiereBildgroesse(_bilddaten);
        erzeugeLeinwand();
    }


    /**
     * Dieses Bild um einen Wert abdunkeln. 
     * 
     * @param delta
     *            Wert der Abdunkelung. Es wird mit dem Betrag von delta gerechnet, 
     *            deshalb darf der Parameter sowohl positiv als auch negativ sein.  
     */
    public void dunkler(int delta)
    {
        if (delta < 0)
        {
            delta = -delta;
        }


        /**
         * Durch alle Bytes des Bildes gehen und jeden Wert dekrementieren
         */
        for (int y = 0; y < _hoehe; y++)
        {
            for (int x = 0; x < _breite; x++)
            {
                if ((_bilddaten[y][x] - delta) > 0) // Wert darf 0 nicht unterschreiten
                {
                    _bilddaten[y][x] = (short) (_bilddaten[y][x] - delta);
                }
                else
                {
                    _bilddaten[y][x] = 0;
                }
            }
        }
        // Neuzeichnen der Bildleinwand, basierend auf den Werten in _bilddaten:
        zeichneBild();
    }

...zur Frage

Java-Code erklärung?

Ich bitte um die genaue ausführliche Erklärung für diese Methode

warum int y=1 und nicht y=0? warum y < höhe-1? warum...

 /**
     * Dieses Bild weichzeichnen.
     */
    public void weichzeichnen()
    {
        int a=0;
        short[][] _kopie = new short[_hoehe][_breite];


        for (int y=1;y<_hoehe-1;y++)
        {
            for (int x=1;x<_breite-1;x++)
            {
                //TODO randbearbeiten y=0...hoehe
                a=(_bilddaten[y+1][x+1]+_bilddaten[y-1][x-1]+_bilddaten[y+1][x-1]+_bilddaten[y-1][x+1]+_bilddaten[y][x+1]+_bilddaten[y][x-1]+_bilddaten[y+1][x]+_bilddaten[y-1][x])/8;
                _kopie[y][x]=(short)a;                
            }
        }
        _bilddaten=_kopie;
        zeichneBild();


    }

...zur Frage

Java-Code erklären?

Ich bitte um eine ausführliche Erklärung!

 * Ein Spielfeld besteht aus drei Zeilen mit je drei Spalten. Man kann an den
 * neun Positionen einen der beiden Spieler als Besitzer eintragen und auslesen.
 */
public class SpielfeldString implements Spielfeld 
{
    private String feld;


    /**
     * Initialisiert ein neues, leeres Spielfeld.
     */
    public SpielfeldString() {
        feld = "000000000";
        //012345678
    }


    /**
     * Die Methode berechnet die bestimmte Position.
     *
     * @param zeile   vertikale Position (0-2)
     * @param spalte  horizontale Position (0-2)
     * @return eine Int-Zahl von 0 bis 8
     */
    private int gibPosition(int zeile, int spalte){
        if (zeile < 0 || zeile > 2 || spalte < 0 || spalte > 2){
            throw new IllegalArgumentException("Spalte oder Zeile ist ausser dem Feld!");
        }
        return zeile * 3 + spalte;
    }


    /**
     * Gibt den Besitzer der angegebenen Position auf dem Spielfeld.
     *
     * @param zeile  vertikale Position (0-2)
     * @param spalte horizontale Position (0-2)
     * @return 0 (unbesetzt), 1 (Spieler 1), 2 (Spieler 2)
     */
    @Override
    public int gibBesitzer(int zeile, int spalte) {
        int besitzer = 0;
        char zeichen = feld.charAt(gibPosition(zeile, spalte));
        switch (zeichen){
            case '0':
                besitzer = 0;
                break;
            case '1':
                besitzer = 1;
                break;
            case '2':
                besitzer = 2;
                break;
        }
        return besitzer;
    }


    /**
     * Besetzt die angegebene Position auf dem Spielfeld fuer einen Spieler.
     *
     * @param zeile   vertikale Position (0-2)
     * @param spalte  horizontale Position (0-2)
     * @param spieler 0 (leer), 1 (Spieler 1), 2 (Spieler 2)
     */
    @Override
    public void besetzePosition(int zeile, int spalte, int spieler) {
        int position = gibPosition(zeile, spalte);
        feld = feld.substring(0, position) + spieler + feld.substring (position + 1);
    }


    /**
     * Gibt an, ob das Spielfeld an allen Positionen belegt ist.
     */
    @Override
    public boolean istVoll() {
        return feld.indexOf("0") == -1; // da wenn es kein 0 mehr in der Zeichenkette gibt,
        // wird -1 zurückgegeben.
    }
}

...zur Frage

Java-Code?

Kann jemand die Methode ausführlich erklären? warum machen wir höhe/2 oder hohe-y-1?

 /**
     * Dieses Bild horizontal spiegeln.
     */
    public void horizontalSpiegeln()
    {
        for (int y = 0; y < _hoehe/2; y++)
        {
            for (int x = 0; x < _breite; x++)
            {
                short i = _bilddaten[y][x];
                _bilddaten[y][x] = _bilddaten[_hoehe - y-1][x]; 
                _bilddaten[_hoehe - y-1][x] = i;
            }
        }
        zeichneBild();


    }

...zur Frage

Java Array ober und Untergrenze?

Hallo,

Ich Versuche seit mehreren Stunden mir eine Array Auszugeben wo ich eine Ober und untergrenze definiert hab aber ich bekomme es nicht hin ergo. ich bite um Hilfe.

Die Array:

zf = new int[11];
zf[1] = 1;
zf[2] = 2;
zf[3] = 3;
zf[4] = 10;
zf[5] = 9;
zf[6] = 8;
zf[7] = 7;
zf[8] = 6;
zf[9] = 5;
zf[10] = 4;

Sortierung:

    private void sortierungsbegrenzung( int a[], int untergrenze, int obergrenze)
    {
         int i, j, n = (obergrenze-untergrenze)-1;  
         int x;
        for ( i = (untergrenze+2); i <= n; i++ )      
        {    
            boolean getauscht = false;
            for (j = n; j >= i; j-- )           
            {                
                if ( a[j-1] > a[j] )           
                {
                    tauschen(zf, j, 1);
                    getauscht = true;
                }
            } /*end for*/
            if (!getauscht)
            {
                break;
            }
            zfAusgeben(zf);
        } /*end for*/
    }

tauschen:

    private void tauschen(int b[], int k, int t)
    {               
        int x;
        x = b[k-t];
        b[k-t] = b[k];
        b[k] = x;
    }

zfAusgabe:

    private void zfAusgeben(int[] a)
    {
        for (int i=1; i<a.length; i++)
        {
            System.out.print( a[i] + "\t");
        }
        System.out.println();
    }

ich finde den Fehler nicht

MfG

...zur Frage

Wie kann ich in Java ein Quadrat auf die Konsole zeichnen?

public class Quardrat {
  public static String quardt() {
    for (int i = 1; i < 5; i++) {
      for (int y = 1; y < 5; y++) {
        if (i == 0 || y == 5) {
        }
      }
    }

    return "*";
  }

  // public static void main(String[] args) {
  //   System.out.println(quardt());
  // }
}

Wie kann ich weitermachen?

...zur Frage

Kann mir jemand bei dem JUnit-Test helfen?

Ich muss eine JUnit-Test für die Klasse NumberInputStream. Kann mir einer helfen. Ich habe schon. Im Datei"zahlen_1.txt"steht diese Zahlen?

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;


public class NumberInputStream extends InputStream {
    Reader in;


    public NumberInputStream(String fileName) throws IOException {
        in = new InputStreamReader(new FileInputStream(fileName));
    }


    @Override
    public int read() throws IOException, NumberToLargeException {
        int c;
        String t = "";
        while ((c = in.read()) != -1) {
            if ((char) c == ' ' || (char) c == '\n' || Character.isWhitespace(c)) {
                if (!t.trim().equals("")) {
                    break;
                }
            } else {
                t += (char) c;
            }
        }


        if (t.trim().equals("")) {
            return -1;
        }


        int value = Integer.parseInt(t.trim());
        if (value > 255) {
            throw new NumberToLargeException();
        }


        return value;
    }


   
}

...zur Frage

Array nach Wert prüfen rekrusiv (java)?

Hi sagen wir mal ich habe einen COde der so aussieht:

  public static int calculateBinomialCoefficient (int n, int k)
   {
      if (k == 1)
         return n;
      else if (n >= k && k == 0)
         return 1;
      else
       return (n * calculateBinomialCoefficient(n - 1, k - 1) / k);
 
   }
}

Nun hat mein Prof gemeint, dass die rekursion nicht linear ist und zu vielen gleichen Aufrufen mit gleichen Parameterkombis führt. EIne Möglichkeit damit das besser läuft ist es berechente Binomialkoeffizienten in einem zwei dimensionalen Array zu speichern und vor einem rekursiven Aufruf zu prüfen, ob die Lösung bereits 1x exisitert hat. EInen Array haben wir schon gegeben, mit der perfekten Länge.Dann habe ich mir das überlegt:

 public static int calculateBinomialCoefficient (int n, int k)
  {
   if (k == 1)
     return n;
   else if (n >= k && k == 0)
     return 1;
   else
for (int a=0; a<array.length;a++)
{
for (int b=0; b<array.length;b++)
{
if (array[a][b]==(n * calculateBinomialCoefficient(n - 1, k - 1) / k)
{
return array[a][b];
}else{
return (n * calculateBinomialCoefficient(n - 1, k - 1) / k);
if(array[a][b]==0){
array[a][b]==(n * calculateBinomialCoefficient(n - 1, k - 1) / k);
}
}
}
}
     
 
  }
}

(Ich hoffe kann man erkennen Tabs sind bisschen verrückt.)

Aber warum funktioniert das nun nicht? Habe doch alles beachtet oder?

...zur Frage

Binärer Suchbaum in Array (Java)?

Hi, ich studiere im ersten Semester medizinische Informatik und wir sollen einen binären Suchbaum in einem sortierten Array zurückgeben. Kann mir da jemand helfen (wir programmieren in Java)? Das habe ich bis jetzt:

int[] sort() {
    zahlenElemente = new int[this.size()];
    return sort(this, zahlenElemente);
}

int[] sort(IntSearchTree suchbaum, int[]array) { if (suchbaum != null) { if (suchbaum.getLeft() != null){ sort(suchbaum.getLeft(), zahlenElemente); zahlenElemente[index] = suchbaum.getValue(); index++; } if (suchbaum.getRight() != null){ sort(suchbaum.getRight(), zahlenElemente); } for (int i = 0; i < this.size(); i++){ System.out.print(zahlenElemente[i] + " "); } } return zahlenElemente; }

Aus irgendeinem Grund werden nur Nullen ausgegeben und ich verstehe nicht warum...

...zur Frage

Verschachtelte for Schleife?

Ich verstehe die for Schleifen nicht so ganz kann mir das jemand erklären? vorallem das mit dem if verstehe ich nicht

public static void main(String args[]) {

for (int i = 0; i < 4;i++) { 1. Schleife

for(int j = 0; j < 7; j++) { 2. Schleife

if(j < (6/2-i)||j>(6/2+i)) {

System.out.print(" ");

}

else{

System.out.print("X");

}

System.out.println();

}

System.out.println(" X ");

}

Ausgabe:

Sprache: Java

...zur Frage

Java Umsetzung von Funktions-Pointern?

Ich habe 2 Methoden, welche fast das gleiche tun. Kurze abgespeckte Darstellung für die 1. Methode:

private List<Auto> getAutoFromResponse(Response response){
  List<Auto> list = new ArrayList<>();
  for(int i=0; i < response.array.length; i++){
    list.add(createAuto(i)); // makrierte Zeile
  }
  return list;
}

Die 2. Methode ruft in der markierten Zeile createHaus() auf. Sonst ist alles gleich! Ich könnte ja dafür eine generische Methode machen:

private <T> List<T> getFromResponse(Response response){ //,T t als Param?
  List<T> list = new ArrayList<>();
  for(int i=0; i < response.array.length; i++){
    list.add(create(i)); //TODO Wie setze ich das um??
  }
  return list;
}

Wie kann ich darin nun die jeweilige Methode aufrufen? Ich bräuchte eig. einen Funktionszeiger - gibts in Java aber nicht. Habe versucht, dass Auto und Haus ein Interface implementieren und sie damit eine gleichnamige Methode create(int i) haben. Aber wie schaffe ich den Aufruf list.add(...) in der gen. Methode?

...zur Frage

Wir sollen im Unterricht eine Schleife erstellen, die alle Primzahlen bis 100 ausgibt, jedoch sitzen wir seid mehreren Stunden dran und kriegen es nicht hin?

Wir sollen das ganze in While schleifen schreiben, doch haben keinen blassen Schimmer wie dieses gehen soll.

Das haben wir bisher.

public class Main {
    public static void main(String[] args) {
        int limit = 100;
        int zahl;                   //überprüfen der zahl
        int counter= 2;
        boolean prim;           //Hilfsvariable ob die aktuelle zahl eine Primzahl ist

        for (zahl = 2; zahl <= limit; zahl++) {
            prim = true;
            while(counter < Math.sqrt(zahl) + 1) {
                counter++;

                if (zahl % counter == 0) {
                    prim = false;

                } else if (prim) {
                    System.out.println(zahl + " ");
                }
            }
        }
    }
}

...zur Frage

Reihenfolge von Java-Code?

Das hier ist mein Java-Code, um ein Schachbrett auszugeben:

public class Chess {
  public static void main(String[] args) {
    int n = Integer.parseInt(args[0]);
    int m = Integer.parseInt(args[0]);

    for (int k = 1; k <= m; k++) {
      for (int i = 1 ; i <= n; i++) {
        if ((i + k) % 2 != 0)
          System.out.print(" ");
        else
          System.out.print("*");
      }

      System.out.print("\n");
    }

Dieser funktioniert soweit auch, nur muss ich noch einbauen das ein ERROR, also

System.out.println("ERROR");

ausgegeben wird, wenn kein Input gegeben wird.

Ich weiß aber nicht, wo ich das in dem Code einbauen muss.

Das hier müsste ich einbauen:

if (args.length == 0)
  System.out.println("ERROR");

Ich hoffe, mir kann da jemand helfen.

...zur Frage

Was möchtest Du wissen?

Deine Frage stellen