Methode um 2D-Punkt zu verschieben

OK, ich glaube ich hab’s jetzt. System.out.println benötigt das toString() Objekt und die Referenz darauf, das hatte ich jedoch noch nicht erzeugt in meinem Code.

Bei einem Point Objekt (java.awt.point) wird de toString() Methode automatisch aufgerufen, deshalb gibt System.out.println hier immer die Koordinaten aus.
d
Da ich in meinem Code nicht mit einem Point Objekt arbeite (sondern ein eigenes 2D Objekt Namens Punkt definiere) , musste ich das toString() Objekt und die Referenz darauf erst erzeugen.

Korrigiert mich bitte, wenn ich falsch liegen sollte.
@CyborgBeta : hatt vergessen mich einzuloggen :smiley:

die Begriffe hapern noch deutlich, toString() ist eine Methode, kein Objekt oder Referenz,
wird nicht erzeugt (man erzeugt Objekte), sondern definiert/ in die Klasse hineingeschrieben

toString() wird bei allen Klassen automatisch aufgerufen, es ist nur die Frage was sie dann liefert,
bei Point explizit was schönes, da Methode überschrieben ist,

bei dir greift bisher die Methode der obersten Klasse Object:

	return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }```

Rückgabe der Methode ist in der Tat ein (oftmals neu erzeugtes) Objekt, ein String

Ich hab’ mal etwas Zeit invertiert und eine Klasse Rechteck geschrieben, mit der du etwas mehr starten könntest als mit nur Punkt (Kritik wie immer erwüscht):

 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package javaapplication1;           // auch ohne Package

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import javax.swing.JFrame;
import javax.swing.WindowConstants;

/**
 * @author CB
 */
public class Rect extends Canvas {

    private int width = 2;          // nicht sichtbar in sub class
    private int height = 3;
    private int x0 = 4;
    private int y0 = 5;
    private int x1 = x0 + width;    // ab hier(<-) nicht so wichtig
    private int y1 = y0;
    private int x2 = x0 + width;
    private int y2 = y0 + height;
    private int x3 = x0;
    private int y3 = y0 + height;

    public Rect() {                 // ueberschreibt default constructor
        recalc();
    }

    public final void rescale(int a, int b) { // nicht ueberschreibbar
        this.width = this.width + a;
        this.height = this.height + b;
        recalc();
    }

    public final void shift(int a, int b) {
        this.x0 = this.x0 + a;
        this.y0 = this.y0 + b;
        recalc();
    }

    private void recalc() {
        x1 = x0 + width;
        y1 = y0;
        x2 = x0 + width;
        y2 = y0 + height;
        x3 = x0;
        y3 = y0 + height;
        int foobar = 50;
        this.setPreferredSize(new Dimension((x0 + width) * foobar + 12, (y0 + height) * foobar + 12));
    }

    @Override
    public final void paint(Graphics g) {
        super.paint(g);
        g.setColor(Color.RED);
        int foobar = 50;
        g.drawRect(foobar * x0, foobar * y0, foobar * width, foobar * height);
    }

    @Override
    public String toString() {
        return "Rect{" + "width=" + width + ", height=" + height + ", x0=" + x0 + ", y0=" + y0 + ", x1=" + x1 + ", y1=" + y1 + ", x2=" + x2 + ", y2=" + y2 + ", x3=" + x3 + ", y3=" + y3 + '}';
    }

    public static void main(String[] args) {
        Rect r = new Rect();
        System.out.println("r = " + r);
        r.shift(-3, -4);
        System.out.println("r = " + r);
        JFrame jf = new JFrame(r.toString());
        jf.add(r);
        jf.pack();
        jf.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
        jf.setVisible(true);
    }
}```

soviele Instanzattribute + recalc() ist etwas unschön,
stark zu bedenkende Alternative ist, erst dynamisch wenn benötigt anderes zu berechnen:
getX2() -> return x0 + width;
usw.

@CyborgBeta : ja cool, Danke…werde ich gleich mal umsetzen und mich da reindenken.

Hier wer von Euch eventuell Interesse hat:

ich bin im Buch Java ist eine Insel gerade bei Kapitel 3.5. ZZZZZnake…

Das ist ein Spiel, hier Der Link:

http://openbook.galileocomputing.de/javainsel/javainsel_03_005.html#dodtpb94d3a89-43d4-45b2-90a6-a0371fb3ed23

Am Ende wird noch eine kleine Hausaufgabe gegeben:

Wer Lust hat, an der Aufgabe noch ein wenig weiter zu programmieren, der kann Folgendes tun:

