Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Naja, die Klasse, die den String "macht", könnte 'static' sein und dann von der anderen aufgerufen werden oder der anderen wird eine Referenz auf sie als Object übergeben, z.B. im Konstruktor oder via setter. Dann noch evtl. importen und gut ist. Nicht?
Naja es geht hier doch noch ein bisschen weiter, weil ich habe festgestellt, dass ichs immer noch nicht gepeilt habe ???:L
Also Ich habe 3 Klassen:
Java:
public class K1 {
public int a;
public k1 () {
a = 10;
System.out.println(""+a);
}
}
Java:
public class K2 {
public k2 () {
a = ??? //Wie kann ich hier a verwenden?
//Hinweis: Ich habe eigentlich mehrere Variable, die ich übergeben möchte.
}
}
Java:
public class C {
public static void main(String[] args) {
K1 k1 = new K1 ();
K2 k2 = new K2 ();
//Reicht das, um die beiden Klassen auszuführen?
}
}
Von der Klasse K1 möchte ich (mehrere) Variablen in der Klasse K2 verwenden. Zusätzlich möchte ich diese beiden Klassen mit der dritten C ausführen.
public class K2 {
private K1 k1;
public K2 (K1 k1) {
this.k1 = k1;
}
public void doIt () {
System.out.println(k1.a); // Besser wäre hier ein getter: getA()
}
}
Beim instantiieren übergibst du dann die Referenz:
Naja es geht hier doch noch ein bisschen weiter, weil ich habe festgestellt, dass ichs immer noch nicht gepeilt habe ???:L
Also Ich habe 3 Klassen:
Java:
public class K1 {
public int a;
public k1 () {
a = 10;
System.out.println(""+a);
}
}
Java:
public class K2 {
public k2 () {
a = ??? //Wie kann ich hier a verwenden?
//Hinweis: Ich habe eigentlich mehrere Variable, die ich übergeben möchte.
}
}
Java:
public class C {
public static void main(String[] args) {
K1 k1 = new K1 ();
K2 k2 = new K2 ();
//Reicht das, um die beiden Klassen auszuführen?
}
}
Von der Klasse K1 möchte ich (mehrere) Variablen in der Klasse K2 verwenden. Zusätzlich möchte ich diese beiden Klassen mit der dritten C ausführen.
Zu allererst musst du darauf achten, dass die namen der Konstruktoren groß geschrieben werden müssen. Also
Java:
public class K1 {
public K1() {}
}
Dann eine andere Sache: Klassen lassen sich nicht "ausführen" oder so. Eine Klasse beinhaltet bestimmte Methoden, die ausgeführt werden können. Ein Beispiel:
Java:
public class ClassA
{
private int x = 0;
public ClassA() {
x = 0;
System.out.println("x mit " + x + " initialisert");
}
public void increaseX() {
x++;
}
public void doSomething() {
System.out.println("Zahl: " + x);
}
}
public class ClassB
{
public ClassB() {
ClassA a = new ClassA(); //Ausgabe müsste sein 'X wird mit 0 initialisert'
a.increaseX(); //keine Ausgabe
a.doSomething(); //Ausgabe 'Zahl: 1
}
public void increaseAndOutput(ClassA a) {
a.increaseX();
a.doSomething();
}
}
Hier wird in der Methode ClassB.increaseAndOutput(Class A) ein Objekt von ClassA verwendet, und x wird erhöht und ausgegeben. Du kannst, wenn du mehrere Objekte von einer Klasse brauchst, auch solche Methoden schreiben:
Java:
public void doSomething(ClassA a1, ClassA a2, int i, int x ....) {
}
public class K2 {
private K1 k1;
public K2 (K1 k1) {
this.k1 = k1;
}
public void doIt () {
System.out.println(k1.a); // Besser wäre hier ein getter: getA()
}
}
Das Problem ist eben noch, dass ich jetzt die beiden Klassen habe und die "getauschten" Variablen nicht gleich wieder Fehler spucken...
Jetzt würde ich gerne eine weitere Klasse zusammenbauen, die die beiden Methoden in den Klassen ausführt, ich habe es so probiert wie unten beschrieben, es funktioniert aber nicht, Fehlermeldung: The constructor K1() is undefined
Die Klasse:
Java:
public class C {
public static void main(String[] args) {
K1 k1 = new K1 ();
K2 k2 = new K2 ();
}
}
Was habe ich wieder versiebt? Ich sehe keinen Fehler mit den Namen
Du solltest dich erstmal schlau machen, was der Compiller dir sagt
Dann schaust du in die Klassen und stellst fest, dass beide K1 und K2 jeweils nur einen Konstruktor haben, der einen Parameter hat. Danach siehst du in der Main Methode, dass die Objekte die du da erzeugst, keine Parameter übergeben bekommen.
Das zu fixen, sollte dann doch kein Problem sein, oder?
Habe ich das richtig verstanden, dass ich in der Main-Methode die Parameter angeben muss, die ich übergebe/zurückbekomme?
Ich habe mal die Compiler-Vorschläge durchprobiert, dort kommen dann eben die Parameter hinten in die Klammern und er will noch Exceptions hinzufügen, habe ich gemacht und jetzt kommt immer die Meldung es gäbe eine Exception in der Main-Methode:
java.lang.NullPointerException
Was heisst das?
Und wie kann man das lösen?
(Beim Ersten aufrufen habe ich hinten in der Klammer "null" und beim 2. dann den Parameter vom 1...
Langsam verstehe ich übrigends gar nichts mehr :autsch:???:L
in diesem Fall geht es darum, dass du in deinen Klassen K1 und K2 jeweils einen Konstruktor hast, der erfordert, dass er Objekt der jeweils anderen Klasse entgegen nimmt.
Ich habe mal die Compiler-Vorschläge durchprobiert, dort kommen dann eben die Parameter hinten in die Klammern und er will noch Exceptions hinzufügen, habe ich gemacht und jetzt kommt immer die Meldung es gäbe eine Exception in der Main-Methode: java.lang.NullPointerException
Was heisst das?
Und wie kann man das lösen?
NullPointerExceptions heißen, dass du versuchst an ''null'' etwas aufzurufen:
Java:
String s = null;
s.length(); // Wirft eine N.P.E. da "s" null ist
Du übergibst einer Klasse da als Parameter null und rufst darauf etwas auf. Das kann man entweder damit lösen, dass man prüft, ob etwas null ist, oder indem man dafür sorgt, dass null nie vorkommt.
(Beim Ersten aufrufen habe ich hinten in der Klammer "null" und beim 2. dann den Parameter vom 1...
Langsam verstehe ich übrigends gar nichts mehr :autsch:???:L
Du solltest dich hier fragen: Warum muss K1 Daten von K2 haben und umgekehrt?
Einfacher wäre es, wenn du z.B. K1 noch einen Konstruktor gibst, der keinen Parameter benötigt.
Wenn du mal natürlichsprachlich erklären kannst, was K1 und K2 machen sollen ist es leicht sowas zu modellieren. Im praktischen Fall hat man nur (ganz ganz ganz)^10 selten den Fall, dass es so einen Zyklus (K1 braucht Objekt von K2, K2 braucht Objekt von K1) gibt und selbst dann, sollte man das vermeiden.
import java.net.SocketException;
public class EnCrypt {
public int p;//Grosse Primzahl p, es gilt p = 2*q +1, öffentlich
public int a;//Primitivwurzel von p, öffentlich
public int y1;//Teilschlüssel 1 (aus a und k1), öffentlich
public int c1;//1. Teil der verschlüsselten Nachricht (aus a und k1 bzw. k2 mod p)
public int c2;//2. Teil der verschlüsselten Nachricht (aus s und m mod p)
private int m;//Erkennungsmerkmal eines Netzteilnehmers (zu verschlüsselnde Zahl), 0<=m<=p-1, geheim
private int k1;//Zufällige Zahl zwischen 0 und p-1 (Teilnehmer A), geheim
private int s;//Geheimer, gemeinsamer Schlüssel (aus a, k1 und k2 mod p), geheim
//Referenz DeCrypt
private DeCrypt deCrypt;
public EnCrypt (DeCrypt deCrypt) {
//Referenz DeCrypt
this.deCrypt = deCrypt;
//Primzahl P (öff)
p = 11;
//Primitivwurzel a (öff)
a = 7;
//geh. Zahl k1
k1 = (int) (Math.random()*(p-1));
//Teilschlüssel (öff)
y1 = (a^k1)%p;
//gemeinsamer Schlüssel s (geh.)
s = ((deCrypt.y2)^k1)%p;
//Mac-Address
m = 4;
//1. Teil der Nachricht (öff)
c1 = (a^k1)%p;
//2. Teil der Nachricht (öff)
c2 = (s*m)%p;
//Kontrollausgabe
System.out.println("Verschlüsselung");
System.out.println("Nachricht 1: "+c1);
System.out.println("Nachricht 2: "+c2);
System.out.println("Nachricht Ursprung: "+m);
System.out.println("Schlüssel: "+s);
}
}
Java:
public class DeCrypt {
private int m;//Erkennungsmerkmal eines Netzteilnehmers (zu verschlüsselnde Zahl), 0<=m<=p-1, geheim
private int k2;//Zufällige Zahl zwischen 0 und p-1 (Teilnehmer B), geheim
public int y2;//Teilschlüssel 2 (aus a und k2), öffentlich
private int s;//Geheimer, gemeinsamer Schlüssel (aus a, k1 und k2 mod p), geheim
//Referenz EnCrypt
private EnCrypt enCrypt;
public DeCrypt (EnCrypt enCrypt) {
//Referenz DeCrypt
this.enCrypt = enCrypt;
k2 = (int) (Math.random()*(enCrypt.p-1));
y2 = (enCrypt.a^k2)%enCrypt.p;
s = (enCrypt.c1^k2)%enCrypt.p;
m = enCrypt.c2/s;
//Kontrollausgabe
System.out.println("Entschlüsselung");
System.out.println("Nachricht1: "+enCrypt.c1);
System.out.println("Nachricht2: "+enCrypt.c2);
System.out.println("Nachricht Ursprung: "+m);
System.out.println("Schlüssel: "+s);
}
}
Java:
import java.net.SocketException;
public class MainICrypt {
public static void main(String[] args) throws NumberFormatException, SocketException {
EnCrypt ec = new EnCrypt (null);
DeCrypt dc = new DeCrypt (ec);
}
}
Und was gibt es sonst noch alles am anfängercode auszusetzen?
Eine Instanz von DeCrypt, die du zu dem Zeitpunkt aber noch nicht hast.
Du könntest die Instanz nach dem erstellen per setter setzen oder du entkoppelst die beiden Klassen. Eine <-> Beziehung macht nur in wenigen Fällen wirklich sinn.
Kleine Brötchen backen, die allmählich immer größer werden bringt im programmieren sehr viel mehr Spaß als sich ohne Grundverständnis an größere Sachen heranzutrauen... Ich war vor nicht allzu langer Zeitr genauso. Guck dir mal sowas an wie Sichtbarkeit von Variablen, das was überhaupt in Variablen gespeichert wird (primitive/komplexe Datentypen) Parameter in Methoden usw... ist jetzt nicht böse und ich bin noch lange nicht das was man als gut bezeichnen würde, aber nimm dir das mal zu Herzen, mir hat's auch geholfen
MfG
öhm ich hab die Suchen-Funktion hier auch grade gefund, sorry. Mit deinem Verweis auf den anderen Beitrag hat sich das Ganze erledigt danke
