翁老师Java基础课程笔记

作者: Juha | 来源:发表于2020-05-02 19:57 被阅读0次

1、超级基础

Hello world

首先使用Eclipse新建项目

New Java Project

hello项目

接着在src下new一个class

new class

Hello Class

第一行代码Hello world！

tips：alt +/会自动补全

输入

Scanner

输入

如果重复运行了，这里会显示多个进程

重复运行中的程序

输出拼接字符串

变量

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()被调用了两次，因此，需要有两次输入，显然不符合要求。因此，就要把第一个输入定义为变量，然后后面使用这个变量，应该如下：

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是输出不加换行。

浮点数

两个整数运算的结果只能是整数

当浮点数和证书放到一起运算时，java会将证书转换成浮点数，然后进行浮点数的运算。

浮点计算是有误差的。但是证书可以进行精确计算，并且比浮点要快。

运算符优先级

单目运算符优先级最高
单目是从左到右
赋值是从右到左

类型转换

<目标变量类型>(<需要变换类型的目标值>)
不会改变原有值，只会转换格式输出。

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));

    }

}

行内注释/**/

可以在打印车票之前做一个判断

关系运算

运算符

运算符	意义
==	相等
!=	不相等
>	大于
>=	大于等于
<	小于
<=	小于等于

所有的关系运算符比算术运算符低，但是比赋值运算符优先级高，==和!=比其他比较
优先级低。

做判断

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元的金额");
    }

}

嵌套和级联的判断

if在if里面
else总是和最近的if匹配，除非有大括号包围。
级联的if
if (xxx)
{
xxx;
}
else if (xx)
{
xxx;
}
else
{
xxx;
}
条件后面不能加分号；

多路分支

switch(控制表达式){
case 常量：
语句
......
break；
case 常量:
语句
......
break；
default:
语句
......
break；
}
每个条件分支后面要加一个break，不然会继续往下运行。

3、While循环

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 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("*******************");
                }
        }
        }

}

数数字

对于一个数字除以10，等到除以10为0时，则获得了数字的位数。

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位数。

由此引出do while
进入循环体的时候不做判断，循环体结束遇到while的时候再做判断是否执行下一步。

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结束的时候需要在后面加一个分号；

到底是用while还是do while呢，可以先不考虑，先去想循环体。

计数循环

不知道运算了多少次，可以把其中的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);
        
    }
}

算平均数

一个记录读入整数之和的变量
一个记录计数值，即数字的数量

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 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("平均数为:"+(double)sum/count);

        
    }
}

猜数游戏

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 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次之内找出正确的数字，说明你猜数的方法不对哈哈。

整数分解/逆序输出

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的数字输出就会有问题*/
        }while(number>0);
        System.out.println();
        System.out.println(result);/*加上result，并且把每次的结果都*10加上所得的余数*/
        
        
    }
}

4、for循环

阶乘

几乎所有的for循环都可以改写为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
如果有固定的次数，用for
如果必须执行一次，用do while
其他情况用while

复合赋值

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都是加操作，数据一致。

循环控制

素数，只能被1和被自己整除的数，且不包括1

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();
        int isPrime = 1;
        for(int i=2;i<number;i++) 
        {
            if(number%i==0)
            {   
                isPrime = 0;
                System.out.println(number+"不是素数，可以被"+i+"整除");
                break;
            }
        }
        if(isPrime==1) {
        System.out.println(number+"是素数");
        }
        
    }
}

break，跳出循环
continue，跳过本环节，继续循环
老师举例是听一群学生唱歌，continue是跳过这个学生听下一个，
break则是没耐心了，后面的学生也不想听了，直接跳过。

多重循环/嵌套循环

求100以内的所有素数

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个素数，这里用for循环不合适

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;/*如果被小于其的数整除则不是素数，跳出循环*/
                    break;
                }
            }
            if(isPrime==1)
            {
                count+=1;/*如果是素数，记个数，然后输出*/
                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;
                        }
            }
        }

    }
}

标号问题，在循环前可以放一个标号来标识循环，即label，带标号的break和continue对那个循环起作用

逻辑类型

boolean布尔类型
可以在判断中把i(isPrime=1)改为if(isPrime)

运算符	意义
!	非
&&	与
II	或

优先级

优先级	运算符	结合性
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("请输入一个数");
        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是有格式的输出，例如想输出保留两位小数的浮点数据：
System.out.printf("%.2f",12.0)
即可输出12.00

1 - 1/2 + 1/3 -1/4 + ... + 1/n [这个目前老师演示的是至少可以有两种办法，并且在for循环中，第三个表达式可以有多个，并且之间可以使用逗号分割，也可以啥也没有直接把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("请输入一个数");
        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("请输入一个数");
        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);
    }
}

最大公约数

可以有两种方法，第一种是最笨的枚举法，第二种是辗转相除法/欧几里得法则。

//方法一
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 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+"的最大公约数为"+gcd);
    }
}