Geht der Spieler über das Gold, soll es vom Spielfeld verschwinden
Statt nur einem Stück Gold soll es zwei Stücke geben.
Statt einer Schlange soll es zwei Schlangen geben.
Mit zwei Schlangen und zwei Stücken Gold kann es etwas eng für den Spieler werden. Er soll daher 5 Züge machen können, ohne dass die Schlangen sich bewegen.
Wenn der Spieler ein Goldstück einsammelt, soll die Länge der Schlange um eins schrumpfen.
Für Vorarbeiter: Das Programm, das bisher nur eine Methode ist, soll in verschiedene Untermethoden aufgespalten werden.

Ich möchte den Code so gestalten, dass die Schlange (welche noch aus einem Symbol besteht), wenn der Spieler Gold eingesammelt hat, einen Schritt zurückgeht. Deshalb meine Frage mit dem verschieben eines Punktes. Was mir jedoch nicht klar ist: wenn die Methode so heissen soll wie die Klasse, muss es dann zwei Klassen geben (eine für die shift methode, und eine wo der Code des Spieles drinn ist?), bzw. kann ich einen code aus mehereren Klassen schreiben ?

Gruß

*** Edit ***
@CyborgBeta : habe den Code nun eingegeben und mit javac umgesetzt, jedoch lädt der compiler die class Datei nicht:

Fehler: Hauptklasse Rect konnte nicht gefunden oder geladen werden

Habe eigentlich die Klasse aufgeführt:


import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import javax.swing.JFrame;
import javax.swing.WindowConstants;

/**
*@author CB
*/
public class Rect extends Canvas {

private int width = 2;
private int height = 3;
private int x0 = 4;
private int y0 = 5;
private int x1 = x0 + width;
private int y1 = y0;
private int x2 = x0 + width;
private int y2 = y0 + height;
private int x3 = x0;
private int y3 = y0 + height;

public Rect() {
recalc();
}

public final void rescale( int a, int b ) {
this.width = this.width + a;
this.height = this.height + b;
recalc();
}

public final void shift( int a, int b ) {
this.x0 = this.x0 + a;
this.y0 = this.y0 + b;
recalc();
}

private void recalc() {
x1 = x0 + width;
y1 = y0;
x2 = x0 + width;
y2 = y0 + height;
x3 = x0;
y3 = y0 + height;
int foobar = 50;
this.setPreferredSize( new Dimension( ( x0 + width ) * foobar + 12, ( y0 + height ) * foobar + 12 ) );
}
@Override

public final void paint( Graphics g ) {

super.paint( g );
g.setColor( Color.RED );
int foobar = 50;
g.drawRect( foobar * x0, foobar * y0, foobar * width, foobar * height );
}
@Override
public String toString() {
return "Rect(" + "width=" + width + ", height=" + height + ", x0=" + x0 + ", y0=" + y0 + ", x1=" + x1 + ", y1=" + y1 + ", x2=" + x2 + ", y2=" + y2 + ", x3=" + x3 + ", y3=" + y3 + '}';
}

public static void main( String[] args ) {

Rect r = new Rect();
System.out.println( "r = " + r );
r.shift( -3, -4 );
System.out.println( "r = " + r );
JFrame jf = new JFrame( r.toString() );
jf.add(r);
jf.pack();
jf.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE );
jf.setVisible( true );
}
}```

Ich hab mir schon so was gedacht: Schreibe in die Datei Rect.java:

import javax.swing.*;

/**
 * @author CB
 */
public class Rect extends Canvas {

    private int width = 2;          // nicht sichtbar in sub class
    private int height = 3;
    private int x0 = 4;
    private int y0 = 5;
    private int x1 = x0 + width;    // ab hier(<-) nicht so wichtig
    private int y1 = y0;
    private int x2 = x0 + width;
    private int y2 = y0 + height;
    private int x3 = x0;
    private int y3 = y0 + height;

    public Rect() {                 // ueberschreibt default constructor
        recalc();
    }

    public /*final*/ void rescale(int a, int b) { // nicht ueberschreibbar
        this.width = this.width + a;
        this.height = this.height + b;
        recalc();
    }

    public /*final*/ void shift(int a, int b) {
        this.x0 = this.x0 + a;
        this.y0 = this.y0 + b;
        recalc();
    }

    private void recalc() {
        x1 = x0 + width;
        y1 = y0;
        x2 = x0 + width;
        y2 = y0 + height;
        x3 = x0;
        y3 = y0 + height;
        int foobar = 50;
        this.setPreferredSize(new Dimension((x0 + width) * foobar + 12, (y0 + height) * foobar + 12));
    }

    @Override
    public /*final*/ void paint(Graphics g) {
        super.paint(g);
        g.setColor(Color.RED);
        int foobar = 50;
        g.drawRect(foobar * x0, foobar * y0, foobar * width, foobar * height);
    }

    @Override
    public String toString() {
        return "Rect{" + "width=" + width + ", height=" + height + ", x0=" + x0 + ", y0=" + y0 + ", x1=" + x1 + ", y1=" + y1 + ", x2=" + x2 + ", y2=" + y2 + ", x3=" + x3 + ", y3=" + y3 + '}';
    }

    public static void main(String[] args) {
        Rect myRect = new Rect();
        System.out.println("myRect = " + myRect);
        myRect.shift(-3, -4);
        System.out.println("myRect = " + myRect);
        JFrame jf = new JFrame(myRect.toString());
        jf.add(myRect);
        jf.pack();
        jf.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
        jf.setVisible(true);
    }
}```

