ASP und JSP im Vergleich

Einleitung

Das vorliegende Seminar gibt einen Einblick in die konkurrierenden Techniken zur Gestaltung dynamischer Webseiten mit JSP und ASP. Beide Techniken haben die gleiche Zielsetzung, kommen aber aus unterschiedlichen Umgebungen. Während ASP als eine Entwicklung von Microsoft überwiegend im Umfeld von Microsofts Internet Information Server (IIS) zu finden ist und als Scriptsprache VBScript aus gleichem Hause einsetzt, steht JSP getreu dem zugrunde liegenden Java-Konzept für die unterschiedlichsten Plattformen (IIS inclusive) zur Verfügung und greift auf den kompletten Funktionsumfang von Java zu. Beide Techniken basieren auf dem Konzept der Einbettung von dynamischem Code in statisches HTML. Deshalb werden ASP- und JSP-Seiten zunächst serverseitig abgearbeitet, um die Stellen an denen der dynamische Code steht durch die Ausgabe des Codes zu ersetzen und die Seite anschließend an den aufrufenden Browser zu senden. Die nachfolgenden Kapitel sollen einen Überblick über die technischen Möglichkeiten und Details beider Konzepte bieten.

Java Server Pages

Überblick

JSP stellt als Technologie für die Programmierung von Webseiten mit dynamischen Inhalten eine Erweiterung der Java-Servlet Technologie dar, welche ein Bestandteil der Java2 Enterprise Edition ist. Diese bereits seit längerem verfügbaren Java-Servlets leisten genau das Gleiche wie es JSP-Seiten auch tun. Der Nachteil der Servlets und gleichzeitig der entscheidende Grund für die Entwicklung der JSP-Technologie ist die Handhabung von statischem HTML-Code. Dieser musste nämlich für die Ausgabe durch Servlets umständlich durch entsprechende Java-Befehle auf den Ausgabekanal des Servers geschrieben werden, um zum Browser zu gelangen. Dadurch wurde die Repräsentation des statischen HTML-Codes innerhalb von Servlets sehr unübersichtlich und dessen Handhabung umständlich, da natürlich alle im Code vorhandenen Sonderzeichen, welche die Java-Methode zur Ausgabe stören würden extra gesperrt werden mussten. Weitere Optimierungen wie z.B. die Ausgabe von Servlet-Variablen und spezielle Meta-Befehle sind hinzugekommen und bilden die Grundlage der JSP-Technologie, welche seit 1999 von Sun Microsystems entwickelt wird. Genau genommen sind JSP-Seiten nichts anderes als in einer übersichtlicheren Syntax dargestellte Servlets und innerhalb des Webservers werden sie tatsächlich auch vor dem ersten Gebrauch in Servlets übersetzt, welche dann die Anforderungen von den Clients abwickeln.

Vorraussetzungen

Damit die Übersetzung von JSP-Seiten einwandfrei funktioniert muss auf dem Webserver eine lauffähige Java-Umgebung inclusive der Packages "javax.servlet.*" aus der Java2 Enterprise Edition (J2EE) vorhanden sein. Darüber hinaus muss eine Servlet-Engine wie z.B. Tomcat oder auch JRun installiert sein, die konfiguriert ist, Anfragen aus dem Internet entgegenzunehmen und zu bearbeiten. Die Servlet-Engine kann dabei entweder direkter Bestandteil des Webservers sein oder als eigenständige Anwendung laufen. Wichtig ist dabei lediglich, dass der Webserver entsprechend der verwendeten Alternative konfiguriert ist und weiß, wie er Anforderungen von JSP-Seiten zu behandeln hat.

Konzeption

JSP-Elemente werden wie oben schon erwähnt in HTML eingebettet. Die statischen HTML-Elemente werden als Templatetext bezeichnet. Es entstehen Seiten, die durch die Erweiterung "*.jsp" kenntlich gemacht werden, damit der Webserver weiß, daß es sich um JSP-Seiten handelt, die an die Servlet-Engine weitergeleitet werden müssen und dort behandelt werden können. Der Servlet-Container wandelt die JSP's bei der ersten Anfrage in Servlets um, welche als *.class-Dateien gespeichert und ausgeführt werden. Der durch JSP-Elemente erzeugte Inhalt wird mit dem statischem HTML verbunden und an den Client gesendet.

