JAVA Deel 6 (SWING begin)
1. Inleiding
2. Swing?
3. Begin: venster met titel
4. Elementen toevoegenl
5. Reageren op een actie
 top
1. Inleiding
Swing staat er in de titel. Leuke naam vind je niet?
Op het begin vond ik swing maar een rare, maar toch een... aardige naam.
Na dat ik 2 dagen met swing had geëxperimenteerd hield ik er evenveel van als PHP.
Het is zo logisch en niet zo moeilijk te begrijpen als je de eerste stappen hebt gezet.
Ik ga jullie dus proberen te begeleiden tijdens deze eerste stappen.
Om het uit te leggen is het niet gemakelijk, dus als je iets niet begrijpt: 'Sorry! Maar PM me gerust:)'.
(Niet voordat je de andere JAVA tutorials hebt gelezen natuurlijk en MOEITE hebt gedaan het te begrijpen!)
top
2. Swing?
Genoeg over die naam. Even naar de betekenis misschien?
Swing is een JAVA aplicatie die verschillende classes bevat. Deze classes kan je simpel inladen via 'import javax.swing.*'.
Je gaat hoogstwaarschijnlijk ook awt classes nodig hebben voor event handling (er word op een button gedrukt: wat nu?).
Nu, allemaal leuk en wel, wat kan je met deze classes doen?
ENORM VEEL! En dan bedoel ik op het gebied van windows (grafische toepassingen dus!).
Hetgeen wat elke 'beginnend programeur' zo snel mogelijk naar toe wil streven.
Je moet vooral al weten: hoe is een classe opgebouwd, hoe maak ik methodes, wat is de main methode... etc...
De basis dus, maar dat zal hopelijk geen probleem worden.
top
3. Begin: venster met titel
En het startschot is gegeven: hier gaan we dan!
Ik ga gebruik maken van een heel simpel voorbeeld:
- een titel geven
- breedte en hoogte instellen
- venster weergeven!
Het leuke is dat dit ook het enige is wat je moet doen.
Je roept JFrame aan (een classe van SWING) en dan geef je deze 3 waardes in en BAF, daar staat je venster.
IK zal de code hiervoor eens laten zien en dan uitleggen.
import javax.swing.*; // dit pakket bevat de definitie van JFrame
public class smSwing1 extends JFrame {
public smSwing1() {
super( "TITEL!" ); //de titel!
}
public static void main ( String argumenten[] ) {
smSwing1 venster = new smSwing1();
venster.setSize( 300, 200 ); //300 = breedte, 200 = hoogte
venster.show();
}
}
|
import javax.swing.* ==> library van SWING inladen
public class smSwing1 extends JFrame ==> basis classe, deze erft (extends) alle eigenschappen van JFrame over, dus ook de mogelijkheid om vensters weer te geven
public smSwing1() ==> een constructor methode, deze word altijd aangeroepen bij het aanroepen van de class
super( "TITEL!" ) ==> de titel meegeven
public static void main ( String argumenten[] ) ==> main class
smSwing1 venster = new smSwing1() ==> hier maak je een object aan die verwijst naar de standaard class. Hierdoor word de constructor aangeroepen en de titel gedefinieërd. Nu kan je vanalles met venster gaan doen.
venster.setSize( 300, 200 ) ==> waardes instellen, in de toekomst ga ik dit in de constructor methode doen omdat dit veel meer mogelijkheden met zich meebrengt.
venster.show() ==> venster laten zien
Zoals je ziet is een simpel venster maken niet moeilijk, en het ziet er al een pak beter uit dan in opdrachtprompt of iets dergelijk een JAVA programma te runnen.
top
4. Elementen toevoegen
Nu je een venster toepassing kan maken wil je dit natuurlijk ook opvullen.
Met tekst, een button, een tekstveldje, etc...
Ik ga eerst een voorbeeldje hiervan geven en daarna elk (nieuw) element weer stap voor stap uitleggen.
import javax.swing.*;
import java.awt.*;
public class smSwing2 extends JFrame {
private JButton knop;
private JTextField tekst;
private JLabel label;
public smSwing2() {
super( "Button, tekstveld en paneel" );
Container c = getContentPane();
c.setLayout( new GridLayout( 3, 1 ) );
knop = new JButton( "Klik hier" );
tekst = new JTextField( "0" );
label = new JLabel( "tekst" );
c.add( knop );
c.add( tekst );
c.add( label );
setSize( 300, 200 );
show();
}
public static void main(String[] argv) {
smSwing2 venster = new smSwing2();
}
}
|
import java.awt.* => de awt library inladen voor buttons, labels, etc...
private JButton knop => declaratie van de button 'knop'. Deze doe ik buiten de contstructor en main methode omdat het je er dan mee kan spelen. Ik maak hem private omdat je dit standaard zou moeten doen. Als je weet wat private betekend en meerdere klassen maakt en deze wilt linken kan je dit veranderen, anders zou ik het gewoon laten staan.
private JTextField tekst => declaratie van het tekstveld 'tekst'
private JLabel label => declaratie van de label 'label'. Labels worden meestal gebruikt om tekst in te zetten.
Container c = getContentPane() => de container bevat alle gegevens: buttons, labels,... Deze moet je toevoegen aan de container (dit gebeurt iets later). Hier declareer ik de container.
c.setLayout( new GridLayout( 3, 1 ) ) => Hier stel ik de layout in. Ik neem een gridlayout omdat dit makelijk werkt en constant is. Het kan wel leiden tot 'lelijke' buttons en tekstveldjes, maar dat kan je later altijd veranderen. De drie staat voor de hoogte van de container ( 3 elementen die verticaal staan) en de 1 voor de breedte van de container (1 element op elke rij).
knop = new JButton( "Klik hier" ) => Hier geef je de button knop een waarde.En maak je er ook een object van dat refereert naar de class JButton.
tekst = new JTextField( "0" ) => Hier geef je het tekstveld tekst een standaard waarde. En maak je er ook een object van dat refereert naar de class JTextField.
label = new JLabel( "tekst" ) => Hier geef je de label 'label' een waarde (tekst). En maak je er ook een object van dat refereert naar de class JLabel.
c.add( knop ) => toevoegen van knop aan de container.
c.add( tekst ) => toevoegen van het tekstveld aan de container.
c.add( label ) => toevoegen van de label aan de container.
En de rest zou je al moeten weten.
top
5. Reageren op een actie
Oke, allemaal leuk en wel. Een button en een tekstveldje toevoegen. Maar wat ben je daar nu mee als je ingevoerde waardes niet kan verwerken.
Hiervoor bestaat er een bepaalde interface die je kan overnemen in een methode (moeilijke zin).
Maar eigenlijk is dit minder dan 1 regeltje code!
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
public class smSwing3 extends JFrame implements ActionListener {
//de actionlistener is voor het kijken of er een actie is ondernomen
//declareer tekstvak
private JTextField txtwoord;
//declareer bijhorende labels
private JLabel text;
private JLabel resultaat;
//declareer knop
private JButton knop;
//declaratie van een String die we later gaan gebruiken
private String woord;
public smSwing3( String sTitel, int iHoogte, int iBreedte ) {
//een leuke en handige toevoeging zijn deze bovenstaande argumenten, zodat je deze gemakelijk onderaan de pagina kan instellen ipv in de code
//----------------------------------------------
//begin van block: dit zou je allemaal al moeten snappen/kunnen
//----------------------------------------------
super( sTitel );
Container c = getContentPane();
c.setLayout(new GridLayout(2, 2));
text = new JLabel( "Geef een woord" );
txtwoord = new JTextField( "woord" );
knop = new JButton( "klik" );
resultaat = new JLabel();
c.add( text );
c.add( txtwoord );
c.add( knop );
c.add( resultaat );
//----------------------------------------------
//eind van block: dit zou je allemaal al moeten snappen/kunnen
//----------------------------------------------
knop.addActionListener(this); //hiermee geef je aan dat je een actie wilt ondernemen als er op de knop is gedrukt
//de actie verwijst door naar deze klasse (this) en zal worden uitgevoerd via de functie: actionPerformed
//deze maken we zo dadelijk aan
//grootte van het venster vastleggen
setSize( iBreedte, iHoogte );
//het volledige venster tonen --> applicatie starten
show();
}
public void actionPerformed( ActionEvent e ) {
//de actie e bevat alle gegevens van het zojuist gebeurde actie
//in ons geval is er op een button geklikt met de naam knop en de titel: 'klik'
//we gaan via onderstaande keuzestructuur kijken of er op die knop is gedrukt: zoja, dan voeren we iets uit
if(e.getActionCommand().equals("klik")) {
woord = txtwoord.getText(); //de waarde van txtwoord ophalen via de methode: getText
resultaat.setText( String.valueOf( woord ) ); //we stellen de label 'resultaat' gelijk aan de waarde van de ingevoerde tekst
//dit, omdat je dan een globaal idee krijgt van de belangrijkste methodes:
//setText en getText
}
}
public static void main(String[] argv) {
//starten van het programma zelf
smSwing3 test = new smSwing3( "Sitemasters tutorial", 300, 300 );
}
}
|
Misschien komt dit af op jou als 1 grote lap tekst. Maar bekijk hem even, bestudeer de commentaar en je begrijpt het wel.
Dit zou een soort van 'standaard programma' kunnen vormen voor als je een simpele applicatie wilt bouwen met knopjes etc.
Als je dit een beetje uitbreid kan je veel doen, bv. mijn 'pils bakken berekenen' programma berust volledig op dit 'skelet'.
Dit was het dan voor deze keer.
Enkele toepassingen met JAVA zijn bv. JSP, meer info daarover: JSP Tutorials
top
|
Wat is jouw favoriete javascript framework? (S: 18, R: 2)