Compiliere (und starte) mit (mit Ausgabe):


C:\Users\HinzUndKunz>cd Desktop

C:\Users\HinzUndKunz\Desktop>javac Rect.java

C:\Users\HinzUndKunz\Desktop>java Rect
myRect = Rect{width=2, height=3, x0=4, y0=5, x1=6, y1=5, x2=6, y2=8, x3=4, y3=8}

myRect = Rect{width=2, height=3, x0=1, y0=1, x1=3, y1=1, x2=3, y2=4, x3=1, y3=4}

C:\Users\HinzUndKunz\Desktop>



Fenster:



Dateien:



Oder erstelle einfach ein JaR. Vollziehe alle Stellen nach und bei Stellen dann fragen. Grüße.

Edit: Achso, was nach rechts oben geht, wird nach rechts unten gezeichnet, hier ist die Spiegelung an der x-Achse (width), und das ist so, weil 0,.0 der erste Punkt auf dem Display ist.

Ich würde mich nicht zu lange mit dem ZZZZZnake aufhalten und mal die weitern Kapitel durcharbeiten. Du beschäftigst Dich ja bereits mit eigenen Klassen und die sind erst ab Kapitel 5 dran. Also: erst einmal bis dahin vorarbeiten und dann wenn man wirklich Lust hat dieses Thema nochmal aufgreifen.

Wie kommst Du darauf? Ein Methode sollte niemals so heißen wie die Klassen! In Java gibt es Code Konventionen die weitestgehend von allen Programmierern akzeptiert und erwartet werden.

Es ist durch aus üblich Code in Mehrere Klassen aufzuteilen. Java ist eine objektorientierte Sprache und es werden üblicherweise eigenständige Objekte in eigenen Klassen abgebildet. Aber soweit bist Du in Kapitel 3 noch nicht und Erfahrungen in anderen (OO) Programmiersprachen scheinst Du noch nicht zu haben. Von daher mein erster Rat: Erst einmal weiter büffeln.

Hallo,
@CyborgBeta : Danke Dir, werde ich ausprobieren!
@Guest: Danke, werde ich so machen. Wollte nur schauen, ob ich die Erweiterungen von ZZZZZnake selbstständig mit meinem bereits vorhandenem Kno How hinbekomme (kann etwas VBA).

by the way: kann vielleicht jemand sagen, wie das mit den Packages und genauen Klassen funktioniert ? Das wir in dem Buch meiner Meinung nach nicht gut erklärt. Hier das Beispiel aus dem Buch:

package com.tutego;

import java.util.Date;

public class DatePrinter
{
public static void printCurrentDate()
{
System.out.printf( “%tD%n”, new Date() );
}
}

Demnach müsste sich das Package auf der Website Tutego.com befinden ? Wie mache ich das wenn ich auf meinem Mac in den eigenen Dateien einen Package Ordner anlege, indem ich die Klassen abspeicher. Was müsste dann oben in der Klasse stehen ? Z.B. für Package (Ordner) Klassen.

package user.Coffeeboy.Klassen

oder ?

Danke und Gruß

Nein. Du kannst deine Packages benennen, wie du selbst möchtest. Solltest dir halt ne sinnvolle Struktur überlegen. Ist halt ähnlich wie eine Art Ordnerstruktur, um zusammengehörende Klassen in dem gleichen Package zu sammeln. Um eine Eindeutigkeit bezüglich Klassen- oder Package-Namen bei späterer Weiterverbreitung oder -entwicklung von eigener Software zu erreichen, gibt es die Möglichkeit, seinen eigenen Domainnamen in die Packagestruktur einzubeziehen, da dieser Domainname einmalig ist. Ist doch bestimmt in deinem Buch irgendwo beschrieben…