(Abb. 1)

Die einzelnen Phasen der Verarbeitung von Anfragen für JSP-Seiten werden durch die Abbildung1 nochmal verdeutlicht.

JSP-Direktiven

JSP-Direktiven sind JSP-Elemente, welche zur Informationsübergabe an die JSP-Engine dienen. Die allgemeine Form der Direktiven sieht folgendermaßen aus:

<%@ direktiveName attribut1="wert1" attribut2="wert2" %>

Hier wird auch gleich die allgemeine Kennzeichnung von JSP Elementen sichtbar, welche immer mit "<%" geöffnet und mit "%>" geschlossen werden. Das "@"-Symbol kennzeichnet darüber hinaus die Verwendung einer Direktive. Weitere Elemente und deren Kennzeichnung werden in den folgenden Abschnitten vorgestellt. Als Beispiel für eine konkrete gültige Direktive sei hier folgende Page-Direktive genannt:

<%@ page contentType="text/html" language="java" %>

JSP Page-Direktive

Die Page Direktive dient der Übermittlung von seitenspezifischen Informationen. Folgende Attribute können dabei angegeben werden:

language - Angabe der Skriptsprache (sollte eigentlich immer Java sein)
import - Java-Import-Deklaration
extends - Java-Extends Anweisung
contentType - MIME-Typ der durch die Seite generierten Antwort
errorPage - Seite, welche bei Exceptions aufgerufen wird
buffer - legt Größe des Zwischenspeichers fest
session - Boolean, der festlegt, ob die Seite Bestandteil einer Benutzersitzung ist. Standardmäßig wickelt der JSP-Container das Sessionmanagement wahlweise über Cookies oder URL-Rewriting ab

JSP Include-Direktive

Zur Einbindung statischer Inhalte in JSP-Seiten gibt es die Include Direktive. Die innerhalb der dieser Direktive eingebundenen Elemente werden vor der Erstellung der Implementierungsklasse der Seite eingefügt. Das bedeutet allerdings, daß später an der includierten Datei vorgenommene Änderungen nicht mehr berücksichtigt werden. Für den Fall, daß dynamisch eingebundene Dateien verwendet werden sollen gibt es spezielle JSP-Aktionselemente, die später behandelt werden. Eine Include-Direktive hat die an folgendem Beispiel erläuterte Syntax:

<%@ include file="header.html" %>

In diesem Beispiel wird zur Übersetzungszeit die Datei "header.html" statisch eingebunden.
Eine Seite kann mehrere include-Direktiven aufweisen. Die übergreifende Seite und alle enthaltenen Seiten bilden zusammen eine sogenannte JSP-Übersetzungseinheit.

JSP Taglib-Direktive

Die taglib-Direktive deklariert eine in der Seite verwendete Taglib-Bibliothek, welche die Verwendung benutzerdefienierter Tags ermöglicht und verwendet die folgende Syntax:

<% taglib uri="bsptaglib" prefix="bsp" %>

Durch den Parameter "uri" wird die URI zur Taglib-Bibliothek angegeben, während "prefix" das Prefix für die benutzerdefienerten Tags festlegt, welches bei Standard-Aktionselementen immer "jsp" lautet, wie im Abschnitt über Standard-Aktionselemente noch ersichtlich werden wird.

Die Definition eines eigenen Tags setzt sich aus zwei verschiedenen Komponenten zusammen:

1. Tag Handler Class - Definiert das Verhalten der Tags:
Dazu muss das Interface javax.servlet.jsp.tagext.Tag implementiert werden. Das kann erreicht werden durch die Ableitung von TagSupport oder BodyTagSupport Klasse.
Dieser Handler wird dann beim erkennen des Tags ausgeführt.

