JVM記憶體圖-類別的載入與執行

寫好的程式編譯成class之後
透過class loader啟動放到記憶體
class 類別檔就好比是一個設計藍圖
藍圖內有static的method或者field都配置在Method area內
可以整個程式使用
物件(Object)則配置在Heap區
JVM stack則是放變數的起始位置

檔案的讀取

寫一個程式，把文件檔的內容讀取出來

import java.io.IOException;
import java.io.FileReader;
import java.io.BufferedReader;

class Print{
    public static void main(String[] args) throws IOException{
      
        FileReader f =new FileReader("d:\\MyWriter.txt");
        FileReader f1 =new FileReader("d:\\MyWriter.txt");
        BufferedReader b = new BufferedReader(f);
        BufferedReader b1 = new BufferedReader(f1);

        String s;
        int i=0;
        int j=0;
        while((s = b.readLine())!=null){
            ++i;
        }
        b.close();
//用變數i來統計總共幾筆資料

        String[][] t =new String[10][];
        while((s = b1.readLine())!=null){
            t[j]=s.split("：");
            ++j;
        }
        b1.close();
//逐行讀取，切割分開後用陣列方式存放

        for(int k=0;k<i;k++){
            System.out.println(t[k][0]+"："+t[k][1]);
        }
    }
}

執行結果：
jack：10
mary：20
tom：30
mark：40

透過把檔案丟到陣列再進行讀取，但實際上不用用到這麼麻煩

import java.io.IOException;
import java.io.FileReader;
import java.io.BufferedReader;

class Print{
    public static void main(String[] args) throws IOException{
      
        FileReader f =new FileReader("d:\\MyWriter.txt");
        BufferedReader b = new BufferedReader(f);
        String s;

        while((s = b.readLine())!=null){
            System.out.println(s);
        }
        b.close();
//這邊改為判斷檔案非空值就列印，如此也可以做到印出整個文件
    }
}

執行結果：
jack：10
mary：20
tom：30
mark：40

檔案的寫入

寫一個程式，可以儲存人名和成績

import java.util.Scanner;
import java.io.FileWriter;
import java.io.IOException;

class Write{
    public static void main(String[] args)throws IOException{
   
        FileWriter f = new FileWriter("d:\\MyWriter.txt", true);
//透過FileWriter來指定位置跟存入一個檔案
   
        Scanner s = new Scanner(System.in);

        System.out.println("請輸入性名");
        String name = s.nextLine();
        System.out.println("請輸入分數");
        int sc = s.nextInt();
       
        f.write(name+"："+sc+"\n");
        f.close();
    }
}

執行後生成一個檔案
檔案內容：
jack：10
mary：20
tom：30
mark：40

多載(Overload)

多載的方式可以用在類別和建構式內，讓程式依照輸入參數的不同去選擇適當的處理方式執行
例如：買蘋果

class apple{
    int app1;
    int app2;
    int sum;
   
    apple(){
        app1 = 0;
        app2 = 0;
    }
//沒有給參數的建構式

    apple(int a, int b){
        app1 = a;
        app2 = b;
    }
//有給參數的建構式

    public void show(){
        sum=app1*15+app2*12;
        System.out.println("共買富士蘋果"+app1+"顆，梨山蘋果"+app2+"顆");
        System.out.println("一共是"+sum+"元");       
    }
   
}

public class Buy{
    public static void main(String[] args){
        apple x = new apple();
        x.show();
       
        apple y = new apple(10,20);
        y.show();
    }
}

執行結果：
共買富士蘋果0顆，梨山蘋果0顆
一共是0元
共買富士蘋果10顆，梨山蘋果20顆
一共是390元

可以觀察到程式自動根據有無參數去呼叫適當的建構式使用了

建構式(Constructor)

建構式的用法，是在建立物件的起始值
例如：寫一個程式做簡單計算第幾次執行

class X{
    int num;
   
    public X(){
        num = 0;
        System.out.println("開始執行");
    }
//Constructor做為初始值
//一定使用class的名稱做為Constructor的名稱
//建構式不能有傳回值
    public void show(){
        num++;
        System.out.println("第"+num+"次執行");
    }
}

public class Constructor{
    public static void main(String[] args){
        X a=new X();
//建立一個新的物件a
        a.show();
        a.show();
    }
}

