Java 基础

声明与教程引用
变量 Variable
变量初始化与赋值 Assignment
- 初始化 Initialization
- 赋值 Assignment
运算符 Operator
函数 Function
面对对象 OOP

声明与教程引用

本篇教程并非为 Java 语言教程，编写 Mod 需进行较深层次的 Java 编程知识，本文只简略介绍一些语法。
以下为普冷姆认为较合适的新手入门教程，您也可以选择更适合自己的，请结合多篇教程来学习。
菜鸟教程：https://www.runoob.com/java/java-tutorial.html
Vamei的博客：https://www.cnblogs.com/vamei/archive/2013/03/31/2991531.html
廖雪峰的官方网站：https://www.liaoxuefeng.com/wiki/1252599548343744

变量 Variable

变量是在 Java 语法和逻辑中最基本的存储单元 (关于更多底层信息，请参见：https://blog.csdn.net/jchen1218/article/details/112737747)。
变量名可以使用—— 英文大小写符号数字下划线美元符号
变量的命名不能以数字开头，可以使用 _ $ 符号。
<变量类型> <变量名>;
在 Java 中所有语句的末尾必须加上分号，如果您的IDEA或编译器报错，请检查分号。

//这是单行注释，在编译的时候会被编译器忽略，不会保留到最终的class字节码中(字节码会在稍后说明)
int abc;            //合法，声明了一个 类型为 int (整数、定点数) 的变量
float 233;            //不合法，因为是以数字开头
float _f;            //合法。声明了一个 类型为 float (小数、单精度浮点数) 的变量
double DDDd;        //合法。声明了一个 类型为 double (小数、双精度浮点数) 的变量
object $obj;        //合法。声明了一个 类型为 object引用 的变量

其他：

变量名称中可以包含 Unicode 字符，例如中文、日文等
变量名称中不可以包含特殊字符或 Java 的运算符，例如 ? / - = \ * - + . ( ) [ ] { } % ^ & @ ! ~ 等
变量名称不可以是 Java 使用的语法关键字，例如 new if while do class 等

注：好的命名可以让其他人对于变量的含义一目了然，或便于他人理解您的代码 (甚至适合您修改代码或重构)
以下是 Java 中的一些规则，您当然可以不遵守。

建议：变量名只包含英文字母，数字和下划线—— int ABCabc_123;
建议：不要在任何名称 (包括变量名) 中使用美元符号 ($)。注：因为 Java 命名匿名类，内部类和Lambda等时使用了这个符号
思考：变量名的长度和清晰度取决于变量的生命周期和重要性，如果一个变量要在很长的时间被反复使用、赋值、被他人浏览，请详细和确切地命名

建议：不要使用汉语拼音为重要的变量命名，或者避免为所有变量使用汉语拼音命名。

变量初始化与赋值 Assignment

在使用 局部变量 (local variable) 之前，需要进行 初始化 (initialization) 或 赋值 (assignment)

初始化 Initialization

int a = 10;                                            //将一个 int 变量 初始化为 10
float f = 3.14f;                                //将一个 float 变量 初始化为 3.14
object plum = new Object( );        //将一个 object引用 变量 初始化为 new Object( )——一个对象
String str = "Hello, plum!";        //将一个 String 变量 初始化为 字符串"Hello, plum!"

赋值 Assignment

byte a;            //声明了一个类型为 byte 的变量，只占1个字节 (即8个位)，取值范围比 int 小
bool b;            //声明了一个类型为 bool 的变量，只有两种值，true 和 false
a = 5;            //将 a 赋值为 5——把 5 赋值给 a
b = false;        //把 false 赋值给 b
char ch;        //声明了一个类型为 char 的变量，存储一个字符
ch = 'A';        //把字符 A 赋值给 ch

更多关于变量与赋值的内容，请参考其他教程。此后本教程默认您已掌握这类知识。

运算符 Operator

Java 支持大部分基础的数学运算符，少数特殊运算需要调用 Java 的 库 (Library)，例如 Math类 (java.lang.Math)。

//本代码段完全符合 Java 语法，可以直接在您的IDEA里运行 (运行方式会在稍后的文章中说明)
int r = 1 + 1;    // r 的值为 2，此处声明了一个变量，类型为 int (整数、定点数)
r = 1 - 1;        // r 的值为 0
r = 3 * 2;        // r 的值为 6
r = 36 / 3;    // r 的值为 12
r = 11 / 5;    // r 的值为 2，int 的除法自动舍弃余数
r = 9 % 2;    // r 的值为 1，这是取余，返回 9 / 2 的余数
bool b = false;    //布尔类型，只有两种值，true 和 false
b = true && false;    // b 的值为 false
b = true || false;    // b 的值为 true
b = ! false;        // b 的值为 true
/*这是多行注释
对于布尔运算符：
&& (和)—— 左右两个操作数均为 true 时，才返回 true，否则返回 false
|| (或)——左右两个操作数至少有一个为true时，就返回 true。都没有为 true 则返回 false
! (否)——取反，使 true 变为 false，false 变为 true。
*/

更多与运算符相关的，请参考其他教程。此后本教程默认您已掌握运算符相关的知识。

函数 Function

仅针对 Java 来说。我们可以把 “f (x) = x * 2” 看做一个函数，也可以把 “plum.runs( )” 看做一个函数。
定义函数的语法：
<返回值的类型> <函数名> (<参数类型> <参数名>)

// 定义一个函数，有一个int 参数，返回值为 int 类型
int multiply2 ( int x ) {                //可以看作为 f (x) = x * 2
  return x * 2 ;                    //使用 return 关键字，返回函数的结果
}
// 函数调用
int res = multiply2 ( 5 ) ;             //此时，res的值为 10
// 定义一个无返回值，无参数的函数
void bark ( ) {
  System.out.println("汪汪！");        //此处调用了System类的out字段的println方法
}
// 调用无返回值的函数
bark( )                             //命令行或调试窗口显示：汪汪！

对于多个参数的函数的示例：

int max( int a , int b ){
  if ( a > b ) {
    return a;
  } else {
    return b;
  }
}
// if 条件语句等语句 请参考：https://www.runoob.com/java/java-if-else-switch.html

更多关于函数的，请参考其他教程或继续随着本教程学习。此后本教程默认您已掌握函数相关知识。

面对对象 OOP

Java 中万物皆对象，除了 int float bool double char long byte short 这些基础类型——不过这些基础类型也有对应的类。更多具体信息，请同时参照：https://www.runoob.com/java/java-object-classes.html 来学习。
定义一个类

public class Person{                     // 类名首字母应当大写,类名为 Person
    private int age;                    // 字段名首字母应当小写,字段名为 age,类型为 int
    private String firstName;                // 字段名为 firstName,类型为 String
    private String lastName;                // 字段名为 lastName,类型为 String
    Person(String firstName,String lastName){    //构造方法
        this.firstName = firstName;        //使用参数 firstName 为字段 firstName命名
        this.lastName = lastName;        //使用参数 lastName 为字段 lastName命名
    }
    public String getFullName( ){            // 方法名首字母应当小写,方法名为 getFullName.返回值为String
        return firstName + lastName;        // 将两个 String 拼接,并返回
    }
    public int getAge( ){                // 方法名为 getAge,返回值为 int
        return age;                        // 直接返回 age 字段的值
    }
}

以上，我们就定义了一个Person类了。下面具体解析其中的部分

类 Class

花括号用于区分不同的代码块，需要成对出现
声明类的语法：class <类名> { }

public class Person{     }

字段 Field

——声明字段不同于普通的局部变量，如果不进行初始化，那么会有默认的初始值。请参见：https://www.cnblogs.com/cao-1/p/12170117.html
一个私有的 int 类型的字段，叫 age
声明字段的语法：<修饰符> <类型> <字段名>;

private int age;

私有字段与私有方法，是外部无法访问的，只有类内的字段和方法可以访问。
公有字段与公有方法，是外部和内部都可以访问的。
私有 (private) 和 公有 (public) 的区别和更多修饰符请参照：https://www.runoob.com/java/java-modifier-types.html，https://blog.csdn.net/weixin_42189643/article/details/80305433

方法 Method

方法是只属于类的函数，Java 中并不允许真正的函数”孤独’地存在，必须被包含在一个类里。

public String getFullName( ){    
    return firstName + lastName;    //同一个类的方法，可以访问这个类的字段和其他方法
}

构造方法 Consturctor

一种特殊的方法，一个类可以拥有一个或多个构造方法。若没有，则默认生成一个没有参数的构造方法。
构造方法会在创建对象的时候被调用，你只能使用构造方法去创建对象——除非使用 反射 (Reflection)

实例化 Instantiation

——或叫创建对象

Person plum = new Person ( "Plum" , "Li" ); 
// 创建了一个Person对象，并赋值给plum变量
String fullName = plum.getFullName( ); 
// fullName变量的值为 "PlumLi"
int age = plum.getAge( ); 
// age变量的值为 0，因为 plum对象 里 age字段 未被赋值，使用了初始值 0

只有对象才能调用方法。与此同时，能被对象和类同时调用的方法叫 静态方法 (Static method)

继承 Inheritance 与多态 Polymorphism

请同时参考：https://www.runoob.com/java/java-object-classes.html
假设，我们认为 “学生” 和 “老师” 都是一种 “人”。学生包含自己的考试分数信息，与此同时，老师包含自己的教学科目。
我们可以写入如下的伪代码

人: 字段姓名字段年龄方法自我介绍学生继承人: 字段姓名来自人字段年龄来自人字段分数方法自我介绍覆盖人老师继承人: 字段姓名来自人字段年龄来自人字段教学科目方法自我介绍覆盖人

字段 (Field) 与方法 (Method) 已经在之前介绍过了，接下来先重点看看 继承 (Inheritance) 的部分。
因为 “人” 具有姓名、年龄字段，又因为 “学生” 是一种 “人”，所以 “学生” 自然应该包含所有 “人” 有的部分。
我们可以说：

“学生” 是一种 “人” —— Student is a (kind of) Person.
“学生” 继承 “人”
“学生” 是 “人” 的子类
“人” 是 “学生” 的父类
“学生” 的 “自我介绍” 方法覆盖/覆写了 “人” 的 “自我介绍”

以上，对 “老师” 与 “人” 同理

接下来用 Java 来重新描述一下上述的伪代码：

public class Person{
    public String name = "LiPlum";    // 手动为字段初始化
    public int age;                    //  未手动初始化的，依然使用默认值
    public void introduceSelf( ){
        System.out.println("I'm "+ name + " and "+age+" year-old.");
        // 向标准输出(这里是控制台)打印文字
    }
}
class Student extends Person{         // extends 表示 继承
    public int score = 100;    
    @Override                    // 覆写了父类的方法，应当使用 @Override 注解
    public void introduceSelf( ){
        System.out.println("I'm "+ name + ", a "+ age +" year-old student, and have got "+score+" in recent exam.");
    }
}
class Teacher extends Person{
    public String subject = "Math";
    @Override
    public void introduceSelf( ){
        System.out.println("I'm "+ name + ", a "+ age +" year-old teacher, and teaching "+subject);
    }
}

我们可以如下创建对象和修改字段

Person nobody = new Person( );    // 创建了一个 名为 nobody 的 Person 类的引用并赋值
nobody.name = "Nobody";        // 使用 变量名 + 点 + 字段名 的方式访问 字段
nobody.introduceSelf( );            // 使用 变量名 + 点 + 方法名 的方式调用 方法
// 控制台输出：I'm Nobody and 0 year-old.
Student plum = new Student( );    // 创建了一个 名为 plum 的 Student 类的引用并赋值
plum.age = 99;
plum.introduceSelf( );
// 控制台输出：I'm Liplum, a 99 year-old student, and have got 100 in recent exam.
Person Ben = new Teacher( );        // 将 一个 Teacher 对象 赋值 给 Person 类的引用 Ben
Ben.name = "Ben";
Ben.age = 25;
//Ben.subject = "Physics";        这行代码会报错，因为Ben 是Person 类的引用，而非 Teacher
Ben.introduceSelf( );            // 因为 Ben 是Person 类的引用，我们只能调用 Person 的方法
// 控制台输出：I'm Ben, a 25 year-old teacher, and teaching Math

剩余OOP相关知识，请继续查阅相关资料与教程，后续本教程假定您已掌握相关知识，如若出现陌生的术语或内容，请合理使用搜索引擎，进行搜索查阅。