翁老師Java基礎(chǔ)課程筆記

1、超級基礎(chǔ)

Hello world

首先使用Eclipse新建項目

New Java Project

hello項目

接著在src下new一個class

new class

Hello Class

第一行代碼Hello world长豁！

tips：alt +/會自動補全

輸入

Scanner

輸入

如果重復(fù)運行了，這里會顯示多個進程

重復(fù)運行中的程序

輸出拼接字符串

變量

package hello;

import java.util.Scanner;

public class Hello {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("你好");
        Scanner in = new Scanner(System.in);
        System.out.println("100-"+in.nextInt()+"="+(100-in.nextInt()));
    }

}

乍一看這么寫是對的征候，實際上這里有問題，就是in.nextInt()被調(diào)用了兩次祟敛，因此疤坝，需要有兩次輸入，顯然不符合要求垒棋。因此卒煞，就要把第一個輸入定義為變量痪宰，然后后面使用這個變量叼架，應(yīng)該如下：

package hello;

import java.util.Scanner;

public class Hello {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("你好");
        Scanner in = new Scanner(System.in);
        int price = in.nextInt();
        System.out.println("100-"+price+"="+(100-price));
    }

}

變量的定義形式：
<類型名稱><變量名稱>;
舉例：
int price;
int price=0;//【初始化】
int amount;
int price,amount;
java是強類型語言，需要定義變量類型衣撬。

賦值

定義變量之后如果不賦值乖订，輸出會報錯的。

package hello;

import java.util.Scanner;

public class Hello {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("你好");
        Scanner in = new Scanner(System.in);
        final int amount =100;//定義常量具练，后面不能再被賦值了
        int price = 0;
        price = in.nextInt();
        System.out.println(amount+"-"+price+"="+(amount-price));
    }

}

System.out.println是輸出加換行乍构，System.out.print是輸出不加換行。

浮點數(shù)

兩個整數(shù)運算的結(jié)果只能是整數(shù)

當(dāng)浮點數(shù)和證書放到一起運算時扛点，java會將證書轉(zhuǎn)換成浮點數(shù)哥遮，然后進行浮點數(shù)的運算。

浮點計算是有誤差的陵究。但是證書可以進行精確計算眠饮，并且比浮點要快。

運算符優(yōu)先級

單目運算符優(yōu)先級最高
單目是從左到右
賦值是從右到左

類型轉(zhuǎn)換

<目標(biāo)變量類型>(<需要變換類型的目標(biāo)值>)
不會改變原有值铜邮，只會轉(zhuǎn)換格式輸出仪召。

2、邏輯判斷

作比較

打印車票最簡單,沒有判斷金額是否滿足>=10

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
//      初始化
        Scanner in = new Scanner(System.in);
        
//      讀取投幣金額
        System.out.println("請投幣:");
        int amount = in.nextInt();
        
//      打印車票
        System.out.println("******************");
        System.out.println("**java城際鐵柱專線**");
        System.out.println("*******堂票************");
        System.out.println("********10元**********");
        System.out.println("******************");
//      計算并打印找零
        System.out.println("找零"+(amount-10));

    }

}

行內(nèi)注釋/**/

可以在打印車票之前做一個判斷

關(guān)系運算

運算符

運算符	意義
==	相等
!=	不相等
>	大于
>=	大于等于
<	小于
<=	小于等于

所有的關(guān)系運算符比算術(shù)運算符低松蒜，但是比賦值運算符優(yōu)先級高扔茅，==和!=比其他比較
優(yōu)先級低。

做判斷

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
//      初始化
        Scanner in = new Scanner(System.in);
        
//      讀取投幣金額
        System.out.println("請投幣:");
        int amount = in.nextInt();
        
//      打印車票
        if (amount >=10) 
{
            System.out.println("******************");
            System.out.println("**java城際鐵柱專線**");
            System.out.println("*******堂票************");
            System.out.println("********10元**********");
            System.out.println("******************");
    //      計算并打印找零
            System.out.println("找零"+(amount-10));
            }
        else
            System.out.println("請輸入大于等于10元的金額");
    }

}

嵌套和級聯(lián)的判斷

