1. Első lépések

Ez a fejezet a Java programozás alapjaihoz mutat utat. Bemutatja, hogyan tudjuk a Javát beszerezni, és hogyan tudjuk elkészíteni, fordítani és futtatni az egyszerű Java programokat. Végül megismerhetjük azt a háttértudást, amely a programok működésének megértéséhez szükséges.

1.1. Az első csésze kávé

A Java programok készítéséhez szükségünk lesz a következőkre:

Java fejlesztőkörnyezet (Java SE Development Kit)

A JDK-t (Java SE Development Kit) a http://www.oracle.com/technetwork/java/javase/downloads/index.html címről tölthetjük le, majd értelemszerűen telepítsük is. (Fontos, hogy a JDK-t, és ne a JRE-t töltsük le!) Ha NetBeanst szeretnénk használni, érdemes eleve az integrált verziót (NetBeans with JDK 8) letölteni és telepíteni. (Bár meg kell jegyezni, hogy a tapasztalatok szerint stabilabb megoldás először a JDK-t, majd a NetBeanst telepíteni.)

JDK letöltése JDK és NetBeans letöltése

A telepítés a Windowsban megszokott egyszerűséggel történik, általában elegendő a Next gombra kattintani.

Telepítés

Fogadjuk el a jogi feltételeket:

Jogi feltételek

Telepítsünk a megadott könyvtárba:

Telepítési könyvtár megadása

A NetBeans számára is maradjon az alapértelmezett könyvtár:

NetBeans telepítési könyvtár

A frissítések figyelését hagyjuk bekapcsolv

jdk_netbeans_telep_5.png

Dokumentáció

A Java fejlesztőkörnyezeten kívül érdemes beszerezni (bár a fordításhoz közvetlenül nem szükséges) az API (Application Programming Interface) dokumentációt is (szintén az előző letöltési oldalról indulva). Ez a Java platformon használható több ezer osztály igen részletes dokumentációját tartalmazza. Természetesen online is elérhető a dokumentáció, pl. a http://docs.oracle.com/javase/7/docs/api/ címen.

Szövegszerkesztő, integrált fejlesztőkörnyezet

Bármilyen editor megfelel a jegyzettömbtől (Notepad) az összetett programozói editorokig. De a legkönnyebb talán az Oracle által hivatalosan támogatott Netbeans használata.

Betöltés folyamatban

A program kissé lassan indul. A kezdőképernyő:

Kezdőképernyő

A Jegyzet 25. fejezetében három népszerű editor használatához találnak tippeket. (E fejezet példái a parancssori fordítás-futtatás kissé nehézkes módszerét mutatják be.)

1.1.1 Az első alkalmazás létrehozása

A fejlesztés menetét jól mutatja a következő ábra: a forrásállományból a fordítás hatására előálló bájtkódot (bytecode) különböző (Java Virtuális Gépet, JVM-et tartalmazó) operációs rendszeren tudjuk futtatni.

HelloWorldApp

Az első program (HelloWorldApp) egyszerűen kiírja a képernyőre a Hello World! üzenetet. A következő lépések szükségesek:

Hozzunk létre egy forrásállományt

A forrásállomány egyszerű szöveges állomány a Java nyelv szintaxisa szerint. A Java forrásállomány kiterjesztése .java.

Megjegyzés: Unicode (egész pontosan UTF) kódolású forráskód is használható!
(A Unicode kódolás két bájton tárol egy-egy karaktert, így a legtöbbet használt nyelvek legtöbb betűje és írásjele ábrázolható vele.)

Az első programunk:

public class HelloWorldApp {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

Mentsük el a programot HelloWorldApp.java néven.

Megjegyzés: A Java nyelvben és az állománynévben is különbséget kell tenni kis-, és nagybetű között, függetlenül a Windowsban megszokott lazaságtól.

Fordítsuk le a forrásállományt bájtkódra

