Zitat von Nachhilfe

...
jedit, den ich verwende, hat das zumindest und das ist weiß Gott kein all zu mächtiger Editor.

hmm. ich hab jedit längere zeit verwendet, und ich finde es ist
ein sehr mächtiges Tool:

• sehr intuitives User Interface.
  
• sehr viele bereits implementierte Funktionalität und extrem
  erweiterbar, durch eine sehr gut dokumentierte und offene API.
  
• Die Scriptsprache (beanshell) ist etwas ärmlich, aber durch
  ein Plugin kann man Makros auch mit groovy, jython, jruby oder
  javascript(rhino) schreiben.
  
• (relativ) aktive community

Vielleicht kein emacs oder vim. Aber dafür ist die Lernkurve
wesentlich niedriger.

Zitat von freakjan

...kennst jemand sowas?
gibts das überhaupt

einer, meiner

auf ruby quiz gibt es verschiedene loesungen, inklusive diskussion.

ein twoday.tuwien blogger, Roland Lezuo, hat mal einen in python geschrieben:

http://twoday.tuwien.ac.at/alias/stories/8519/

getested hab ich ihn aber nie.

Zitat von Blixa Barscheck

Poseidon for UML...

Anm.: Das basiert so weit ich weiss auf dem code von argouml, das ich schon angesprochen hatte.

fuer eclipse kenn ich nur Omondo , das ist auch schon in der freeversion ziemlich maechtig und unterstuetzt UML 2.0. Gerade wenn der fokus auf reverse engineering liegt, wuerd ich dir das empfehlen. Ansonsten kenn ich noch nicht-clipse basierte applicationen wie Jude oder ArgoUML. Jude ist sehr einfach und deshalb mein favorit. Mit ArgoUML konnte ich mich nie anfreunden.

Btw, ich suche auch schon laenger ein gutes tool, das aber nicht so sehr auf reverse engineering fixiert ist, sondern das sich auf das freie erstellen von
diagrammen (vor allem, aber nicht nur UML) spezialisiert. Also so in der art wie Visio oder Dia. Nur das Visio leider viel zu komplex ist und dia offensichtlich nicht mehr weiterentwickelt wird.

Derzeit ist mein bevorzugtes UML tool ein moleskine

Ein Recursiver algorithmus fuer die potenz von positiven, ganzen zahlen koennte z.b so aussehen:

public static int powerRecursive(int x, int y){
  return (y==0) ? 1 : x * powerRecursive(x, y-1); 
}

hier der selbe algorithmus auf mehrere zeilen aufgespalten. vielleicht ist das leserlicher:

public static int powerRecursive2(int x, int y){
    int result = 0;
    if(y == 0){
      result = 1;
    }else{
      result = x * powerRecursive2(x, y-1); 
    }
    return result;
  }

und hier ist ein iterativer ansatz:

public static int powerIter(int x, int y){
    int result = x;
    for(int i=1;i<y;i++){
      result = result * x;
    }
    return result;
  }

Aber achtung!

Es gibt einen unterschied zwischen einer rekursiven methode und einem rekursiven algorithmus.

eine rekursive methode ist eine methode, die sich selber aufruft. Ein rekursiver algorithmus drueckt die loesung durch sich selber aus.

Man kann einen iterativen algorithmus auch mit hilfe einer rekursiven methode ausdruecken:

public static int powerIter2(int x, int y) {
    return powerIter2Helper(x, y, 1);
  }




  public static int powerIter2Helper(int x, int y, int result) {
    if (y == 0) {
      return result;
    } else {
      return powerIter2Helper(x, y - 1, result * x);
    }
  }

hier druecke ich nicht das ergebnis durch sich selbst aus, sondern multipliziere die faktoren y mal, genauso wie ich es in powerIter gemacht habe. Ich habe halt nur das while konstrukt durch einen rekursiven aufruf ersetzt. der algorithmus ist aber immer noch der gleiche, also iterativ.

interressant ist hier noch, dass der iterative ansatz weniger speicher verbraucht als der rekursive. Rekursive algorithmen sind dafuer in der regel simpler und einfacher zu lesen. Zumindest wenn man mit rekursion etwas uebung hat.