if在if里面
else總是和最近的if匹配秸苗，除非有大括號包圍召娜。
級聯(lián)的if
if (xxx)
{
xxx;
}
else if (xx)
{
xxx;
}
else
{
xxx;
}
條件后面不能加分號；

多路分支

switch(控制表達式){
case 常量：
語句
......
break惊楼；
case 常量:
語句
......
break玖瘸；
default:
語句
......
break吐句；
}
每個條件分支后面要加一個break，不然會繼續(xù)往下運行店读。

3嗦枢、While循環(huán)

while循環(huán)

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
//      初始化
        Scanner in = new Scanner(System.in);
        int balance = 0;
//      讀取投幣金額
        while(true) {
            System.out.println("請投幣:");
            
            int amount = in.nextInt();
            balance = amount + balance;
    //      打印車票
            if (balance >=10) {
                System.out.println("******************");
                System.out.println("**java城際鐵柱專線**");
                System.out.println("*******堂票************");
                System.out.println("********10元**********");
                System.out.println("******************");
        //      計算并打印找零
                System.out.println("找零"+(balance-10));
                balance = 0;
                System.out.println("*******************");
                }
        }
        }

}

數(shù)數(shù)字

對于一個數(shù)字除以10，等到除以10為0時屯断，則獲得了數(shù)字的位數(shù)文虏。

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int number;
        int count = 0;
        
////        初始化
        Scanner in = new Scanner(System.in);
        number = in.nextInt();
        while (number>0)
        {
            number = number /10;
            count = count +1;
        }
        System.out.print(count);
        
    }
}

但是這個語句有問題，因為如果輸入是0的話殖演，那么0是0位數(shù)氧秘。

由此引出do while
進入循環(huán)體的時候不做判斷，循環(huán)體結(jié)束遇到while的時候再做判斷是否執(zhí)行下一步趴久。

do while

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int number;
        int count = 0;
        
////        初始化
        Scanner in = new Scanner(System.in);
        number = in.nextInt();
        do 
        {
            number = number /10;
            count = count +1;
        }
        while (number>0);
        System.out.print(count);
        
    }
}

do while和while的判斷的地方不一樣丸相，并且do while在while結(jié)束的時候需要在后面加一個分號；

到底是用while還是do while呢彼棍，可以先不考慮灭忠，先去想循環(huán)體。

計數(shù)循環(huán)

不知道運算了多少次座硕，可以把其中的count弄成5或者是10試一下

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        int count = 100;
        
        
        while (count>0)
    
        {
            System.out.println(count);
            count = count - 1;
            
        }
        ;
        System.out.print(count);
        
    }
}

算平均數(shù)

一個記錄讀入整數(shù)之和的變量
一個記錄計數(shù)值弛作，即數(shù)字的數(shù)量

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("請輸入數(shù)字:");
        Scanner in = new Scanner(System.in);
        int count = 0;
        int number;
        int sum=0;
        do {
            number = in.nextInt();
            if(number!=-1) {
            sum = number + sum;
            count = count +1;
                }
        }
        while (number!=-1);
    
        
            System.out.println("平均數(shù)為:"+(double)sum/count);

        
    }
}

猜數(shù)游戲

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("請輸入數(shù)字:");
        Scanner in = new Scanner(System.in);
        int ran_num = (int)(Math.random()*100+1);
        int count = 0;
        int number;
        do {
            number = in.nextInt();
            count = count +1;
            if(number>ran_num) 
            {
                System.out.println("偏大");
            }
            else if(number<ran_num) 
            {
                System.out.println("偏小");
            }
        }
        while (number!=ran_num);
    
        
            System.out.println("恭喜你猜對啦！你猜了"+count+"次");

        
    }
}

如果不能在7次之內(nèi)找出正確的數(shù)字华匾，說明你猜數(shù)的方法不對哈哈映琳。

整數(shù)分解/逆序輸出

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
    
        Scanner in = new Scanner(System.in);
        int number;
        int result=0;
        number = in.nextInt();
        do {
            int digit = number % 10;
            number = number/10;
            result = result *10 +digit;
            System.out.print(digit);/*這里是把每一個獲得不換行輸出，但是如果末尾是0的數(shù)字輸出就會有問題*/
        }while(number>0);
        System.out.println();
        System.out.println(result);/*加上result蜘拉，并且把每次的結(jié)果都*10加上所得的余數(shù)*/
        
        
    }
}