  • A javac (bin\javac.exe) fordító a szövegből olyan utasításokat állít elő, amelyeket a JVM (Java Virtual Machine, Java virtuális gép) végre tud hajtani. A bájtkódú programállomány kiterjesztése .class.
  • Nyissunk meg egy parancssor ablakot (Start menü / Futtatás / cmd.exe), majd állítsuk be az aktuális könyvtárat a Java bin alkönyvtárára (pl. cd ”C:\Program Files\ jdk1.6.0_01\bin”).
  • Indítsuk el a javac fordítót: javac HelloWorldApp.java. (Bizonyos esetekben szükség lehet a forrásállomány teljes elérési útjának megadására.)

Futtassuk a programot tartalmazó bájtkód állományt

A Java értelmező (bin\java.exe) a számítógépre telepített Java VM számára értelmezi a bájtkódú program utasításait, a VM pedig futtatja azokat.

Gépeljük be (kiterjesztés nélkül):

java HelloWorldApp

Ha mindent jól csináltunk, megjelenik a konzol ablak következő sorában a program üdvözlete.

1.2. Bevezetés a Java technológiába

A Java technológia egyaránt programozási nyelv és platform.

1.2.1. A Java programozási nyelv

A Java egy magas szintű nyelv a következő főbb jellemzőkkel:

  • egyszerű
  • objektumorientált
  • előfordított
  • értelmezett
  • robusztus
  • biztonságos
  • semleges architektúrájú
  • hordozható
  • nagy teljesítményű
  • többszálú
  • dinamikus

Megjegyzés: Valószínűleg a felsorolás egy része most még nem sokat mond. Mire azonban a jegyzet végére érnek, és a Java nyelvű fejlesztésben legalább alap szintű gyakorlatuk lesz, ez a lista sokkal többet fog mondani.

A legtöbb programozási nyelv esetén fordítást vagy értelmezést hajtunk végre, mielőtt a program futna a gépünkön. A Java esetén a kettőnek egy különös keverékét használjuk. Először a forrásprogramot (myProgram.java) a fordító (compiler, bin\javac.exe) egy közbülső nyelvre fordítva Java bájtkódot (myProgram.class) állít elő, és ezt a platform-független kódot értelmezi és futtatja a Java VM (interpreter, bin\java.exe). A fordítás egy alkalommal történik, az értelmezés pedig minden alkalommal, ahányszor a program végrehajtódik. A következő ábra ennek működését illusztrálja.

Compiler és VM

A Java bájtkódot gépi kóddá alakítja a Java VM. Minden Java értelmező, akár a fejlesztőkörnyezet, akár egy böngészőben futó applet, tartalmaz Java VM-et a futtatáshoz.

A Java bájtkód segítségével megoldható az, hogy csak egyszer kell megírni egy Java programot, majd tetszőleges (megfelelő verziójú) Java VM-et tartalmazó gépen futtatni lehet. A Java programunkat bármelyik operációs rendszeren telepített fordítóval le lehet fordítani, mindenütt használható lesz.

Megjegyezés: A fordítást és értelmezést is alkalmazó hibrid megoldás manapság egyre nagyobb népszerűségnek örvend. A Microsoft .Net platformja sok architektúrális elemet vett át a Javától, a web hagyományos értelmező megoldásai ma már sokszor előfordítással is kombinálhatók.

1.2.2 A Java platform

A platform hardver vagy szoftverkörnyezet, ahol a programok futnak. A legtöbb platform a hardvert és az operációs rendszert jelenti. A Java platform annyiban különbözik a legtöbb más platformtól, hogy teljesen szoftverplatform, és más hardver alapú platformokra épül. A Java platform két komponensből áll:

  • Java VM
  • Java API

A Java API igen sok (több ezer) használatra kész szoftverkomponenst tartalmaz: csomagokba szervezett osztályokat és interfészeket.

A következő ábra bemutatja a Java platform működését.

Java platform működése

A natív kód olyan kódot jelent, amelyik a hardveren közvetlenül futtatható. A platformfüggetlen Java kód valamivel lassabb, mint a natív kód. Azonban jó fordítóval, optimalizált értelmezővel, és JIT bájtkód fordítóval a különbség elég kicsi lehet. A mai futtatókörnyezetek már tartalmazzák a JIT (Just in time) fordítót, amivel az első futtatás előtt natív kódra fordul a bájtkód, így a további futások során már közvetlenül a natív kód futtatható.

Megjegyzés: Az előzőek következménye, hogy egy Java alkalmazás első futtatása több ideig tarthat, de a további futtatásoknál ez az időveszteség nem fog jelentkezni.

1.3. Mire jó a Java technológia?

A java korábbi időszakában a legtöbb Java platformra készült program asztali alkalmazás vagy applet volt. Ha a weben szörfözünk, találkozhatunk appletekkel. Az applet olyan program, amely bizonyos megszorításokkal futtatható Javát ismerő böngészőben. Kezdetben ezt látványos grafikai effektusok készítésére használták. Mára ez a felhasználás visszaszorult, és viszonylag ritkán találkozhatunk appletekkel.

Az eredeti célja szerint a Java magas szintű programozási nyelv és erős szoftverplatform kíván lenni. A gazdag osztálykönyvtár segítségével nagyon sokféle programot készíthetünk.

Az asztali alkalmazás olyan program, amely közvetlenül a Java platformon (pl. nem böngészőben) futtatható. Az alkalmazások speciális fajtája szerverként fut, hálózati klienseket kiszolgálva. Például lehet webszerver, proxy-szerver, levelező szerver vagy nyomtató szerver.

Szintén speciális program a szervlet (servlet). Szerver oldalon fut, de nem önállóan, hanem egy szerver-futtatókörnyezet részeként. Pl. egy portált ki lehet szolgálni néhány szervlet együttesével, vagy akár egyetlen szervlettel. Ebben az esetben a szervlet a webszerver részeként fut. A szervletek hasonlóak az appletekhez, mivel futásidejű kiterjesztései a (szerver) alkalmazásoknak.

A mobil telefonon, kézi számítógépen futó alkalmazást midletnek hívjuk.

(Bár nem az Oracle fejleszti, az Android platformra is döntően Java nyelven készítik az alkalmazásokat.)

Hogyan nyújtja az API ezt a sokféle támogatást? Szoftverkomponensek csomagjaiként, amelyek sokféle feladatot ellátnak. A Java platform minden teljes implementációja (például a midlet futtatókörnyezet nem teljes) rendelkezik a következő tulajdonságokkal:

  • Alap összetevők: objektumok, sztringek, szálak, számok, I/O, adatstruktúrák, dátum és időkezelés, stb.
  • Appletek: a szokásos felhasználások
  • Hálózatok: URL, TCP, UDP, socket-ek, IP címzés
  • Nemzetközi programozás: Segítség az egész világon használható alkalmazások írásához. A programok könnyedén tudnak alkalmazkodni a helyi sajátosságokhoz, és többféle nyelven kommunikálni a felhasználókkal
  • Biztonság: alacsony és magas szintű védelem, beleértve az elektronikus aláírást, titkos-, és nyilvános kulcsú titkosítást, hozzáférés-szabályozást és azonosítást
  • Szoftver komponensek: a JavaBeans használatával könnyen összeilleszthető komponenseket fejleszthetünk
  • Objektum szerializáció: lehetővé teszi a könnyűsúlyú perzisztenciát és az RMI‑t
  • JDBC: relációs adatbázis-kezelők széles köréhez nyújt egységes elérési felületet

A Java platform ezen felül tartalmaz API-t a 2D és 3D grafikához, szerverekhez, telefóniához, beszédfeldolgozáshoz, animációhoz stb.

1.3.1. Applet példa

import java.applet.*;
import java.awt.*;

public class DrawingLines extends Applet {

   int width, height;

   public void init() {
      width = getSize().width;
      height = getSize().height;
      setBackground( Color.black );
   }

   public void paint( Graphics g ) {
      g.setColor( Color.green );
      for ( int i = 0; i < 10; ++i ) {
         g.drawLine( width, height, i * width / 10, 0 );
      }
   }
}

1.3.2. Midlet példa

/*
* Copyright © 2013 Nokia Corporation. All rights reserved. Nokia and Nokia
* Connecting People are registered trademarks of Nokia Corporation. Oracle and
* Java are trademarks or registered trademarks of Oracle and/or its affiliates.
* Other product and company names mentioned herein may be trademarks or trade
* names of their respective owners. See LICENSE.TXT for license information.
*/
package com.nokia.example;

import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.midlet.MIDlet;

public class HelloWorldMIDlet extends MIDlet {

    public HelloWorldMIDlet() {
    }

