Java: Intro Pemrogramman Java
Intro Pemrogramman Java
- Tutorial ini menjelaskan tentang bahasa pemrogramman Java. Juga berisi "Contekan" dengan contoh untuk task standard saat pemrogramman.
- Tulisan ini tidak membahasa tentang instalasi Java Development Kit (JDK).
Pendahuluan
Sejarah
Bahasa Pemrograman Java pertama kali di buat oleh James Gosling dari Sun Microsystems tahun 1991. The first public available version of Java (Java 1.0) was released 1995. Over time several version of Java were released which enhanced the language and its libraries. The current version of Java is Java 1.6 also known as Java 6.0.
From the Java programming language the Java platform evolved. The Java platform allows that code is written in other languages then the Java programming language and still runs on the Java virtual machine. 1.2. Overview
The Java programming language consists out of a Java compiler, the Java virtual machine, and the Java class libraries. The Java virtual machine (JVM) is a software implementation of a computer that executes programs like a real machine.
The Java compiler translates Java coding into so-called byte-code. The Java virtual machine interprets this byte-code and runs the program.
The Java virtual machine is written specifically for a specific operating system.
The Java runtime environment (JRE) consists of the JVM and the Java class libraries. 1.3. Characteristics of Java
The target of Java is to write a program once and then run this program on multiple operating systems.
Java has the following properties:
Platform independent: Java programs use the Java virtual machine as abstraction and do not access the operating system directly. This makes Java programs highly portable. A Java program which is standard complaint and follows certain rules can run unmodified all several platforms, e.g. Windows or Linux.
Object-orientated programming language: Except the primitive data types, all elements in Java are objects.
Strongly-typed programming language: Java is strongly-typed, e.g. the types of the used variables must be pre-defined and conversion to other objects is relatively strict, e.g. must be done in most cases by the programmer.
Interpreted and compiled language: Java source code is transfered into byte-code which does not depend on the target platform. This byte-code will be interpreted by the Java Virtual machine (JVM). The JVM contains a so called Hotspot-Compiler which translates critical byte-code into native code.
Automatic memory management: Java manages the memory allocation and de-allocation for creating new objects. The program does not have direct access to the memory. The so-called garbage collector deletes automatically object to which no active pointer exists.
The Java syntax is similar to C++. Java is case sensitive, e.g. the variables myValue and myvalue will be treated as different variables. 1.4. Development with Java
The programmer writes Java source code in an text editor which supports plain text. Normally the programmer uses an IDE (integrated development environment) for programming. An IDE support the programmer in the task of writing code, e.g. it provides auto-formatting of the source code, highlighting of the important keywords, etc.
At some point the programmer (or the IDE) calls the Java compiler (javac). The Java compiler creates platform independent code which is called bytecode. This byte-code is stored in ".class" files.
Bytecode can be executed by the Java runtime environment. The Java runtime environment (JRE) is a program which knows how to run the bytecode on the operating system. The JRE translates the bytecode into native code and executes it, e.g. the native code for Linux is different then the native code for Windows.
By default, the compiler puts each class file in the same directory as its source file. You can specify a separate destination directory with -d 2. Classpath
The classpath is the connection between the Java compiler and Java interpreter. It defines where the compiler and interpreter look for .class files to load.
The classpath in Java defines which Java class are available for your Java program. For example if you want to use an external Java library you have to add this library to your classpath to use it in your your program. 3. Your first Java program 3.1. Write source code
The following Java program is developed under Microsoft Windows. The process on other operating system should be similar but will not be covered here. Select a directory which should contain your code. I will use the directory c:\temp\java which will be called "javadir".
Open a text editor which supports plain text, e.g. notepad under Windows and write the following source code. You can start notepad via Start->Run-> notepad and pressing enter.
// The smallest Java program possible
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
}
}
Save the source code in your directory "javadir" under the name "HelloWorld.java".The name of a Java source file must always equals the class name (within the source code) and end with .java. In our case the filename must be HelloWorld.java because the class is called HelloWorld. 3.2. Compile the code
Switch to the command line, e.g. under Windows Start-> Run -> cmd. Switch to the "javadir" directory with the command cd javadir, for example in my case cd c:\temp\java. Use the command dir to see that the source file is in the directory.
Type javac HelloWorld.java .
Check the content of the directory with the command "dir". The directory contains now a file "HelloWorld.class". If you see this file you have successfully compiled your first Java source code into byte-code. 3.3. Run the code
Switch again to the command line, e.g. under Windows Start-> Run -> cmd. Switch to the directory jardir.
Type java HelloWorld .
The system should write "Hello World" on the command line.
undefined
3.4. Using the classpath
You can use the classpath to run the program from another place in your directory.
Switch to the command line, e.g. under Windows Start-> Run -> cmd. Switch to any directory you want.
Type java HelloWorld .
If you are not in the directory in which the compiled class is stored then the system should result an error message Exception in thread "main" java.lang.NoClassDefFoundError: test/TestClass
Type java -classpath "mydirectory" HelloWorld . Replace "mydirectory" with the directory which contains the test directory. You should again see the "HelloWorld" output. 4. Integrated Development Environment
The previous chapter explained how to create and compile a Java program on the command line. A Java Integrated Development Environment (IDE) provides lots of ease of use functionality for creating java programs. There are other very powerful IDE's available, for example Eclipse .
For an introduction on how to use the Eclipse IDE please see Eclipse Tutorial .
In the following I will say "Create a Java project SomeName". This will refer to creating an Eclipse Java project. If you are using a different IDE please follow the required steps in this IDE. 5. Your first graphical user interface application (GUI)
Using Eclipse create a new Java project "JavaIntroductionUI".
Create the following class MyFirstUI.java in package ui.
package ui;
import java.awt.BorderLayout; import java.awt.GridLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener;
import javax.swing.JButton; import javax.swing.JCheckBox; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JOptionPane; import javax.swing.JPanel; import javax.swing.JTextField;
public class MyFirstUI extends JFrame {
private JCheckBox checkbox; private JTextField firstName; private JTextField lastName;
public MyFirstUI() {
// Lets make it look nice // This you can ignore / delete if you don't like it // try { // for (LookAndFeelInfo info : UIManager.getInstalledLookAndFeels()) { // if ("Nimbus".equals(info.getName())) { // UIManager.setLookAndFeel(info.getClassName()); // break; // } // } // } catch (Exception e) { // e.printStackTrace(); // }
setTitle("My First UI");
// We create a panel which will hold the UI components JPanel pane = new JPanel(new BorderLayout()); // We always have two UI elements (columns) and we have three rows int numberOfRows = 3; int numberOfColumns = 2; pane.setLayout(new GridLayout(numberOfRows, numberOfColumns));
// create and attach buttons // create a label and add it to the main window JLabel firstNamelabel = new JLabel(" Firstname: "); pane.add(firstNamelabel); firstName = new JTextField(); pane.add(firstName);
JLabel lastNamelabel = new JLabel(" Lastname: "); pane.add(lastNamelabel); lastName = new JTextField(); pane.add(lastName);
JButton sayHello = new JButton("Say something"); pane.add(sayHello);
checkbox = new JCheckBox("Nice"); pane.add(checkbox);
// Add the pane to the main window getContentPane().add(pane);
// Pack will make the size of window fitting to the compoents // You could also use for example setSize(300, 400); pack();
// Set a tooltip for the button sayHello .setToolTipText("This button will say something really nice of something bad"); // sayHello need to do something sayHello.addActionListener(new MyActionListener()); }
private class MyActionListener implements ActionListener { public void actionPerformed(ActionEvent e) { if (!checkbox.isSelected()) { JOptionPane.showMessageDialog(null, "I don't like you, " + firstName.getText() + " " + lastName.getText() + "!"); } else { JOptionPane.showMessageDialog(null, "How are you, " + firstName.getText() + " " + lastName.getText() + "?"); } }
} }
Create also the following class MainTester.java in package test and start this class.
package test;
import ui.MyFirstUI;
public class MainTester { public static void main(String[] args) { MyFirstUI view = new MyFirstUI(); view.setVisible(true); } }
You should see the following. A mesage dialog should be seen if you press the button.
6. Statements
The following describes certain aspects of the software. 6.1. Boolean Operations
Use == to compare two primitives or to see if two references refers to the same object. Use the equals() method to see if two different objects are equal.
&& and || are both Short Circuit Methods which means that they terminate once the result of an evaluation is already clear. Example (true || .... ) is always true while (false && ...) always false is. Usage:
(var !=null && var.method1()..) ensures that var is not null before doing the real check.
Table 1. Boolean Operations Description == Is equal, in case of objects the system checks if the reference variable point to the same object, is will not compare the content of the objects! && And != is not equal, similar to the "==" a.equals(b) Checks if string a equals b a.equalsIgnoreCase(b) Checks if string a equals b while ignoring lower cases If (value ? false : true) {} Return true if value is not true. Negotiation
6.2. Switch Statement
The switch statement can be used to handle several alternatives if they are based on the same constant value.
switch (expression) {
case constant1:
command;
break; // Will prevent that the other cases or also executed
case constant2:
command;
break;
...
default:
}
Example:
switch (cat.getLevel()) { case 0: return true; case 1: if (cat.getLevel() == 1) { if (cat.getName().equalsIgnoreCase(req.getCategory())) { return true; } } case 2: if (cat.getName().equalsIgnoreCase(req.getSubCategory())) { return true; } }
7. Working with Strings
The following lists the most common string operations.
Table 2. Command Description text1.equals("Testing"); return true if text1 is equal to "Testing". The test is case sensitive. text1.equalsIgnoreCase("Testing"); return true if text1 is equal to "Testing". The test is not case sensitive. For example it would also be true for "testing" StringBuffer str1 = new StringBuffer(); Define a new String with a variable length. str.charat(1); Return the character at position 1. (Strings starting with 0) str.substring(1); Removes the first characters. str.substring(1, 5); Gets the substring from the second to the fifths character. str.indexOf(String) Find / Search for String Returns the index of the first occurrence of the specified string. str.lastIndexOf(String) Returns the index of the last occurrence of the specified string. StringBuffer does not support this method. Hence first convert the StringBuffer to String via method toString. str.endsWith(String) Returns true if str ends with String str.startsWith(String) Returns true if str starts with String str.trim() Removes spaces str.replace(str1,str2) Replaces all occurrences of str1 by str2 str.concat(str1); Concatenates str1 at the end of str. str.toLowerCase() str.toUpperCase() Converts string to lower- or uppercase str1 + str2 Concatenate str1 and str2 String[] zeug = myString.split("-"); String[] zeug = myString.split("\\."); Spits myString at / into Strings. Attention: the split string is a regular expression, so if you using special characters which have a meaning in regular expressions you need to quote them. In the second example the . is used and must be quoted by two backslashes.
8. Collection
A collection is a data structure which is used to contain and process sets of data. The data is encapsulated and the access to the data is only possible via predefined methods.
For example if your applications saves data in the object People you can store different People objects about people in a collection.
Tip While arrays are fixed sized, collections have a dynamic size, e.g. a collection can contain a flexible number of object.
When you need elements of various types or a dynamically changing number of them you use Java Collections.
Typical collections are: stacks, queues, deques, lists and trees.
As of Java 5 collections should get parameterized with an object declaration to enable the compiler to check if objects which are added to the collection have the correct type.
package collections;
import java.util.ArrayList;
public class MyArrayList {
public static void main(String[] args) { // Declare the ArrayList ArrayList<String> var = new ArrayList<String>(); // Add a few Strings to it var.add("Lars"); var.add("Jennifer"); // Loop over it and print the result to the console for (String s : var) { System.out.println(s); } } }
java.util.Collections is the basis class which provides you useful functionality.
Table 3. Sample Table Collections.copy(list, list) Copy a collection to another Collections.reverse(list) Reserve the order of the list Collections.shuffle(list) Shuffles the list Collections.sort(list) Sort the list
9. Type Conversion
If you use variables of different types Java requires for certain types an explicit conversion. The following gives examples for this conversion. 9.1. Conversion to String
Use the following to convert from other types to Strings
// Convert from int to String
String s1 = String.valueOf ( 10 ); // "10" String s2 =
// Convert from double to String
String.valueOf ( Math.PI ); // "3.141592653589793"
// Convert from boolean to String
String s3 = String.valueOf ( 1 < 2 ); // "true"
// Convert from date to String
String s4 = String.valueOf ( new Date() ); // "Tue Jun 03 14:40:38 CEST 2003"
9.2. Conversion from String to Number
// Conversion from String to int
int i = Integer.parseInt(String);
// Conversion from float to int
float f = Float.parseFloat(String);
// Conversion from double to int
double d = Double.parseDouble(String);
The conversion from string to number is independent from the Locale settings, e.g. it is always using the English notification for number. In this notification a correct number format is "8.20". The German number "8,20" would result in an error.
To convert from a German number you have to use the NumberFormat class. The challenges is that if the value is for example 98.00 then the NumberFormat class would create a Long which cannot be casted to Double. Hence the following complex conversion class.
private Double convertStringToDouble(String s) {
Locale l = new Locale("de", "DE"); Locale.setDefault(l); NumberFormat nf = NumberFormat.getInstance(); Double result = 0.0; try { if (Class.forName("java.lang.Long").isInstance(nf.parse(s))) { result = Double.parseDouble(String.valueOf(nf.parse(s))); } else { result = (Double) nf.parse(new String(s)); } } catch (ClassNotFoundException e1) { e1.printStackTrace(); } catch (ParseException e1) { e1.printStackTrace(); } return result; }
9.3. Double to int
int i = (int) double; 9.4. SQL Date conversions
Use the following to convert a Date to a SQL date
package test;
import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat;
public class ConvertDateToSQLDate {
private void convertDateToSQL(){ SimpleDateFormat template = new SimpleDateFormat("yyyy-MM-dd"); java.util.Date enddate = new java.util.Date("10/31/99"); java.sql.Date sqlDate = java.sql.Date.valueOf( template.format(enddate));
} public static void main(String[] args) { ConvertDateToSQLDate date = new ConvertDateToSQLDate(); date.convertDateToSQL(); }
}
10. JAR files - Java Archive 10.1. What is a jar
A JAR file is a Java Archive based on the pkzip file format. A jar files can contain java classes and other resources (icons, property files) and can be executable.
JAR files are the deployment format for Java. You can distribute your program in a jar file or you can use exiting java code via jars by putting them into your classpath. 10.2. Executable jar
An executable JAR means the end-user doesn't have to pull the class files out before running the program. This is done via a manifest.txt file which tells the JVM which class has the main() method. The content of the manifest.txt file:
Manifest-Version: 1.0 Main-Class: MyApp Class-Path:
. lib/jcommon-1.0.6.jar lib/itext-1.4.6.jar "Empty Line"
An empty line is required otherwise the jar won't be executable. Space after a new line is also required
To create one executable JAR file run on the command line
jar -cvmf mainfest.txt app1.jar *.class
11. Cheat Sheets
The following can be used as a reference for certain task which you have to do. 11.1. Working with classes
While programming Java you have to create several classes, methods, instance variables. The following uses the package test.
Table 4. What to do How to do it Create a new class called "MyNewClass".
package test;
public class MyNewClass {
}
Create a new attribute (instance variable) "var1" in MyNewClass with type String
package test;
public class MyNewClass { private String var1; }
Create a Constructor for "MyNewClass which has a String parameter and assigns the value of it to the "var1" instance variable.
package test;
public class MyNewClass { private String var1;
public MyNewClass(String para1) { var1 = para1; // or this.var1= para1; } }
Create a new method "doSomeThing" in class which do not return a value and has no parameters
package test;
public class MyNewClass { private String var1;
public MyNewClass(String para1) { var1 = para1; // or this.var1= para1; }
public void doSomeThing() {
}
}
Create a new method "doSomeThing2" in class which do not return a value and has two parameters, a int and a Person
package test;
public class MyNewClass { private String var1;
public MyNewClass(String para1) { var1 = para1; // or this.var1= para1; }
public void doSomeThing() {
}
public void doSomeThing2(int a, Person person) {
}
}
Create a new method "doSomeThing2" in class which do return an int value and has three parameters, two Strings and a Person
package test;
public class MyNewClass { private String var1;
public MyNewClass(String para1) { var1 = para1; // or this.var1= para1; }
public void doSomeThing() {
}
public void doSomeThing2(int a, Person person) {
}
public int doSomeThing3(String a, String b, Person person) { return 5; // Any value will do for this example }
}
Create a class "MyOtherClass" with two instance variables. One will store a String, the other will store a Dog. Create getter and setter for these variables.
package test;
public class MyOtherClass { String myvalue; Dog dog;
public String getMyvalue() { return myvalue; }
public void setMyvalue(String myvalue) { this.myvalue = myvalue; }
public Dog getDog() { return dog; }
public void setDog(Dog dog) { this.dog = dog; } }
11.2. Working with local variable
A local variable must always be declared in a method.
Table 5. What to do How to do it Declare a (local) variable of type string. String variable1; Declare a (local) variable of type string and assign "Test" to it. String variable2 = "Test"; Declare a (local) variable of type Person Person person; Declare a (local) variable of type Person, create a new Object and assign the variable to this object. Person person = new Person(); Declare a array of type String String array[]; Declare a array of type Person and create an array for this variable which can hold 5 Persons. Person array[]= new Person[5]; Assign 5 to the int variable var1 (which was already declared); var1 = 5; Assign the existing variable pers2 to the exiting variable pers1; pers1 = pers2; Declare a ArrayList variable which can hold objects of type Person ArrayList<Person> persons; Create a new ArrayList with objects of type Person and assign it to the existing variable persons persons = new ArrayList<Person>(); Declare a ArrayList variable which can hold objects of type Person and create a new Object for it. ArrayList<Person> persons = new ArrayList<Person>();