Co a naè je JAVA


Referát k semináøi Linux (19. prosince 1995)

Obsah:


Co je to Java?

Java je jednoduchý, objektovì orientovaný, distribuovaný, dynamický, pøenositelný, výkoný, robustní, bezpeèný, multithreadový, interpretovaný programovací jazyk nezávislý na architektuøe.

Tolik definice teï už zbývá pouze vysvìtlit co vlastnì znamenají všechny slova v ní použité.

Jednoduchý

Java je jazyk navržený tak aby byl co nejblíže k C++; proto je srozumitelný a dá se rychle nauèit. Java z C++ vynechává prvky, které jsou tìžko pochopitelné, zavádìjící nebo málo používané (hlavnì pøetypování operátorù a vícenásobnou dìdiènost) a pøidává automatický garbage-collection, takže programování je jednodušší a sníží se poèet chyb vzniklých pøi alokaci a uvolòování pamìti.

Objektovì orientovaný

Objektové vlastnosti Javy vycházejí z C++ a jsou pøidány nìkteré prvky z Objective C (kvùli nutnosti využívat dynamic method resolution).

Distribuovaný

Java má výkoné knihovny pro jednoduchý pøístup k protokolùm TCP/IP jako je HTTP a FTP. Aplikace napsané v Javì mohou pøistupovat pøes ULR k objektù na síti stejnì jako by byly na lokálním file-systému.

Dynamický

Java je mnohem dynamiètìjší jazyk než C a C++, protože byla navržena s ohledem na použití ve vyvíjejícím se prostøedí.

Jeden z hlavních problémù C++ jsou vedlejší efekty závislé na implementaci. Díky nim je nutno znovu pøekládat alikace pokud se zmìní specifikace nebo implementace nìkteré z knihoven. Tím, že Java zajišťuje propojení mezi moduly až za bìhu aplikace, zcela pøedchází tìmto problémùm. Knihovny mohou pøidávat nové metody a promìnné bez toho že by bylo nutno nìjak modifikovat aplikace, které je používají.

Java používá interface, prvek, který je pøevzat z Objective C. Interface je specifikace metod, které je objekt schopen zpracovat; souèástí interfacu nejsou deklarace promìnných nebo implementaènì závislé metody. Interfacy mohou být vícenásobnì dìdìny (narozdíl od tøíd) a napomáhají k vìtší flexibilitì pøi vytváøení stromu dìdiènosti než v klasickém C++.

Pøenositelný

Pøenositelnost není jen nezávislost na architektuøe cílového procesoru, ale ještì nìco navíc. Narozdíl od C a C++ specifikace Javy neobsahuje žádné implementaènì závislé prvky. Jsou pøenì specifikovány velikosti, kódování a aritmetika základních datových typù (napø. int je vždy 32-bitový ve dvojkovém doplòku a se znaménkem). Tyto vlastnosti jsou navrženy tak aby odpovídaly standardùm, které používají dnešní procesory.

Knihovny, které jsou souèástí specifikace Javy, definují pøenositelné rozhraní (napø. existuje abstraktní tøída Window a její implementace pro UNIX, Windows a Macintosh).

Samotné prostøedí Javy je pøenositelné. Nový pøekladaè je napsán v Javì a runtime je napsán V ANSI C splòujícím normu POSIX.

Výkoný

Pøestože výkon interpretovaného mezikódu je vìtšinou naprosto postaèující, jsou situace kdy je potøeba maximální rzchlosti aplikace. Mezikód mùže být pøeložen zy bìhu pøímo do strojového kódu procesoru na kterém aplikace v Javì bìží. To je zajištìno umístìním generátoru cílového kódu CPU do dynamického zavadìèe Javy.

Mezikód je navržen s tím že bude pøekládán do strojového kódu, proto je tento pøeklad celkem jednoduchý. Java produkuje pomìrnì rychlý kód s automatickou alokací registrù a generátor strojového kódu dìlá nìkteré další optimalizace.

Interpretovaný kód provádí asi 300,000 volání metod za sekundu (na SPARCStation 10); výkon vygenerovaného strojového kódu je srovnatelný s aplikacemi generovanými C a C++.

Robustní

Java je pøedurèená pro psaní spolehlivých programù. Proto vìnuje zvýšenou pozornost odhalování možných problémù programových konstrukcí, dynamické kontrole za bìhu a eliminaci situací ve kterých by mohlo docházet k chybám.