執行結果：
開始執行
第1次執行
第2次執行

但若是沒有定義Constructor，在java程式會自動準備一個沒有參數的建構式來使用
像是改成：
    public X(){

            }
也是可以被執行

結果如下：
第1次執行
第2次執行

方法的類型(method)

method分為兩種類型

instance method

class test{
    void ln(){
        System.out.println("Hello");
    }
}

public class Imethod{
    public static void main(String[] args){
        test a=new test();
        a.ln();

//要先建立新物件後才能使用

    }
}

class method

class test{
    static void ln(){
        System.out.println("Hello");
    }
}

public class Cmethod{
    public static void main(String[] args){
        test.ln();

//不需要建立物件就可以使用

    }
}

兩者差別在於，class method有用static宣告
instance method再使用前要先建立物件，class method則不用，可以立即被使用
並且class method只能使用class field

變數的類型(Field)

基本上分三類
Class Field (Static)

class vclass {
  static int a=100;

// class field
  static void va(){
     System.out.println(++a);
  }
}

不在method內，前面有static宣告，置於method area
classfield可以被整個運作中的java程式使用，所以又稱為全域變數
再使用上也可以不用給初值

Instance Field (Heap)

public class vinstance {
    int a=100; 
}

沒有寫在method內，也沒有static宣告，再JVM記憶體內配置在heap
有效的範圍只在整個class內

Local Field (Stack)  

class vlocal {
  void z(){
     int  b; 

// b 沒有設定初值, 這行單獨編譯是會成功
     System.out.println(b); 

// 編譯時出現 vlocal.java:4: variable b might not have been initialized
  }
}

在method內宣告的變數，再JVM記憶體內配置在stack 

在使用上，一定要有初值
而且不能有static宣告

作業練習-字串切割

題目：將 "2008-10-31" 這字串轉換成 "2008 年 10 月 31 日"

class HomeWork2{
    public static void main(String[] args){
   
      String d = "2008-10-31";
      String[] t; 
//字串物件陣列變數
     
      t=d.split("-");
//把字串切割後用陣列存放
     
      System.out.println(t[0] +"年" + t[1] +"月"+ t[2] +"日");
   
    }
}

執行結果
2008年10月31日

作業練習-數字排列

寫出一個程式，限定數字1-9，讓數字可以做到下面的排列
/*
輸入數字 : 3  
1
 2
333

輸入數字 : 5
1
 2
  3
   4
55555
*/

程式如下

import java.util.Scanner;
import java.io.IOException;
public class HomeWork1{

    public static void main(String[] args) throws IOException{
   
        Scanner k = new Scanner(System.in);
       
         int c;
         do{
              System.out.println("請輸入數字:");
             c = k.nextInt();

         }while (c<1 || c>9);
//判斷數字範圍再1-9
        
         String str="", sp="";
         for(int i=1;i<c;i++){
           System.out.println(sp+i);
           sp += ' ';
//透過sp來延伸空格的長度,然後在加上數字
           str=str+c;        
//str用來累計最後要的數字的長度
         }
         System.out.println(str+c);
            
    }
}

這樣就可以求得想要的結果

作業練習-根據老師給的程式寫出比較用的程式

作業程式如下：

class StudentDO {
   String name;
   int chinese;
   int english;
   int math;

   // 建構子 (無參數)
   StudentDO () {
     this("Nobody",0,0,0);
   }
   // 建構子 (四個參數)
   StudentDO (String n, int c, int e, int m){
     name=n;
     chinese=c;
     english=e;
     math=m;
   }
}

public class TestStudentDB {
   public static void main(String[] argv) {
      StudentDO x = new StudentDO("Tom",12,23,33);
      StudentDO y = new StudentDO("Mary",55,44,33);

      // 在此加入程式, 比較 x 與 y 物件大小 (根據物件中數字總合來比較),
      // 將大的物件總和顯示出來
   }
}

下面是作業的答案

class StudentDO {
   String name;
   int chinese;
   int english;
   int math;

   // 建構子 (無參數)
   StudentDO () {
     this("Nobody",0,0,0);
   }
   // 建構子 (四個參數)
   StudentDO (String n, int c, int e, int m){
     name=n;
     chinese=c;
     english=e;
     math=m;
   }
}

