解析hello world程序

  1. package com.company;
  3. /*
  4. * public 表示这个类是公开的
  5. * class (类)
  6. * Main 类名（首字母大写）
  7. * {} 类的定义
  8. * */
  9. public class Main {
  10.     /*public、static 用来修饰方法，她是一个公开的静态方法
  11.     * void 方法的返回类型
  12.     * {} 中间就是方法的代码
  13.     * main方法 参数类型是String[]，参数名是args
  14.     * */
  15.     public static void main(String[] args) { // java固定入口方法
  16.         // write your code here
  17.         System.out.println("hello world");
  18.     }
  19. }

基本数据类型

变量

  1. public class Main{
  3.     public static void main(String[] args){
  4.         int a = 100;  // 定义int类型变量a,并赋予初始值100
  5.         System.out.print(a);  // 打印不换行
  6.         System.out.println(a);   // 打印换行
  7.         a = 200;  // 重新赋值为200
  8.         System.out.println("a = " + a);
  9.     }
  10. }

整数类型：byte(1个字节)，short(2个字节)，int(4个字节)，long(8个字节)

  1. byte：-128 ~ 127
  2. short: -32768 ~ 32767
  3. int: -2147483648 ~ 2147483647
  4. long: -9223372036854775808 ~ 9223372036854775807
  6. public class Main {
  7.     public static void main(String[] args) {
  8.         int i = 2147483647;
  9.         int i2 = -2147483648;
  10.         int i3 = 2_000_000_000; // 加下划线更容易识别
  11.         int i4 = 0xff0000; // 十六进制表示的16711680
  12.         int i5 = 0b1000000000; // 二进制表示的512
  13.         long l = 9000000000000000000L; // long型的结尾需要加L
  14.     }
  15. }

浮点数类型：float(4个字节)，double(8个字节)

  1. float f1 = 3.14f;
  3. // 对于float类型，需要加上f后缀。
  4. // 浮点数可表示的范围非常大，float类型可最大表示3.4x10^38，而double类型可最大表示1.79x10^308。

字符类型：char(2个字节)与字符串类型：String

  1. char a = 'A';
  2. char zh = '中';
  4. // 注意char类型使用单引号'，且仅有一个字符，要和双引号"的字符串类型区分开。
  6. // 定义字符串类型
  7. // 字符串是不可变类型
  8. String s = "hello";
  10. public class Main {
  11.     public static void main(String[] args){
  12.         String s1 = "hello";
  13.         String s2 = "world";
  14.         String s = s1 + " " + s2 + "!";
  15.         System.out.println(s);
  16.     }
  17. }

布尔类型：boolean

  1. boolean b1 = true;
  2. boolean isGreater = 5 > 3; // 计算结果为true

常量

  1. // 定义变量的时候，如果加上final修饰，这个变量就变成了常量
  2. final double PI = 3.14; // PI是一个常量

var关键字

  1. StringBuilder sb = new StringBuilder();
  2. // 可以简写为如下
  3. var sb = new StringBuilder();

运算

image.png

整数运算

  1. public class Main{
  2.     public static void main(String[] args){
  3.         //int x = 123456/66;   // 结果取整数
  4.         //int x = 123456%66;    // 取余数
  5.         //int x = 12345678912;   // 造成数据溢出,要用long
  6.         int n = 3300;
  7.         //n++; // 3301,相当于n=n+1;
  8.         ++n;
  9.         System.out.println(n);
  10.     }
  11. }
  13. // 移位运算
  14. // 当n为正数时
  15. int n = 7;       // 00000000 00000000 00000000 00000111 = 7
  16. int a = n << 1;  // 00000000 00000000 00000000 00001110 = 14
  17. // <<右边的数字是几，就往左移动几位
  19. int n = 7;       // 00000000 00000000 00000000 00000111 = 7
  20. int a = n >> 1;  // 00000000 00000000 00000000 00000011 = 3
  21. // >>右边的数字是几，就往右移动几位
  23. // 当n为负数时（最高位的1不动，进行右移，结果还是负数）
  24. int n = -536870912;
  25. int a = n >> 1;  // 11110000 00000000 00000000 00000000 = -268435456
  26. int b = n >> 2;  // 11111000 00000000 00000000 00000000 = -134217728
  27. // >>右边的数字是几，就往右移动几位补一
  29. // 当n为负数(不管符号位，右移后高位补0)
  30. int n = -536870912;
  31. int a = n >>> 1;  // 01110000 00000000 00000000 00000000 = 1879048192
  33. // 位运算（位运算是按位进行与、或、非和异或的运算。）
  34. /*
  35. 与： &      (两正为正)
  36. 或：|       (一正为正)
  37. 非：~       (非0为正)
  38. 异或：^     (有一个正为正)
  39. */
  41. // 计算前N项和（利用前N项和公式(1+N)*N/2）
  42. public class Main{
  43.     public static void main(String[] args){
  44.         int N = 100;
  45.         N = (1+N)*N/2;
  46.         System.out.println(N);
  47.     }
  48. }

浮点数运算

  1. // 浮点数常常无法精确表示
  3. // 根据一元二次方程ax^2+bx+c=0的求根公式：
  4. // 计算出一元二次方程的两个解：
  6. public class Main {
  8.     public static void main(String[] args) {
  9.         // x*x + 3*x - 4 = 0
  10.         double a = 1.0;
  11.         double b = 3.0;
  12.         double c = -4.0;
  13.         // 求平方根可用 Math.sqrt():
  14.         // double x = Math.sqrt(2)); // ==> 1.414
  15.         //double r1 = 0;
  16.         //double r2 = 0;
  17.         double r1,r2;  // 定义的变量不赋值，默认就是0
  18.         r1=(-b+Math.sqrt(b*b-4*a*c))/2*a;
  19.         r2=(-b-Math.sqrt(b*b-4*a*c))/2*a;
  20.         System.out.println(r1 + ", " + r2);
  21.         System.out.println(r1 == 1 && r2 == -4 ? "测试通过" : "测试失败");
  22.     }
  24. }
  27. // 三元运算符b ? x : y  b成立返回x,不成立返回y

数组类型

  1. // 整数数组
  2. // 数组大小是不可变的
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         // 5位同学的成绩:
  7.         int[] ns;
  8.         int[] ns = new int[5];  // 定义数组的大小，超出数组范围将会报错
  9.         // ns = new int[] { 68, 79, 91, 85, 62 };  // 定义数组的同时初始化元素
  10.         System.out.println(ns.length); // 5
  11.         ns = new int[] { 1, 2, 3 };
  12.         System.out.println(ns.length); // 3
  13.     }
  14. }
  17. // 字符串数组
  18. public class Main {
  19.     public static void main(String[] args) {
  20.         String[] names = {"ABC", "XYZ", "zoo"};
  21.         String s = names[1];
  22.         names[1] = "cat";  // 把原来在该索引的字符串替换掉了
  23.         System.out.println(s); 
  24.         System.out.println(names[1]+" "+names[2]);
  25.     }
  26. }