4萨西、for循環(huán)

階乘

幾乎所有的for循環(huán)都可以改寫為while

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
    
        Scanner in = new Scanner(System.in);
        int number;
        int factor=1;
//      int count = 1;
        number = in.nextInt();
//      while(count<=number)
//      {
//          factor = factor*count;
//          count = count +1;
//          
//      }
        for(int i=1;i<=number;i++) 
        {
            factor = factor*i;
        }
        System.out.println(factor);
        
    }
}

tips for loops
如果有固定的次數(shù)，用for
如果必須執(zhí)行一次旭旭，用do while
其他情況用while

復(fù)合賦值

a = a +6 => a + = 6
a * = b +6 => a = a * (b +6)
i++ => i = +1
++i => i = i + 1
a = i ++ 后綴谎脯，a是原來的值，i做加操作
a = ++i 前綴您机，a和i都是加操作穿肄，數(shù)據(jù)一致。

循環(huán)控制

素數(shù)际看，只能被1和被自己整除的數(shù)咸产，且不包括1

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("請輸入一個數(shù)");
        Scanner in = new Scanner(System.in);
        int number = in.nextInt();
        int isPrime = 1;
        for(int i=2;i<number;i++) 
        {
            if(number%i==0)
            {   
                isPrime = 0;
                System.out.println(number+"不是素數(shù)，可以被"+i+"整除");
                break;
            }
        }
        if(isPrime==1) {
        System.out.println(number+"是素數(shù)");
        }
        
    }
}

break仲闽，跳出循環(huán)
continue脑溢，跳過本環(huán)節(jié)，繼續(xù)循環(huán)
老師舉例是聽一群學(xué)生唱歌，continue是跳過這個學(xué)生聽下一個屑彻，
break則是沒耐心了验庙，后面的學(xué)生也不想聽了，直接跳過社牲。

多重循環(huán)/嵌套循環(huán)

求100以內(nèi)的所有素數(shù)

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        for(int i =2;i<100;i++)
        {
            int isPrime = 1;
            for (int j=2;j<i;j++)
            {
                if(i%j==0)
                {
                    isPrime=0;
                    break;                  
                }
            }
            if(isPrime==1)
            {
            System.out.print(i+" ");
            }
        }


    }
}

求前50個素數(shù)粪薛，這里用for循環(huán)不合適

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int count=0;
        int number=2;
        while(count<50)
        {
            int isPrime=1;
            for(int i=2;i<number;i++)
            {
                if(number%i==0)
                {
                    isPrime=0;/*如果被小于其的數(shù)整除則不是素數(shù)，跳出循環(huán)*/
                    break;
                }
            }
            if(isPrime==1)
            {
                count+=1;/*如果是素數(shù)搏恤，記個數(shù)违寿，然后輸出*/
                System.out.print(number+" ");
            }
            number+=1;
            
        }


    }
}

湊硬幣問題，如何使用1角熟空、2角藤巢、5角湊出10元以下的金額，枚舉息罗、窮舉比較適合掂咒。

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("請輸入金額(元)");
        Scanner in = new Scanner(System.in);
        int number = in.nextInt();
        OUT:/*這里的OUT是個label，用于地下的break迈喉，或者continue*/
        for(int i=0;i<=number*5;++i) 
        {
            for(int j=0;j<=number*2;++j)
            {
                for(int k=0;k<=number*10;++k)
                    if(i*0.5+j*0.2+k*0.1==number)
                        {
                            System.out.println(i+"張5角"+j+"張2角"+k+"張1角");
                            break OUT;
                        }
            }
        }

    }
}

標(biāo)號問題绍刮，在循環(huán)前可以放一個標(biāo)號來標(biāo)識循環(huán)，即label弊添，帶標(biāo)號的break和continue對那個循環(huán)起作用

邏輯類型

boolean布爾類型
可以在判斷中把i(isPrime=1)改為if(isPrime)

運算符	意義
!	非
&&	與
II	或

優(yōu)先級

