Sichtbarkeit - Modifier

maxxi

Bekanntes Mitglied
Hi!

Ich würd gern einen Blick in die Vergangenheit werfen :)

Angeblich soll es zu den Urzeiten Javas 2 unterschiedliche Arten des private-Modifiers gegeben haben.

Das heutige - und einzige private - ist ja nicht so privat, wie man das auf den ersten Blick vielleicht vermuten würde. Beliebige Objekte einer gemeinsamen Klassen haben direkten Zugriff auf private deklarierte Eigenschaften und Methoden von Objekten der gleichen Klasse.

Es soll ursprünglich jedoch auch ein anderes private angedacht gewesen sein. Bei dieser Form sollte alles private deklarierte wirklich privat sein. D. h. ausschließlich nur das eigene Objekt konnte dann darauf zugreifen.

Ich suche nun die Bezeichnung dieses Modifiers. Neben private, public und protected soll es also noch etwas zusätzliches gegeben haben, worüber man die Sichtbarkeit steuern konnte.
 
Zuletzt bearbeitet:
H

hüteüberhüte

Gast
default hast du vergessen. Du meinst, eine Klasse kann Variablen eines anderen Objekts gleichen Typs sehen?
 

maxxi

Bekanntes Mitglied
Du meinst, eine Klasse kann Variablen eines anderen Objekts gleichen Typs sehen?
Ja genau. So ist das heutige private definiert (nicht nur in Java).

Aber ich suche den Namen dieser anderen private-Variante, die es angeblich ursprünglich gegeben haben soll.
 

maxxi

Bekanntes Mitglied
Danke für den Link, aber diese Seite hatte ich schon gesehen. Dort ist dieser Modifier, den ich suche, nicht aufgelistet.
 

maxxi

Bekanntes Mitglied
Ich glaube nicht, dass es das ist, was ich suche. Dort scheint eine spezielle Variante vom protected beschrieben zu werden. Ich suche aber diese spezielle Variante von private (die es angeblich gegeben haben soll).
 

D4rkscr43m

Bekanntes Mitglied
was soll dieser private modifier denn gemacht haben?

private - Sichtbarkeit in Klasse
default - Sichtbarkeit in Klasse und Package
protected - Sichtbarkeit in Klasse, Package und Ableitungen
public - Sichtbarkeit überall

mit dem private protected gäbe es noch einen, der Sinn macht. Sonst kann ich mir aber keinen vorstellen.
 
Zuletzt bearbeitet:
N

nillehammer

Gast
Habe nie davon gehört, dass die Zugriffsmodifizierer jemals anders waren als heute. Bin aber auch erst bei Java 1.4 eingestiegen, also möglicherweise zu spät, um das noch mitbekommen zu haben.

D4rkscr43m hat gesagt.:
mit dem private protected gäbe es noch einen, der Sinn macht. Sonst kann ich mir aber keinen vorstellen.
Ich glaube, der TO ist auf der Suche nach sowas wie "instance private", damit sowas hier nicht geht:
Java:
public class Mensch {

  private int age;