public class TestStudentDB {
   public static void main(String[] argv) {
      StudentDO x = new StudentDO("Tom",12,23,33);
      StudentDO y = new StudentDO("Mary",55,44,33);
    
      if((x.chinese+x.english+x.math)>(y.chinese+y.english+y.math))
         System.out.print(x.chinese+x.english+x.math);
      if((x.chinese+x.english+x.math)<(y.chinese+y.english+y.math))
         System.out.print(y.chinese+y.english+y.math);
      if((x.chinese+x.english+x.math)==(y.chinese+y.english+y.math))
         System.out.print("相等");     
   }
}

執行結果
132

但是這樣寫是把事先準備好的instancefield呼叫下來使用

也可以準備一個method去處理


class StudentDO {
   String name;
   int chinese;
   int english;
   int math;

   // 建構子 (無參數)
   StudentDO () {
     this("Nobody",0,0,0);
   }
   // 建構子 (四個參數)
   StudentDO (String n, int c, int e, int m){
     name=n;
     chinese=c;
     english=e;
     math=m;
   }

   public int getSum() {
      return chinese + english + math;
//用這個method去做總和再來回傳
   }
}

public class StudentDB01 {
   public static void main(String[] argv) {
      StudentDO x = new StudentDO("Tom",12,23,33);
      StudentDO y = new StudentDO("Mary",55,44,33);

      if ( x.getSum() > y.getSum() )
         System.out.println(x.getSum());
      else
         System.out.println(y.getSum());
//直接用method做總和以後,再來做比較
   }
}

這樣子可以讓程式用method做完運算再來取得想要得值，可以讓整個程式看起來比較乾淨，method也可以重複被使用

作業練習-讀取log

課程作業：撈取log檔中的IP

import java.io.*;
import java.net.*;
import java.util.*;

public class  myLog01{
    public static void main(String[] args) throws IOException{
        URL fileURL = myLog01.class.getResource("/wiki.myruby.net-May-2012");
        FileReader fileReader = new FileReader(fileURL.getFile());
        BufferedReader bReader = new BufferedReader(fileReader);
       
   
        String y;
        int x=0;
        while((y = bReader.readLine()) != null ){
            ++x;
        }
        System.out.println("此文件總共"+x+"個IP");

//用來逐行讀取,先求出ip總數(含重複)
       
        String[] t;
        String[] ip=new String[x];
        int i=0;
       
        FileReader f1=new FileReader(fileURL.getFile());
        BufferedReader b1 =new BufferedReader(f1);
        while((y = b1.readLine()) != null ) {
               t=y.split(" ");
               ip[i]=t[0];
               ++i;
        }
//再從頭讀取一次,然後用空格做分割,再取出第一個位置的值直接放到ip陣列內

        Arrays.sort(ip);
//把ip按照順序排列一次

        int s=0;
        int m = 0;
        int j;
        for(j=0; j<x-1 ; j++) {
            if(ip[j].equals(ip[j+1])!=true){
                s=j-s;
                System.out.println(ip[j]+" 造訪 "+s+" 次");
                s=j;
                m++;
            }       
        }
        System.out.println(m+"個ip造訪");
    }
}
//把陣列ip值做比較,後一個等於前一個的時候就做累計,用來求出同個ip有幾次的造訪
//最後再統計扣掉重複以後,總共是幾個ip造訪

檔案 wiki.myruby.net-May-2012 內容大概都像下面這樣

1.202.218.8 - - [30/Apr/2012:07:04:47 -0600] "GET /robots.txt HTTP/1.0" 404 2554 "-" "\"Mozilla/5.0"

最後運算的結果如下(取一行)

1.202.218.8 造訪 206 次

 這個程式是用來練習撈取ip記錄檔，像大型網站要看有多少訪客的時候就可能用上這樣的程式撈資料

類別與物件

類別
java內的class檔
可以想像為一個東西的"規格"
因此在大量作相同屬性物件的時候
可以透過使用類別方式提升效率

物件
實際上，物件當中可以包含了資料和方法
也可以透過類別來產生物件

有夠模糊的說明
講白了就是
java將很多類型相同的功能都集合在同一個類別檔內
這些類型相同的功能就形成了類別

物件則就好比一個物體
這個東西可以純粹的只是物體
也可以是包含產生物體的機器
當然這台機器就有生產物體的方法