優(yōu)先級	運算符	結(jié)合性
1	()	從左到右
2	! + - ++ --	從右到左
3	* / %	從左到右
4	+ -	從左到右
5	< <= > >=	從左到右
6	== !=	從左到右
7	&&	從左到右
8	II	從左到右
9	= += -= *= /= %=	從右到左

求和

1 + 1/2 + 1/3 + 1/4 + ..+ 1/n

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        System.out.println("請輸入一個數(shù)");
        int number = in.nextInt();
        double sum=0;
        for(int i =1;i<=number;i++)
        {
            sum = sum + 1.0/i;

        }
        System.out.println("和為"+sum);
    }
}

Java里的printf是有格式的輸出录淡，例如想輸出保留兩位小數(shù)的浮點數(shù)據(jù)：
System.out.printf("%.2f",12.0)
即可輸出12.00

1 - 1/2 + 1/3 -1/4 + ... + 1/n [這個目前老師演示的是至少可以有兩種辦法捌木，并且在for循環(huán)中油坝，第三個表達式可以有多個，并且之間可以使用逗號分割刨裆，也可以啥也沒有直接把i++拉下來]

//方法一
package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        System.out.println("請輸入一個數(shù)");
        int number = in.nextInt();
        double sum=0;
        int sign = 1;
        for(int i =1;i<=number;i++,sign = -sign)
        {
            sum = sum + 1.0/i*sign;/*上面的sign和-sign其實也可以拿下來*/
        }
        System.out.printf("和為"+"%.2f",sum);
    }
}

//方法二
package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        System.out.println("請輸入一個數(shù)");
        int number = in.nextInt();
        double sum=0;
        for(int i =1;i<=number;i++)
        {
            if(i%2==0)
                sum = sum -1.0/i;
            else
                sum = sum+1.0/i;
        }
        System.out.printf("和為"+"%.2f",sum);
    }
}

最大公約數(shù)

可以有兩種方法澈圈，第一種是最笨的枚舉法，第二種是輾轉(zhuǎn)相除法/歐幾里得法則帆啃。

//方法一
package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        System.out.println("請輸入兩個數(shù)");
        int a = in.nextInt();
        int b = in.nextInt();
        int gcd=1;
        for(int i =1;i<=a&&i<=b;i++)
        {
            if(a%i==0&&b%i==0)
                gcd=i;
        }
        System.out.printf(a+"和"+b+"的最大公約數(shù)為"+gcd);
    }
}

輾轉(zhuǎn)相除法/歐幾里得法則求最大公約數(shù)
1瞬女、如果b=0，計算結(jié)束努潘，a就是最大公約數(shù)诽偷，
2、否則計算a%b疯坤，讓a等于b报慕，b等于余數(shù)
3、回到第1步

//方法二
package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        System.out.println("請輸入兩個數(shù)");
        int a = in.nextInt();
        int b = in.nextInt();
        int ca = a;/*將輸入的數(shù)據(jù)進行按照歐幾里得法則進行判斷*/
        int cb = b;/*將輸入的數(shù)據(jù)進行按照歐幾里得法則進行判斷*/
        while(cb!=0)
        {
            int r;
            r =  ca%cb;
            ca = cb;
            cb = r;
            
        }   
        System.out.printf(a+"和"+b+"的最大公約數(shù)為"+ca);
    }
}

5压怠、數(shù)組

初試數(shù)組

以上面的求平均數(shù)為例眠冈，在這里依然是求所有輸入的平均數(shù)，并且輸出所有大于平均數(shù)的值菌瘫，這里就需要存儲所有輸入的值了蜗顽。

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        System.out.println("請輸入數(shù)字");
        int[] numbers = new int[100];
        int cnt = 1;
        numbers[cnt]=in.nextInt();
        double sum=0.0;
        while(numbers[cnt]!=-1)
        {
            sum = sum + numbers[cnt];
            cnt++;
            numbers[cnt]=in.nextInt();
                    
        }
        double average = sum/(cnt-1);
        System.out.println("平均數(shù)為"+average);
        for(int i =1;i<cnt;i++)
        {
            if(numbers[i]>average)
            {
                System.out.println(numbers[i]+"是大于平均數(shù)"+average+"的");
            }
        }
    }
}
//老師說這個程序有危險性布卡，因為可能會存在數(shù)據(jù)越界的問題。