Zitat von maciek

Gibt es in Java keine Möglichkeit, das Objekt zu finden, das ursprünglich den Aufruf durchgeführt hat?

Nein, denn das wuerde dem gedanken der modularitaet wiedersprechen: Du willst ja, das Objekte unabhaengig arbeiten, damit du sie ihn verschiedenen kontexten verwenden kannst. Wenn du den erzeuger doch merken willst, musst du das schon explizit machen:

public class ObjectA {
  public void XY() {
    ObjectB b = new ObjectB(this);
  }
}


public class ObjectB {
  private ObjectA caller;
  public ObjectB(ObjectA caller){
    this.caller = caller;
  }
}

Noch als anmerkung: wenn du variablen wie ein request object ueber mehrere ebenen hinweg benoetigst, ist das meistens ein zeichen fuer einen fehler im design.

Das kommt darauf an, was '==' fuer dich bedeutet:).

:= ist hier wohl ein zuweisungsoperator (also wie z.b. '=' in java)

Zitat von PeterS.

ich brauche ein textfeld, in welches nicht mehr als 20 zeichen engetragen werden können.

/*
 * Created on 04.01.2006
 * 
 * @author Benjamin Ferrari
 */


import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.PlainDocument;


public class SwingTest extends JPanel {


  private static final int LIMIT = 20;

  private JTextField textField = new JTextField(50);


  
  public SwingTest() {
    this.add(this.textField);
    this.textField.setDocument(new PlainDocument() {


      public void insertString(int offset, String str, AttributeSet attr)
          throws BadLocationException {
        if ((getLength() + str.length()) <= LIMIT) {
          super.insertString(offset, str, attr);
        }
      }


    });
  }


  public static void main(String[] args) {
    JFrame frame = new JFrame();
    frame.add(new SwingTest());
    frame.pack();
    frame.setVisible(true);
  }


}

Zitat von freakjan

Hallo :verycool:

wollte gerne wissen...
1. warum man überhaupt diesen SEMIKOLON immer benutzt :confused:

Das ist eine Anlehnung an die Sprachen c und c++, von denen java viel syntax geerbt hat.

Dadurch, dass jedes Statement durch ein zeichen abgeschlossen werden muss, lassen sich lange ausdruecke auf beliebig viele zeilen verschachteln:

new World()
      .getContinent("europe")
      .getCountry("austria")
      .getCity("vienna")
      .getBuilding("haas haus")
      .burn();

hier ein Beispiel fuer eine Variable, die meiner Meinung nach gueltig, aber nicht sichtbar ist:

class Life{
  private String meaning;
}


public class Test {

  public static void main(String[] args) {
    Life life = new Life(); // [1]
    System.out.println(life.meaning); // [2]
  }
}

Die variable 'meaning' ist nach dem aufruf [1] solange gueltig, solange eine referenz auf das object, das mit 'new Life()' erzeugt wurde, existiert. Sie kann aber in [2] nicht angesprochen werden, da sie von aussen nicht sichtbar ist.