陣列的排序-遞增的另一個做法

還有一個方式也可以做到陣列排序由小到大
使用 Arrays.sort()

程式：
import java.util.Arrays;

public class Test{

    public static void main(String[] args){

        int[] i ={80,20,40,30,10};

        Arrays.sort(i);
        System.out.println(Arrays.toString(i));
    }
}

執行結果：
[10, 20, 30, 40, 80]

可以看到程式自動將一開始我們指定的數由小到大重新排列了

當然也可以用在文字排列上

程式：
import java.util.Arrays;

public class Test{

    public static void main(String[] args){

        String[] i ={"ada","sid","data"};

        Arrays.sort(i);
        System.out.println(Arrays.toString(i));
    }
}

執行結果：
[ada, data, sid]

程式自動按照字首的順序將字串進行排序了
可是值得注意的是
他是按照第一個字元做大小排列

類別庫

java.lang　　   　　　語言的相關類別
java.io　　　　　　　輸出入的相關類別
java.util　  　   　　　工具程式的相關類別
java.security　 　　　安全性的相關類別
java.text           　　　數值與日期等國際化的相關類別
java.awt           　　　AWT(abstract Window Tookit)的相關類別
java.applet       　　　Applet的相關類別
java.beans       　　　JavaBeans的相關類別
java.math         　　　數值運算的相關類別
java.net            　　　網路的相關類別
java.rmi            　　　RMI(Remote Method Invocation)的相關類別
java.sql            　　　存取資料來源的相關類別
javax.accessibility   　使用者輔助功能的相關類別
javax.naming          　名稱搜尋服務的相關類別
java.sound   　　　　音訊的相關類別
javax.swing  　　　　Swing的相關類別
javax.xml.parsers　　處理XML文件的類別
javax.xml.transform    執行XML文件之轉換的類別

相關類別庫的參考網址：
http://docs.oracle.com/javase/7/docs/

在java內已經有不少類別物件提供開發者使用，開發程式時會使用到的類別(class)檔案都可以從這邊去尋找並使用

基本中的基本

程式的基本架構
一定先有一個框架

public class Test{

    public static void main(String[] args){

    }
}

再來看程式內容需要
有需要什麼類型的變數就宣告變數型態
像是
int i  整數型態

int[] i 陣列型態

如果需要顯示出結果則是
System.out.print();

程式內需要條件判斷時，則使用
if()

switch(){
　case :
　break;
　default:
　break;
}

有需要用到迴圈則是
while(){
}

do(){
}while();

for(){
}

透過鍵盤輸入值則是

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

使用前要先宣告
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

另一個用法是
Scanner a = new Scanner(System.in);

使用前要宣告
import java.util.Scanner;

最基本型態大致上就如此
我覺得就像是人體最基本的單位，細胞吧

多維陣列

多維陣列的概念就是陣列中還有陣列
像是 test[0][0] ，這是個二維陣列

舉例說明，例如有兩個人，分別有3科成績國文、英文、數學

就可以用多維陣列表示

test[0][0]  第一個人的國文　test[1][0]  第二個人的國文
test[0][1]  第一個人的英文　test[1][1]  第二個人的英文
test[0][2]  第一個人的數學　test[1][2]  第二個人的數學

陣列的排序

將陣列內的數字排列大小後顯示出來
使用之前的輸入成績的程式來加東西

程式：
import java.util.Scanner;

public class Test{

    public static void main(String[] args){

        System.out.println("請輸入班級人數：");
        Scanner a = new Scanner(System.in);

        int num = a.nextInt();
        int[] t = new int[num];
        System.out.println("請輸入考試分數：");

        for(int i = 0; i < num; i++){
            t[i]=a.nextInt();
        }

        for(int i = 0; i < num; i++){
            System.out.println("第"+(i+1)+"個人"+t[i]+"分");
        }

//這段開始作成績排序       
        System.out.println("成績排序");
        for(int x=0;x<t.length-1; x++){
            for(int y=x+1;y<t.length; y++){
                if(t[y] > t[x]){
                    int tmp = t[y];
                    t[y] = t[x];
                    t[x] = tmp;
                }
            }
        }
       
        for(int j=0; j<t.length; j++){
            System.out.println("第"+(j+1)+"名"+t[j]+"分");
        }
       

    }
}

