JavaSE小集合（复盘）

初识Java

学过了C语言之后，我们已经对基础语法有了自己的认识，java其实和C差不多，只不过在某些方面不一样。首先不一样的就是main函数的定义，在C语言中，我们进入主函数的语句是int main( ),而在Java中，主函数的语句是这样的：

public static void main(String[] args)
{

}

Java主函数的书写较为麻烦，不过好在IDEA能够有简便写法，在编译器中输入main或者psvm就会自动联想补全，一个文件中只能有一个public修饰的类，这个类和我们在目录中创建的类名相同，注意类名的使用是大驼峰如：

public class Test{

}

看见主函数的参数中有一个String[ ] args，这里我们就要提出一个问题了：C语言有字符串类型吗？     答案是没有

另一个奇怪的地方在于，参数中的数组为什么是这样的？这是因为Java定义数组的方式和C有很大不同，这点我们说到数组时再进行讲述。在上述代码框中，public，class都是紫色的，这是因为他们是Java中定义的关键字，所以在方法以及对象命名时不可以使用关键字进行命名。

Java数据类型与变量

public class Test{
public static void main(String[] args){
System.Out.println("hello world!");
System.Out.println(100);
System.Out.println(3.14);
System.Out.println('A');
System.Out.println(true);
System.Out.println(false);
}
}
//System.Out.println是Java的打印函数，ln相当于换行符，打印出来自带换行符

其中： 100 、 3.14 、 ‘A’ 、 true/false 都是常量，将其称为字面常量。

字面常量的分类：

1. 字符串常量：由 "" 括起来的，比如 “12345” 、 “hello” 、 “ 你好 ” 。

2. 整形常量：程序中直接写的数字 ( 注意没有小数点 ) ，比如： 100 、 1000

3. 浮点数常量：程序中直接写的小数，比如： 3.14 、 0.49

4. 字符常量：由 单引号 括起来的当个字符，比如： ‘A’ 、 ‘1’

5. 布尔常量：只有两种 true 和 false

6. 空常量： null

其实跟C语言中也大差不差，但是数据类型的内存占用却发生了变化，下图是Java的数据类型表：

注意：

不论是在 16 位系统还是 32 位系统， int 都占用 4 个字节， long 都占 8 个字节

整形和浮点型都是带有符号的

整型默认为 int 型，浮点型默认为 double

java的变量在使用时必须进行初始化，否则会报错，我们可以用java中的方法查看各个字符类型的数据范围，如使用 Integer.MAX_VALUE 查看int最大值

System.out.println(Integer.MAX_VALUE)

在java中的字符串通常以最后一个字符结尾，统计个数也有其简便的方法，如：

String str = "hello";//java中的字符串就以最后一个字符结尾
System.out.println(str.length());

下面是几个有关于数据类型的例子

  int a = 10;
  int b = 5;
  System.out.println(" a = "+ a +" b = "+ b);  //+在这里是拼接符
  System.out.println("a + b = " +a+b);//a+b=1020
  System.out.println(a+b+"a + b ");//30a+b

首先第一条语句中“+”的作用就是拼接作用，第二句因为前面是字符串拼接a，他们也被看成了一个字符串整体，所以起到的也是拼接作用，第三句就不一样了，首先读取的就是a+b，所以就是运算作用。

System.out.println(5/2);//2
System.out.println((float)5/2);//2.5
System.out.println(5/(float)2);//2.5*
System.out.println((float)(5/2));//2.0

在此例中，由于5和2都是整数，所以他们相除之后的结果仍然是一个整数，在2，3中，他们进行了float类型的转换，所以得到的结果也是float类型，4中，由于括号中的表达式优先级更高，所以首先执行5/2 = 2，再进行float转换。

System.out.println(10%3);//1
System.out.println(-10%3);//-1
System.out.println(10%-3);//1
System.out.println(-10%-3);//-1

在C语言中，我们获取键盘输入的语句是

scanf("%d",&a)

而在Java中，java有一个专门的方法来获取键盘输入：

 Scanner scanner = new Scanner(System.in)表示从键盘获取
 scanner.next()遇到空格结束
 scanner.nextline()遇到换行结束

判断是否是闰年：