s="IyBUaGFua3MgZm9yIGxvb2tpbmcgYXQgbXkgY29kZ
S4KIwojIENvcHlyaWdodCAoQykgMjAwMiAgQ2hyaXN0a
WFuI      E       5       l       d     Wtpc                                
mNoZ  W       4      gP       G       N obmV
1a2l      y       Y 2hlb  k       B     nbWF
pbC5  j       b    20+CiM     K       I yBUa
GlzI      H       Byb2dyYW        0     gaXM
gZnJ  l       Z  SBzb2Z0d2F   y       Z Tsge
W91I      G     NhbiByZWRpc3      R     yaWJ
1dGU  g        aXQgYW5kL29yCi M       g bW9k
aWZ5      I   Gl0IHVuZGVyIHRoZ    S     B0ZX
Jtcy  B      vZiB0aGUgR05VIEdlb       m VyYW
wgUH      V      ibGljIExpY       2     Vuc2
UuCg  p       T VERPVVQuc3lu  Y       y A9IH
RydW      U    KZDEsIGQyID0gM     C     4xNS
wgMC  4       wNgpzID0gIk1lcnJ        5 IGNo
cmlz      d  G1hcywgLi4uIGFuZCB   h     IGhh
cHB5  I     G5ldyB5ZWFyIgptID0gJ      X d7LC
AuID       ogISArICogMCBPIEB9CnUg P     SAiI
CIgK  i   BzLnNpemUKCnByaW50ICJcci    A gI3t
1fVx      y   IjsKCigwLi4ocy5z    a     XplL
TEpK  S      50b19hLnNvcnRfYnkg       e yByY
W5kI      H 0uZWFjaCB7IHxyfAogIH  N     sZWV
wIGQ  x    CiAgbmV4dCBpZiBzW3JdID     0 9ICI
gIls      wXQogIG0uZWFjaCB7IHxrfAo      gICA
gdVt  y  XSA9IGsKICAgIHByaW50ICIgIC   N 7dX1
cciI    KICAgIHNsZWVwIGQyCiAgfQogIHV    bcl0
gPSB   zW3JdCiAgcHJpbnQgIiAgI3t1fVxyI g p9Cg
pzbG  VlcCBkMgpwcmludCAiICAje3V9IVxyI   jsKc
2xlZ  X       A    gMwpwc     m       l udCA
iICA      j        e3V9IS A       g     LS1j
aHJp  c       z    JcbiI7     C       g ojIG
ZpbG      x        lciBzc G       F     jZSA
jIyM  j       I    yMjIyM     j       I yMjI
yMjI      y       M       j       I     yMjI
yMK";eval s.delete!(" \n").unpack("m*")[0]##
### Copyright (C) 2004  Christian Neukirchen

auszufuehren mit einem ruby interpreter > 1.8

anleitung

Wenn Du mich fragst, wurde Java generell als Kanone entwickelt und ist fuer Spatzen eher nicht so gut geeignet. Das betrifft nicht nur, aber auch, die Template Engines. Die meisten Java Frameworks sind halt fuer sehr grosse Applikationen ausgelegt. Daher sind die vorhandenen Loesungen generell fuer kleine - mittelgrosse Programme relativ umstaendlich zu implementieren.

Wenn es bei dir Java sein muss, magst du es vielleicht mal mit FreeMarker versuchen? Kann ich aber nicht wirklich empfehlen, habs grad erst gefunden

Eine Alternative ist vielleicht noch Helma, mit dem bei uns in der Arbeit sehr viel gemacht wird. Das ist ein Webframework (aus Oesterreich) fuer die Java Platform, das ueber Rhino mit ECMA-Script(Javascript) gecodet wird. Also mehr als nur eine Template Engine, und vielleicht mehr als du willst. Der orf.at und twoday.net (bzw. twoday.tuwien) laufen z.b damit.

[deleted]

Es gibt andere moeglichkeiten, aber die sind nicht unbedingt eleganter. Wenn du aus Main z.b. ein Singleton machst, kannst du dir das durchreichen der referenz spaaren. Ob das Sinn macht haengt aber natuerlich von der applikation ab.

die einzelnen komponenten deiner software sollten ja eigentlich nur durch klahr definierte schnittstellen miteinander kommunizieren. Und wenn du in Service die Main Komponente brauchst, dann waehre eine referenz im Konstruktor so eine Schnittstelle.

Du kannst eine referenz von Main an die Klassen Service und Database weitergeben.

(pseudocode)

class Main


 service = new Service(this) 
 window = new Window(this)


end


....


class Service


 database= new Database(this) 


 def foo
   database.service.main.window.window_foo
 end


end

wenn die instanz von service von aussen zugaenglich ist, kannst du ueber die main referenz darauf zugreifen.

Du machst die beiden klassen halt somit voneinander abhaengig.

Zitat von ich

Die "Java Language" ist derzeit die am weitesten verbreitete und am besten
unterstuetzte Programmiersprache fuer die Java Platform.

Zitat von hal

Oh mein Gott, ist das typisches Marketing-Speak

Das waehre es ganz sicher gewesen gewesen, wenn es sich nicht auf diesen Absatz bezogen haette:

Zitat von ich

Der Erfolg haengt nicht nur mit der Qualitaet einer Sprache zusammen, sondern
vor allem auch mit den Parteien, die dahinterstehen, und der Software, auf und
mit der die Sprache laueft.