結果：
請輸入班級人數：
5
請輸入考試分數：
10
30
20
50
40
第1個人10分
第2個人30分
第3個人20分
第4個人50分
第5個人40分
成績排序
第1名50分
第2名40分
第3名30分
第4名20分
第5名10分

單把成績排序那段拿出來看好了

        for(int x=0;x<t.length-1; x++){
            for(int y=x+1;y<t.length; y++){
                if(t[y] > t[x]){
                    int tmp = t[y];
                    t[y] = t[x];
                    t[x] = tmp;
                }
            }
        }

這段程式使用了兩個for迴圈來做數字大小的比較

第一個 for 宣告了 int x ，需要的範圍是0~3
第二個 for 宣告了 int y ，需要的範圍則是1~4

if 則開始判斷 t[y] > t[x] 的時候，將兩個數值交換

然後依序下去判斷接下來的數值，來進行排序

推算如下：

判斷式    如果後面真的比前面大 排序就交換，否則不換
t[1] > t[0] 30 10 20 50 40
t[2] > t[0] 30 10 20 50 40
t[3] > t[0] 50 30 10 20 40
t[4] > t[0] 50 30 10 20 40

t[2] > t[1] 50 30 10 20 40
t[3] > t[1] 50 30 10 20 40
t[4] > t[1] 50 40 30 10 20

t[3] > t[2] 50 40 30 10 20
t[4] > t[2] 50 40 30 10 20

t[4] > t[3] 50 40 30 20 10

完成排序

陣列的長度

如果要得知一個陣列有多長，可以使用 length 來取得長度

例如：

public class Test{

    public static void main(String[] args){

//先準備5格空間
        int[] t = new int[5];

//列出陣列長度
       System.out.println("陣列的長度為"+t.length);

    }
}

結果：
陣列的長度為5


若是透過鍵盤輸入的話

import java.util.Scanner;

public class Test{

    public static void main(String[] args){

//透過鍵盤輸入想要的長度
        System.out.println("請輸入想要的陣列長度：");
        Scanner a = new Scanner(System.in);
        int num = a.nextInt();
        int[] t = new int[num];

//將輸入的長度讀取出來
        System.out.println("陣列的長度為"+t.length);

    }
}

結果：
請輸入想要的陣列長度：
5
陣列的長度為5

陣列-array

陣列的概念，就像是準備很多箱子，用來存放資料
它的特性是，「一次可以存放大量同性質資料」

例如
int[] test;
宣告了一個陣列變數

test = new int[5];
準備了五個空間，每個都可以儲存int型態的資料

當然也可以寫在一起
int[] test = new int[5];

指定資料給陣列

在每個陣列的格子內放入整數資料

int[] test = new int[5];

test[0] = 80;
test[1] = 60;
test[2] = 22;
test[3] = 50;
test[4] = 75;

然後就可以列印出來

class Test{

    public static void main(String[] agrs){

//這邊宣告陣列和陣列中的值
        int[] test = new int[5];

        test[0] = 80;
        test[1] = 60;
        test[2] = 22;
        test[3] = 50;
        test[4] = 75;

//此行開始宣告第幾個人幾分
        for(int i = 0;i < 5; i ++)
        System.out.println("第"+(i+1)+"個人"+test[i]+"分");

    }
}

得到結果：
第1個人80分
第2個人60分
第3個人22分
第4個人50分
第5個人75分 


但是要注意的是，上面的陣列程式只有指定了５個位置來存放資料，如果刻意去讀取不存在的資料位置就會出錯
例如 int[10] ，並沒有這個值，所以會讀取不到資料

也可以使用陣列的初始化方式，得到的結果也會和上面相同

int[] test = {80,60,22,50,75}

透過鍵盤輸入陣列值

假設一個目標
現在需要一個程式，一開始可以先指定班級有幾個人，然後再逐一輸入成績，最後列印出結果

程式：
//一開始宣告要使用到的class
import java.util.Scanner;

public class Test{