  public int compareTo(Mensch other) {
    // weil selbe Klasse, kann auf private 
    // variable einer anderen instanz zugegriffen werden
    // und damit invarianten verletzt werden
    other.age = -1000;
 }
Ich sehe genauso wie D4rkscr43m keinen Nutzen in so einem Modifier. Immerhin kann ja nur der Autor der Klasse selbst so einen schädlichen Code schreiben.
 
Zuletzt bearbeitet von einem Moderator:
T

TryToHelp

Gast
...
Ich sehe genauso wie D4rkscr43m keinen Nutzen in so einem Modifier. Immerhin kann ich ja nur der Autor der Klasse selbst so einen schädlichen Code schreiben.
Sehe ich auch so, der Sinn der Sichtbarkeit ist ja für andere Programierer, die meinen Code verwenden und die sollen schließlich meiner getter und setter verwenden und nicht direkt in meinen Objekten rumfuschen, aber wenn es die selbe Klasse ist, dann ist das mein code und ich habe mir dann ja dabei was gedacht und somit ist es in ordnung, wenn ich das nicht will, dann mache ich das nicht und es passiert nicht.
 

maxxi

Bekanntes Mitglied
@nillehammer
Ja, du hast das von mir angesprochene Thema richtig verstanden.
Angeblich gab es zu den Anfängen von Java einen anderen Modifier, wo man dann nicht mehr auf other.age zugreifen konnte.

Ich sehe genauso wie D4rkscr43m keinen Nutzen in so einem Modifier
Wenn ich das richtig verstanden hatte, hatten es die Java-Entwickler auch so gesehen und darum diesen speziellen modifier gestrichen.

Immerhin kann ja nur der Autor der Klasse selbst so einen schädlichen Code schreiben.
Das war auch die Aussage des Professors auf der Uni. Von ihm kam auch der Hinweis darauf, dass es früher so einen zusätzlichen speziellen Modifier gegeben haben soll.

Allerdings bin ich da nicht unbedingt ganz seiner Meinung. Hier ein Zitat aus einem Buch, mit dem wir an der UNI lernen:
Eine Methode darf den Zustand eines Objekts niemals auf unerwartete Weise ändern.

Beispielsweise darf eine Methode wie "entfernung" zur Berechnung des Abstands zwischen 2 Punkten die Koordinaten dieser Punkte nicht ändern.
Hierzu ein Programm:
Java:
public class Punkt {
   private float x;   
   private float y;
   public Punkt(float x, float y) {
      this.x = x;
      this.y = y;
   }
   public float entfernung(Punkt other) {
      float dX = x - other.x; // Direkter Zugriff auf private Eigenschaften
      float dY = y - other.y; // anderer Instanzen der gleichen Klasse.
      return Math.sqrt(dY * dX + dY * dY);
   }
}
Ich glaube, hier ist alles korrekt programmiert. Vermutlich machen das Profis so.

Zurück zum Buch-Zitat. Im Programm habe ich keine Möglichkeit zu verhindern, dass die eigene Instanz auch Änderungen an x und y von der other-Distanz vornimmt.

Sofern der Programmierer der Klasse Punkt keinen Fehler macht, wird es nie zu Problemen kommen.

Allerdings ist es in der Praxis so, dass eine bestimmte Klasse nicht nur von einem einzigen Programmierer programmiert wird. Normalerweise ändern oft mehrere Personen den Code einer Klasse. Darum finde ich es etwas riskant, die Verantwortung den Programmierern zuzuschieben.

Meiner Meinung nach wäre es besser, wenn das Programm selbst dafür verantwortlich wäre, dass gewisse Eigenschaften nicht verändert werden können. Und hier kommt dieser modifier ins Spiel, den es früher irgendwann mal gegeben haben soll.

Eigentlich kann es mir egal sein, ob die Wahl der modifier in Java gut getroffen wurde, ob es zusätzlich geben sollte oder gewisse modifier vielleicht total unnütz sind. Als Java-Programmierer muss man nur wissen, welche es gibt und wie sie funktionieren :)

Trotzdem würde mich der Name dieses modifiers interessieren. Falls euch auch nichts dazu einfällt, muss ich wohl den Professor nochmals darauf ansprechen. Vielleicht weiß er noch, wie dieser modifier damals geheißen hatte. Ich würd nämlich gerne eine kleine Randnotiz in meine Java-Notizen machen :)
 

Kar

Mitglied
In Scala kann man den Modifizierern einen Scope mitgeben.
private[this] ist wohl das, was du suchst. Allerdings habe ich noch davon gehört, dass es das auch in Java gab. ^^
 
B

bygones

Gast
Ich glaube, hier ist alles korrekt programmiert. Vermutlich machen das Profis so.
Zurück zum Buch-Zitat. Im Programm habe ich keine Möglichkeit zu verhindern, dass die eigene Instanz auch Änderungen an x und y von der other-Distanz vornimmt.

immutable ist das stichwort hier

Java:
public class Punkt {
   private final float x;   
   private final float y;
   public Punkt(float x, float y) {
      this.x = x;
      this.y = y;
   }
   public float entfernung(Punkt other) {
      float dX = x - other.x; // Direkter Zugriff auf private Eigenschaften
      float dY = y - other.y; // anderer Instanzen der gleichen Klasse.
      return Math.sqrt(dY * dX + dY * dY);
   }
}
nun kann man nur lesend darauf zugreifen
 
T

TryToHelp