Wenn es 1995 schon Sprachen wie Groovy/Nice/Jython/Ruby/Javascript fuer die Java VM gegeben haette, haette sich Java (die Sprache) kaum durchgesetzt. Damals hat man Java ja noch hauptsaechlich fuer kleine Applets verwendet, und dafuer waehren dynamische Sprachen ja viel besser geeignet gewesen.

Die Java Platform war fuer Java das, was Unix fuer C war: Das Sprungbrett in die
Popularitaet.

Zitat von hal

Nona ist das die am weitesten verbreitete Sprache, is ja auch die
einzige, die offiziell vom VM-Hersteller beworben wird.

Ganz meine Rede

Zitat von Maxii

Perl ist mMn ein guter Wurf aus folgendem Grund:
Wenn man mal kapiert hat wie es läuft, ist man irre schnell im implementieren

Das stimmt, aber das gilt auch fuer viele andere Sprachen, wie zum Beispiel Python, Ruby, Haskell oder Lisp. Im Gegensatz zu diesen Sprachen ist Perl aber sehr unkonsistent und wird ganz schnell schwer zu lesen. Bei einem 100 Zeilen Skript mag das noch ueberschaubar bleiben, aber solche Skripte wachsten ganz schnell, und dann skalieren andere Sprachen viel besser.

Zitat von Maxii