創(chuàng)建數(shù)組

數(shù)組的特點

是一種數(shù)據(jù)結(jié)構(gòu)雇盖，能夠記錄同一種類型的多個數(shù)據(jù)忿等；
數(shù)組中的每個數(shù)據(jù)叫做元素，所有的元素具有相同的數(shù)據(jù)類型崔挖。

定義數(shù)組變量

<類型> [] <名字> = new <類型>[元素個數(shù)]
int [] grades = new int[100];
double [] averages = new double[20]

元素個數(shù)必須是整數(shù)
元素個數(shù)必須給出
元素個數(shù)可以是變量

數(shù)組的元素

每個元素都是那種類型的變量这弧，索引或者下標(biāo)都是從0開始的，最大是元素個數(shù)-1虚汛。如果超過了元素個數(shù)-1或者小于0了匾浪，則為越界。

因此卷哩，上面那個求平均數(shù)的程序就是有問題的蛋辈，會存在越界的問題。

//此方法確實不會越界将谊，并且定義了多大的長度冷溶，就得輸入多少的值
package heIIo;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("請輸入數(shù)組的數(shù)量");
        Scanner in = new Scanner(System.in);
        int cnt = in.nextInt();
        int [] numbers = new int[cnt];
        int sum = 0;
        for(int i=0;i<cnt;i++)
        {
            numbers[i] = in.nextInt();
            sum = sum + numbers[i];
        }
        int average = sum/cnt;
        System.out.println("平均數(shù)為"+average);
        System.out.print("其中大于平均數(shù)的有： ");
        for (int i =0;i<numbers.length;i++)
        {
            if(numbers[i]>average)
            {
                System.out.print(numbers[i]+" ");
            }
        }
        

    }

}

投票統(tǒng)計

寫一個程序，輸入數(shù)量不確定的[0,9]范圍內(nèi)的整數(shù)尊浓，統(tǒng)計每一個數(shù)字出現(xiàn)的次數(shù)逞频，輸入-1時表示輸入完畢。

//這個算法真的秒栋齿，想半天才想明白
package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Scanner in = new Scanner(System.in);
        int x;/*記錄輸入的數(shù)字*/
        int [] numbers = new int [10];/*用數(shù)組記錄每個數(shù)字出現(xiàn)的次數(shù)*/
        x = in.nextInt();
        while(x!=-1)
        {
            if(x>=0&&x<=9)
            {
                numbers[x]++;/*如果在0-9之內(nèi)苗胀，那么數(shù)組變量計數(shù)加一*/
            }
            x = in.nextInt();
        }
        for(int i=0;i<numbers.length;i++)
        {
            System.out.println(i+"出現(xiàn)了"+numbers[i]+"次");
        }
    }
}

數(shù)組變量

直接初始化數(shù)組

new 創(chuàng)建的數(shù)組內(nèi)的值都是0
int [] scores = {}

數(shù)組變量賦值

普通變量是所有者，數(shù)組變量是管理者
int [] a ={1,2,5,10};
int [] b = a;
b[0] = 10;
此時a[0]也是10

數(shù)組變量之間的比較是判斷是否管理同一個數(shù)組瓦堵。

例如：
int [] a ={1,2,3}
int [] b ={1,2,3}
System.out.println(a==b);
是false

遍歷數(shù)組

定義一個數(shù)組基协，里面有幾個數(shù)，然后讀取屏幕輸入的一個數(shù)菇用，計算此數(shù)是否在定義的數(shù)組內(nèi)澜驮，并且讀出是第幾個：

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.print("請輸入數(shù)字:");
        Scanner in = new Scanner(System.in);
        int[] data = {4,6,10,3};
        int num = in.nextInt();
        int loc = -1;
        for(int i = 0;i<data.length;i++)
        {
            if(num == data[i]) {
                loc = i+1;
                System.out.print("此數(shù)字是數(shù)組中的第"+loc+"個");
                break;
            }
        }
        if(loc==-1)
            System.out.println("您輸入的數(shù)字不在數(shù)組中！");
    }
}