2. Tag Library Descriptor File - Versieht die XML Elemente mit einem Namen:
Hier wird die oben definierte Klasse dem Server mit den zugehörigen XML-Tag-Namen unter Benutzung eines XML-Dokuments bekannt gemacht, welches folgende Struktur hat:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE taglib
PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN"
"http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd">
<taglib>
<taglibversion>1.0</tablibversion>
<jspversion>1.1</jspversion>
<shortname>bsp</shortname>
<info>......</info>
<tag>
<name>NameDesTags</name>
<tagclass>package.class</tagclass>
<info>TestTag</info>
<bodycontent>EMPTY</bodycontent>
</tag>
</taglib>

Nun können die neuen Tags wie unten gezeigt verwendet werden. Der Body ist hier nicht berücksichtigt worden, da dies den Rahmen sprengen würde.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
......
<%@ taglib uri="bsp-taglib.tld" prefix="bsp" %>
<bsp:NameDesTags />
Oder
<bsp:NameDesTags>
</bsp:NameDesTags>
......
</HTML>

JSP-Aktionselemente

JSP-Aktionselemente sind in Form von XML-Elementen, also mit Start-Tag, Inhalt und Ende-Tag versehen in die Seite eingebettet und werden bei Anforderung der Seite ausgeführt. Neben den benutzderdefinierten Aktionselementen, welche wie im obigen Abschnitt erläutert verwendet werden gibt es eine Reihe vordefinierter Standardaktionselemente, mit denen häufig benötigte Funktionen zur Anfragezeit ausgeführt werden können. Einige häufig benötigte Elemente seien im Folgenden genannt:

<jsp:forward>
Leitet auf eine andere Seite oder ein anderes Servlet weiter.
Beispiel:
<jsp:forward page="list.jsp" />

<jsp:include>
Fügt eine Antwort aus einer anderer JSP-Seite, einem Servlet oder statischen Dateien ein und
wird zur Anfragezeit ausgewertet. Dieses Element dient zum dynamischen Einbinden von Dateien, was mit der oben genannten include-Direktive nicht möglich ist, da dabei die Includes zur Übersetzungszeit und nicht während der Anfrage eingebunden werden.

<jsp:param>
Dieses Element findet Verwendung innerhalb von <jsp:forward> oder <jsp:include> und dient der Angabe zusätzlicher Anfrageparameter für die Ziel-Ressource.

<jsp:plugin>

Dient zum Einbinden von Java-Applets oder benannten Bean-Komponenten und unterstützt zahlreiche Attribute zur Applet-Konfiguration.

<jsp:useBean>
Ermöglicht die Benutzung von Java-Beans.

<jsp:setProperty>
Legt den Wert einer oder mehrerer Bean-Eigenschaften fest.

JSP-Skriptelemente

Mit Skriptelementen können kleine Programmstücke in eine JSP-Seite eingefügt werden. Sie werden wie Aktionen zur Anfragezeit der Seite ausgeführt. Es gibt folgende Arten von Skriptelementen:

Scriptlets

Scriptlets sind (Java)-Code-Blöcke, die zwischen dem Start- <% und dem Ende-Kennzeichen %> eingeschlossen sind. Als Beispiel sei hier eine JSP-Seite angegeben, welche in Abhängigkeit von der Uhrzeit "Guten Morgen!", "Guten Tag!" oder "Guten Abend!" ausgibt:

