本专栏教程合适有其他言语基础的人快速入门，编写时基于 Java 17

hello world

public class Hello {
    public static void main(String[] args) {
        System.out.println("hello world");
    }
}
  • public: 是关键字；表明揭露的
  • class: 是关键字；用来界说类
  • Hello: 是类名；巨细写灵敏；命名一般为大驼峰格局
  • static: 是关键字；表明静态的
  • void: 是关键字；表明办法的回来类型为 void
  • main 办法: Java 程序的入口办法；是可执行的代码块
  • 分号: Java 的每一行语句有必要有必要以分号结束

留意：一个 Java 源码只能界说一个 public 类型的 class，并且 class 名称和文件名保持一致

注释

// 单行注释

/*
多行注释
多行注释
*/

/**
 * 能够用来主动创立文档的多行注释, 需求写在类和办法的界说处
 * 
 * @auther pany
 */

变量

  • Java 变量分为两种：根本类型的变量和引证类型的变量
  • 有必要先界说后运用
  • 不能重复界说
  • 假如不写初始值，就相当于给它指定了默认值

根本类型

  • 整数类型：byte，short，int，long
  • 浮点数类型：float，double
  • 字符类型：char
  • 布尔类型：boolean

不同基础类型占用字节数：

Java 入门 - 语法基础
语法：

int i = 100;
long l = 100L; // long 型的结束需求加 L
float f = 3.14f; // float 型的结束需求加 f
double d = 3.14;
boolean b = true;
char c = '中';

引证类型

除了上述根本类型，其他的都是引证类型，比方字符串

String s = "hello";

常量

加上 final 修饰符，这个变量就变成了常量：

final double PI = 3.14; // PI 是一个常量

var 关键字

有些时分，类型的名字太长，写起来比较麻烦。例如：

StringBuilder sb = new StringBuilder();

这个时分，假如想省掉变量类型，能够运用 var 关键字：

var sb = new StringBuilder(); // 编译器会主动推断类型

整数运算

除法 & 溢出

int x = 12345 / 67; // 等于 184，因为只取整数部分

int y = 12345 % 67; // 等于 17，因为 12345  67 的余数是 17

留意：整数的除法对于除数为 0 时运行时将报错，但编译不会报错

溢出：整数因为存在规模限制，假如核算结果超出了规模，就会产生溢出，而溢出不会犯错，却会得到一个奇怪的结果

类型转化

主动转化（假如参加运算的两个数类型不一致，那么核算结果为较大类型的整型）

short s = 10;
int i = 10;
int x = s + i; // s 主动转型为 int
short y = s + i; // 编译过错

强制转化（将大规模的整数转型为小规模的整数）

int i = 12345;
short s = (short) i; // 12345

浮点数运算

除法 & 溢出

整数运算在除数为 0 时会报错，而浮点数运算在除数为 0 时不会报错，但会回来几个特殊值：

double d1 = 0.0 / 0; // NaN; 表明 Not a Number
double d2 = 1.0 / 0; // Infinity; 表明无穷大
double d3 = -1.0 / 0; // -Infinity; 表明负无穷大

类型提高

假如参加运算的两个数其间一个是整型，那么整型能够主动提高到浮点型：

int i = 5;
double d = 1.2 + 24.0 / n; // 6.0

留意，在一个复杂的四则运算中，两个整数的运算不会呈现主动提高的情况：

double d = 1.2 + 24 / 5; // 5.2

原因是编译器核算 24 / 5 这个子表达式时，按两个整数进行运算

强制转化

能够将浮点数强制转型为整数。在转型时，浮点数的小数部分会被丢掉 假如转型后超过了整型能表明的最大规模，将回来整型的最大值

int n1 = (int) 12.7; // 12
int n2 = (int) -12.7; // -12
int n3 = (int) (12.7 + 0.5); // 13; 假如要四舍五入就能够采用该 +0.5 的办法
int n3 = (int) 1.2e20; // 2147483647; 最大值

字符 & 字符串

字符

一个 char 保存一个 Unicode 字符

char c = 'A';

要显示一个字符的Unicode编码，只需将 char 类型直接赋值给 int 类型即可：

int i = 'A'; // 字母 'A' 的 Unicodde 编码是 65

还能够直接用转义字符 \u + Unicode 编码来表明一个字符：

// 留意是十六进制
char c = '\u0041'; // 'A'; 因为十六进制 0041 = 十进制 65

字符串

和 char 根本类型不同，字符串类型 String 是引证类型，并且是双引号来表明

String s = "abc\"xyz"; // 包括 7 个字符: a, b, c, ", x, y, z

其间 \ 是转义字符

衔接字符串

假如用 + 衔接字符串和其他数据类型，会将其他数据类型先主动转型为字符串，再衔接

int age = 24;
String s = "age is " + age; // age is 24

多行字符串

假如我们要表明多行字符串，运用 + 号衔接会十分不方便

String s = "榜首行 \n"
         + "第二行 \n"
         + "第三行";

所以用 """xxx""" 表明多行字符串

String s = """
           榜首行
               第二行
           第三行
           """;

留意：多行字符串前面一起的空格会被去掉。将上面每行代码前端的一起空格去掉后相当于：

"""
榜首行
    第二行
第三行
"""

空值 null

引证类型的变量能够指向一个空值 null，它表明不存在，即该变量不指向任何目标

String s1 = null; // s1 是 null
String s2; // 没有赋初值值，s2 默认值也是 null

转义字符

常见的转义字符包括：

  • \"表明字符 "
  • \'表明字符 '
  • \\表明字符 “
  • \n表明换行符
  • \r表明回车符
  • \t表明 Tab
  • \u####表明一个 Unicode 编码的字符

数组

特色

  • 数组一切元素初始化为默认值，整型都是 0，浮点型是 0.0，布尔型是 false
  • 数组一旦创立后，巨细就不可改动
  • 是引证类型

一维

语法： 类型[]

// 界说
int[] ar1 = new int[2];
// 赋值
ar1[0] = 0;
ar1[1] = 1;
// 也能够界说时指定初始值
int[] ar2 = new int[] { 0, 1 };
// 简化
int[] ar3 = { 0, 1 };

二维

int[][] as = {
    { 1, 2, 3 },
    { 4, 5, 6 },
    { 7, 8, 9 }
}

打印数组

Arrays.deepToString(as) // 当然也能够用 for 循环

输出

System.out.print("A"); // 输出，但不换行

System.out.println("A"); // 输出并换行

double d = 3.1415926;
System.out.printf("%.2f\n", d); // 格局化输出，显示两位小数

判别是否持平

Java 中判别值类型的变量是否持平能够运用 == 运算符。可是，判别引证类型的变量是否持平，== 表明 引证是否持平，或者说，是否指向同一个目标

要判别引证类型的变量内容是否持平，有必要运用 equals() 办法

String s1 = "hello";
String s2 = "HELLO".toLowerCase(); // "hello"
boolean b1 = s1 == s2;
boolean b2 = s1.equals(s2);
System.out.println(b1); // false
System.out.println(b2); // true

End

  • 上一篇：无
  • 下一篇：Java 入门 – 面向目标

该系列的每篇文章都收录在本专栏《Java 后端从 0 到 1》

本文正在参加「金石计划」