    // Sets the MIDlet's current Display to a HelloScreen object.
    public void startApp() {
        Displayable current = Display.getDisplay(this).getCurrent();
        if (current == null) {
            HelloScreen helloScreen = new HelloScreen(this, "Hello, world!");
            Display.getDisplay(this).setCurrent(helloScreen);
        }
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }
}

1.3.3. Servlet példa

package org.ow2.frascati.examples.helloworld.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.osoa.sca.annotations.Property;

public class HelloWorldHttpServlet
     extends HttpServlet
{
private static final long serialVersionUID = 1L;

/**
* A configurable property 'name'.
*/
@Property(name = "name")
private String name;

/**
* @see HttpServlet#doGet(HttpServletRequest, HttpServletResponse)
*/
@Override
public final void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException
    {
      response.setContentType("text/html");
      PrintWriter out = response.getWriter();
      String query = request.getQueryString();
      out.println("<html><body>Hello " + (query==null?"World":query) + " I'm " + name + "</body></html>");
      out.close();
    }

}

1.3.4. Activity példa

/*
* Copyright 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package com.example.android.basicnetworking;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Bundle;
import android.support.v4.app.FragmentActivity;
import android.util.TypedValue;
import android.view.Menu;
import android.view.MenuItem;

import com.example.android.common.logger.Log;
import com.example.android.common.logger.LogFragment;
import com.example.android.common.logger.LogWrapper;
import com.example.android.common.logger.MessageOnlyLogFilter;

/**
* Sample application demonstrating how to test whether a device is connected,
* and if so, whether the connection happens to be wifi or mobile (it could be
* something else).
*
* This sample uses the logging framework to display log output in the log
* fragment (LogFragment).
*/
public class MainActivity extends FragmentActivity {

    public static final String TAG = "Basic Network Demo";
    // Whether there is a Wi-Fi connection.
    private static boolean wifiConnected = false;
    // Whether there is a mobile connection.
    private static boolean mobileConnected = false;

    // Reference to the fragment showing events, so we can clear it with a button
    // as necessary.
    private LogFragment mLogFragment;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.sample_main);

        // Initialize text fragment that displays intro text.
        SimpleTextFragment introFragment = (SimpleTextFragment)
                    getSupportFragmentManager().findFragmentById(R.id.intro_fragment);
        introFragment.setText(R.string.intro_message);
        introFragment.getTextView().setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16.0f);

        // Initialize the logging framework.
        initializeLogging();
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            // When the user clicks TEST, display the connection status.
            case R.id.test_action:
                checkNetworkConnection();
                return true;
            // Clear the log view fragment.
            case R.id.clear_action:
                mLogFragment.getLogView().setText("");
                return true;
        }
        return false;
    }

    /**
     * Check whether the device is connected, and if so, whether the connection
     * is wifi or mobile (it could be something else).
     */
    private void checkNetworkConnection() {
      ConnectivityManager connMgr =
          (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
      NetworkInfo activeInfo = connMgr.getActiveNetworkInfo();
      if (activeInfo != null && activeInfo.isConnected()) {
          wifiConnected = activeInfo.getType() == ConnectivityManager.TYPE_WIFI;
          mobileConnected = activeInfo.getType() == ConnectivityManager.TYPE_MOBILE;
          if(wifiConnected) {
              Log.i(TAG, getString(R.string.wifi_connection));
          } else if (mobileConnected){
              Log.i(TAG, getString(R.string.mobile_connection));
          }
      } else {
          Log.i(TAG, getString(R.string.no_wifi_or_mobile));
      }
    }

    /** Create a chain of targets that will receive log data */
    public void initializeLogging() {

        // Using Log, front-end to the logging chain, emulates
        // android.util.log method signatures.

        // Wraps Android's native log framework
        LogWrapper logWrapper = new LogWrapper();
        Log.setLogNode(logWrapper);

        // A filter that strips out everything except the message text.
        MessageOnlyLogFilter msgFilter = new MessageOnlyLogFilter();
        logWrapper.setNext(msgFilter);

        // On screen logging via a fragment with a TextView.
        mLogFragment =
                (LogFragment) getSupportFragmentManager().findFragmentById(R.id.log_fragment);
        msgFilter.setNext(mLogFragment.getLogView());
    }
}

1.3.5. Swing példa