<%@ page language="java" contentType="text/html" %>
<html> <body bgcolor="white">
<jsp:useBean id="clock" class="java.util.Date" />
<% if (clock.getHours() < 12 { %>
Guten Morgen!
<% } else if (clock.getHours() < 17 { %>
Guten Abend!
<% } else { %>
Guten Abend!
<% } %>
</body
</html>

Hierbei fällt auf, daß Kontrollstrukturen, wie in diesem Beispiel die if-Schleife über den Bereich eines einzelnen Skriptlets heraus gültig sind. Das liegt daran, daß der Serlet-Container während der Übersetzung den Templatetext in Java-Methoden zur Textausgabe verpackt und mit den Skriptlets zu einer Implementierung der abstrakten Servlet-Methode init() zusammenfügt, in der dann nicht mehr zwischen Templatetext und Skriptlets unterschieden werden kann und die Kontrollstrukturen somit übergreifende Gültigkeit haben.

Ausdrücke

Ausdrücke beginnen mit <%= und enden mit %>. Wie bei allen JSP-Blöcke wird auch hier <% und %> zur Klammerung des JSP-Bereichs verwendet. Das Gleichheitszeichen kennzeichnet hier die Verwendung eines Ausdrucks und ermöglicht die Unterscheidung zu Direktiven und anderen Skriptelementen. Folgendes Beispiel soll die Syntax verdeutlichen:

<%= userInfo.getUserName() %>

Das Ergebnis des Ausdrucks wird in den Body der Antwort geschrieben. Zu beachten ist hier, daß der Code des Ausdrucks nicht mit einem Semikolon enden darf, da der Webcontainer während der Übersetzung den Ausdruck mit den Programmteilen kombiniert, die das Erbegnis in die Antwort schreiben. Wenn der Ausdruck mit einem Semikolon endet ist das entstehende Programmstück syntaktisch nicht korrekt.

Eine interessante Verwendungsmöglichkeit von Ausdrücken stellt die Festlegung von Attributwerten zur Anfragezeit dar. In vielen Fällen ist nämlich der Wert eines Attributs unbekannt, wenn die JSP-Seite geschrieben wird. Hier können Ausdrücke wie im folgenden Beispiel verwendet werden:

<jsp:useBean id="logEntry" class="com.foo.LogEntryBean" />
<jsp:setProperty name="logEntry" property="entryTime"
value="<%= new java.util.Date() %>" />
...

Deklarationen

JSP-Deklarationselemente beginnen mit <%! und enden mit %>:

<%@ page language="java" contentType="text/html" %>
<%!
  int globalCounter = 0;
%>

Das Ausrufezeichen im Start-Identifier dient hier wieder der Unterscheidung zwischen Deklarationen, Skriptlets und Direktiven. Solche Deklarationen sind global verfügbar und werden von allen Anfragen an die Seite gleichermaßen verwendet, entsprechen also statischen Klassenvariablen. Hier kann es evtl. zu Multithreading-Problemen kommen, wenn mehr als eine Anfrage an die Seite zur selben Zeit bearbeitet wird und z.B. eine Anfrage den Wert einer Variablen überschreibt, die durch eine andere Anfrage gesetzt wurde. In den meisten Fällen empfiehlt es sich also, die Skriptvariablen innerhalb von Skriptlets zu deklarieren. Dann werden die Variablen nicht gemeinsam genutzt, sondern enthalten jeweils einen eigenen Wert für jede Anfrage. Deklarationselemente können auch zur Deklaration von Methoden verwendet werden, die dann von allen Skriptlets innerhalb der Seite aufgerufen werden können.

JSP-Kommentare

JSP-Kommentare haben folgende Struktur:

<%-- Dies ist ein Kommentar --%>

Der Text zwischen den Start- und Ende-Tags wird vom Servlet-Container ignoriert und nicht in die Anwort geschrieben.

Implizite JSP-Objekte

Implizite JSP-Objekte sind Instanzen von Klassen, die durch die Servlet- und JSP-Spezifikationen definiert sind und werden durch den JSP-Container bereitgestellt.

Folgende Objekte sind in jeder JSP-Seite verfügbar:

application: Das Application-Objekt dient dem Zugriff auf Informationen über die Anwendungsumgebung. Bsp.: getServerInfo()

config: Dieses Objekt ermöglicht den Zugriff auf Initialisierungsparameter der Web-Anwendung und den Context.

exception: Das Exception-Objekt ist in Fehlerseiten zur Fehlerbehandlung verfügbar
out: Out bietet Zugriff auf den Ausgabekanal des Servlets.

request: Das Request-Objekt stellt zahlreiche Methoden zum Zugriff auf Anfrage-parameter zur Verfügung.

response: Stellt zahlreiche Methoden zum Zugriff auf das in Servlets vorhandene Response-Objekt zur Verfügung.

session: Dieses Objekt ist eine Referenz auf ein HttpSession-Objekt, welches die Steuerung einer Session ermöglicht.

Active Server Pages

Überblick

Active Server Pages (ASP) ist ein Produkt der Firma Microsoft und verhält sich in der
Zielsetzung, dem Aufbau und der Konzeption ähnlich JSP. Als Microsoft-Produkt läuft es ausschließlich auf dem Microsoft Internet Information Server (IIS) und verwendet als Scriptsprache hautsächlich VBScript. Andere Scriptsprachen wie z.B. JScript sind allerdings auch möglich. Die Dateierweiterung ist hier immer *.asp.

Vorraussetzungen

Laut Spezifikation von Microsoft müssen für den Einsatz von ASP einige Vorraussetzungen erfüllt sein. Als Hardware sollte mindestens ein Pentium 100 mit 32 MB Arbeitsspeicher und 100 MB Festplattenplatz eingesetzt werden, welcher mit Windows 9x/ME/NT/2000 oder XP betrieben wird. Zusätzlich wird der Personal Web Server oder der IIS von Microsoft benötigt, welche beide von Hause aus mit ASP-Implementierungen ausgestattet sind. Der Einsatz von ASP ist also bei Verwendung dieser Produkte etwas einfacher, da hier keine zusätzliche Software wie z.B. eine Servlet-Engine auf dem Server bereitgestellt werden muß.

Grundlagen

Da die Grundlagen von ASP denen von JSP sehr stark ähneln, werden die Konzepte im Folgenden etwas kürzer dargestellt, da weitestgehend die im Kapitel zu JSP schon erläuterten Aufgabenfelder bedient werden.

ASP bietet wie JSP auch die Möglichkeit, die verwendete Scriptsprache anzugeben:

<%@ language="javascript" %>

Scriptelemente sind genau wie bei JSP begrenzt durch das Start- <% und Ende-Tag %>.
Globale Variablen werden hier außerhalb einer Prozedur deklariert und lokale innerhalb derselben. Die Speicherung von Session- und Application-Variablen ist möglich.
Statische Includes in ASP verwenden die gleiche Syntax wie Server Side Includes (SSI):

<!--#include file(virtual)="header.inc"-->

Ausdrücke werden wie bei JSP von <%= und %> begrenzt und die Verwendung von Ausdrücken als Attributwerte ist hier ebenfalls möglich. Zusätzlich gibt es die optionale Datei "global.asa", welche die Deklaration von Objekten und Variablen ermöglicht und darüber hinaus die Verwendung von Application und Session-Events ermöglicht. Diese lösen beim ersten Start bzw. Beenden einer ASP-Anwendung oder Aufbau einer Session festlegbare Ereignisse aus. Die Application-Events heißen "Application_OnStart" und "Application_OnEnd" und bedürfen wohl keiner weiteren Erklärung. Session-Events verhalten sich analog, d.h. auch hier gibt es einen "Session_OnStart"-Event und einen "Session_OnEnd"-Event.

ASP Objekte

Analog zu JSP gibt es die folgenden impliziten Objekte Response, Request, Application, Session, Server und Error mit ähnlicher Funktionsweise.

Zusätzlich werden bei ASP folgende Objekte angeboten:

FileSystem - Zugriff auf das Dateisystem
TextStream - Zugriff auf Textdateien
Drive - Zugriff auf Informationen über lokale und Netzwerkdateisysteme
File - Zugriff auf Informationen über einzelne Dateien
Folder - Informationen über einzelne Ordner
Dictionary - Speichern von Attributname/Wert-Paaren

ASP Components

ASP Components sind vorgefertigte Module, die dem Programmierer durch die Bereitstellung spezieller Funktionen die Arbeit erleichtern sollen.

AdRotator

Erzeugt ein AdRotator Objekt, welches bei jedem Aufruf oder Refresh der Seite ein anderes Bild lädt. Dieses Modul wird findet häufig bei Werbebannern Anwendung.
Beispiel:

<%
url=Request.QueryString("url")
If url<>"" then Response.Redirect(url)
%>
<html>
<body>
<%
set adrotator=Server.CreateObject("MSWC.AdRotator")
response.write(adrotator.GetAdvertisement("testfile.txt"))
%>
</body>
</html>

Struktur der oben verwendeten Datei "testfile.txt":

REDIRECT banners.asp
WIDTH 468
HEIGHT 60
BORDER 0
*
w3schools.gif
http://www.w3schools.com/
Visit W3Schools
80
microsoft.gif
http://www.microsoft.com/
Visit Microsoft
20

Durch die Redirect-Anweisung wird festgelegt, welche Seite bei einem Click auf das AdRotator-Objekt aufgerufen werden soll. Die Zielseite erhält den Parameter "URL" mit der Seite, welche aufgerufen werden soll. Das angegebene Beispiel ruft sich selbst auf und wertet direkt zu Beginn der ASP-Seite aus, ob ein entsprechender Parameter übergeben wurde.

Browser Capabilities

Erzeugt ein BrowserType Objekt, welches den Typ, die Fähigkeiten und die Version des Client-Browsers ermittelt. Das untenstehende Beispiel legt ein BrowserType Objekt innerhalb einer ASP-Seite an und gibt eine Tabelle mit einigen Features des aufrufenden Browsers aus:

<html>
<body>
<%Set Browser=Server.CreateObject("MSWC.BrowserType")%>
<table border="1" width="100%">
<tr>
  <th>Client OS</th>
  <th><%=Browser.platform%></th>
</tr>
<tr>
  <td > Web Browser</td>
  <td > <%=Browser.browser%> </td>
</tr>
<tr>
  <td> Browser version</td>
  <td><%=Browser.version%></td>
</tr>
<tr>
  <td>Frame support?</td>
  <td><%=Browser.frames%></td>
</tr>
<tr>
  <td>Table support?</td>
  <td><%=Browser.tables%></td>
</tr>
<tr>
  <td>Sound support?</td>
  <td><%=Browser.backgroundsounds%></td>
</tr>
<tr>
  <td>Cookies support?</td>
  <td><%=Browser.cookies%></td>
</tr>
<tr>
  <td>VBScript support?</td>
  <td><%=Browser.vbscript%></td>
</tr>
<tr>
  <td>JavaScript support?</td>
  <td><%=Browser.javascript%></td>
</tr>
</table>
</body>
</html>

Content Linking

Dient der Erzeugung eines einfachen Navigationssystems. Ein File "links.txt" enthält alle erforderlichen links, welche automatisch in die Navigation eingebunden werden. Beim Ändern der Links braucht nur dieses Textfile angepasst zu werden:

Beispiel für links.txt:

asp_intro.asp ASP Intro
asp_syntax.asp ASP Syntax
asp_variablen.asp ASP Variablen
asp_proceduren.asp ASP Proceduren

<%'Use the Content Linking Component 'to navigate between the pages listed'in links.txt
dim nlSet nl=Server.CreateObject("MSWC.NextLink")
if (nl.GetListIndex("links.txt")>1)
then
Response.Write("<a href='" & nl.GetPreviousURL("links.txt"))
Response.Write("'>Previous Page</a>")end if
Response.Write("<a href='" & nl.GetNextURL("links.txt"))
Response.Write("'>Next Page</a>")%>

Content Rotator

Diese Komponente erzeugt Content, welcher sich bei jedem Aufruf der Seite ändert.

Beispiel:

<html>
<body>
<%set contentrotator=server.createobject("MSWC.ContentRotator")
response.write(contentrotator.ChooseContent("content.txt"))%>
</body>
</html>

Zugehörige Datei "content.txt":

#1This is a great day!!%%
#2 <h1>Smile</h1>%%
#3<img src="smiley.gif">%%
#4Here's a <a href="http://www.w3schools.com">link.</a>

Vergleich beider Techniken

Im Folgenden werden die wichtigsten Unterschiede der beiden konkurrierenden Techniken vorgestellt.

Gross- und Kleinschreibung

Ein häufiger Fehler wird zwar vom Compiler erkannt, ist aber trotzdem am Anfang ziemlich lästig. ASP unterscheidet nicht zwischen Gross- und Kleinschreibung, JSP/Java dagegen schon. Dies betrifft sowohl Sprachelemente wie Namen von Variablen und Parametern.

Beispiel:

ASPDim intCounter'dies ist dieselbe Variable wieintcounter = 0 ‚Schreibweise in ASP spielt keine RolleIF intCOUNTER = 0 then Response.Write("erster")Else Response.Write("weitere")EnD iF JSPint intCounter;//Gross- und Kleinschrift muss stimmenintCounter = 0; //Schlüsselwörter sind in Java immer kleinif (intCounter == 0) { out.println("erster");} else { out.println("weitere");}

Statement Abschluss

In ASP ist ein Statement grundsätzlich eine Zeile lang und muss deshalb nicht mit einem speziellen Zeichen abgeschlossen werden. Wenn ein Statement über mehr als eine Zeile läuft, dann muss am der Zeile das Zeichen _ als Zeilenfortsetzung stehen.
In Java wird ein Statement wie in den meisten Programmiersprachen mit einem speziellen Zeichen, nämlich mit ; abgeschlossen. Da es einen klar definierten Abschluss hat, kann das Statement über beliebig viele Zeilen laufen. In Java ist es ausserdem auch möglich (aber nicht empfehlenswert), mehr als ein Statement auf eine Zeile zu packen.

Beispiel:

Operatoren

Bei den Operatoren folgt Java der C++-Syntax. Das ermöglicht äusserst kompakte Statements, die aber für all jene, die C++ nicht kennen, auf den ersten Blick ziemlich unverständlich sind.
Die Operatoren in Java werden nicht nur anders geschrieben, sondern sie funktionieren z.T. auch anders. Bei && für die logische UND-Verknüpfung ist das allerdings ein Vorteil, denn in Java wird die zweite Bedingung gar nicht mehr geprüft, wenn die erste Bedingung bereits nicht erfüllt ist. Damit lassen sich in Java Prüfungen in einem IF-Statement mit verknüpften Bedingungen abhandeln, die in ASP zwei verschachtelte IF-Statements benötigen.

Einige vergleichende Beispiele unterschiedlicher Operatoren:

Bedingungen

Zu den am häufigsten verwendeten Statements in einer Programmiersprache gehören vermutlich Bedingungen, d.h. IF-Statements. Leider unterscheidet sich hier die Syntax von ASP und JSP erheblich, wie im folgenden Beispiel ersichtlich wird:

Mehrfachverzweigungen

Mehrfachverzweigungen existieren sowohl in ASP wie JSP, doch sie unterscheiden sich nicht nur durch ihre Syntax. Während in ASP immer nur genau ein Ast durchlaufen wird, werden in Java alle hintereinander folgenden Äste bis zum nächsten break abgearbeitet. Sowohl in ASP wie Java lässt sich mit case nur auf Gleichheit prüfen. In Java ist die Prüfung ausserdem auf die Typen char, byte, short, oder int beschränkt.

Beispiel:

Vergleich mit Srings

In Java sind Strings Objekte. Wenn man in Java herausfinden möchte, ob eine Variable einen bestimmten Textwert hat, darf man deshalb für den Vergleich nicht == verwenden (denn das prüft Objektidentität, also die Gleichheit der Referenzen), sondern die Methode equals(..). Unbequem ist dieser Fehler vor allem, weil er nicht vom Compiler gefunden wird. Das Statement mit == ist ja gültig, es macht nur nicht das, was eigentlich beabsichtigt ist.

Beispiel:

Features im Vergleich

Abschließend seien noch einmal die wichtigsten Merkmale beider Techniken in einer tabellarischen Übersicht zusammengefasst:

Quellen