Z jazyka C++, ze kterého vychází, Java odstranila nìkteré "nebezpeèné" konstrukce, které sebou vláèí jako pozùstatek jazyka C (Java nepodporuje implicitní deklarace jak jsou použité v C).
Dalším závažným rozdílem je zcela pøedìlaná aritmetika pointerù. Java podporuje "true arrays" (pole která nejsou kus pamìti, ale jednotlivé položky) což umožnuje mimo jiné kontrolu rozsahu a zabraòuje náhodnému pøepisu pamìti spojenému s destrukcí dat.
Runtime linker uvažuje typové informace a opakuje mnoho kontrol, které se provádìly už pøi pøekladu, aby se eliminovaly problémy vzniklé použitím jiných verzí knihoven.

Bezpeèný

Java byla navžena pro použití v síťovém distribuovaném prostøedí, proto byla velká pozornost vìnována bezpeènosti. Použitý autentizaèní protokol je založen na kódování veøejným klíèem. Bezpeènost hodnì souvisí s robustností. Zmìna sémantiky pointerù zcela odstranila možnost pøístupu k privátním datùm tøídy (pomocí pøiètení offsetu dat k pointeru na danou tøídu v C++).

Multithreadový

Java má implementovaný multithreading - systémovou technologii umožnující "paralelní" bìh více vìtví programu souèasnì.

Souèástí jazyka Java jsou monitory - synchronizaèní primitiva založená na konceptu C.A.R.Hoarea. Zakomponováním tìchto primitiv pøímo do jazyka je jejich použití mnohem jednodušší a pochopitelnìjší.

Jedním z velkých pøínosù multithreadingu je lepší interaktivita programù a silná podpora real-time aplikací. Pøestože má Java sama o sobì dobrou podporu pro real-time na platformách jako jsou UNIX, Windows nebo Macintosh jsou tyto vlastnosti limitovány operaèním systémem.

Interpretovaný

Interpret Javy umožnuje spouštìt alikace na, kažé platformì pro kterou byl pøeložen runtime sytém. soucástí interpretovaného mezikódu jsou i informace vzniklé pøi pøekladu které napomáhají typové kontrole linkeru a zlepšují možnosti lazení.

Nezávislý na architektuøe

Java byla vyvíjena pro nasazení v síťovém prostøedí tj. v prostøedí ve kterém je spojeno mnoho operaèních sytémù používajících ruzné procesory. Aby bylo možné vykonávat aplikace Javy kdekoliv v síti pøekladaè negeneruje výsledný kód pro urèitý typ procesoru, ale mezikód - Java class file - který je nezávislý na typu procesoru a lze jej vykonávat kdekoli kde bìží Java runtime systém. Tento mezikód je, ale navržen tak aby jeho interpretace na bìžných procesorech byla co nejjednodušší, a aby bylo eventuelnì možno tento mezikód pøeložit do cílového kódu procesoru.

Tyto vlastnosti nejsou užiteèné jen v síťovém prostøedí, ale kdekoli potøebujeme vyvíjet jednu aplikaci pro více platforem.


Gramatika Jazyka Java:

Každé pravidlo je ve tvaru neterminál = meta-výraz ;
V meta výrazech mùže být použito :
| - jako nebo
( ... ) - pro združování
postfixový ? - pokud se má nìco vyskytovat maximálnì jednou
postfixové + - pokud se má nìco vyskytovat minimálnì jednou
postfixové * - pokud se má nìco vyskytovat libovolì krát (i nula krát)

CompilationUnit =
	PackageStatement? ImportStatement* TypeDeclaration*
;
PackageStatement =
	`package' PackageName `;'
;
ImportStatement =
	`import' PackageName `.' `*' `;'
|	`import' ( ClassName | InterfaceName )`;'
;
TypeDeclaration =
	ClassDeclaration
|	InterfaceDeclaration
|	`;'
;
ClassDeclaration =
	Modifier* `class' Identifier 
	(`extends' ClassName)?
	(`implements' InterfaceName (`,' InterfaceName)*)?
	`{' FieldDeclaration* `}'
;
InterfaceDeclaration =
	Modifier* `interface' Identifier
	(`extends' InterfaceName (`,' InterfaceName)*)?
	`{' FieldDeclaration* `}'
;
FieldDeclaration =
	DocComment? MethodDeclaration