    public static void main(String[] args){

//這行宣告輸入班上多少人
        System.out.println("請輸入班級人數：");
        Scanner a = new Scanner(System.in);


//接下來把輸入的數字變成準備多少陣列空間
        int num = a.nextInt();
        int[] t = new int[num];


//接著依序輸入成績
        System.out.println("請輸入考試分數：");
        for(int i = 0; i < num; i++){
            t[i]=a.nextInt();
        }

//最後列印出陣列的內容
        for(int i = 0; i < num; i++){
            System.out.println("第"+(i+1)+"個人"+t[i]+"分");
        }

    }
}

結果：
請輸入班級人數：
5
請輸入考試分數：
10
20
304
40
50
第1個人10分
第2個人20分
第3個人304分
第4個人40分
第5個人50分

do~while

do{
  敘述;
}while(條件);

先直行一次do裡面的程式，再來判斷while裡面的條件是否為true,只要為true就再次執行do裡面的程式

與while不同的地方是，while是先判斷再執行，do~while是先執行再判斷

public class Test{

    public static void main(String[] args){
  
        int i = 1;

        do{

            System.out.println("第"+ i +"次執行");
            i++;

        }while(i < 5);
      
        System.out.println("執行結束");  
    }

}

結果：
第1次執行
第2次執行 
第3次執行
第4次執行 
執行結束

while

while(條件式){
敘述句;
 ...
}

當條件式為true時，程式區段內的程式碼會重複執行


例如：

public class Test{

    public static void main(String[] args){

        int i = 1;

        while(i < 5){

            System.out.println("第"+ i +"次執行");
            i++;
 
        }
        System.out.println("執行結束");

    }

}

結果：
第1次執行
第2次執行
第3次執行
第4次執行
執行結束

其中 i++; 如果沒有寫入，則會造成無窮迴圈

for

for(設定段;條件段;運算段){
...
}

設定段：可以設定一個變數的起始值

條件段：條件如果為true，則執行 {} 內程式

運算段：在條件段值變為false前，重複執行運算

例如：


public class Test{

    public static void main(String[] args){

        for(int i = 1; i < 5 ; i++){
            System.out.println("第" + i + "次執行");
        }
        System.out.println("執行結束");

    }

}

結果：
第1次執行
第2次執行
第3次執行
第4次執行
執行結束

switch

switch (運算式){

    case 值1:
        敘述句1;
        break ;

    case 值2:
        敘述句2;
        break ;


    default:
        敘述句 d;
        break;
}

命令寫法如上，case部分則看有多少可能發生的值，就輸入多少次
例如：

import java.util.Scanner;

public class Test{

    public static void main(String[] args){


        System.out.println("請輸入1或2");
        Scanner a = new Scanner(System.in);
        int x =a.nextInt();

     
            switch(x){
            case 1:
            System.out.println("輸入的是1");
            break;
            case 2:
            System.out.println("輸入的是2");
            break;
            default:
            System.out.println("請輸入1或2");
            break;
            }

    }

}

結果會執行：
請輸入1或2
1
輸入的是1

break部分如果都沒有加上，則會發生命令一直被使用下去的結果
例如：

import java.util.Scanner;

public class Test{

    public static void main(String[] args){


        System.out.println("請輸入1或2");
        Scanner a = new Scanner(System.in);
        int x =a.nextInt();

     
            switch(x){
            case 1:
            System.out.println("輸入的是1");

            case 2:
            System.out.println("輸入的是2");

            default:
            System.out.println("請輸入1或2");

            }

    }

}

結果沒有中斷：
請輸入1或2
1
輸入的是1
輸入的是2
請輸入1或2

if

if的敘述有分做以下三種

if()

if() ... else

if() ... else if() ...else

1.if()
在小括號內輸入的是一個boolean值，也就是判斷真假的條件

例如，５>3表示真，3>5表示假

條件達成以後，執行以下的動作

if(5>3)

System.out.println("正確");

如此一來畫面就會輸出：正確

2.當 if() 之後要執行兩個敘述時，一定要使用 {} 將內容包起來，否則只會執行最後一條敘述

例如，用鍵盤輸入數字的程式：

import java.util.Scanner;

public class Test{

    public static void main(String[] args){

        System.out.println("請輸入數字");
        
        Scanner a = new Scanner(System.in);

        int x = a.nextInt();

        if( x == 1)
        System.out.println("輸入了1");
        System.out.println("選擇了1");


    }

}

在 if 後面沒有加 {}，再輸入1時會輸出