Gast
...
Allerdings ist es in der Praxis so, dass eine bestimmte Klasse nicht nur von einem einzigen Programmierer programmiert wird. Normalerweise ändern oft mehrere Personen den Code einer Klasse. Darum finde ich es etwas riskant, die Verantwortung den Programmierern zuzuschieben.
...
Ja das schon, aber wenn die Programmierer-Gruppe die es programmiert murx macht, macht sie murks. das mit der sichtbarkeit betrifft den zugriff von anderen Klassen, die diese nur werwenden. Also so nach dem Prinziep wie du Bibliotheken verwendest. Der Programmierer der Klasse (oder die Gruppe an Programierern) denkt sich was dabei und alles ist ok, nur wenn dann diese Klasse von anderen verwendet wird, die benutzen sie eventuell Falsch und deswegen, sollen sie keinen direkten Zugriff haben, was sie ja auch nicht haben ;-)
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
K Sichtbarkeit protected: Attribute trotzdem aufrufbar. Java Basics - Anfänger-Themen 4
A OOP Komposition per Package-Sichtbarkeit Java Basics - Anfänger-Themen 2
melaniemueller Datenkapselung Sichtbarkeit public Java Basics - Anfänger-Themen 4
C Sichtbarkeit in Pakten Java Basics - Anfänger-Themen 2
Y JFrame sichtbarkeit Java Basics - Anfänger-Themen 4
Y Panels sichtbarkeit Java Basics - Anfänger-Themen 3
J Sichtbarkeit und Zugriff Java Basics - Anfänger-Themen 9
A Sichtbarkeit in Methoden/Listen Java Basics - Anfänger-Themen 3
W Sichtbarkeit vom Variablen, Klassen usw. Java Basics - Anfänger-Themen 3
P Klasse mit eingeschränkter Sichtbarkeit Java Basics - Anfänger-Themen 3
J Sichtbarkeit Variable in Schleife Java Basics - Anfänger-Themen 5
C OOP Aufruf von Methoden höherer Sichtbarkeit Java Basics - Anfänger-Themen 10
S Sichtbarkeit Problem Java Basics - Anfänger-Themen 10
J Sichtbarkeit von Objecten in JSP's Java Basics - Anfänger-Themen 7
L sichtbarkeit von checkboxen Java Basics - Anfänger-Themen 2
C OOP Vererbung und Sichtbarkeit Java Basics - Anfänger-Themen 14
B Konstruktoren Sichtbarkeit Java Basics - Anfänger-Themen 2
M Sichtbarkeit von Methoden Java Basics - Anfänger-Themen 7
A Allgemeine Frage zur Sichtbarkeit "private" Java Basics - Anfänger-Themen 5
C Überdecken von Attributen und Sichtbarkeit von Variablen Java Basics - Anfänger-Themen 8
H2SO3- sichtbarkeit con classen und functionen Java Basics - Anfänger-Themen 8
M Vererbung und Sichtbarkeit von Methoden Java Basics - Anfänger-Themen 7
R Sichtbarkeit von Methoden Java Basics - Anfänger-Themen 14
G konstanten leicht benutzen? (sichtbarkeit) Java Basics - Anfänger-Themen 17
G Deklaration und Sichtbarkeit von Variablen Java Basics - Anfänger-Themen 2
H statische methoden und sichtbarkeit Java Basics - Anfänger-Themen 13
B Sichtbarkeit von Variablen Java Basics - Anfänger-Themen 2
F Sichtbarkeit von Buttons un Frame Java Basics - Anfänger-Themen 7
M Sichtbarkeit von private Java Basics - Anfänger-Themen 2
G Sichtbarkeit von Variablen Java Basics - Anfänger-Themen 4
J protected und Standard Sichtbarkeit Java Basics - Anfänger-Themen 2
P Sichtbarkeit Java Basics - Anfänger-Themen 5
R Sichtbarkeit bei Vererbung Java Basics - Anfänger-Themen 2
K Sichtbarkeit von Komponenten prüfen Java Basics - Anfänger-Themen 5
M Access Modifier oder so ähnlich Java Basics - Anfänger-Themen 6
K modifier public Java Basics - Anfänger-Themen 3
Q Unterschied zwischen static und keinem Modifier Java Basics - Anfänger-Themen 15
O Main-Methode static modifier umgehen Java Basics - Anfänger-Themen 10
nrg OOP Konstruktor Modifier Java Basics - Anfänger-Themen 4
php1 Was bedeutet der Modifier static ? Java Basics - Anfänger-Themen 3
S Modifier Java Basics - Anfänger-Themen 8

Ähnliche Java Themen

Neue Themen


Oben