|	DocComment? ConstructorDeclaration
|	DocComment? VariableDeclaration
|	StaticInitializer
|	`;'
;
MethodDeclaration =
	Modifier* Type Identifier `(' ParameterList? `)' ( `[' `]' )*
	( `{' Statement* `}' | `;' )
;
ConstructorDeclaration =
	Modifier* Identifier `(' ParameterList? `)'
	`{' Statement* `}'
;
VariableDeclaration =
	Modifier* Type VariableDeclarator (`,' VariableDeclarator)* `;'
;
VariableDeclarator =
	Identifier (`[' `]')* (`=' VariableInitializer)?
;

VariableInitializer  =
	Expression
|	`{'  ( VariableInitializer  ( `,' VariableInitializer  )* `,'? )? `}'
;
StaticInitializer = 
	`static' `{' Statement* `}'
;
ParameterList =
	Parameter (`,' Parameter)*
;
Parameter =
	TypeSpecifier Identifier (`[' `]')*
;
Statement =
	VariableDeclaration
|	Expression `;'
|	`{' Statement* `}'
|	`if' `(' Expression `)' Statement (`else' Statement)?
|	`while' `(' Expression `)' Statement
|	`do' Statement `while' `(' Expression `)' `;'
|	`try' Statement (`catch' `(' Parameter `)' Statement)* 
		(`finally' Statement)?
|	`switch' `(' Expression `)' `{' Statement* `}'
|	`synchronized' `(' Expression `)' Statement
|	`return' Expression? `;'
|	`throw' Expression `;'
|	`case' Expression `:' 
|	`default' `:' 
|	Identifier `:' Statement
|	`break' Identifier? `;'
|	`continue' Identifier? `;'
|	`;'
;
Expression =
	Expression `+' Expression
|	Expression `-' Expression
|	Expression `*' Expression
|	Expression `/' Expression
|	Expression `%' Expression
|	Expression `^' Expression
|	Expression `&' Expression
|	Expression `|' Expression
|	Expression `&&' Expression
|	Expression `||' Expression
|	Expression `<<` Expression
|	Expression `>>' Expression
|	Expression `>>>' Expression
|	Expression `=' Expression
|	Expression `+=' Expression
|	Expression `-=' Expression
|	Expression `*=' Expression
|	Expression `/=' Expression
|	Expression `%=' Expression
|	Expression `^=' Expression
|	Expression `&=' Expression
|	Expression `|=' Expression
|	Expression `<<=' Expression
|	Expression `>>=' Expression
|	Expression `>>>=' Expression
|	Expression `<` Expression
|	Expression `>' Expression
|	Expression `<=' Expression
|	Expression `>=' Expression
|	Expression `==' Expression
|	Expression `!=' Expression
|	Expression `.' Expression
|	Expression `,' Expression
|	Expression `instanceof' ( ClassName | InterfaceName )
|	Expression `?' Expression `:' Expression
|	Expression `[' Expression `]'
|	`++' Expression
|	`--' Expression
|	Expression `++'
|	Expression `--'
|	`-' Expression
|	`!' Expression
|	`~' Expression
|	`(' Expression  `)'
|	`(' Type `)' Expression
|	Expression  `(' ArgList? `)'
|	`new' ClassName  `(' ArgList?`)'
|	`new' TypeSpecifier  ( `[' Expression `]' )+ (`['  `]')*
|	`new' `(' Expression  `)'
|	`true'
|	`false'
|	`null'
|	`super'
|	`this'
|	Identifier
|	Number
|	String
|	Character
;
ArgList =
	Expression (`,' Expression )*
;
Type =
	TypeSpecifier (`[' `]')*
;
TypeSpecifier =
	`boolean'
|	`byte'
|	`char'
|	`short'
|	`int'
|	`float'
|	`long'
|	`double'
|	ClassName
|	InterfaceName
;


Modifier =
	`public'
|	`private'
|	`protected'
|	`static'
|	`final'
|	`native'
|	`synchronized'
|	`abstract'
|	`threadsafe'
|	`transient'
;
PackageName =
	Identifier 
|	PackageName `.' Identifier
;

ClassName =
	Identifier
| 	PackageName `.' Identifier
;

InterfaceName =
	Identifier
| 	PackageName `.' Identifier
;


Java a Linux:


Aby bylo možno Javu na Linuxu spustit je potøeba:


Originální dokumenty týkající se Javy:


Domovská stránka Javy

Poznámky a pøipomínky posílejte na adresu Jakub.VOTAVA@st.mff.cuni.cz