OK, hab’s in der Insel gefunden:

Der Aufbau von Paketnamen

Prinzipiell kann ein Paketname beliebig sein, doch Hierarchien bestehen in der Regel aus umgedrehten Domänennamen. Aus der Domäne zur Webseite http://tutego.com wird also com.tutego. Diese Namensgebung gewährleistet, dass Klassen auch weltweit eindeutig bleiben. Ein Paketname wird in aller Regel komplett kleingeschrieben.

sich nicht an Java-Tags zu halten ist aktive Sabotage an Lesern…,
zitiere ein anderes Posting um den Aufbau zu sehen falls noch nicht bekannt

packages immer klein schreiben, ‘Klassen’ brauchst du kaum, jedes package enthält Klassen, sonst höchstens ein Unterverzeichnis,
die Benennung ist im Grunde egal, ‘test’ reicht genauso sofern die kein zwingender Grund (für sich gibts keinen) oder Wunsch entgegensteht

default-package/ Klassen ohne package-Angaben sind das einfachste, aber leider mit gewissen Haken:
Klassen IN einem package können keine Klassen OHNE package importieren…,
insofern immer etwas kritisch und Empfehlung nicht recht möglich

Hallo,

an alle die interessiert sind. Ich habe das mit dem Package geschafft :smiley:

Dabei habe ich die Klasse, die aufgerufen wird DatePrinter im Package Paket in meinem Benutzerordner abgelegt:

Coffeeboy/Paket/DatePrinter.java

Die erste Zeile der in der DatePrinter.java Datei dabei ist:

package Paket;

Die Klasse, die darauf zugreift (DatePrinterUser) befindet sich dabei im übergeordneten Verzeichnis Coffeboy (mein Benutzerverzeichnis), also:

Coffeeboy/DatePrinterUser.java

von hier aus rufe ich die Klasse DatePrinterUser im Terminal auf, und diese Klasse greift dann auf DatePrinter zurück.

Weiter gehts…:smiley:

Da muss ich Slater zustimmen. Selbst ,wenn es erste Gehversuche in JAVA sins, sollte man wenigstens den und-Tag eingügenf, zumal das schon von two Persons angemerkt wurde. Alles im allen kann man die Frage jetzt nicht mehr ernst nehmen.

Aber dennoch: package und package-Struktur kannst du erst mal weglassen, und ,insofern es einfacher ist, kannst du private, public usw. auch erst mal weglassen. Importieren tust du mit java.util.; , java.io.; usw. Alles in java.lang. braucht gar nicht importiert werden. Jetzt kannst du mit Datentypen und einfachen Objekten weitermachen.

Hallo,

hab’s nicht gecheckt mit den Java-Tags. Werde ich ab jetzt machen.

Gruß und schöne Feiertage an alle!

Kar-Freitag und -Samstag gilt genau als Stiller Feiertag. Schön muss er nicht unbedingt sein… Aber danke für deine Grüße, ich denke mal, du schaust hier wieder vorbei.^^ Bis dann.

Edit: Jetzt habe ich einenm Fachbeitrag einfach so abgestaubt. :slight_smile:

Klar, sobald sich eine Frage ergibt, werde ich hier fortführen, und meine neuen homies aus der Byte Welt um Rat fragen. ;)…habe auch das Gefühl, dass es gar nicht so lange dauern wird :smiley:

Gruß

Wir geben Tipps und Tricks zu/in/zu allen Lebenslagen, Sie sollten uns einfach darauf ansprechen.

[QUOTE=Coffeeboy]Hallo,

an alle die interessiert sind. Ich habe das mit dem Package geschafft :smiley:

Dabei habe ich die Klasse, die aufgerufen wird DatePrinter im Package Paket in meinem Benutzerordner abgelegt:

Coffeeboy/Paket/DatePrinter.java

Die erste Zeile der in der DatePrinter.java Datei dabei ist:

package Paket;

Die Klasse, die darauf zugreift (DatePrinterUser) befindet sich dabei im übergeordneten Verzeichnis Coffeboy (mein Benutzerverzeichnis), also:

Coffeeboy/DatePrinterUser.java

von hier aus rufe ich die Klasse DatePrinterUser im Terminal auf, und diese Klasse greift dann auf DatePrinter zurück.

Weiter gehts…:D[/QUOTE]

Wie schon erwähnt wurde, sollten Paketnamen komplett kleingeschrieben werden.