基础语法上
变量
变量名：程序通过改变变量的值来改变整个程序的状态。为了方便使用变量，所以变量都需
要命名，叫做变量名
变量名称是改变量的标识符
常量
常量代表程序运行过程中不能改变的值；
常量的值是不能被修改的；
final：在变量前面添加关键字final即可声明一个常量；
语法格式： final 数据类型 常量名=值
字符串是常量，创建后不能修改。
数据类型
| 数据类型 | 位数 | 默认值 | 取值范围 | 举例说明 |
|---|---|---|---|---|
| byte(位) | 8 | 0 | -2^7 - 2^7-1 | byte b = 10; |
| short(短整数) | 16 | 0 | -2^15 - 2^15-1 | short s = 10; |
| int(整数) | 32 | 0 | -2^31 - 2^31-1 | int i = 10; |
| long(长整数) | 64 | 0 | -2^63 - 2^63-1 | long l = 10l; |
| float(单精度) | 32 | 0.0 | -2^31 - 2^31-1 | float f = 10.0f; |
| double(双精度) | 64 | 0.0 | -2^63 - 2^63-1 | double d = 10.0d; |
| char(字符)16 | 空 | 0 | - 2^16-1 | char c = 'c'; |
| boolean(布尔值) | 8 | false | true、false | boolean b = true; |
整数型：byte、short、int、long，long修饰变量，需要在数值后加L或l
浮点数：float、double，表示小数点部分，float后面需要加上F或f，否则会被当成double处理，同double可以加D或d，也可不加
char类型：表示单个字符。字符需用单引号括起来，如：char a='a',可以和整数互相装换，字符a也可以写成 char a=97。也可以写成十六进制表示char a='\u0061'。
boolean类型：布尔类型，表示真值ture或者价值false，java中不能和整数类型或者其他类型互相转化。
String
String对象的初始化格式有如下两种：
String s0="abc";
String s1=new String("abc");
计算字符串长度：lenght()方法
public int lenght(){ }
调用方法：字符串标识符.lenght();
字符串比较：equals()方法
判断字符串内容是否相同，相同返回true，不同返回false。
equalsIgnoreCase()方法：可以将大小写忽略。
"==":比较的是两个对象在内存中存储的地址是否一样。相同为true，反为false。
字符串连接：
方法：1、使用+，比如：String s="Hello"+"World!"
2、使用String类的concat()方法
+：即可以连接字符串，也可以连接其他类型
charAt()方法：按照索引值（规定字符串中第一个字符的索引值是0，第二个字符的索引值是1，依此类推），获得字符串中的指定字符。
字符串常用提取方法
| 方法 | 返回值 | 功能描述 |
|---|---|---|
| indexOf(int ch) | int | 搜索字符ch第一次出现是索引 |
| indexOf(String value) | int | 搜索字符串value第一次出现是索引 |
| lastlndexOf(int ch) | int | 搜索字符ch最后一次出现是索引 |
| lastlndexOf(String value) | int | 搜索字符串value最后一次出现是索引 |
| substring(int index) | stirng | 提前从位置索引开始到结束的字符串 |
| substring(int beginindex/endindex) | stirng | 提取beginindex和endindex之间的字符串部分 |
| trim() | stirng | 返回一个前后不含任何空格的调用字符串的副本 |
Java语言支持一些特殊的转义字符序列。
| 符号 | 字符含义 |
|---|---|
| \n | 换行 (0x0a) |
| \r | 回车 (0x0d) |
| \f | 换页符(0x0c) |
| \b | 退格 (0x08) |
| \0 | 空字符 (0x20) |
| \s | 字符串 |
| \t | 制表符 |
| " | 双引号 |
| ' | 单引号 |
| \ | 反斜杠 |
| \ddd | 八进制字符 (ddd) |
| \uxxxx | 16进制Unicode字符 (xxxx) |
构造方法
构造方法=构造函数 是一种特殊的方法，它是一个与类同名的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的初始化。当类实例化一个对象时会自动调用构造方法。构造方法和其他方法一样也可以重载。
具有以下特点：
（1）构造方法的方法名必须与类名相同。
（2）构造方法没有返回值类型，可以有return，但是不能有返回值，在这里只是表示结束，并不是返回的表示，一般也不使用return。
（3）构造方法的主要作用是完成对象的初始化工作，它能够把定义对象时的参数传给对象的域。
（4）一个类可以定义多个构造方法，如果在定义类时没有定义构造方法，则编译系统会自动插入一个无参数的默认构造方法，这个构造方法不执行任何代码。
（5）构造方法可以重载，以参数的个数，类型，顺序。
构造方法示例：
public class Puppy{
//这个构造方法不执行任何代码
public Puppy(){
}
//完成对象初始化
public Puppy(String name){
// 这个构造器仅有一个参数：name
}
}
创建对象
对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：
声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字new来创建一个对象。
初始化：使用new创建对象时，会调用构造方法初始化对象。
下面是一个创建对象的例子：
public class Puppy{
public Puppy(String name){
//这个构造器仅有一个参数：name
System.out.println("小狗的名字是 : " + name );
}
public static void main(String[] args){
// 下面的语句将创建一个Puppy对象
Puppy myPuppy = new Puppy( "tommy" );
}
}
Puppy myPuppy = new Puppy( "tommy" );//Puppy为类名，myPuppy为对象名，new为创建对象的关键字，Puppy（“tommy”）为在类Puppy中创建对象的名称
运算符
是一种符号，它是连接一个以上的操作符，实现某种功能的运算。
算术运算符
算术运算符用在数学表达式中，主要实现的是算术运算，如常见的加法、减法、乘法、除法等。
表格中的例子中，变量a的值为 5，变量b的值为 3，变量i的值为 1：
| 算数运算符 | 名称 | 描述 | 类型 | 举例 |
|---|---|---|---|---|
| + | 加法 | 相加运算符两侧的值 | 双目运算符 | a + b 等于 8 |
| - | 减法 | 左操作数减去右操作数 | 双目运算符 | a - b 等于 2 |
| * | 乘法 | 相乘操作符两侧的值 | 双目运算符 | a * b 等于 15 |
| / | 除法 | 左操作数除以右操作数 | 双目运算符 | a / b 等于 1 |
| % | 取余 | 左操作数除右操作数的余数 | 双目运算符 | a % b 等于 2 |
| ++ | 自增 | 操作数的值增加 1 | ++i（或 i++） | 等于 2 |
| -- | 自减 | 操作数的值减少 1 | --i（或 i--） | 等于 0 |
其中，自增(++)和自减(--)运算符有两种写法：前缀（++i,--i）和后缀（i++,i--）。
- 前缀自增自减法(++i,--i): 先进行自增或者自减运算，再进行表达式运算。
- 后缀自增自减法(i++,i--): 先进行表达式运算，再进行自增或者自减运算。
新建一个源代码文件ArithmeticOperation.java。
public class ArithmeticOperation {
public static void main(String args[]) {
int a = 5;
int b = 3;
int c = 3;
int d = 3;
System.out.println("a + b = " + (a + b));
System.out.println("a - b = " + (a - b));
System.out.println("a * b = " + (a * b));
System.out.println("a / b = " + (a / b));
System.out.println("a % b = " + (a % b));
System.out.println("a++ = " + (a++));
System.out.println("++a = " + (++a));
System.out.println("b-- = " + (b--));
System.out.println("--b = " + (--b));
System.out.println("c++ = " + (c++));
System.out.println("++d = " + (++d));
}
}
编译运行：
$ javac ArithmeticOperation.java
$ java ArithmeticOperation
a + b = 8
a - b = 2
a * b = 15
a / b = 1
a % b = 2
a++ = 5
++a = 7
b-- = 3
--b = 1
c++ = 3
++d = 4
位运算符
Java 定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。位运算时先转换为二进制，再按位运算。
表格中的例子中，变量a的值为 60，变量b的值为 13：
| 位运算符 | 名称 | 描述 | 举例 |
|---|---|---|---|
| & | 按位与 | 如果相对应位都是 1，则结果为 1，否则为 0 | （a＆b），得到 12，即 0000 1100 |
| 丨 | 按位或 | 如果相对应位都是 0，则结果为 0，否则为 1 | （ a 丨 b ）得到 61，即 0011 1101 |
| ^ | 按位异或 | 如果相对应位值相同，则结果为 0，否则为 1 | （a^b）得到 49，即 0011 0001 |
| ~ | 按位补 | 翻转操作数的每一位，即 0 变成 1，1 变成 0 | （〜a）得到-61，即 1100 0011 |
| << | 按位左移 | 左操作数按位左移右操作数指定的位数 | a<<2 得到 240，即 1111 0000 |
| >> | 按位右移 | 左操作数按位右移右操作数指定的位数 | a>>2 得到 15 即 1111 |
| >>> | 按位右移补零 | 左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充 | a>>>2 得到 15 即 0000 1111 |
在/home/project目录下新建一个源代码文件BitOperation.java
public class BitOperation {
public static void main(String args[]) {
int a = 60;
int b = 13;
System.out.println("a & b = " + (a & b));
System.out.println("a | b = " + (a | b));
System.out.println("a ^ b = " + (a ^ b));
System.out.println("~a = " + (~a));
System.out.println("a << 2 = " + (a << 2));
System.out.println("a >> 2 = " + (a >> 2));
System.out.println("a >>> 2 = " + (a >>> 2));
}
}
编译运行：
$ javac BitOperation.java
$ java BitOperation
a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2 = 15
a >>> 2 = 15
逻辑运算符
逻辑运算符是通过运算符将操作数或等式进行逻辑判断的语句。
表格中的例子中，假设布尔变量 a 为真，变量 b 为假：
| 逻辑运算符 | 名称 | 描述 | 类型 | 举例 |
|---|---|---|---|---|
| && | 与 | 当且仅当两个操作数都为真，条件才为真 | 双目运算符 | （a && b）为假 |
| ｜｜ | 或 | 两个操作数任何一个为真，条件为真 | 双目运算符 | （a ｜｜ b）为真 |
| ！ | 非 | 用来反转操作数的逻辑状态。如果条件为真，则逻辑非运算符将得到假 | 单目运算符 | （!a）为假 |
| ^ | 异或 | 如果两个操作数逻辑相同，则结果为假，否则为真 | 双目运算符 | （a ^ b）为真 |
当使用&&(与)逻辑运算符时，在两个操作数都为 true 时，结果才为 true，但是当得到第一个操作为 false 时，其结果就必定是 false，这时候就不会再判断第二个操作了。 在/home/project目录下新建一个LogicOperation.java。
public class LogicOperation {
public static void main(String args[]) {
boolean a = true;
boolean b = false;
System.out.println("a && b = " + (a && b));
System.out.println("a || b = " + (a || b));
System.out.println("!a = " + (!a));
System.out.println("a ^ b = " + (a ^ b));
}
}
编译运行：
$ javac LogicOperation.java
$ java LogicOperation
a && b = false
a || b = true
!a = false
a ^ b = true
关系运算符
关系运算符生成的是一个 boolean（布尔）结果，它们计算的是操作数的值之间的关系。如果关系是真实的，结果为 true（真），否则，结果为 false（假）。
表格中的例子中，假设变量 a 为 3，变量 b 为 5：
| 比较运算符 | 名称 | 描述 | 举例 |
|---|---|---|---|
| == | 等于 | 判断两个操作数的值是否相等，如果相等则条件为真 | （a == b）为 false |
| ！= | 不等于 | 判断两个操作数的值是否相等，如果值不相等则条件为真 | (a != b) 为 true |
| > | 大于 | 判断左操作数的值是否大于右操作数的值，如果是那么条件为真 | （a > b）为 false |
| < | 小于 | 判断左操作数的值是否小于右操作数的值，如果是那么条件为真 | （a < b）为 true |
| >= | 大于等于 | 判断左操作数的值是否大于或等于右操作数的值，如果是那么条件为真 | （a >= b）为 false |
| <= | 小于等于 | 判断左操作数的值是否小于或等于右操作数的值，如果是那么条件为真 | （a <= b）为 true |
除了上表列出的二元运算符，Java 还有唯一的一个三目运算符 ?: 。
语法格式： 布尔表达式？表达式 1 : 表达式 2
运算过程：如果布尔表达式的值为true ，则返回 表达式1 的值，否则返回 表达式2 的值。
在/home/project目录下新建一个源代码文件RelationalOperation.java。
public class RelationalOperation {
public static void main(String args[]) {
int a = 3;
int b = 5;
System.out.println("a == b = " + (a == b));
System.out.println("a != b = " + (a != b));
System.out.println("a > b = " + (a > b));
System.out.println("a < b = " + (a < b));
System.out.println("a >= b = " + (a >= b));
System.out.println("a <= b = " + (a <= b));
System.out.println("a > b ? a : b = " + (a > b ? a : b));
}
}
编译运行：
$ javac RelationalOperation.java
$ java RelationalOperation
a == b = false
a != b = true
a > b = false
a < b = true
a >= b = false
a <= b = true
a > b ? a : b = 5
强调：
- ==和!=适用于所有的基本数据类型，其他关系运算符不适用于boolean，因为 boolean 值只有true和false，比较没有任何意义。
- ==和!=也适用于所有对象，可以比较对象的引用是否相同。
引用：Java 中一切都是对象，但操作的标识符实际是对象的一个引用。
运算符优先级
运算符的优先级是帮助我们在一个表达式中如何对于不同的运算符和相同的运算符，进行正确的运算顺序。
运算符的优先级不需要特别地去记忆它，比较复杂的表达式一般使用圆括号()分开，提高可读性。
练习：计算数字和
在/home/project/目录下新建文件Sum.java，你需要实现以下需求：
- 获取控制台输入的两个整型参数
- 输出两个整型参数和
比如输入 3 和 4 对应输出 7
示例：
输入：
3
4
输出：
7
提示：java.util.Scanner可以获取控制台输入。
Scanner in =new Scanner(System.in);
//获取int值
int x1=in.nextInt();
int x2=in.nextInt();
实验解答
须先导入包：import java.util.Scanner; 再在控制台输入得出结论
import java.util.Scanner;
public class Sum{
public static void main(String args[]){
Scanner in =new Scanner(System.in);
int x1=in.nextInt();
int x2=in.nextInt();
System.out.println(x1+x2);
}
}
关键字和语句
关键字
Java 的关键字对 java 的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名。
Java 关键字有如下表所列，目前共有 50 个 Java 关键字，其中，"const"和"goto"这两个关键字在 Java 语言中并没有具体含义。
方法
Java 中的方法，可以将其看成一个功能的集合，它们是为了解决特定问题的代码组合。
方法的定义语法：
访问修饰符 返回值类型 方法名(参数列表){
方法体
}
比如：
public void functionName(Object arg){
}
在上面的语法说明中：
1.访问修饰符： 代表方法允许被访问的权限范围， 可以是 public、protected、private 或者省略（default） ，其中 public 表示该方法可以被其他任何代码调用
2.返回值类型： 方法返回值的类型，如果方法不返回任何值，则返回值类型指定为 void (代表无类型)；如果方法具有返回值，则需要指定返回值的类型，并且在方法体中使用 return 语句返回值。
3.方法名： 是方法的名字，必须使用合法的标识符。
4.参数列表： 是传递给方法的参数列表，参数可以有多个，多个参数间以逗号隔开，每个参数由参数类型和参数名组成，以空格隔开。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
5.方法体： 方法体包含具体的语句，定义该方法的功能。
根据方法是否带参、是否带返回值，可将方法分为四类：
- 无参无返回值方法
- 无参带返回值方法
- 带参无返回值方法
- 带参带返回值方法
当方法定义好之后，需要调用才可以生效，我们可以通过 main 方法（main 方法是 Java 程序的入口，所以需要用它来调用）来调用它，比如：
在/home/project下建立MethodDemo.java
public class MethodDemo{
public static void main(String[] args){
method();
}
//这里要加上static关键字 应为静态方法只能调用静态方法
public static void method(){
System.out.println("方法被调用");
}
}
编译运行：
javac MethodDemo.java
java MethodDemo
方法被调用