辗转相除法/欧几里得法则求最大公约数
1、如果b=0，计算结束，a就是最大公约数，
2、否则计算a%b，让a等于b，b等于余数
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("请输入两个数");
        int a = in.nextInt();
        int b = in.nextInt();
        int ca = a;/*将输入的数据进行按照欧几里得法则进行判断*/
        int cb = b;/*将输入的数据进行按照欧几里得法则进行判断*/
        while(cb!=0)
        {
            int r;
            r =  ca%cb;
            ca = cb;
            cb = r;
            
        }   
        System.out.printf(a+"和"+b+"的最大公约数为"+ca);
    }
}

5、数组

初试数组

以上面的求平均数为例，在这里依然是求所有输入的平均数，并且输出所有大于平均数的值，这里就需要存储所有输入的值了。

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[] 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("平均数为"+average);
        for(int i =1;i<cnt;i++)
        {
            if(numbers[i]>average)
            {
                System.out.println(numbers[i]+"是大于平均数"+average+"的");
            }
        }
    }
}
//老师说这个程序有危险性，因为可能会存在数据越界的问题。

创建数组

数组的特点

是一种数据结构，能够记录同一种类型的多个数据；
数组中的每个数据叫做元素，所有的元素具有相同的数据类型。

定义数组变量

<类型> [] <名字> = new <类型>[元素个数]
int [] grades = new int[100];
double [] averages = new double[20]

元素个数必须是整数
元素个数必须给出
元素个数可以是变量

数组的元素

每个元素都是那种类型的变量，索引或者下标都是从0开始的，最大是元素个数-1。如果超过了元素个数-1或者小于0了，则为越界。

因此，上面那个求平均数的程序就是有问题的，会存在越界的问题。

//此方法确实不会越界，并且定义了多大的长度，就得输入多少的值
package heIIo;

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 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("平均数为"+average);
        System.out.print("其中大于平均数的有： ");
        for (int i =0;i<numbers.length;i++)
        {
            if(numbers[i]>average)
            {
                System.out.print(numbers[i]+" ");
            }
        }
        

    }

}

投票统计

写一个程序，输入数量不确定的[0,9]范围内的整数，统计每一个数字出现的次数，输入-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;/*记录输入的数字*/
        int [] numbers = new int [10];/*用数组记录每个数字出现的次数*/
        x = in.nextInt();
        while(x!=-1)
        {
            if(x>=0&&x<=9)
            {
                numbers[x]++;/*如果在0-9之内，那么数组变量计数加一*/
            }
            x = in.nextInt();
        }
        for(int i=0;i<numbers.length;i++)
        {
            System.out.println(i+"出现了"+numbers[i]+"次");
        }
    }
}

数组变量

直接初始化数组

new 创建的数组内的值都是0
int [] scores = {}

数组变量赋值

普通变量是所有者，数组变量是管理者
int [] a ={1,2,5,10};
int [] b = a;
b[0] = 10;
此时a[0]也是10

数组变量之间的比较是判断是否管理同一个数组。

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

遍历数组

定义一个数组，里面有几个数，然后读取屏幕输入的一个数，计算此数是否在定义的数组内，并且读出是第几个：

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.print("请输入数字:");
        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("此数字是数组中的第"+loc+"个");
                break;
            }
        }
        if(loc==-1)
            System.out.println("您输入的数字不在数组中！");
    }
}

for each循环

for(<类型><变量>:<数组>)
{
...
}

package hello;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.print("请输入数字:");
        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("您输入的数字在此数组中~");
                break;
            }
        }
        if(!isExist)
            System.out.println("您输入的数字不在数组中！");
    }
}

利用数组找素数

实际上，对于for循环来说，找一个素数，可以不用找到n-1，找到次数的开方就可以了，然后步进为2.
还有一种办法是通过已知的素数，新的数不能被已知的素数整除也是素数。
构建前50个素数表：

\\方法一：传统方法
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开始，现在数组中也只有一个素数*/
        MAIN_LOOP:
        for(int x=3;cnt<50;x++)
        {
            //已有的素数能否整除
            for(int i=0;i<cnt;i++)
            {
                if(x%primes[i]==0)
                {
                    continue MAIN_LOOP;/*如果不是素数，则直接跳出小循环，但是还是继续大循环*/
                }
            }
            primes[cnt++]=x;/*如果x在上面的小循环内没有被数组内的现有值整除，那么则是素数，记录下来，同时cnt加1，所获得的素数加一个*/
        }
        for(int k:primes)
        {
            System.out.print(k+" ");
        }
    }
}

欲构造n以内的素数表：
1、令x为2；
2、将2x、3x、4x直至ax<n的数标记为非素数
3、令x为下一个没有被标记为非素数的数，重复2；直至到所有的书都已经尝试完毕。