for each循環(huán)

for(<類型><變量>:<數(shù)組>)
{
...
}

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.print("請輸入數(shù)字:");
        Scanner in = new Scanner(System.in);
        int[] data = {4,6,10,3};
        int num = in.nextInt();
        boolean isExist = false;
        for(int k:data)
        {
            if(num == k) {
                isExist = true;
                System.out.println("您輸入的數(shù)字在此數(shù)組中~");
                break;
            }
        }
        if(!isExist)
            System.out.println("您輸入的數(shù)字不在數(shù)組中惋鸥！");
    }
}

利用數(shù)組找素數(shù)

實際上杂穷，對于for循環(huán)來說，找一個素數(shù)卦绣，可以不用找到n-1耐量，找到次數(shù)的開方就可以了，然后步進為2.
還有一種辦法是通過已知的素數(shù)迎卤，新的數(shù)不能被已知的素數(shù)整除也是素數(shù)拴鸵。
構(gòu)建前50個素數(shù)表：

\\方法一：傳統(tǒng)方法
package hello;



public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int [] primes = new int[50];
        primes[0] = 2;
        int cnt = 1;/*后面的primes從1開始，現(xiàn)在數(shù)組中也只有一個素數(shù)*/
        MAIN_LOOP:
        for(int x=3;cnt<50;x++)
        {
            //已有的素數(shù)能否整除
            for(int i=0;i<cnt;i++)
            {
                if(x%primes[i]==0)
                {
                    continue MAIN_LOOP;/*如果不是素數(shù)，則直接跳出小循環(huán)劲藐，但是還是繼續(xù)大循環(huán)*/
                }
            }
            primes[cnt++]=x;/*如果x在上面的小循環(huán)內(nèi)沒有被數(shù)組內(nèi)的現(xiàn)有值整除八堡，那么則是素數(shù)，記錄下來聘芜，同時cnt加1兄渺，所獲得的素數(shù)加一個*/
        }
        for(int k:primes)
        {
            System.out.print(k+" ");
        }
    }
}

欲構(gòu)造n以內(nèi)的素數(shù)表：
1、令x為2汰现；
2挂谍、將2x、3x瞎饲、4x直至ax<n的數(shù)標(biāo)記為非素數(shù)
3口叙、令x為下一個沒有被標(biāo)記為非素數(shù)的數(shù)，重復(fù)2嗅战；直至到所有的書都已經(jīng)嘗試完畢妄田。

算法描述：
1、創(chuàng)建prime為boolean[n]驮捍，初始化其所有元素為true疟呐，prime[x]為true表示x是素數(shù)
2、令x=2
3东且、如果x是素數(shù)启具，則對于(i=2;xi<n;i++)令prime[ix]=false
4、令x++珊泳，如果x<n鲁冯，重復(fù)3，否則結(jié)束旨椒。
計算機的算法不一定要和人的思考方式相同晓褪。

package hello;



public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        boolean [] primes = new boolean[100];
        for (int i=0;i<primes.length;i++)
        {
            primes[i] = true;
        }
        for(int i =2;i<primes.length;i++)/*這里表示從2到99開始試*/
        {
            if(primes[i])
            {
                for(int k=2;k*i<primes.length;k++)/*這里表示從2開始，作為i的倍數(shù)综慎，如果i為素數(shù)，那么其倍數(shù)都不是*/
                {
                    primes[k*i]=false;
                }
            }
        }
        for (int i=2;i<primes.length;i++)
        {
            if(primes[i])
                System.out.print(i+" ");;
        }
    }
}

二維數(shù)組

int[][] a = new int [3][5]
遍歷：
for (int i=0;i<3;i++){
for(int j =0;j<5;j++){
a[i][j] = i*j;
}
}
a[i,j]并不存在

二維數(shù)組的初始化
int[][] a = {
{1,2,3,4},
{1,2,3}
};
上面這個數(shù)組a,a[1][3]則越界了勤庐。

tic-tac-toe游戲

讀入一個3x3的矩陣示惊，矩陣中的數(shù)字為1表示該位置上有一個X，為0則表示為O
程序判斷這個矩陣中是否有獲勝的一方愉镰，輸出表示獲勝的一方的字符是X或O米罚，或輸出無人獲勝。
這個還沒想好怎么寫丈探。

