套件

當程式寫得越來越多，管理檔案將不容易。
因此需要將程式分類，
也就是俗稱的：套件 package。
分類通常都採用目錄的方式
如將 bank 所屬的 Account.java SavingAccount.java 和 CreditAccount.java 放在同一個目錄
放到 bank 目錄後
要加上 package 名稱 (也就是資料夾名稱)；

package bank;

同樣在 util 目錄中心增一個 report

package util;

public class Report {
　public static void list (CreditAccount[] cas){
　　for (int c=0; c < cas.length; c++) {
　　　System.out.println( cas[c].toString() );
　　}
　}
}

這時邊議會有很多錯誤，要 import 才能讓編譯器知道改怎麼找 class
最重要的程式

import bank.CreditAccount;
import util.Report;

public class Test {
　public static void main(String[] args) {
　　CreditAccount[] cas = new CreditAccount[3];
　　cas[0] = new CreditAccount(101,"Simon",200,0.02,100);
　　cas[1] = new CreditAccount(102,"Mary",300,0.01,200);
　　cas[2] = new CreditAccount(103,"John",500,0.01,300);

　　Report.list(cas);
　}
}

這樣可以清楚的列出 creditAccount 陣列資料
而如果要每次都 import 一個檔案的話就累人了
因此可以改用 import 一個套件的所有檔案

import bank.*;
import util.*;
//這樣可以使用套件中的所有 class
import static java.lang.System.out;
//這樣可以少寫 System.out.println 的 System
import static util.Report.list;
//這樣也可以少寫 Report.

public class Test {
　public static void main(String[] args) {
　　CreditAccount[] cas = new CreditAccount[3];
　　cas[0] = new CreditAccount(101,"Simon",200,0.02,100);
　　cas[1] = new CreditAccount(102,"Mary",300,0.01,200);
　　cas[2] = new CreditAccount(103,"John",500,0.01,300);

　　//原來是 Report.list(cas);
　　list(cas);
　　Account a = new Account(105,"Ban",200);
　　//原來是 System.out.println(a);
　　out.println(a);
　}
}

這樣就可以管理大量的程式，又不會混淆啦！

重新定義方法
任何類別物件都有一個父類別 是 Object
因此也繼承了這個 Object 的方法

我們可以加以改寫橫跨多個 class 的方法
首先改寫 Account.java
重新定義方法，就會把 Object 的 toString 方法覆蓋

public String toString(){
　return number+"\t"+name+"\t"+balance;
}

接下來改寫 SavingAccount.java
重新定義方法

public String toString(){
　return super.toString() + "\t"+rate;
}

接下來改寫 CreditAccount.java
重新定義方法

public String toString(){
　return super.toString() + "\t"+limit;
}

最後執行

public class Test2 {
　public static void main(String[] args) {
　　CreditAccount ca = new CreditAccount(101,"Simon",200,0.02,30000);
　　System.out.println( ca.toString() );
　}
}
//結果顯示 101 Simon 200.0 0.02 30000.0

就可以看到結果。

垃圾收集
當物件記憶體被剷除的時候，物件會發生一個 finalize() 物件
這也是 Object 物件的一個方法。
首先在 Account.java 中加入

protected void finalize(){
　System.out.println(number+"clean.");
}

測試程式

public class Test2 {
　public static void main(String[] args) {
　　CreditAccount ca = new CreditAccount(101,"Simon",200,0.02,30000);
　　System.out.println( ca );
　　ca = null;
　　System.gc();
　}
}

會看到記憶體垃圾回收的訊息

繼承

先前談到了 Account 物件
適用來處理帳戶
有一個帳戶名稱、編號、存款餘額
但當我們來思考 SavingAccount 儲蓄存款的時候
我們會寫一個全新的 SavingAccount 物件
會發現也有一個帳戶名稱、編號、存款餘額，
只是多了一個利率 Rate

如果我們又要思考一個 CreditAccount 信用卡帳戶
又要寫一次 帳戶名稱、編號、存款餘額?
於是 '繼承' 的必要就產生了

擴充父類別
建立 SavingAccount.java 的時候擴充父類別

