【从零开始学Java之基础知识①变量、运算符、表达式、输入与输出】

典中典之”Hello World“

public class Main{// 类名，首字母大写
	public static void main(String[] args){// 函数名，小写
		System.out.println("Hello World");
	}
}

变量

1. 变量需要先定义才能使用，且不能重名。
2. 内置数据类型
   
3. 常量
   使用 final 修饰，类似于C语言的const

final int N = 110;

4. 类型转换

int x = (int)'A';// 显性转换
double x = 12, y = 4 * 3.3;// 隐性转换

运算符

/：java和c中的/是向0取整，python中的/是向下取整；例如 -3.6取整Java为-3。
%：数学中的取模的结果只能是正数，但java和c中可以为负数

表达式

1. 自增自减 b = a++ 与 b= ++a
2. 浮点数的比较（重点）

if(x == y)//不建议使用，会有误差
if(Math.abs(x - y) < 1e-8)// 通过计算两个数的差的绝对值和一个很小的数进行比较来判断

输入与输出

1. 输入
   方式一：效率较低，输入规模较小时使用

import java.util.Scanner;//引入对应包

public class Main{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		String str = sc.next();  // 读入下一个字符串
        int x = sc.nextInt();  // 读入下一个整数
        float y = sc.nextFloat();  // 读入下一个单精度浮点数
        double z = sc.nextDouble();  // 读入下一个双精度浮点数
        String line = sc.nextLine();  // 读入下一行
	}
}

注意：next遇到空白字符就会输入结束(空格、回车、制表符等等)，nextLine可以读入一行字符串。此方法是比较慢的数据输入方式，如果输入的数在10的5次方以内可以用。
方式二：效率较高，输入规模较大时可以使用，注意要抛异常。

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

public class Main{
	public static void main(String[] args) throws Exception{// 抛异常
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String str = br.readLine();
		System.out.println(str);
	}
}

注意：① 注意抛出异常
② BufferedWriter输入整数要手动输入：String[] str = br.readLine().split(” “); int x = Integer.parseInt(str[0]); int y = Integer.parseInt(str[1]);
2. 输出
方式一：效率较低，输出规模较小时使用。

public class Main {
   public static void main(String[] args) throws Exception {
       System.out.println(123);  // 输出整数 + 换行
       System.out.println("Hello World");  // 输出字符串 + 换行
       System.out.print(123);  // 输出整数
       System.out.print("yxc\n");  // 输出字符串
       System.out.printf("%04d %.2f\n", 4, 123.456D);  // 格式化输出，float与double都用%f输出
   }
}

System.out.printf()中不同类型变量的输出格式：

(1) int：%d
(2) float: %f， 默认保留6位小数
(3) double: %f， 默认保留6位小数
(4) char: %c，回车也是一个字符，用’\n’表示
(5) String: %s

方式二：效率较高，输出规模较大时使用。注意需要抛异常。

import java.io.BufferedWriter;
import java.io.OutputStreamWriter;

public class Main{
	public static void main(String[] args) throws Exception{
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		bw.write("Hello World\n");
		bw.flush();//需要手动刷新缓冲区
	}
}

注意最后要手动刷新缓冲区，如果不刷新会获取不到输出。

---

习题

1. 显性转换
   

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int v = sc.nextInt();
        int t = sc.nextInt();
        System.out.printf("%.3f", (double) v * t / 12);//需要类型转换
    }
}

2. Double类型是不精确的，存储的是近似值。
   
   本题用循环和数组来写更精简，此处不使用

import java.util.Scanner;

public class Main{
    public static void main(String[] args)  {
        Scanner sc = new Scanner(System.in);
        System.out.printf("NOTAS:\n");
        double n = sc.nextDouble();
        n += 1e-8;//加上一个很小的数
        int cnt = (int) (n / 100.0);
        System.out.printf("%d nota(s) de R$ %.2f\n",  cnt, 100.0);
        n -= cnt * 100;
        cnt = (int) (n / 50.0);
        System.out.printf("%d nota(s) de R$ %.2f\n",  cnt, 50.0);
        n -= cnt * 50;
        cnt = (int) (n / 20.0);
        System.out.printf("%d nota(s) de R$ %.2f\n", cnt, 20.0);
        n -= cnt * 20;
        cnt = (int) (n / 10.0);
        System.out.printf("%d nota(s) de R$ %.2f\n",  cnt, 10.0);
        n -= cnt * 10;
        cnt = (int) (n / 5.0);
        System.out.printf("%d nota(s) de R$ %.2f\n",  cnt, 5.0);
        n -= cnt * 5;
        cnt = (int) (n / 2.0);
        System.out.printf("%d nota(s) de R$ %.2f\n",  cnt, 2.0);
        n -= cnt * 2;
        System.out.printf("MOEDAS:\n");
         cnt = (int) (n / 1.0);
        System.out.printf("%d moeda(s) de R$ %.2f\n",  cnt, 1.0);
        n -= cnt * 1;
        cnt = (int) (n / 0.5);
        System.out.printf("%d moeda(s) de R$ %.2f\n",  cnt, 0.5);
        n -= cnt * 0.5;
        cnt = (int) (n / 0.25);
        System.out.printf("%d moeda(s) de R$ %.2f\n",  cnt,  0.25);
        n -= cnt * 0.25;
        cnt = (int) (n / 0.1);
        System.out.printf("%d moeda(s) de R$ %.2f\n",  cnt,  0.1);
        n -= cnt * 0.1;
        cnt = (int) (n / 0.05);
        System.out.printf("%d moeda(s) de R$ %.2f\n",  cnt,  0.05);
        n -= cnt * 0.05;
         cnt = (int) (n / 0.01);
        System.out.printf("%d moeda(s) de R$ %.2f\n",  cnt,  0.01);
    }
}

求到后面时cnt的值可能为0.9999999... 此时强行类型转换只会得到0，因此在一开始给n加上一个很小的数来减小误差。

---

后记

本文只为记录自己学习Java的过程，如果对你也有帮助，不胜荣幸。