Außerdem wurden RegEx brauchbar umgesetzt(in C# zB eine Katastrophe)

RegEx werden in Ruby ca. gleich verwendet wie in Perl (Ruby hat sich das von Perl abgeschaut). In Perl ist so ein Ausdruck allerdings wieder ein eigenes Konstrukt. In Ruby hingegen ist eine Regular Expression einfach nur die Instanz von einer Klasse, genau wie alles andere auch in dieser Sprache:

irb(main):005:0> pattern = /[^a-zA-Z0-9]/ #same as 'Pattern.new("[^a-zA-Z0-9]") '...
=> /[^a-zA-Z0-9]/
irb(main):007:0> pattern.class
=> Regexp
irb(main):008:0> pattern.public_methods
=> ['source', 'send', 'object_id', 'singleton_methods', '__send__', 'equal?', 'taint', 'frozen?', 'instance_variable_get', 'kind_of?', 'to_a', 'instance_eval', 'require', 'typ
e', 'protected_methods', 'extend', 'eql?', 'casefold?', 'instance_variable_set', '~', 'hash', 'is_a?', 'to_s', 'options', 'match', 'class', 'tainted?', 'private_methods', 'req
uire_gem_with_options', 'untaint', 'id', 'inspect', 'kcode', '==', '===', 'clone', 'public_methods', 'respond_to?', 'display', 'freeze', '__id__', '=~', 'methods', 'require_ge
m', 'method', 'nil?', 'dup', 'instance_variables', 'instance_of?']
irb(main):009:0>

Das gleiche gilt auch fuer Zahlen, Listen, module oder die datei in die du schreibst. Sogar Klassen sind nur instanzen von anderen Klassen:

irb(main):010:0> t = Time.new
=> Fri Oct 28 13:32:55 Westeuropõische Normalzeit 2005
irb(main):011:0> t.class
=> Time
irb(main):012:0> Time.class
=> Class
irb(main):013:0> Time.public_methods
=> ['send', 'name', 'class_eval', 'object_id', 'new', 'singleton_methods', 'utc', '__send__', 'private_method_defined?', 'equal?', 'taint', 'frozen?', 'instance_variable_get',
 'constants', 'kind_of?', 'to_a', 'instance_eval', 'require', 'ancestors', 'const_missing', 'type', 'gm', 'instance_methods', 'protected_methods', 'extend', 'protected_method_
defined?', 'eql?', 'public_class_method', 'const_get', 'instance_variable_set', 'hash', 'is_a?', 'autoload', 'to_s', 'class_variables', 'class', 'tainted?', 'private_methods',
 'local', 'at', 'public_instance_methods', 'instance_method', 'require_gem_with_options', 'untaint', 'included_modules', '_load', 'private_class_method', 'const_set', 'id', 't
imes', '<', 'inspect', '<=>', '==', 'method_defined?', '>', '===', 'clone', 'public_methods', 'mktime', 'protected_instance_methods', '>=', 'respond_to?', 'display', 'freeze',
 '<=', 'module_eval', 'autoload?', 'allocate', '__id__', '=~', 'methods', 'now', 'require_gem', 'method', 'public_method_defined?', 'superclass', 'nil?', 'dup', 'private_insta
nce_methods', 'instance_variables', 'include?', 'const_defined?', 'instance_of?']
irb(main):014:0> Class.class
=> Class
irb(main):015:0> Class.public_methods
=> ['send', 'name', 'class_eval', 'object_id', 'new', 'singleton_methods', '__send__', 'private_method_defined?', 'nesting', 'equal?', 'taint', 'frozen?', 'instance_variable_g
et', 'constants', 'kind_of?', 'to_a', 'instance_eval', 'require', 'ancestors', 'const_missing', 'type', 'instance_methods', 'protected_methods', 'extend', 'protected_method_de
fined?', 'eql?', 'public_class_method', 'const_get', 'instance_variable_set', 'hash', 'is_a?', 'autoload', 'to_s', 'class_variables', 'class', 'tainted?', 'private_methods', '
public_instance_methods', 'instance_method', 'require_gem_with_options', 'untaint', 'included_modules', 'private_class_method', 'const_set', 'id', '<', 'inspect', '<=>', '==',
 'method_defined?', '>', '===', 'clone', 'public_methods', 'protected_instance_methods', '>=', 'respond_to?', 'display', 'freeze', '<=', 'module_eval', 'autoload?', 'allocate'
, '__id__', '=~', 'methods', 'require_gem', 'method', 'public_method_defined?', 'superclass', 'nil?', 'dup', 'private_instance_methods', 'instance_variables', 'include?', 'con
st_defined?', 'instance_of?']
irb(main):016:0>

Sogar nil ( null in java/C#) ist in Ruby ein Objekt.

Das (unter anderem) macht die Sprache um ein vielfaches einfacher und logischer. Es gibt keine 1000 Ausnahmen, die man sich merken muss. Es gibt nur Objekte mit Zustaenden, an die ich nachrichten schicken kann, um diesen Zustand zu manipulieren und abzufragen.

Zitat von Maxii

Dennoch bin ich der Ansicht, dass C++ eine der besten Sprachen ist, die es zur Zeit gibt:

- irre schnell
- leicht zu erlernen
- man kann echt alles damit machen(man wird nicht so schnell bevormundet)
- eigentlich Plattformunabhängig
- bekannt

Das Problem mit C++ ist, das es auf verschiedenen Hochzeiten tanzen will. Wenn ich eine Software schreibe, will ich mich ganz auf die Funktionalitaet und Lesbarkeit konzentrieren, das heisst die Programmiersprache soll mich moeglichst nicht vom Programmieren abhalten :). Also suche ich ein moeglichst abstraktes Tool.

Ich bin ein Freund von der OptimizeLater technik, aber mit C++ muss ich mich mit Dingen wie Memorymanagement und Pointern befassen, obwohl ich mich eigentlich um Algorithmen und Design kuemmern will. Und wenn es dann tatsaechlich um Performance geht, bremsen die Objektorientierten Eigenschaften von C++ wiederum stark die Geschwindigkeit und blaehen den Code unnoetig auf. Dafuer ist dann C sicherlich besser geeignet.

Maschinennaehe und Abstraktion sind zwei gegensaetzliche Ansaetze. Eine Sprache, die beides zu implementieren versucht, kann meiner Meinung nach keines davon richtig.

Zitat von Maxii

Alleine mit
der struktur und den problemen beim import befehl.

Ich sehe nicht, wo Java hier groessere probleme bereitet als C# oder Perl.
Liegen deine Schwierigkeiten nicht vielleicht nur daran, dass Du die Sprache
einfach noch nicht so gut kennst?

Zitat von Maxii

die datentypen sind äußerst
unflexibel

Wo sind denn die Datentypen in Java so viel 'unflexibler' als in C#?
C# unterscheidet zwischen primitiven Datentypen, Objekten, Klassen, null Objekten, usw. sehr aehnlich wie Java das tut. Es gibt auch in C# all die Ungereimtheiten und Ausnahmen bei der Typisierung, genau wie in Java.
Reflection ist meiner Meinung nach in beiden Sprache gleich gut bzw. schlecht implementiert.

Zitat von Maxii

Wieso wird Java verwendet?

Q: Wieso werden Sprachen wie Perl, PHP oder C++ verwendet?

A: Alle diese Sprachen hatten in der Geschichte im richtigen Moment das richtige
anzubieten, und wurden von den richtigen Leuten gepuscht.

Der Erfolg haengt nicht nur mit der Qualitaet einer Sprache zusammen, sondern
vor allem auch mit den Parteien, die dahinterstehen, und der Software, auf und
mit der die Sprache laueft.

Larry Walls Perl war seinerzeit viel besser zum Scripten geeignet als
Bashscript, PHP Entwickler Rasmus Lerdorf hatte die Niesche fuer "schnelle,
schmutzige webanwendungen" als erster gefuellt, und Stroustrup's C++ hat sich
vor allem durchgesetzt, weil die Syntax aehnlich ausgeschaut hat wie C.

VB war vor allem erfolgreich, weil es (bzw VBA) die Sprache ist, mit der MS
Windows und MS Office gescripted werden, und aus dem gleichen Grund beruht auch
der Erfolg von C# durch Dotnet.

Ruby gibt es schon seit einem Jahrzehnt, aber richtig bekannt geworden ist es
erst dieses Jahr durch Rails. Wuerden
sich immer die intelligentesten Technologien durchsetzen, waehre Lisp heute viel
popularer.

Die "Java Language" ist derzeit die am weitesten verbreitete und am besten
unterstuetzte Programmiersprache fuer die Java Platform. Praktisch alle
Grossunternehmen, die in der IT etwas zu sagen haben (mit Ausnahme von
Microsoft), stehen hinter dieser Platform. Im Bereich Buisinesssoftware fuer
Grossunternehmen steht man auf 500 Seiten lange Spezifikationen, die jeden
einzelnen Aspect eines Interfaces beschreiben. Und von denen hat Java
haufenweise. Und bei mobilen Geraeten bleiben auch nicht sehr viele gute
Alternativen, weil praktisch alle wichtigen Hersteller die Platform
unterstuetzen.

Zitat von Maxii

Das super tolle, achso vergötterte Java ist echt nicht
"toll"

Es gibt kaum jemanden, die Java so beschreiben. Vielleicht die
Trolle im Heise Online Forum, die dann auch meistens genauso allgemeine Aussagen
ueber Betriebsysteme treffen.

Ich kenne viele Schwaechen im Design von Java, aber das trifft auch auf C# zu,
und auf jedenfall auf C++ und Perl.

Besser als die anderen wird eine Sprache immer erst in einem bestimmten Kontext.
Und bei aufwaendigen Serverapplikationen, sowie bei mobilen Geraeten, hat Java
derzeit die Nase vorne.

Ich halte mich da ganz an die Empfehlung aus dem Pragmatic Programmer, jedes jahr mindestens eine neue Programmiersprache zu erlernen. Hinter jeder Sprache steckt eine eigene Denkweise, und wenn man die lernt, lernt man auch viel uebers Programmieren. Zumindest sollte man aber eine sehr abstrakte und gut skalierende Sprache (wie Ruby), und eine low level sprache (wie C) beherrschen.

In der Arbeit arbeite ich hauptsaechlich mit Java, und setze Ruby ein wo ich kann. Ruby ist von Grund auf objektorientiert, hat viele Sprachelemente aus der funktionalen Programmierung uebernommen, und ist sehr flexibel. Die gute Syntax wirkt sich meist auch auf die verfuegbaren APIs aus, die bei Ruby in der Regel wirklich smart implementiert sind.

Fuer 2006 habe ich mir uebrigens Io vorgenommen, das scheint mir ein interessanter Ansatz zu sein..

Als IDE verwende ich eclipse, als Texteditor emacs.

siehe auch eine aeltere diskussion zu dem thema.