public class SavingAccount extends Account {
}

很厲害的地方就是
父類別所有功能就可以立刻使用了！

public class TestAccount {
　public static void main(String[] args) {
　　SavingAccount sa = new SavingAccount ();
　　sa.setNumber(101);
　　sa.show();
　}
}

於是我們只要把屬性 rate 以及相關法加入即可
並且重新定義方法。

public class SavingAccount extends Account {
　private double rate;

　public void setRate(double rate){
　　this.rate = rate;
　}

　public void show() {
　　//不用寫同樣的東西了，是不是很方便呢
　　//System.out.println("Number: " + number);
　　//System.out.println("Name: " + name);
　　//System.out.println("Balance: " + balance);
　　super.show();
　　System.out.println("Rate: " + this.rate);
　}
}

所謂的重新定義，是 Account 方法中的 show 和
SavingAccount 中的 show 可能不完全相同
因此借用了部份父類別的 show()
同時增加自己所需要的程式碼

子類別的建構式

//建構式, 還是要有參數
public SavingAccount(int number, String name, double balance,double rate){
　//同樣的也不需要再重新建構一次
　//this.number = number;
　//this.name = name;
　//this.balance = balance;
　super(number, name, balance); //網父類別找, 找到三個參數
　this.rate = rate;
}

加入這行建構式以後
子類別的功能可說是如虎添翼了

SavingAccount sa = new SavingAccount (101,"Simon",200,0.02);
sa.show();

最後執行只需要這樣！
真是太漂亮了

快速建立子類別
信用卡的子程序，繼續繼承前述子程序

public class CreditAccount extends SavingAccount {
　private double limit;

　public CreditAccount(int number, String name, double balance, double rate, double limit){
　　super(number, name, balance,rate); //使用父類別的建構式
　　this.limit = limit;
　}

　public void show(){
　super.show();
　　System.out.println("Rate: " + this.limit);
　}
　
　//信用卡專用的提款
　//使用 private 就可以用父類別的屬性了！
　public boolean withdraw(double amount) {
　　if (balance + limit >= amount) {
　　　balance = balance - amount;
　　　if (balance < 0 ) {
　　　this.limit = this.limit + balance;
　　　}
　　　System.out.println("提款成功，您提了"+ amount +"元，剩餘額度"+ limit);
　　　return true;
　　}
　　else {
　　　System.out.println("餘款或額度不足，提款未執行");
　　　return false;
　　}
　}
}

執行測試程式

public class TestAccount {
　public static void main(String[] args) {
　　CreditAccount ca = new CreditAccount(101,"Simon",200,0.02,30000);
　　ca.show();
　　//信用卡的餘額很特殊，可以是負的
　　//這裡使用的是信用卡 CreditAccount 裡的 withdraw 方法
　　ca.withdraw(350);
　　ca.show();
　}
}

保護類型
先前提到了 public 和 private 但還有一個重要的 protected，
這是允許子類別使用父類別的屬性。
這樣子類別才可以用前面的 (父類別) 屬性。

因此將 Account.java、SavingAccount.java 還有 CreditAccount.java 裡的
屬性的 private 都改為 protected (因為共用屬性的需要)

子類別的程式雖然少
但功能能夠繼續累積，非常有用！

建構式

撰寫類別 (class) 的時候，通常會設定許多屬性
但如果類別的方法經常要用到這些屬性 (類別變數) 呢？
能不能一次設定好呢？
當然可以…
就是使用建構式了。

//建立建構式
public Account(int number, String name, double balance){
　this.number = number;
　this.name = name;
　this.balance = balance;
}

//建構式也可以多載
public Account(int number, String name){
　this.number = number;
　this.name = name;
}

參見上述範例。

公開與私用
寫 class 的時候要不要公開類別？
通常，屬性要加上 private 避免被其他程式使用；

Account a = new Account(101,"Simon",200);
a.withdraw(1000); //方法有檢查的程式，不會扣成複數
a.show();

a.balance = a.balance - 1000;　//外部程式試圖改變屬性的值
a.show();

程式在執行的時候，如果屬性是 "封裝" 的，
就能保護變數不會被執行範圍外的程式，
而扣到不合理的負數。
完整程式如下