//判断是否是闰年
        //java的输入，要导入scanner
        Scanner scanner =new Scanner(System.in);
        int year;
        do {
             year = scanner.nextInt();
            if (year % 100 != 0 && year % 4 == 0) {
                System.out.println(year + "是闰年");
            } else if (year % 400 == 0) {
                System.out.println(year + "是闰年");
            } else {

                System.out.println(year + "不是闰年");
            }
        }while(year!=0);

java中一样含有continue和break语句，让我们来回顾一下，break指直接退出循环，continue指跳过循环中剩下的语句，再次进入循环。

 int i = 1;
        while(i<=10)
        {
            if(i%3 == 0)
            {
                System.out.println(i);
                break;
            }
            i++;
        }

不妨想一想这几条语句的执行结果如何？

由于在i = 3时触发了if条件，导致执行break直接跳出循环，执行结果为3；那么换成continue呢，由于continue直接跳过了后续语句，导致i = 3不断进入循环，导致死循环输出3；

//用for写1！+2！+3！+4！+5！
        int i1 = 1;
        int sum = 1;

        for(i1=2;i1<6;i1++)
        { int jc1 = 1;
            for(int j1 = i1;j1>0;j1--)
            {
                jc1 = jc1 *j1;

            }
            System.out.println(jc1);
            sum = sum + jc1;
        }
        System.out.println(sum);

 //使用scanner循环读取N个数，求平均值

        Scanner n = new Scanner(System.in);
        int N = n.nextInt();
        int i2 = 0;
        int sum1 = 0;
        while(i2<N)
        {
            int num = n.nextInt();
            sum1 = sum1 + num;
            i2++;
        }
        System.out.println(sum1/i2);

 //随机数游戏

        Random random = new Random();//生成随机数
        int randNum = random.nextInt(100);//[0,100)
         Scanner scanner1 = new Scanner(System.in);
        while(true) {
            int num2 = scanner1.nextInt();
            if (num2 < randNum) {
                System.out.println("猜小了");
            } else if (num2 > randNum) {
                System.out.println("猜大了");
            } else {
                System.out.println("恭喜你猜对啦！！！");
                break;
            }
        }
    }

值得一提的是，在switch方法中，long double float boolean不能做switch的参数 switch中不能存放太过复杂的语句

Java方法及重载

java的方法就相当于C语言的函数，把频繁使用的代码封装成方法便于重复使用，定义方式如下：

public static 返回值 方法名（形式参数列表）{方法体}

示例：

  public static int sum(int a,int b){
        return a+b;
    }

在java中，如果我想用sum函数来实现float类型的相加呢？再写一遍未免也太麻烦了点，于是Java诞生了方法重载功能如：

public static float sum(float a,float b){//方法的重载
       
        return a+b;
    }

方法重载的条件：

1.方法名相同  2.参数列表不同（个数，类型，顺序） 3.返回值不影响重载  重载类似于（一个词语有多种意思）。

递归

递归：原问题拆分为子问题，子问题和原问题有相同的解法，子问题解决了，原问题也就解决了
递归的必要条件： 1.原问题化为子问题（相同解法）  2.递归出口，与C语言类似，这里不再赘述

下面来看几个例题：

 //递归求N的阶乘

    public static int func1(int N) {
        if (N == 1) {
            return 1;
        } else {
            int tmp = N * func1(N - 1);
            return tmp;
        }
    }

//递归打印一个数字的每一位
    public static void func2(int num) {
        if (num / 10 == 0) {
            System.out.println(num);
        } else {
            int wei = num % 10;
            System.out.println(wei);
            func2(num / 10);
        }
    }

//返回组成他的数字之和
    public static int func3(int num) {

        if (num < 10) {
            return num;
        } else {
            return num % 10 + func3(num / 10);
        }
    }

//斐波那契数列(递归)

    public static int fib(int n){
        if(n == 0){
            return 0;
        }
        if(n == 1){
            return 1;
        }

            return fib(n-1)+fib(n-2);

    }

斐波那契数列也可以用非递归循环的方式来解决，具体代码如下：

//斐波那契数列(非递归)

    public static int fib1(int n) {
        if(n == 1 || n == 2){
            return 1;
        }
        int f1 = 1;
        int f2 = 1;
        int f3 = 1;
        for(int i = 3;i <= n;i++){
            f3=f1+f2;
            f1=f2;
            f2=f3;
        }
        return f3;

    }

系列还会更新，今天就到此为止，下一篇会仔细讲述关于Java数组的一系列知识