/*
* Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
*   - Redistributions of source code must retain the above copyright
*     notice, this list of conditions and the following disclaimer.
*
*   - Redistributions in binary form must reproduce the above copyright
*     notice, this list of conditions and the following disclaimer in the
*     documentation and/or other materials provided with the distribution.
*
*   - Neither the name of Oracle or the names of its
*     contributors may be used to endorse or promote products derived
*     from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

/**
* This example, like all Swing examples, exists in a package:
* in this case, the "start" package.
* If you are using an IDE, such as NetBeans, this should work
* seamlessly.  If you are compiling and running the examples
* from the command-line, this may be confusing if you aren't
* used to using named packages.  In most cases,
* the quick and dirty solution is to delete or comment out
* the "package" line from all the source files and the code
* should work as expected.  For an explanation of how to
* use the Swing examples as-is from the command line, see
* http://docs.oracle.com/javase/javatutorials/tutorial/uiswing/start/compi... */
package start;

/*
* HelloWorldSwing.java requires no other files.
*/
import javax.swing.*;       

public class HelloWorldSwing {
    /**
     * Create the GUI and show it.  For thread safety,
     * this method should be invoked from the
     * event-dispatching thread.
     */
    private static void createAndShowGUI() {
        //Create and set up the window.
        JFrame frame = new JFrame("HelloWorldSwing");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        //Add the ubiquitous "Hello World" label.
        JLabel label = new JLabel("Hello World");
        frame.getContentPane().add(label);

        //Display the window.
        frame.pack();
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        //Schedule a job for the event-dispatching thread:
        //creating and showing this application's GUI.
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShowGUI();
            }
        });
    }
}

1.4. Még egyszer a HelloWorld programról

Ezen az egyszerű példán áttekintjük a nyelv legalapvetőbb szabályait.

1.4.4 Osztályok és objektumok használata

A példaalkalmazásunk egy nagyon egyszerű Java program, ezért nincs szüksége arra, hogy más osztályokat alkalmazzunk, a képernyőre írást kivéve. Összetettebb programok használni fognak más segítő osztályokat.

A HelloWorld alkalmazás egyedül a System osztályt használja. Ez az osztály rendszer-független hozzáférést tesz lehetővé a rendszerfüggő szolgáltatásokhoz.

Példánkban egy osztályváltozó (out) példány metódusát (println) hívjuk meg.

Osztálymetódusok és változók használata