//屬性，且被保護
private int number;
private String name;
private double balance;

//建立建構式
public Account(int number, String name, double balance){
　this.number = number;
　this.name = name;
　this.balance = balance;
}

//建構式也可以多載
public Account(int number, String name){
　this.number = number;
　this.name = name;
}

//公開的方法
public void setNumber(int number) {
　this.number = number;
}

public void deposit(double amount) {
　this.balance = this.balance + amount;
}

public boolean withdraw(double amount) {
　if (this.balance >= amount) {
　　this.balance = this.balance - amount;
　　System.out.println("提款成功");
　　return true;
　}
　else {
　　System.out.println("您的餘額不足，提款未執行");
　　return false;
　}
}

public void show() {
　System.out.println("Number: " + this.number);
　System.out.println("Name: " + this.name);
　System.out.println("Balance: " + this.balance);
}

於是我們了解什麼是 public 和 private，與其主要功能

自訂方法

方法的重載
設定一個稱為 Util 的 Class

public int summary (int x, int y){
return x+y;
}
public int summary (int x, int y,int z){
return x+y+z;
}

建立一個 testUtil 使用這個 Util

Util u = new Util();
System.out.println(u.summary(2,3));
System.out.println(u.summary(2,3,4));

在 JDK 5.0 以後可以使用不定長度引數。

//自訂一個加總的方法
public double total (double... nums){
double sum =0;
for (int i=0; i < nums.length ;i++ ) {
sum = sum +nums[i];
}
return sum;
}
//注意其中的引數 nums 要放在最後

執行時呼叫該方法

System.out.println(u.total(1,2,3,4,5));
System.out.println(u.total(1,2,3,4,5,6,7,8,9,10));
//分別獲得 15.0 和 55.0

這樣可以用在參數無法確認個數的方法。

自訂類別

自訂類別
建立有相似屬性的物件的類別
在建立物件類別的檔案中不需要 main 的區塊。

//決定這個物件變數
int number;
String name;
double balance;

然後建立一個含有 main 區塊的程式

//建立物件
Account a = new Account();
//設定資料
a.number = 101;
a.name = "Simon";
a.balance = 300;
//顯示資料
System.out.println("number: " + a.number);
System.out.println("name: " + a.name);
System.out.println("blance: " + a.balance);

就可以正確印出資料。
但如果要進行存款、提款的動作，不要在 main 中製作，
要在 method 中進行處理。

方法
定義參數和返回值

//設定存款動作
public void deposit(double amount){
}
//設定提款動作
public boolean withdraw(double amount){
if (balance -amount <0) {
balance = balance-amount;
return true;
}
else{
return false;
}
}

然後再回到主程式。
加上使用方法的程式：

a.deposit(5000);
//顯示資料
System.out.println("number: " + a.number);
System.out.println("name: " + a.name);
System.out.println("blance: " + a.balance)

就會發現存款加上 5,000元了呢。
提款的範例

a.withdraw(5000);
//餘額判斷
if (a.withdraw(5000)) {
System.out.println("number: " + a.number);
System.out.println("name: " + a.name);
System.out.println("blance: " + a.balance);
}
else
{
System.out.println("帳戶不足無法提款");
}

甚至，我們可以把帳號資訊顯示整個作為方法來用。
只要 a.show() 就可以顯示帳號資訊

public void show(){
System.out.println("number: " + number);
System.out.println("name: " + name);
System.out.println("blance: " + balance);
}

陣列物件

陣列物件
陣列也是一種物件。通常用來放置同型態的資料。
如果要放 10 個人的年齡，而要取 10 個變數名稱的話，
那就太麻煩了！

因此，除了用 int 變數名稱 = 數字的這種方法外，
利用一維陣列 (one-dimensional arrays) 把他們整理起來。

int v;
int[] va　= new int[5]; //宣告，建立這個物件
System.out.println(va[0]); //會印出陣列的初始值

va[0]=32;
va[1]=33;
va[2]=34;
va[3]=35;
va[4]=36;
for (int i=0 ; i <5 ; i++) {
System.out.println( va[i]);
}

