1. 基本程序框架
package *; // 表示这个文件属于哪个包
import *; // 引入一些库，不必重复造轮子
/*
* name：Java 基本程序框架
* describe: NULL
*/
// public 称为访问修饰符，这部分会在后面详细说明，现在只需要知道它可以控制访问权限即可
// class，类，表明这是一个类，而不是方法或其它什么
// Basiframework 类名称，自定义，一般首字母大写，建议使用驼峰命名法
// 源代码文件的命名必须与公共类一致，即一个代码文件中只能有一个 public class
public class BasicFramework {
// Java 虚拟机总是从指定类中的 main 方法开始执行
// Java 项目中每个类都可以有一个 main 方法，但只有一个会被执行，其它的可用作单元测试
public static void main(String[] args) {
// 以下是程序的代码主体，在此编写程序的主要功能
// program statements
System.out.print("I wana see you at this time .");
}
// 可以在这里编写一些其它方法
}
-
Java 区分大小写，出现拼写错误时，程序将无法运行
-
每个语句以分号结束
2. 注释
注释有常规注释和文档注释两种，常规注释的内容在且只在源代码中，而文档注释在编写之后会自动由源文件生成一个HTML文档，类似于联机API文档（可以在控制台使用命令将文档注释抽取出来成为一个文档）
1. 常规注释
// 单行注释，直到本行结尾
/*
* 常规多行注释。注意，不要嵌套
*/
2. 文档注释
/**
* 文档注释
* @author guyan
* @param 元素注释
* @return
* @throws
*
* @version
* @since 引入版本特性的描述
* @deprecated 对类 方法或变量添加一个不再使用的注释,
* 给出取代或修改的意见
* @see 用到的时候再说
* @link
*/
// 注释抽取
javadoc -d 存放地址 fileName.java
3. 数据类型
Java 是一种强类型语言，这要求每个变量在声明的时候必须声明变量的类型。此外，Java 中的基本数据类型的取值范围不受系统的字长影响。
Java 有 8 种基本数据类型，以及多到不知道有多少种的引用数据类型。
8 种基本数据类型中，有 4 种整型，2 种浮点型，1 种字符型，和一种用于表示真值的 boolean 类型
-
整型：byte(1字节)，short(2字节)，int(4字节)，long(8字节)
-
浮点型：float(4字节)，double(8字节)
-
字符型：char(2字节)
-
Boolean值：Boolean(1 bit)
// 声明变量
byte a;
short b;
int c;
long d;
// 变量赋值
// 通常在书写代码的时候并不会十进制之外的进制，但要能看懂当前数字所使用的进制
// 长整形,后缀为 L ;十六进制前缀为 0X ;八进制前缀为 数字0 ;二进制前缀是0B
// 前缀都是数字 0
int n = 0B10011; // n=19
// 连续赋值
int a,b,c;
a = b = c = 4; //从右往左赋值
// 这种形式的赋值是可行的，但是不建议这样做
// 浮点数的其它进制的写法和整型是一样的
// 声明变量
float e;
double f;
// 浮点数除正常的浮点数之外还有 3 个表示溢出和出错的浮点数值
- 正无穷大
- 负无穷大
- NAN（不是一个数字）
// 字符类型除了表示一个字符的用法之外，还可以用于表示 Unicode 的编码
// 其中最有代表性的是转义字符，一个字符长度的 Unicode 编码可以将值赋给 char 变量
// 声明
char g = 'A';
// 布尔值，Boolean,只有两种取值：false true
// 声明
Boolean flag01 = false;
Boolean flag02 = true;
上面是八种基础数据类型的声明示例，尽量让变量的声明靠近第一次使用的地方
4. 变量与常量
与所有程序设计语言一样，Java 也使用变量来存储值，常量就是值不变的变量
1. 变量
int a ;
char c ;
...
// 如果可以从变量的初始值推断出它的类型，就不需要再声明其类型，而只需要用 var 关键字代替
var a = 10;
var s = "String";
2. 常量
// Java 中的常量需要使用关键字 final 明确指示
final int a = 10;
// 以上常量 a 在程序员想要再次修改它的值的时候会拒绝修改
// 常量名 通常使用全大写，请忽视这个示例的大小写问题
5. 运算符
算术运算符
加 减 乘 除
+ - * /
赋值运算符
// 赋值运算符除了‘=’，其它赋值运算符都偷偷加了私料
=
// 将运算符 左边的数值 [+,-,*,/,%] 右边的结果
+= -= *= /= %=
自增与自减运算符
// 自增与自减，通常用作在某次循环中对起到标志作用的变量进行操作
int a = 10;
--a; // 9
a--; // 8
++a; // 9
a++; // 10
// --a 与 a-- 的差异，如 int n = --a; 会先进行自减操作然后再赋值
// 而 int n = a--; 则是先进行赋值然后再自减
关系运算符
== != >= <= ? :
// 关系运算符通常与 Boolean 联系起来，因为关系运算的结果就是 布尔值
int a = 3;
int b = 4;
int c = 0;
Boolean flag ;
a == b; // 判定 a 与 b 是否相等，返回布尔值。此处返回 false
a != b; // 判定 a 与 b 是否不等，返回布尔值。此处返回 true
a >= b; // ...
a <= b; // ...
c = a>b ? a : b; // 判断 a 是否大于 b,如果为真，返回 a,如果为假，返回 b
//
flag = (a == b); // flag = false
// 虽然这里的括号有和没有对于计算机来说没什么区别，但对于人来说，明确的划分方便查看
逻辑运算符
且 与
&& ||
// 数学自行对号入座
位运算符
and or xor not
& | ^ ~
关于运算符的优先级：
尽量加括号
自增自减 的优先度最高（忽略括号）
赋值运算符 优先度最低
数学运算
// 当想要对某个数进行数学操作的时候，不需要自己再次重新编写
// Java 有一个 Math 函数库，大部分的数学运算的函数代码都在这个库中
// 如果想要在代码中调用这些库函数，则需要导入相应的库
import static java.lang.Math.*;
// Math 类中的静态常量
E // 自然数 e
PI // 圆周率 π
// 常用数学运算函数
abs(int a) // 返回 a 的绝对值，a 可以是所有数值类型
max(int x,int y) // 返回 x 和 y 中的最大值，x 和 y 可以是所有数值类型
min(int x,int y) // 返回 x 和 y 中的最小值，同上
ceil(double a) // 返回大于或等于 a 的最小整数
floor(double a) // 返回小于或等于 a 的最大整数
rint(double a) // 返回最接近 a 的整数值，如果有两个同样接近的整数，则结果取偶数
round(float a) // 将参数加上 1/2 后返回与参数最近的整数
exp(double a) // 返回 e 的 a 次幂
pow(double a,double b) // 返回以 a 为底数，以 b 为指数的幂值
sqrt(double a) // 返回 a 的平方根
cbrt(double a) // 返回 a 的立方根
log(double a) // 返回 a 的自然对数，即 lna 的值
log10(double a) // 返回以 10 为底 a 的对数
6. 数值类型转换
1. 自动转换数据类型
从低精度的数据类型转向高精度的数据类型是自动的，无需特别标明
但我们必须清楚，这里发生了数据类型转换
int a = 10;
float b = a;
// a 的值并不会发生实际的变化，只是在赋值过程中，先取出 a 的只
// 将其转化为 浮点数，然后将浮点数赋给变量 b
2. 强制转换数据类型
高精度的变量向低精度的变量进行转换时会丢失数据数据精度
Java 会对此发出警告，要想屏蔽这种警告需要进行强制类型转换
double x = 9.997;
int nx = (int)x; // nx = 9
7. 字符串
概念上，Java 的字符串就是 Unicode 字符序列。
实际上，Java 并没有内置的字符串类型，而是在标准的 Java 类库中提供了一个预定义类，很自然地叫做 “String”
String s = ""; // 一个空字符串
String greeting = "Hello";
在 Java 中字符串是不可变的，即一个字符串里不可以改变其中的字符，但是可以通过字符串拼接或其它操作，将新的字符串赋给字符串变量，实现字符串的变化。
关于效率问题，所有字符串都都存放在公共的存储池中，字符串变量指向存储池中相应的位置。
下面的例子将展示一个项目中源码文件书写格式 并在其中展示有关字符串的一些操作。
package chapter03;
import java.lang.String;
import java.util.Locale;
/*
* NO:02
* Name：字符串测试
* Describe：
* Java 共享池的基本性质
* 一些字符串处理函数
*/
public class StringTest {
public static void main(String[] args) {
// Java 字符串共享池 测试
// "==" 可用于检测两个字符串是否存放在同一个位置上，即检查引用是否相同
System.out.println("字符串共享池测试：");
String s1 = "share pool";
String s2 = s1;//"share pool";
String s3 = new String("share pool");
System.out.println("字符串 s1 为："+s1);
System.out.println("字符串 s2 为："+s2);
System.out.println("字符串 s3 用 new 方法创建为："+s3);
System.out.println("(s1 == s2) = " + (s1 == s2)); // true
System.out.println("(s1 == s3) = " + (s1 == s3)); // false
// 提取字符串字串
// 相同的字符串字面量共享地址，提取或拼接后的字符串不共享
System.out.println();
System.out.println("字符串提取字串测试：");
System.out.println("字符串 s3 为："+s3);
String s4 = s3.substring(0,5);
System.out.println("从字符串 s2 中提取字符串，" +
"字符串 s4 为："+s4); // s3="share"
System.out.println("(s3 == s4) = " + (s3 == s4));
// 字符串拼接
System.out.println();
System.out.println("字符串拼接测试：");
String s5 = " pool";
String s6;
s6 = s4 + s5;
System.out.println("字符串 s4 为："+s4);
System.out.println("字符串 s5 为："+s5);
System.out.println("拼接字符串 s4 与 s5,生成字符串 s6" +
"\n"+
"字符串 s6 为："+ s6);
// 字符串相等测试 equals
// “equals” 用于对比两个字符串中的字符，“==”用于检测引用是否相等
System.out.println();
System.out.println("字符串 equals() 测试：");
System.out.println("字符串 s2 为：" + s2 +
"\n" +
"字符串 s3 为：" + s3 +
"\n" +
"字符串 s4 为：" + s4 );
System.out.println("s2 equals s3 ? " + (s2.equals(s3)));
System.out.println("s3 equals s4 ? " + (s3.equals(s4)));
// 空字符串测试
System.out.println();
System.out.println("空字符串检测方式：");
String s7 = "";
System.out.println("空串 s7 长度为：" + s7.length());
Boolean flag = (s7.length() == 0); // flag = true
flag = (s7 == null); // flag = true
// 码点单元，码点是字符的 Unicode 编码
// 获取字符串中的字符数量，即字符串的长度
String greeting = "hello";
int n = greeting.length(); // is 5
// 获取字符串实际长度，即码点数量
int cpCount = greeting.codePointCount(0, greeting.length()); // 5
// charAt() 返回某个位置的码点单元
char first = greeting.charAt(0); // is 'h'
char last = greeting.charAt(4); // is 'o'
// 获取码点
int index = greeting.offsetByCodePoints(0,2);
// 返回从给定位置开始的码点
int cp = greeting.codePointAt(index);
System.out.println(index +" "+ cp);
// 字符串大小写转换
String name = "guyan";
name = name.toUpperCase(); // GUYAN
name = name.toLowerCase(); // guyan
// 删除字符串头或尾的空格
String space = " space ";
System.out.println(space.length()); // 9
space = space.strip();
System.out.println(space.length()); // 5
// 多字符串连接
// 返回一个字符串，用给定的定界符连接所有元素
String sencent = "q";
sencent.join(" ","a");
System.out.println(sencent);
// StringBuilder 字符串构建
// Stringbuilder 构建一个容器，在容器里的内容被转化为字符串前
// 可以任意对其中的内容进行修改
// 创建一个新的容器
StringBuilder builder = new StringBuilder();
// 追加一个字符串，并返回 this
builder.append("stabt"); // "stabt"
// 追加一个字符并返回 this
builder.append(" "); // "stabt "
// 追加一个码点
builder.append(118); // "stabt 118"
// 修改某个代码党员的值
builder.setCharAt(2, 'r'); // "start 118"
// 将字符串构建器中的内容转化为字符串
String s = builder.toString();
System.out.println(s);
}
}
8. 输入与输出
package chapter03;
import java.io.IOException; // 输入输出异常包，检测输入输出
import java.io.PrintWriter; // 用于创建一个文件并向文本写入数据
import java.nio.charset.StandardCharsets; // 标准Charsets的常量定义
import java.nio.file.Path; // 指向文件的路径
import java.util.Scanner; // 标准输入相关的包
/*
* NO：03
* Name：输入输出测试
* Describe：
* 输入输出
* 格式化输入输出
*/
public class IO {
public static void main(String[] args) throws IOException {
// 构造一个与标准输入流 System.in 相关联的Scanner 对象
// 其中，System.in 可以换成 字符串变量，读取的时候和i自动从字符串读取
Scanner input = new Scanner(System.in);
// 获取下一行输入
String line = input.nextLine();
// 获取下一个字符串（以空格作为分隔符）
String word = input.next();
// 获取下一个整数
int n = input.nextInt();
// 获取下一个浮点数,依次类推，double 类型的浮点数类似
float f = input.nextFloat();
// 检查键盘是否还有未使用的 单词、整数、浮点数
input.hasNext(); //返回 Boolean 值
input.hasNextInt(); // 可以将 Int 换成其它数据类型
input.hasNextFloat();
// 关闭输入流
input.close();
// 格式化输出
// Java 继承了 C 语言的 printf(),格式化输出数据
int a = 10;
f = (float) 12345.54;
// '%'是格式化输出的标志，后面的字母 'd' 表示整数
// 连起来的意思是将 a 替换到 %d 里
System.out.printf("%d \n",a);
// 常用的还有 %f %s %c %b
// 上面的字母通常只是用来表示数据类型
// 还可以在 '%' 与 'd' 之间添加其它参数来确认数据的打印格式
// emmmm, 不想写了，过
// 文件输入与输出
// 如果想要读取一个文件的内容，打开一个文件输入流
Scanner in =new Scanner(Path.of("myfile.txt"), StandardCharsets.UTF_8);
// 如果想要将内容写入文件，需要构造一个 PrintWriter 对象
PrintWriter out = new PrintWriter("myfile.txt", StandardCharsets.UTF_8);
}
}
9. 控制流程
// 块作用域
{}
// 条件语句
if(condition) {}
if(condition) {}
else {}
if(condition1) {}
else if(condition2){}
else{}
// 循环
while(){}
do{}while();
// 确定循环
// 在一个 for 循环中，“int i=10”只执行一次
// 在一个 for 循环中，“i>0” 每次循环前进行一次判断，如果为真，执行循环体
// 在一个 for 循环中，在执行完循环体之后，执行 “i--”
for( int i=10; i>0; i--) {}
// 多重选择
switch(choice) // 传入一个参数，匹配下面的case
{
// choice 可以为 char byte short int enum String，这例子里的是 int
// 当 choice = 1 时，执行 case 1 后面的块，其它 case 以此类推
case 1:{} // 最好每个 {} 里都有一个 break，否则就会在switch 里不断匹配
case 2:{}
case 3:
case 4:{}
//此时 3 和 4 将会执行同一块
default: {};
}
// 中断控制循环 break
// 当一个循环体执行到一条 break 语句的时候，会直接终止“当前“循环
break;
// 当在循环体中，执行到 continue 语句的时候
// 会跳过当前循环剩余未执行的语句，提前进入下一次循环
continue;
// for each
// for each 会遍历数组中的所有元素而不是固定的次数
for(int element : a)
System.out.print(element+" ");
10. 大数
当 long 或 double 的精度不足以满足使用的需求，可以使用大数，即 BigInteger 或 BigDecimal，这两个类可以处理任意长度的数字序列数值
package chapter03;
import java.math.BigInteger;
import java.util.Scanner;
/*
* NO：04
* Name：大数
* Describe：
* 大数声明
* 对大数操作
*/
public class BigIntegerTest {
public static void main(String[] args) {
BigInteger x = new BigInteger("1234567890123456789012345678901234567890");
BigInteger y = new BigInteger("1231231231231231231231231231212312312312");
BigInteger z = new BigInteger("0");
// +
System.out.println(x.add(y));
// -
System.out.println(x.subtract(y));
// *
System.out.println(x.multiply(y));
// /（除）
System.out.println(x.divide(y));
// 取余
System.out.println(x.mod(y));
// 平方根
System.out.println(x.sqrt());
// 比较
System.out.println(x.compareTo(y));
// 基本数据类型转大数
long n = 100;
z = BigInteger.valueOf(n);
System.out.println(z);
System.out.println(y);
}
}
11. 数组
package chapter03;
import java.util.Arrays;
import java.util.Scanner;
/*
* NO:05
* name：Java 数组
* describe: 测试数组基本操作
* 声明数组
* 访问数组元素
* for each 遍历数组
* 数组拷贝
* 数组排序
* 二维数组
*/
public class ArrayTest {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 声明数组
int[] a = new int[10];
int[] aExtra = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
a = new int[]{1, 11, 111}; // 匿名数组
// 可以使用上面这种声明匿名数组的语法
// 声明数组的时候，声明的是一个数组的引用，这个数组引用可以指向任意该类型的数组
// 访问数组元素
// 常规获取数组元素的方式是通过数组下标
System.out.println(a[1]);
// for each 遍历数组
// for功能更为强大，但 foreach 对遍历数组来说，更加方便
for(int element : a)
System.out.println(element);
// 数组拷贝 copyOf()
// 如果直接用 '=' 复制数组，那新数组的地址依旧为旧数组的地址
// 第一个参数是将要被复制的数组名
// 第二个参数是新数组的长度，只可以比原数组的长
int[] b = Arrays.copyOf(a, a.length+2);
for(int element : b)
System.out.print(element + " ");
System.out.println();
// 数组排序
// Java 库中有排序方法，当然，平时练还是要练的
a = new int[] {2, 6, 5, 9};
Arrays.sort(a); // sort() 是快速排序方法
for(int element : a)
System.out.print(element + " ");
System.out.println();
// 二维数组（平时使用的最多是二维，三维或者三维以上是很少的,也不建议使用）
int[][] square = new int[10][10];
// 声明使用方式和一维数组基本相同，过
}
}
参考
-
Java 核心技术 11版 Cay S.Horstmann 著 林琪 等译
-
联机 API 文档Overview (Java SE 11 & JDK 11 )