算法描述：
1、创建prime为boolean[n]，初始化其所有元素为true，prime[x]为true表示x是素数
2、令x=2
3、如果x是素数，则对于(i=2;xi<n;i++)令prime[ix]=false
4、令x++，如果x<n，重复3，否则结束。
计算机的算法不一定要和人的思考方式相同。

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的倍数，如果i为素数，那么其倍数都不是*/
                {
                    primes[k*i]=false;
                }
            }
        }
        for (int i=2;i<primes.length;i++)
        {
            if(primes[i])
                System.out.print(i+" ");;
        }
    }
}

二维数组

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]并不存在

二维数组的初始化
int[][] a = {
{1,2,3,4},
{1,2,3}
};
上面这个数组a,a[1][3]则越界了。

tic-tac-toe游戏

读入一个3x3的矩阵，矩阵中的数字为1表示该位置上有一个X，为0则表示为O
程序判断这个矩阵中是否有获胜的一方，输出表示获胜的一方的字符是X或O，或输出无人获胜。
这个还没想好怎么写。

6、字符/字符串

字符类型

单个的字符：char
使用单引号表示，Java使用Unicode来表示字符，可以表达包括汉字在内的多种文字。

字符可以计算
会以Unicode编码表中的编码值来计算。计算结果是数值型的。

逃逸字符

用来表达无法印出来的控制字符或特殊字符，由反斜杠""开头，后面跟上另一个字符，合起来组成一个字符。
\b回退一格
\t到下一个表格位
\n换行
\n回车
"双引号
'单引号
\反斜杠本身

包裹类型

每种基础类型都有对应的包裹类型

基础类型	包裹类型
boolean	Boolean
char	Character
int	Integer
double	Double

包裹类型的用处

获得该类型的最大最小值
Integer.MIN_VALUE
Integer.MAX_VALUE

.运算符
Character.isDigit()

字符串变量

String，它不是基础类型，二是一个类
像数组遍历是数组的管理者一样，String变量是对象的管理者而非所有者。

String s = new String("a string");
创建了一个String对象，用a string初始化这个对象，创建管理这个对象的变量s，让s管理这个对象。

字符串连接：+
如果一个是字符串另一个不是，那么会自动将非字符串变为字符串后连接。

输入字符串
in.next();读入一个单词，单词分隔的标志是空格
空格包括空格、tab和换行
in.nextLine()读入一整行

比较字符串
如果使用==，是判断两个字符串是不是同一个，即管理同一个内存变量，
而.equals才是比较内容是否相同。

字符串操作

.操作

比较大小
s1.compareTo(s2);

长度
s1.length();

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

获得子串
s.substring(n)
得到从n号到末尾的全部内容
s.substring(b,e)
得到从b号到e号之前的内容，不包含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、函数

对象的操作

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

这些都是对象在执行函数

原来计算两个值之间的素数数量，并求和是这样做的

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 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+"个素数，且和为"+sum);
    }
}

可以把下面的判断，作为函数写到上面

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("请输入两个数");
        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+"个素数，且和为"+sum);
    }
}

函数是一块代码，接受零个或多个参数，做一件事情，并返回零个或一个值。

函数定义：
函数头：
public static void【这个是返回类型】 func_name【这个是函数名】(int a,int b【a和b是参数表】)
void表示无返回值的函数
public和static在后面进阶课会说

调用函数

函数名(参数值)
()起到了表示函数调用的重要作用，即使没有参数也需要()

debug 三个功能【只是大概，不准确】
step into 进入函数
step over直接进行下一步，不会进入函数，会跳出
step return直接把返回值带出，不会进入函数

参数传递

类型不匹配怎么办
当函数期望的参数类型比调用函数时给的值得类型宽，编译器可以将类型悄悄转换好；
当函数期望的参数类型比调用函数时给的值得类型窄的时候，需要强制类型转换，例如(int)5.0；
当函数期望的参数类型与调用函数时给的值得类型之间无法转换的时候，那就没办法了，例如boolean类型无法转换为整型。

java在调用函数时，传递的永远是值，二人不是变量本身。例如，
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);
}
这里打印出来的结果是a和b还是原来的值。

每个函数有自己的变量空间，参数也位于这个独立的空间中，和其他函数没有关系。

过去，对于函数参数表中的参数，叫做"形式参数"，调用函数时给的值，叫做"实际参数"。

由于容易让初学者误认为十实际参数就行实际在函数中进行计算的参数，误会了调用函数的时候把变量而不是值传进去，所以不建议继续用这种古老的方式来称呼，而叫做参数和值的关系。

本地变量

函数的每次运行，就产生了一个独立的变量空间，在这个空间中的变量，是函数的这次运行所独有的，称作本地变量。
定义在函数内部的变量就是本地变量。
参数也是本地变量。

变量的生存期和作用域，都是在大括号【块】内。

本地变量的规则：
本地变量定义在块内的；
可以定义在函数的块内；
可以定义在语句的块内；
甚至可以随便拉一对大扩招定义变量。
程序在进入这个块之前，其中的变量不存在，离开这个块，其中的变量就消失了。

在块外面定义的变量，在里面仍然有效；
不能在一个块内定义同盟的变量，也不能定义块外面定义过的变量。