A System.out a System osztály out változójának a teljes neve. (A System osztályból soha nem fog példányosítani az alkalmazásunk, csupán az osztály nevével tudunk hivatkozni a tagjaira. Ez azért van, mert az out osztályváltozó (static), és az osztályhoz van kapcsolva, nem egy példányhoz.

Példánymetódusok és változók használata

Azokat a metódusokat és változókat, amelyek nem az osztályhoz, hanem egy konkrét objektumpéldányhoz vannak kapcsolva, példánymetódusoknak vagy példányváltozóknak nevezzük.

Az out osztályváltozó, a PrintStream osztály egy példányára hivatkozik, és megvalósítja a standard kimenetet. Amikor a System osztály betöltődik, a PrintStream osztály példánya jön létre, és System.out változó néven hivatkozhatunk rá. Most már van egy példányunk, meg tudjuk hívni a példánymetódusát:

System.out.println("Hello World!");

Ahogy látszik, a példánymetódusok és változók használata hasonló az osztálymetódusok és változók működéséhez.

A Java fordító megengedi egy lépésben a többszörös hivatkozást:

System.out.println("Hello World!");

1.4.1 Megjegyzések a Java nyelvben

/*
* A HelloWordApp program kiírja a köszöntő szöveget
*/
public class HelloWorldApp {
    public static void main(String[] args) {
        // Kiírja: "Hello World!"
        System.out.println("Hello World!");
    }
}

A Java nyelv a megjegyzések három típusát támogatja. Hagyományos (C stílusú) megjegyzés:

/* szöveg */

A fordító a begépelt szöveget figyelmen kívül hagyja a /*-tól a */-ig.

/** dokumentáció */

Ez egy dokumentációs megjegyzés, a fordító figyelmen kívül hagyja, mint az előző típust is, de a javadoc eszköz (bin\javadoc.exe) segítségével automatikusan lehet generálni hypertext (HTML) dokumentációt, ami felhasználja a dokumentációs megjegyzéseket is.

Megjegyzés: a letölthető Java dokumentáció is ez alapján készült.

// szöveg

A fordító figyelmen kívül hagyja a sort a //-től a sor végéig.

1.4.2 Osztálydefiníció

A következő kód mutatja az osztálydefiníciós blokkot.

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

Az osztály (class) alapvető építőeleme az objektumorientált nyelveknek. Az osztály az adatok és viselkedések összességéből álló példányok sablonját adja meg. Amikor az osztályból példányt hozunk létre, akkor tulajdonképpen egy olyan objektum jön létre, amelyik úgy épül fel, és úgy viselkedik, mint az osztály egyéb példányai.

Az adatok az objektumpéldányok változóiként írhatók le, a viselkedések pedig a metódusokkal.

A valós életből egy hagyományos példa a téglalap osztály. Az osztály tartalmaz változókat a pozíció, valamint a szélesség és magasság leírására, és tartalmaz metódust a terület kiszámítására.

A Java nyelvben a legegyszerűbb osztálydefiníció a következő:

class name {
}

A class kulcsszóval és az osztály nevével kezdődik az osztálydefiníció, majd kapcsos-zárójelek között változók és metódusok következnek. A korábbi példa alkalmazásunkban nincs változó, és csak egyetlen metódus van main néven.

1.4.3 A main metódus

Minden Java alkalmazásnak tartalmaznia kell main metódust a következő deklarációval:

public static void main(String[] args)

A main metódus deklarációja három módosítót tartalmaz:

  • public: jelzi, hogy a metódust más osztálybeli objektumokból is meg lehet hívni
  • static: jelzi, hogy a main osztálymetódus
  • void: jelzi, hogy a metódusnak nincs visszatérési értéke

Hogyan hívódik meg a main metódus?

A Java nyelvben a main metódus hasonló a C nyelv main függvényéhez. Amikor a Java értelmező végrehajt egy alkalmazást, először meghívja az osztály main metódusát. Az alkalmazásunk további metódusait (közvetlenül vagy közvetve) a main fogja meghívni. Ha main nélkül próbálunk egy alkalmazást futtatni, az értelmező megtagadja a végrehajtást, és hibaüzenetet kapunk.

Megjegyzés: A main függvényre csak hagyományos alkalmazások esetén van szükség. Beágyazott Java program (applet, midlet, servlet) esetén a program az őt tartalmazó futtatókörnyezet (böngésző, szervlet konténer) speciális közreműködésével fog futni.

A main metódus paramétere

A main metódusnak egy paramétere van, amely sztringek tömbje. Ez a tömb a parancssori paramétereket tartalmazza. A példaprogramunkban nem foglalkoztunk az esetleges parancssori paraméterekkel.

Megjegyzés: A C nyelvtől eltérően az args tömb nem tartalmazza a program nevét. Ez ugyanis az önelemzés (reflection) módszerével könnyen megállapítható. Másrészt a Java nyelvben a tömb objektum, tudja a méretét, így nincs szükség további paraméterre.

1.5. Ellenőrző kérdések

  • Mi a különbség a gépi kód és a Java bájtkód között?
  • Mi a Java platform két fő összetevője?
  • Mi a Java VM?
  • Mi a legfontosabb feltétele annak, hogy egy adott gépen lehessen Java programot futtatni?
  • Mi a Java API?
  • Milyen parancs indítja el a Java fordítóprogramot?
  • Milyen parancs indítja el a Java VM-t?
  • Mi az a Java nyelvi szerkezet, amivel a konzolra lehet írni?
  • Mire szolgálnak a megjegyzések a programban?
  • Mi a különbség a /* …*/, /** …*/ és a //… megjegyzés-szintaktika között?
  • Melyik metódus fog először elindulni egy Java program esetén? Írjon egy egyszerű példát az alkalmazására!

Igaz vagy hamis? Indokolja!

  • A natív kód az ember számára könnyen értelmezhető programkód.
  • A Java fordító gépfüggetlen közbenső kódot, bájtkódot generál.
  • Az interpreter a tárgykódot visszaalakítja forráskóddá.
  • A forráskód egy szöveg, melyet a fordítóprogram értelmez, illetve fordít le.
  • A forráskód a számítógép által értelmezhető, közvetlenül futtatható kód.

Mit tartalmaz a main függvény paraméterének 0. eleme?

  • A program nevét
  • A paraméterek számát
  • Az első paramétert