輸入了1
選擇了1

的結果，但是如果輸入2，結果卻出現

選擇了1

表示，結果就算錯誤，if()後面只跟著判斷一行敘述執不執行

但是如果用 {} 後

 import java.util.Scanner;

public class Test{

    public static void main(String[] args){

        System.out.println("請輸入數字");
       
        Scanner a = new Scanner(System.in);

        int x = a.nextInt();

        if( x == 1){
       
            System.out.println("輸入了1");
            System.out.println("選擇了1");
       
        }

    }

}

程式便會把 {} 內的敘述當作同一個程式區段執行，因此輸入非1的值就不會執行後面的命令

new

new的概念就像是配置一個新的記憶體空間出來，準備給後面的東西使用

像是

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      
Scanner a = new Scanner(System.in);

都表示配置新的記憶體空間給鍵盤輸入使用

public

就像一個遊戲程式來說，一定是由大大小小的各類檔案所組成，寫程式就是如此，寫小的程式，像是加法運算，或者寫一個很大，由眾多class檔組成的java程式，大到如同銀行的系統，高鐵的售票系統等

如何讓程式可以被其他程式使用呢

像一個小的程式來說

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


就算寫成


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


也是可以執行的


差別在於有沒有public，今天這個程式是否會被別的程式使用，有宣告則可以，沒宣告則不行

如何去使用他?

public class UseHello{

    public static void main(String[] args){

        String[] x = null;
        Hello.main(x);

    }

}

就可以使用剛剛所寫的Hello的程式

透過鍵盤輸入做運算

1.BufferedReader 輸入

import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Test{

    public static void main(String[] args)throws IOException{
  
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));


//這邊讓畫面顯示出輸入第幾個數字，方便識別
        System.out.println("請輸入第一個數");
        String str1 = br.readLine();
        System.out.println("請輸入第二個數");
        String str2 = br.readLine();

//將輸入的數值轉換成int值
        int num1 = Integer.parseInt(str1);
        int num2 = Integer.parseInt(str2);
        int sum = num1+num2;


        System.out.println("第一個數是" + num1);
        System.out.println("第二個數是" + num2);
        System.out.println("兩者相加是" + sum);
  
    }

}
由於變數宣告都是統一寫在一起，因此一旦輸入非數字，在最後運算結果的時候就會跳出錯誤的訊息
但是如果寫成如下：
        String str1 = br.readLine();
        System.out.println("請輸入第二個數");
         int num1 = Integer.parseInt(str1);
 便會在一開始輸入值就產生錯誤

2.Scanner 輸入

import java.util.Scanner;

public class Test{

    public static void main(String[] args){
 

        System.out.println("請輸入第一個數");
        Scanner a = new Scanner(System.in);
//這邊用int宣告可以確保輸入一定是數字
        int x =a.nextInt();

      
        System.out.println("請輸入第二個數");
        Scanner b = new Scanner(System.in);
        int y = b.nextInt();

        int sum = x + y;
        System.out.println("第一個數是"+x);

        System.out.println("第二個數是"+y);

        System.out.println("總和是"+sum);
 


    }

}
一旦輸入非數字，在第一個值就會跳出錯誤訊息

簡單的加法運算

以下用加法作範例

class Test{
    public static void main(String[] agrs){

//以下先宣告3個變數，分別是num1,num2,sum
        int num1 = 2;
        int num2 = 3;
        int sum = num1+num2;

//讓num1,num2.sum在畫面上顯示
        System.out.println("變數num1是" + num1);
        System.out.println("變數num2是" + num2);
        System.out.println("兩者相加是" + sum);
//當然也可以把運算式寫在輸出
        System.out.println("兩者相加是" + (num1+num2));

// 將num1的值再加1
        num1 = num1+1;

        System.out.println("變數num1加1以後是" + num1);

    }

}

從鍵盤輸入變數-2

從此處開始會使用到
import java.io.*;
 
import java.io.IOException;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Scanner;

在java程式中會使用到一些方法讓使用者可以透過鍵盤輸入變數數值，並且在畫面中列印出來讓使用者確認是否有得到結果

因此Compiler會先檢查再 rt.jar 檔案中的相對應位置，是否有需要的class檔案
例如：

 import java.io.IOException;