6录择、字符/字符串

字符類型

單個的字符：char
使用單引號表示，Java使用Unicode來表示字符，可以表達包括漢字在內(nèi)的多種文字隘竭。

字符可以計算
會以Unicode編碼表中的編碼值來計算塘秦。計算結(jié)果是數(shù)值型的。

逃逸字符

用來表達無法印出來的控制字符或特殊字符动看，由反斜杠""開頭尊剔，后面跟上另一個字符，合起來組成一個字符菱皆。
\b回退一格
\t到下一個表格位
\n換行
\n回車
"雙引號
'單引號
\反斜杠本身

包裹類型

每種基礎(chǔ)類型都有對應(yīng)的包裹類型

基礎(chǔ)類型	包裹類型
boolean	Boolean
char	Character
int	Integer
double	Double

包裹類型的用處

獲得該類型的最大最小值
Integer.MIN_VALUE
Integer.MAX_VALUE

.運算符
Character.isDigit()

字符串變量

String须误，它不是基礎(chǔ)類型，二是一個類
像數(shù)組遍歷是數(shù)組的管理者一樣仇轻，String變量是對象的管理者而非所有者京痢。

String s = new String("a string");
創(chuàng)建了一個String對象，用a string初始化這個對象篷店，創(chuàng)建管理這個對象的變量s历造，讓s管理這個對象。

字符串連接：+
如果一個是字符串另一個不是船庇，那么會自動將非字符串變?yōu)樽址筮B接吭产。

輸入字符串
in.next();讀入一個單詞，單詞分隔的標(biāo)志是空格
空格包括空格鸭轮、tab和換行
in.nextLine()讀入一整行

比較字符串
如果使用==臣淤，是判斷兩個字符串是不是同一個，即管理同一個內(nèi)存變量窃爷，
而.equals才是比較內(nèi)容是否相同邑蒋。

字符串操作

.操作

比較大小
s1.compareTo(s2);

長度
s1.length();

訪問字符串指定位置的字符【字符串是不可以使用for each的】
.charAt(index)

獲得子串
s.substring(n)
得到從n號到末尾的全部內(nèi)容
s.substring(b,e)
得到從b號到e號之前的內(nèi)容，不包含e按厘。

查找字符
s.indexOf(c)找到c字符/字符串(字符串使用""包圍)在字符串s的位置医吊，找不到返回-1
s.indexOf(c,n)從n號位置開始尋找c字符，返回的是實際index值
s.lastIndexOf(c)從右邊開始找
s.lastIndexOf(c,n)從右邊開始找

其他String操作
startWith(t)
endsWith(t)
trim() 跳過空格
replace(a,b)
toLowerCase()
toUpperCase()

但是這些操作都不會改變字符串本身逮京，而是制作出新的字符串卿堂。

switch case也可以使用String類型

Math類

abs
round
pow
sqrt
...

7、函數(shù)

對象的操作

String s = "hello";
int i = s.length();
System.out.println(s+"bye");

這些都是對象在執(zhí)行函數(shù)

原來計算兩個值之間的素數(shù)數(shù)量懒棉，并求和是這樣做的

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("請輸入兩個數(shù)");
        Scanner in = new Scanner (System.in);
        int m = in.nextInt();
        int n = in.nextInt();
        if(m==1)m=2;
        int cnt = 0;
        int sum = 0;
        for(int i =m;i<n;i++)
        {
            boolean isPrime=true;
            for(int j=2;j<i;j++)
            {
                if(i%j==0) {
                    isPrime = false;
                    break;
                }
            }
            if(isPrime) {
                cnt++;
                sum = sum+i;
            }
        }
        
        System.out.println("在"+m+"和"+n+"之間有"+cnt+"個素數(shù)草描，且和為"+sum);
    }
}

可以把下面的判斷，作為函數(shù)寫到上面

package hello;

import java.util.Scanner;

