Java零基础入门（二）
基础语法
一 注释
注释不会被运行，帮我们阅读代码，要养成写注释的习惯
- 单行注释 用 // 开头即可
- 多行注释 用/*开头 */结束，将需要写的内容夹在中间
- 文档注释用/**开头 */结尾，里边特殊名词可以被识别
二 标识符与关键字
在Java中所有的组成部分都需要名字。其中变量名、类名和方法名都被称为标识符。在这其中，我们规定了一部分字符作为关键字，关键字可以被编译器自动识别，变量名不可以用关键字作为标识符。关键字见下表：
所有的标识符需要遵循以下的规范：
- 标识符必须以大小写字母、$或者是英文下划线 _ 开始，不可以使用数字开头
- 开头以后的字符可以使用任意字符
- Java是大小写敏感的，注意字符的大小写
具体来说类名一般需要用大写字母开始，而方法名需要用小字字母开头。
三 变量与数据类型
变量类似于我们在数学函数方程中的概念，Java中的变量也有自己的作用域，在它定义的{~~}内才有意义。
Java中的变量有两种数据类型，基础数据类型和引用数据类型。
- 基础数据类型有8种：
其中整数类型有4种，byte、short、int、long。其中byte占有1个字节，即为8个bit，可以显示的范围是 -2的7次方到2的7次方-1；short类型占有2个字节，即为16个bit，可以显示的范围是 -2的15次方到2的15次方-1；其中int占有4个字节，即为32个bit，可以显示的范围是 -2的31次方到2的31次方-1；其中long占有1个字节，即为64个bit，可以显示的范围是 -2的63次方到2的63次方-1，在定义long类型的变量的时候，需要在数字的后边加上L，以表示该数字为long类型的变量。
public class Hello{
byte i=10;
short i1=200;
int i2=3920;
long i3=381928L;
}
浮点数类型的变量有两种，float和double，浮点数即为小数，因为用科学计数法表示小数的时候，小数点可以浮动。在用float定义小数的时候，需要在数字后边加上F，表示为float类型的浮点数。
public class Hello{
float i4=0.2564F;
double i5=12.254125;
}
布尔类型boolean的变量只有两个值true和false.布尔类型总是关系运算的结果。
public class Hello {
public static void main(String[] args) {
boolean b1=true;
boolean b2=false;
boolean isGreater=5>3;
System.out.println(isGreater);
int age=20;
boolean isRight=age<=18;
System.out.println(isRight);
}
}
字符类型char，可以表示单个字符，可以表示一个大小写字母，或者是一个中文汉字，需要注意的是char定义时候需要使用单引号
public class Demo01 {
public static void main(String[] args) {
char name='A';
char name2='中';
System.out.println(name);
System.out.println(name2);
}
}
- 引用数据类型，除了基本数据类型以外的数据类型均为引用类型，例如字符串String，需要用双引号来定义
常量 除了变量以外，如果我们在定义变量时候，在他前边加上修饰词final，那么该变量就会变成常量；
常量在初始定义以外的地方不可以进行再次赋值；常量的作用是用有意义的变量名来避免魔术数字（Magic number），例如，不要在代码中到处写3.14，而是定义一个常量。如果将来需要提高计算精度，我们只需要在常量的定义处修改，例如，改成3.1416，而不必在所有地方替换3.14。；
为了与变量区分开，通常常量我们会使用大写来表示。
四 整数运算
- Java的整数运算遵循数学的四则运算规则
public class Demo02 {
public static void main(String[] args) {
int i = 100*(6/2+3);
System.out.println(i);
}
}
Java的运算结果永远为整数，包括除法，除法除不尽的时候只显示整数，余数的运算符号为%。特别注意：整数的除法对于除数为0时运行时将报错，但编译不会报错。
public class Demo02 {
public static void main(String[] args) {
int i = 100/(6/2+3); //100/6
int j = 100%(6/2+3);
//报错 int k = 100/(6/2-3);
//报错 int l = 100%(6/2-3);
System.out.println(i);//输出结果为16
System.out.println(j);//输出结果为4
}
}
-
溢出 由于整数数据类型存在范围限制，当计算结果超出范围的时候会出现奇怪的结果：
public class Demo02 { public static void main(String[] args) { int i = 2147483640; int j = 8; int sum = i + j; System.out.println(sum);//输出结果-2147483648 } }这就是因为在计算机在计算的时候转为二进制计算，产生了进位，最高位变成了1，在Java中int类型的二进制32位的最高位为1的时候表示的就是负数，例如
1000 0000 0000 0000 0000 0000 0000 0000就是代表了十进制数字-2147483648，二级制数字每增加1，则其代表的十进制数字也增加1；而0111 1111 1111 1111 1111 1111 1111 1111则代表了数字2147483647；斜体部分为个人理解，待深入学习后查证0111 1111 1111 1111 1111 1111 1111 1000 + 0000 0000 0000 0000 0000 0000 0000 1000 ------------------------------------------- 1000 0000 0000 0000 0000 0000 0000 0000 -
自增与自减
Java还提供了自增
++与自减--的运算，相当于i = i + 1和i = i - 1。public class Demo02 { public static void main(String[] args) { int i = 21; i++; System.out.println(i);//22 i--; System.out.println(i);//21 } } -
移位运算
在计算机中，整数总是以二进制的形式表示。例如，
int类型的整数7使用4字节表示的二进制如下：00000000 0000000 0000000 00000111可以对整数进行移位运算。对整数
7左移1位将得到整数14，左移两位将得到整数28：int n = 7; // 00000000 00000000 00000000 00000111 = 7 int a = n << 1; // 00000000 00000000 00000000 00001110 = 14 int b = n << 2; // 00000000 00000000 00000000 00011100 = 28 int c = n << 28; // 01110000 00000000 00000000 00000000 = 1879048192 int d = n << 29; // 11100000 00000000 00000000 00000000 = -536870912左移29位时，由于最高位变成
1，因此结果变成了负数。类似的，对整数28进行右移，结果如下：
int n = 7; // 00000000 00000000 00000000 00000111 = 7 int a = n >> 1; // 00000000 00000000 00000000 00000011 = 3 int b = n >> 2; // 00000000 00000000 00000000 00000001 = 1 int c = n >> 3; // 00000000 00000000 00000000 00000000 = 0如果对一个负数进行右移，最高位的
1不动，结果仍然是一个负数：int n = -536870912; int a = n >> 1; // 11110000 00000000 00000000 00000000 = -268435456 int b = n >> 2; // 11111000 00000000 00000000 00000000 = -134217728 int c = n >> 28; // 11111111 11111111 11111111 11111110 = -2 int d = n >> 29; // 11111111 11111111 11111111 11111111 = -1还有一种无符号的右移运算，使用
>>>，它的特点是不管符号位，右移后高位总是补0，因此，对一个负数进行>>>右移，它会变成正数，原因是最高位的1变成了0：int n = -536870912; int a = n >>> 1; // 01110000 00000000 00000000 00000000 = 1879048192 int b = n >>> 2; // 00111000 00000000 00000000 00000000 = 939524096 int c = n >>> 29; // 00000000 00000000 00000000 00000111 = 7 int d = n >>> 31; // 00000000 00000000 00000000 00000001 = 1对
byte和short类型进行移位时，会首先转换为int再进行位移。仔细观察可发现，左移实际上就是不断地×2，右移实际上就是不断地÷2。这个地方转为为十进制就容易理解了例如000300，左移两位就是030000，就是乘以10后再乘以10，而000300右移1位，就是除以10。同理在二级制中就是不断的乘以2和除以2。
-
位运算
位运算是按位进行与、或、非和异或的运算，然后输出结果
-
与运算：符号&两边必须同时为1的时候，显示为1，否则为0；
n = 1 & 1;// n = 1 n = 1 & 0;// n = 0 n = 0 & 1;// n = 0 n = 0 & 0;// n = 0 -
或运算：符号｜两边有一个是1的时候，就显示为1，否则为0；
n = 1 | 1;//n = 1 n = 1 | 0;//n = 1 n = 0 | 1;//n = 1 n = 0 | 0;//n = 0 -
非运算：符号～0和1互换；
n = ~1;//n = 0 n = ~0;//n = 1 -
异或运算：符号^两边相同时为1，否则为0。
n = 1 ^ 1;//n = 1 n = 1 ^ 0;//n = 0 n = 0 ^ 1;//n = 0 n = 0 ^ 0;//n = 1对两个整数进行位运算就是把他们在二进制下的数字对齐以后进行运算public class Hello { public static void main(String[] args) { int n = 16; // 0000 0000 0000 0000 0000 0000 0001 0000 int m = 19; // 0000 0000 0000 0000 0000 0000 0001 0011 int i = m | n; // 0000 0000 0000 0000 0000 0000 0001 0011 System.out.println(i); } }
-
-
运算优先级
在Java的计算表达式中，运算优先级从高到低依次是：
()!~++--*/%+-<<>>>>>&|+=-=*=/=
记不住也没关系，只需要加括号就可以保证运算的优先级正确。
-
类型自动提升与强制转换
在Java中除了
boolean类型以外的基本数据类型之间可以转换，按照他们所占字节大小从低到高依次为byte < short = char <int < long < float < double。较高等级类型与低等级类型进行运算的时候，低等级类型会自动转换为高等级类型，byte short类型在参与运算时会自动转换为int类型。
public class Demo02 {
public static void main(String[] args) {
byte n = 100;
short m = 200;
short sum = m + n;//编译会报错，因为在此处 m + n的值被自动转为int
System.out.println(sum);
}
}
也可以强制转换，只需要在前边加上括号，括号内为强制转换类型；但是因为强制转换是直接去掉了前边多的字节，所以有可能会出现结果错误。
public class Demo02 {
public static void main(String[] args) {
byte n = 100;
short m = 200;
short sum = (short) (m + n);//强制将int类型转换为short
System.out.println(sum);
byte i = 100;
byte sum2 = (byte)(i + n);
System.out.println(sum2);//输出结果错误，i + n的和是200，超出了byte的范围
}
}
五 浮点数运算
浮点数运算和整数运算一样可以进行四则运算，但是不能进行位运算与移位运算。另外浮点数在计算机中无法精确的表示，因为一些浮点数在二级制中是无限循环小数，所以计算机在表示他们的时候会用一个比较近似的值。
public class Demo02 {
public static void main(String[] args) {
float m = 0.1F;
double n = 1-0.9;
System.out.println( m==n );//false
}
}
如果要比较两个浮点数的大小，可以用他们的差的绝对值和一个很小的数字进行比较。
public class Demo02 {
public static void main(String[] args) {
float m = 0.1F;
double n = 1 - 0.9;
double i = Math.abs(m - n);
if (i < 0.000001) {
System.out.println("相等");
} else {
System.out.println("不相等");
}
}
}
- 类型转换如果参与运算的有浮点数和整数，那么整数类型会自动提升为浮点数类型；浮点数也可以强制转换为整数，但是会丢失小数点后的数字,如果转型为
int以后超过了整数型的范围，那么将会返回该整数型的最大值。如果转型为byte或short超过了范围，则会范围一个负数。
public class Demo02 {
public static void main(String[] args) {
float m = 21474836481.4F;
int n = (int)m;
float m1 = 129.3F;
byte n1 = (byte) m1;
System.out.println(n);//2147483647
System.out.println(n1);//-127
}
}
- 如果要对浮点数进行四舍五入的操作，可以先将浮点数加上0.5以后再转换为相应的整数类型即可。
public class Demo02 {
public static void main(String[] args) {
float m = 1.4F;
int n = (int)(m + 0.5);
float i = 1.6F;
int j = (int)(i + 0.5);
System.out.println(n);//1
System.out.println(j);//2
}
}
六 布尔运算
布尔boolean运算的值永远只有两个，true和false。运算的符号包括以下：
- 比较运算：>, <, >= , <= , == , !=
- 与运算 && ；或运算 ||; 非运算 ！
布尔运算的一个重要特点是短路运算。如果一个布尔运算的表达式能提前确定结果，则后续的计算不再执行，直接返回结果。
因为false && x的结果总是false，无论x是true还是false，因此，与运算在确定第一个值为false后，不再继续计算，而是直接返回false。
此外，Java的布尔运算还提供了一种三元运算符 b ? x : y，根据b的运算结果，返还x或者是y
public class Demo02 {
public static void main(String[] args) {
int n = 3;
char m = n > 0 ? '正' : '负';
System.out.println(m);
}
}
在三元运算中，首先会计算b，如果为true，则只计算x；如果为false，则只计算y。此外，x和y的类型必须相同，因为返回值不是boolean，而是x和y之一。
七 字符和字符串
1.字符
字符char是一种基本数据类型，用单引号表示，一个char表示一个Unicode字符，占用两个字节。可以通过直接将char类型字符赋值给int类型的变量，来实现类型转换；也可以用强制转换，将int类型转换为char类型。
public class Hello {
public static void main(String[] args) {
int m = 'f';
int n = '中';
System.out.println(m);//102
System.out.println(n);//20013
int i = 89;
char j = (char)i;
System.out.println(j);//Y
}
}
还可以直接用转义字符\u+Unicode编码来表示一个字符：
// 注意是十六进制:
char c3 = '\u0041'; // 'A'，因为十六进制0041 = 十进制65
char c4 = '\u4e2d'; // '中'，因为十六进制4e2d = 十进制20013
2.字符串
字符串String是一种引用类型的变量，我们用双引号" "来表示字符串，字符串可以表示从0到无限个的字符；
转义符 由于字符串和字符都是用的引号来表示的，如果在字符串中出现了引号，我们就需要用转义符，来进行转义。常见的转义符有
\"
\'
\\ 用来表示\
\n 换行
\t 缩进
\r 回车
\u 加上16进制数字 表示Unicode编码
3.字符串连接
Java中对字符串的连接做了方便化的处理，我们可以使用+把字符串连接起来，字符串与其他数据类型连接的时候，会自动将其他数据类型转变为字符串。
public class Demo02 {
public static void main(String[] args) {
int n = 35;
String m = "age is " ;
String i = ",so young";
String j = m + n + i;
System.out.println(j);
}zi
}
4.多行字符串
如果我们有多行的字符串，用+连接的话，就比较麻烦，在Java15以后的版本中中允许使用"""...."""来处理多行字符串
public class Demo02 {
public static void main(String[] args) {
String j = """
头顶的太阳
燃烧着青春的预热
它永远不会放弃
照耀着我们前进""";
System.out.println(j);
}
}
5.字符串的不可变性
Java的字符串除了是一个引用类型外，还有个重要特点，就是字符串不可变。考察以下代码：
// 字符串不可变
public class Main {
public static void main(String[] args) {
String s = "hello";
System.out.println(s); // 显示 hello
s = "world";
System.out.println(s); // 显示 world
}
}
观察执行结果，难道字符串s变了吗？其实变的不是字符串，而是变量s的“指向”。
执行String s = "hello";时，JVM虚拟机先创建字符串"hello"，然后，把字符串变量s指向它：
s
│
▼
┌───┬───────────┬───┐
│ │ "hello" │ │
└───┴───────────┴───┘
紧接着，执行s = "world";时，JVM虚拟机先创建字符串"world"，然后，把字符串变量s指向它：
s ──────────────┐
│
▼
┌───┬───────────┬───┬───────────┬───┐
│ │ "hello" │ │ "world" │ │
└───┴───────────┴───┴───────────┴───┘
原来的字符串"hello"还在，只是我们无法通过变量s访问它而已。因此，字符串的不可变是指字符串内容不可变。至于变量，可以一会指向字符串"hello"，一会指向字符串"world"。
6.空值null
字符串可以指向空值null，即它不指向任何对象
public class Demo02 {
public static void main(String[] args) {
String j = null;
System.out.println(j);//输出null
String i = j;
String k = "";
System.out.println(i);//输出null
System.out.println(k);//无任何输出 只是空了一行
}
}
要注意区分null和 ""，前者代表无任何对象，后着是代表了一个空字符串，是一个有效的字符串对象，它不等于null。
八 数组类型
数组类型是一种引用类型，用于存储一组数据类型相同的变量，在定义数组类型时，需要用“数组类型[]”，例如int[]。数组和其他类型不同，必须使用new int[n] 来定义一个含有 n 个变量的数组.
public class Demo02 {
public static void main(String[] args) {
int[] t = new int[3];
t[0] = 1;
t[1] = 2;
t[2] = "a";
System.out.println(t[2]);
}
}
Java中的数组有以下特性
- 所有数组中的变量初始值为默认值，int为 0，float为0.0，boolean为false，String为null。
- 数组创建后，长度不可改变。
数组创建后，获取数组内的内容需要使用索引。索引从0开始，如new int[5]，就代表了创建了一个长度为5个的数组，索引为0，1，2，3，4，int[4]，就是其中第五个元素。
可以通过赋值来修改数组内的元素。
public class Demo02 {
public static void main(String[] args) {
int[] t = new int[3];
t[0] = 1;
t[1] = 2;
t[2] = 3;
System.out.println(t[2]);//3
t[2] = 5;
System.out.println(t[2]);//5
}
}
可以通过数组变量.length来获取数组的大小。在创建数组变量的时候，可以直接在后边用{}把元素加进去，这样子就不用定义数组的大小了，编译器可以自动算出来数组的大小。
public class Demo02 {
public static void main(String[] args) {
int[] t = new int[]{1,2,5};
int[] m = {5,6,7,9,5};//简化写法
System.out.println(t.length);
System.out.println(m.length);
}
}
数组是一个引用类型的变量，和String数据类型一样，在对数组变量或者是数组变量内的元素进行重新赋值以后，原有变量和元素并没有消失，只是没有办法通过原来的数组变量或者是元素索引指向它了。
public class Demo02 {
public static void main(String[] args) {
int[] t;
t = new int[]{1,2,5};
System.out.println(t.length);//3
t = new int[]{5,6,7,9,5};
System.out.println(t.length);//5
System.out.println(t[4]);//5
t[4] = 9;
System.out.println(t[4]);//9
}
}