會檢查 rt.jar 的壓縮檔內，java\io 內是否有 IOException.class的檔案

從鍵盤輸入變數

可使用兩種方式
使用者可以自行輸入數值,並且在結果中列印出來

1.BufferedReader

import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Test{

    public static void main(String[] args)throws IOException{
  
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        String str = br.readLine();

        System.out.println(str);

  
    }

}

使用了兩次變數,感覺上繞了一圈才完成

2.Scanner

import java.util.Scanner;

public class Test{

    public static void main(String[] args){
  
        Scanner a = new Scanner(System.in);

        System.out.println(a.next());

  
    }

}

只使用一次變數就完成

同樣的，要輸入兩個以上時，就宣告兩次輸入的指令就可以

1.
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Test{

    public static void main(String[] args)throws IOException{
  
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        String str1 = br.readLine();
        String str2 = br.readLine();

        System.out.println(str1);
        System.out.println(str2);

  
    }

}

2.
import java.util.Scanner;

public class Test{

    public static void main(String[] args){
  
        Scanner a = new Scanner(System.in);
        Scanner b = new Scanner(System.in);

        System.out.println(a.next());
        System.out.println(b.next());
  
    }

}

變數

變數可以當作假想的箱子 


宣告變數型態 宣告變數名稱 = 值;

byte a =10;        

short b = 10;


int c = 10;

long d = 10;

float e =2.1;

double f = 2.1;

宣告變數型態類似於設定一個假想箱子的大小 ，變數就可以放入相對應大小的東西

byte = 1 byte

short = 2 byte

int = 4 byte

long = 8 byte

float = 4 byte

double = 8 byte

簡單的進位換算

16進位的0061
 先換成2進位

0000 0000 0110 0001 =0061
8421 8421 8421 8421

換十進位

0000 0000   0      1     1    0    0  0  0  1   =總和97
                      128  64  32  16  8  4  2  1

常值-Literal

Literal 常值

常值的資料是寫死的

常值有4種型態

1.字元

2.字串

3.整數


4.浮點數


System.out.println( 'A' );           單引號表示字元，佔2個byte

System.out.println( 100 );         都沒有表示數值  整數，佔4個byte

System.out.println( 2.890 );      小數點表示浮點數，佔4或8個byte

System.out.println( '\'' );             \後面帶出特殊字元

System.out.println( '\\' );
 
System.out.println( "\u0061" );  \u後面為16進位數字
                                                    \u  Unicode
                                     0061      每個4bits   16bits=2byte

                                  \u0061=a 換算十進位=97 A=65

JAVA入門-註解

1.//  雙斜線
只有單行註解

2. /* */ 區塊註解
可以跨越多行
在星號內輸入文字進行註解

3./**
   */   雙星註解
用來編輯文件用的
當文件轉換為html時會進行標註

JAVA入門-字串內的文字換行

public class Cross{
    public static void main(){

         System.out.println("1*1=1\n1*2=2\n1*3=3\n1*4=4");

    }
}

結果：
1*1=1
1*2=2
1*3=3
1*4=4

\n表示換行,在字串內才可以使用

JAVA入門-一個程式的基本重點

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

1.檔名 Hello 要和程式預設名稱一樣,並且第一個字要大寫

2.小括號前單字為Method

3.雙引號內容為字串
   單引號為字元

4. ; 分號為程式結束符號

5.// 表示註解的意思

JAVA入門-使用的編譯器

1.java-CMD
最原始的命令提示字元介面
從建立檔案名稱到寫完程式
到compiler後執行
全部手動

2.java-NPP
有操作介面,在使用上比命令提示字元方便很多
存檔讀檔可透過圖形介面使用
較為人性化,關鍵字也會自動轉換顏色,方便辨識

3.Eclipse
業界較常用的開發工具,內建java compiler
不必再透過javac去做編譯

4.RAD
IBM_RAD
IBM的開發工具,從Eclipse改裝而來
目前編譯最好
為IBM公司在用的開發工具

JAVA入門-讓編輯器輸出Hello

使用工具： Java-CMD

>notepad Hello.java
使用記事本創建.Hello.java的檔案

輸入以下文字後存檔,存檔檔名要同class之後的字(Hello)

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


Compiler(編譯)

>Javac Hello.java

執行

>java Hello

得到結果

Hello