public class Main {
    public static boolean isPrime(int i)
    {
        boolean isPrime=true;
        for(int j=2;j<i;j++)
        {
            if(i%j==0) {
                isPrime = false;
                break;
            }
        }

        return isPrime;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("請輸入兩個數(shù)");
        Scanner in = new Scanner (System.in);
        int m = in.nextInt();
        int n = in.nextInt();
        if(m==1)m=2;
        int cnt = 0;
        int sum = 0;

        for(int i =m;i<n;i++)
        {
            if(isPrime(i)) {
                cnt++;
                sum = sum+i;
            }
        }
        System.out.println("在"+m+"和"+n+"之間有"+cnt+"個素數(shù)策严，且和為"+sum);
    }
}

函數(shù)是一塊代碼穗慕，接受零個或多個參數(shù)，做一件事情妻导，并返回零個或一個值逛绵。

函數(shù)定義：
函數(shù)頭：
public static void【這個是返回類型】 func_name【這個是函數(shù)名】(int a,int b【a和b是參數(shù)表】)
void表示無返回值的函數(shù)
public和static在后面進階課會說

調(diào)用函數(shù)

函數(shù)名(參數(shù)值)
()起到了表示函數(shù)調(diào)用的重要作用怀各，即使沒有參數(shù)也需要()

debug 三個功能【只是大概，不準(zhǔn)確】
step into 進入函數(shù)
step over直接進行下一步术浪，不會進入函數(shù)瓢对，會跳出
step return直接把返回值帶出，不會進入函數(shù)

參數(shù)傳遞

類型不匹配怎么辦
當(dāng)函數(shù)期望的參數(shù)類型比調(diào)用函數(shù)時給的值得類型寬添吗，編譯器可以將類型悄悄轉(zhuǎn)換好沥曹；
當(dāng)函數(shù)期望的參數(shù)類型比調(diào)用函數(shù)時給的值得類型窄的時候，需要強制類型轉(zhuǎn)換碟联，例如(int)5.0妓美；
當(dāng)函數(shù)期望的參數(shù)類型與調(diào)用函數(shù)時給的值得類型之間無法轉(zhuǎn)換的時候，那就沒辦法了鲤孵，例如boolean類型無法轉(zhuǎn)換為整型壶栋。

java在調(diào)用函數(shù)時，傳遞的永遠是值普监，二人不是變量本身贵试。例如，
public static void swap(int a,int b)
{
int t;
t =a;
a = b;
b = t;
}
public static void main(String[] args){
int a = 5;
int b = 6;
swap(a,b);
System.out.println(a,b);
}
這里打印出來的結(jié)果是a和b還是原來的值凯正。

每個函數(shù)有自己的變量空間毙玻，參數(shù)也位于這個獨立的空間中，和其他函數(shù)沒有關(guān)系廊散。

過去桑滩，對于函數(shù)參數(shù)表中的參數(shù)，叫做"形式參數(shù)"允睹，調(diào)用函數(shù)時給的值运准，叫做"實際參數(shù)"。

由于容易讓初學(xué)者誤認為十實際參數(shù)就行實際在函數(shù)中進行計算的參數(shù)缭受，誤會了調(diào)用函數(shù)的時候把變量而不是值傳進去胁澳，所以不建議繼續(xù)用這種古老的方式來稱呼，而叫做參數(shù)和值的關(guān)系米者。

本地變量

函數(shù)的每次運行韭畸，就產(chǎn)生了一個獨立的變量空間，在這個空間中的變量塘雳，是函數(shù)的這次運行所獨有的陆盘，稱作本地變量。
定義在函數(shù)內(nèi)部的變量就是本地變量败明。
參數(shù)也是本地變量。

變量的生存期和作用域太防，都是在大括號【塊】內(nèi)妻顶。

本地變量的規(guī)則：
本地變量定義在塊內(nèi)的酸员；
可以定義在函數(shù)的塊內(nèi)；
可以定義在語句的塊內(nèi)讳嘱；
甚至可以隨便拉一對大擴招定義變量幔嗦。
程序在進入這個塊之前，其中的變量不存在沥潭，離開這個塊邀泉，其中的變量就消失了。

在塊外面定義的變量钝鸽，在里面仍然有效汇恤；
不能在一個塊內(nèi)定義同盟的變量，也不能定義塊外面定義過的變量拔恰。