剛建立好陣列的時候，各資料的資料型態會有不同的初始值。
每個資料稱為：元素 (element)。
初始值還可以這樣設定

int[] va= new int[]{32,33,34,35,36};
for (int i=0 ; i < names.length ; i++) {
//存取時不能超過陣列邊界
System.out.println(va[i]);
}

所有的陣列物件都有一個 .length 屬性。
可以善加利用

String[] names = new String[3];
names[0] = "Simon";
names[1] = "Mary";
names[2] = "John";
for (int i=0; i < names.length ; i++){
System.out.println(names[i]);
}
//String 物件的初始值為 null //

利用迴圈印出 3x3的方塊(二維矩陣)
但3x3程式無法適用於不規則陣列。
要改成下列程式：

int[][] ia = {{1,2,3},{4,5,6,7,8},{9,10,11,12}};
for (int i=0; i<ia.length; i++) {
for (int i2=0; i2<ia[i].length; i2++) {
System.out.print(ia[i][i2] + "\t");
}
System.out.println();
}
//其中尤其是 la[i].length 要特別小心

不規則陣列用於行事曆程式

int m=PPJUtil.getInt("Month");
//簡易行事曆程式
String[][] cal = new String[12][];
cal[0] = new String[31];
cal[1] = new String[28];
cal[2] = new String[31];
cal[3] = new String[30];
cal[4] = new String[31];
cal[5] = new String[30];
cal[6] = new String[31];
cal[7] = new String[31];
cal[8] = new String[30];
cal[9] = new String[31];
cal[10] = new String[30];
cal[11] = new String[31];
//行事曆內容
cal[11][16] = "要上Java課"
cal[11][23] = "要上Java課"
//顯示內容
for(int j=0; j<cal[m-1].length; j++) {
if (cal[m-1][j] != null) {
System.out.println((m) + "/" + (j+1) + ":" + cal[m-1][j]);
}

另外有一種foreach 的作法

for (int[] x:ia ) {
for (int y:x ) {
System.out.print(y+ "\t");
}
System.out.println();
}

main 方法中的參數
命令列引數是一個非常特別字串物件陣列
例如操作者下
編譯 javac Test.java
執行 java Test Simon Mary "This is a book"

在 EditPlus 執行過程中可以用 Ctrl-3 來加入命令參數。

for (String s:args) {
System.out.println(s);
}

J2SE API

http://java.sun.com./j2se/1.5.0/docs/api/
Java 語言套件包括 lang, util, 和 net…
了解 Java 語言以後，查詢 API 文件是必要的。

先前說得字串物件 String 有哪些方法，都能在這裡查到。

型態與物件 III 包裝類別

包裝類別 (Wrapper 類別) 也是一種和許多基本型態對應的物件，如 int 資料型態，對應了一種 java.lang.Integer 類別，我們可以用 Integer 宣告一個參考名稱為 v 的物件。

int i = 3;
Integer v = new Integer(3);

int v2 = v.intValue();
byte b = v.byteValue();
System.out.println(v2);
System.out.println(b);
//兩個都可以正確輸出 3

而 Integer 物件的方法 .intVlaue()，則是將物件傳回來那種基本型態，如 v 這個物件，以 int 型態傳回來它的資料。

自動裝箱
先前的範例，將 v 設為物件，而 v2 是一個數字，在早期 JDK 版本， v2 是不能直接 = 物件 v 的，不過新的 JDK 5.0 支援了自動幫忙做 v2 = v.intValue() 這個動作，所以 v2 = v 編譯會成功！

int v2 = v
//在 JDK 5.0 以後有自動 unboxing

Integer i = 100;
Integer i2 = 100;
System.out.println( i == i2 );
//兩個物件用 == 比較參考值為 true，表示參考值相同
Integer i3 = 128;
Integer i4 = 128;
System.out.println(i3==i4);
//兩個物件 == 比較值超過裝箱重複範圍

自動裝箱的現象只發生在數字為 -128~127 之間 (byte 的範圍)。不過還是要注意只有 JDK 5.0 開始才支援 int v2 = v 這動作；原來是 v2 = v2.intValue() 。

型態與物件 II 字串物件

字串物件的進階探討
程式碼執行到 s3 的位置時，只要看到 new 的字樣，就會配置一塊新的記憶體給 s3。但 Java 語言運作的時候，會產生一個字串儲存池 (String Literal Pool)，且字串儲存池的內容部會重複。也因此， s 的 "Simon" 會放在字串儲存池中，同時 s2 會共用儲存池中的 "Simon"。

String s = "Simon";
String s2 = "Simon";
String s3 = new String("Simon");
String s4 = new String("Simon");
System.out.println(s3==s4);
//結果顯示 false
System.out.println(s==s2);
//結果則是 true
//利用字串儲存池將會節省記憶體

型態與物件

物件的概念
設定一個物件 String name2= new String("Simon");
型態 名稱 物件

為什麼 String 和以前的「基本資料型態」不同？
1. 物件是否 "相等"？

String name = new String("Simon");
String name2 = new String("Simon");
System.out.println( name == name2);

答案是 false (布林值為否)，也就是 name 和 name2 是不一樣的。物件 name = new String("Simon") 會在記憶體中有自己的編號，並與 name 變數名稱為參照；同樣的，name2 = new String("Simon") 會在記憶體中有自己的編號，並與 name2 變數名稱為參照。因此兩者是不同的。其中，name 是該物件的參考變數。

2. 一個字串的內容提供了許多 "方法" 來產生功能
例如：

String name= new String("Simon");
String upper = name.toUpperCase(); //呼叫字串的方法
System.out.println (upper); //結果會印出 SIMON

有些人也將 "方法"，稱為函式。真是太方便了！如果我們使用 lenght() 這種方法，就可以算出該字串的長度、使用 charAt() 這種方法，取得其中的某個字元

System.out.println (name.length()); //結果會印出 5
System.out.println (name.charAt(2)); //結果會印出 m

搭配使用可以寫出

//用一個迴圈印出名字
for (int c=0; c<=name.length()-1;c++ ) {
System.out.println (name.charAt(c));
}

檢查網址是否為 .tw，檢查某段字串的索引位置

//檢查網址
//了解 boolean startsWith(String s) 的用法
String url= new String("http://tw.yahoo.com");
System.out.println( url.startsWith("http://"));
System.out.println( url.endsWith(".tw"));
System.out.println( url.indexOf("yahoo"));
//結果會傳回 10 (在第11字元的位置)

比較兩個物件

String name = new String("Simon");
String name2 = new String("simon");
System.out.println( name2.equals(name));
//比較字串，結果 false
System.out.println( name2.equalsIgnoreCase(name));
//比較字串但不分大小寫，結果 true

取得某部份的字串

String url= new String("http://tw.yahoo.com");
System.out.println( url.substring(10,15));
//可以顯示出 yahoo
String addr= new String("台北市大安區…");
int p = addr.indexOf("區");
if (p != -1 ) {
System.out.println( addr.substring( p-2, p-2+3) ) ;
}
else {
System.out.println( "沒有區的資料" );
}
//找到區的位置
//顯示台北市的區別或沒有區的資料

迴圈的整理

巢狀 for 迴圈

//主要的3種迴圈架構
//while (判斷) { … }
//do { … } while{判斷};
//for (起始值;判斷;數值遞增) {}
int r = PPJUtil.getInt("Lines");
int t = PPJUtil.getInt("Times");

for (int c=1;c<=r ;c++ ) { for (int c2=1; c2<=t; c2++) { System.out.print("*");
}
System.out.println();
}

把 while 流程改寫為 for 流程
這是一段 while 迴圈的區塊

int c=1;
int c2=2;
while (c<=10) {
System.out.println(c+"-"+c2);
c++;
c2+=2;
}

可以這樣寫

//兩個變數同時增加
for (int c=1,c2=2; c<=10 ; c++,c2=c2+2) {
System.out.println(c+"-"+c2);
}

中斷或繼續
迴圈中使用 break 會立刻離開迴圈；
迴圈中使用 continue 會掠過迴圈後面的程式，
但繼續執行

//利用無窮迴圈持續執行
while (true) { //無窮迴圈
char g = PPJUtil.getChar("性別");
int w = PPJUtil.getInt("體重");
int h = PPJUtil.getInt("身高");
int sw = 0;
//性別輸入Q就離開迴圈
if (g =='Q') {
break;
}
//設定標準體重 (略)
//判斷超過標準體重判斷的資料
if (sw == 0) {
System.out.println("Error");
continue; //發生錯誤了！利用 continue 略過後續程式
}
//else {
System.out.println("體重:"+w);
System.out.println("性別:"+g);
System.out.println("身高:"+h);
System.out.println("標準:"+sw);
// }
System.out.println(w>sw ? "太重了!" : "很好,請保持!");
}
//迴圈又再度回到 while 處繼續持行

這樣就可以持續的輸入並判斷資料。
此外，break 還可以搭配 label 使用。

Java 程式流程

使用 switch 敘述

//獎金判斷程式
public class grade {
public static void main(String[] args) {
char grade = PPJUtil.getChar("成績");
int bonus = 0;
switch (grade) {
case 'A': //成績為 A的時候，設定獎金為 50000
bonus = 50000;
break;
case 'B': //成績為 B的時候，設定獎金為 30000
bonus = 30000;
break;
case 'C': //成績為 C的時候，設定獎金為 10000
bonus = 10000;
break;
default: //其他成績設定獎金為 1000
bonus = 1000;
}
System.out.println("Grade:"+grade);
System.out.println("Bonus:"+bonus);
}
}

switch 結構適用於檢測相等的情況。如果要用條件判斷的話，要使用 if 和 if/else 的敘述。
[!] switch 只能接受 int、short、byte、char 這4種變數型態。

迴圈 while 與 do / while

//輸出 1-5
int count = 1;
//布林值為真時候,會持續執行
while ( count <= 5 ) {
System.out.println(count);
count++;
//要記得讓 count 變數增加，否則將無法離開迴圈
}

迴圈是一個很方便的工具，可以重複同樣的工作。

int max = PPJUtil.getInt("輸入每列星星數量");
int maxline = PPJUtil.getInt("輸入行數");
int count = 1;
int line = 1;

//外迴圈 (當行數小於最大行數的時候，繼續執行)
while (line <= maxline) { //內迴圈 (當星星數未達每行星星數的時候，繼續執行)
count = 1;
while ( count <= max ) { System.out.print("*");
count++;
}
//內迴圈結束
System.out.print("\n");
line++;
}
//外迴圈結束

除此之外，也可以先要求執行某件事情，然後把判斷式放在後面，用 do 配合 while

//外迴圈
do {
count = 1;
//內迴圈：持續印出 "*"，直到到達每行所需星星數
do {
System.out.print("*");
count++;
} while (count <= max); System.out.print("\n");
//內迴圈結束
line++;
} while (line <= maxline); //外迴圈結束

for 的迴圈

int max = PPJUtil.getInt("輸入每列星星數量");
int maxline = PPJUtil.getInt("輸入行數");
for (int line=1; line <= maxline; line++) {
for (int count=1; count<=max; count++) {
System.out.print("*");
}
System.out.print("\n");
}

練習

int max = PPJUtil.getInt("輸入累進數");
int total = 0;
for (int count=1; count<=max; count++) {
if (countSystem.out.print(count+"+");
}
else if (count==max) {
System.out.print(count+"=");
}
total += count;
}
System.out.println(total);

Java 運算子

運算子
標準數學運算子包括加法「+」減法「-」乘法「*」和除法「/」；尚有一個餘數「%」 ，格式為：num1 % num2。舉例一個除法運算。

System.out.println(10.0/3)
顯示的值為 3.3333
但 System.out.println(10/3)
顯示的值為 3

[!] Java 計算時會自動賦予數字 (運算元) 一個型態。遞增/遞減運算子

當要處理比較大的整數的時候，要注意超過 int 型態範圍的問題：

//一年的秒數
int y = 70;
long s = y*365L*24*60*60;
system.out.println(s);
//計算過程中 y 是 long, 或把其中一個數字改為 L
//計算的結果 s 用 long 來儲存

位元的計算
使用 Java 內建的換算功能

public class Test1 {
public static void main(String[] args) {
System.out.println(Integer.toBinaryString(1024));
}
}

展示位元計算子「&(and)」的計算結果。

public class Test2 {
public static void main(String[] args) {
System.out.println(Integer.toBinaryString(13));
System.out.println(Integer.toBinaryString(12));
System.out.println("--------------");
System.out.println(Integer.toBinaryString(13 & 12));
}
}

輸出結果是

1101
1100
-----
1100

對於 & 運算，當兩個對應位元都是 1 的時候，才輸出 1。至於其他的運算子「|」「^」「~」分別說明如下：
「|」位元運算，對照的位元，只要有任一個位元是 1，則輸出 1。
「^」位元運算，對照的位元都是 0 或都是 1時輸出 0，否則輸出 1。
「~」位元運算，會換算成互補的 0 和 1

[!] int 包含 16 位元，第一個位元是正或負號的旗標。
位移運算子「<<」「>>」「>>>」是將位元向左或右移動數個單位。

指定運算子
常見要把變數 v 加上1，寫成

v = v + 1
v++
v += 1

效果是相同的。其中 += 是指定運算子。
[!] v++ 稱為後置遞增。請看下列範例：

int v =3;
int v2 = v++;
// v++ 的意含是 把 v 的值 +1
// v2 的敘述是 '後置遞增'；會先作 v2 = v 再進行 v+1
System.out.println(v);
System.out.println(v2);
//目前這個狀況 v1 會顯示 4，v2 會顯示 3

值的比較和判斷
查看兩數值大小關係的運算，使用關係運算子。常見如「==」判斷是否相等，「<」判斷左是否小於右者，「<=」判斷左是否小於等於右。若同時需要取兩組判斷結果的交集，使用「&&」連接兩者。

//徵友的條件
int age = PPJUtil.getInt("Age");
char gender=PPJUtil.getChar("Gender");
System.out.println(age >= 18 && age <= 28 && gender == 'F');
//年齡大於等於18歲，小於等於28歲，同時性別為 F

配合 if/else 陳述處理

//公車收費標準
int age = PPJUtil.getInt("Age");
char gender=PPJUtil.getChar("Gender");
if (age > 60 || age < 5 || gender == 'F') {
System.out.println("免費");
} //年齡大於60歲，或小於5歲，或性別為 F 都顯示為免費
else {
System.out.println("請投入15元");
} //其餘都顯示"請投入15元"

更多關於程式流程的內容，請參考 Java 程式流程

Java 程式語言

前言
Java 是一種程式語言，起源於 1991年的一個 程式語言的計畫，當時是為了開發一個稱為 Star 7 的產品。不過這項產品後來並沒有成功，而開發小組 Green team 仍開發了一個以 Java 技術為基礎的瀏覽器，名為 WebRunner。支援 Java Applet。Green team 認為這種程式有助於開發網頁多媒體元件，提昇網頁的品質。因此 Java 最初以 Applets 的形式應用為網頁上，後來演變為我們熟知的 Java 語言。

環境
Sun Microsystems 提供 Java 標準版、Java 微型版以及 Java 企業版。另外還提供了軟體開發工具，也就是所謂的 SDK (Software Developer's Kit)；裨益程式設計者能製作、編譯和執行 Java 程式。

如前述的 Applet 執行時需要 Java 執行環境 (Java Runtime Environment) 的支援；以 Java 撰寫並編譯好的程式，則透過 Java 虛擬機器 (Java Virtual Machine) 可以運行在不同的平台上。

下載 Java SDK
[!] 下載 Java SDK 之後，您可能還需要設定環境變數，包括 Path 環境變數及 Classpath 環境變數。

編輯器
文 字編輯器，如 Windows 記事本能編輯 Java 程式。從 Windows 命令提示字元執行 javac 則負責將 .java 程式檔案編譯為 .class 檔案。此外筆者，使用 EditPlus 2 這套軟體編寫 Java 程式。使用編輯器的好處是有行數號碼，同時顏色的區隔、排版都能幫助程式寫作的進行。