Java语法基础02

1.Java语法格式

任何一种语言都有自己的语法规则，Java也一样，既然是规则，那么知道其如何使用就可以了
如何定义Java中的类
Java代码都定义在类中，类由class来定义，区分 public class 和 class
main方法的作用
main方法是程序的入口；保证程序的独立运行；被JVM调用
注：代码严格区分大小写,如main 和 Main 是不一样的;
Java语言分隔符
分号; ：语句的分割，表示一句话结束，好比咱们使用的句号；
花括号{} ：表示一个代码块，是一个整体，花括号要一起使用；
方括号[] ：定义数组和访问数组元素时使用；
圆括号() ：使用很广泛，具体用到细讲；
圆点 . ：类/对象访问它的成员(字段，方法)时使用等；
空格 ：分割一条语句的不同部分，空格的次数不限制。
注释
注释：用于解释说明程序的文字就是注释。有利于提高了代码的阅读性。
注释分类：
单行注释 //注释内容
//后到本行结束的所有字符会被编译器忽略;
多行注释 /注释内容/
/* /之间的所有字符会被编译器忽略
文档注释 /注释内容/
在/ */之间的所有字符会被编译器忽略，java特有的(用于生成文档);
注意：多行和文档注释都不能嵌套使用
对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行。对于文档注释，是java特有的注释，其中注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。
注释是一个程序员必须要具有的良好编程习惯。
初学者编写程序可以养成习惯：

●先写注释再写代码

●将自己的思想通过注释先整理出来

●在用代码去体现
注释还有一个功能就是调试程序用
代码举例：
/**
这是我的Hello World程序。
/
class Demo{
/
这是主函数，是程序的入口，它的出现可以保证程序的独立运行，
*/
public static void main(String[] args){
//这是输出语句用于将括号内的数据打印到控制台。
System.out.println(“Hello World”);
}
}
在学习语法时，必选先要从最简单的字、词、句、段落开始。只有掌握这些最基本语法和组织结构才能写出一篇寓意饱满、情意连绵、词韵丰富的文章！
Java语言同样也有属于自己的字、词、句、段落，最后组织成一个符合需求的应用程序！现在就让我们从Java中的“字”学起。

2.Java关键字和标识符

Java中的关键字
关键字：被Java语言赋予了特定含义的一些字符！关键字中所有字母都为小写。好比汉字中的专有名词，例如：中国、北京、上海等。一般我们不能将这些词用在其他地方，改变其含义。
关键字分类：

不用刻意去记每个关键字的用法和意义，后面学习中，陆陆续续都会接触到，自然而然就记住了！
Java中的标识符
可简单理解为在Java程序中为了增强阅读性自定义的名称。比如：类名，方法名，变量名等
标识符书写规则

●标识符由字母、数字、下划线、$组成，不能以数字开头，注意：此处的字母还可以是中文，日文等
●标识符大小写敏感
●标识符不得使用java中的关键字和保留字
●别用Java API里面的类名作为自己的类名
注意：在起名字的时，只要标识符不是关键字就可以了，但为了提高阅读性，经常用有意义的英文单词作为标识符。
标识符书写规范：

●包名：多单词组成时所有字母都小写。xxxyyyzzz
●类名接口名：多单词组成时，所有单词的首字母大写。XxxYyyZzz
●变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。xxxYyyZzz
●常量名：所有字母都大写。多单词时每个单词用下划线连接。XXX_YYY_ZZZ
明确了什么是关键字和标识符，即相当于知道了Java语言中的“字”该如何书写。接下来学习Java中的数据。

3.Java常量和变量

在日常生活中，经常使用数据表示事物的某些特性。比如：年龄，身高，日期等等，这些数据都是具体的数值
那么在Java中像这样的数据如何描述呢？像这样数值确定的数据，Java中用常量来描述。
常量
常量：程序中固定不变化的值。比如：整数1,2,3，小数3.14,false,true等。
常量分类

●整数常量：所有整数 三类 正整数 零 负整数
●小数常量：所有小数
●布尔型常量：较为特有，只有两个数值。true false
●字符常量：将一个数字字母或者符号用单引号( ’ ’ )标识
●字符串常量：将一个或者多个字符用双引号(“ ”)标识
●null常量：只有一个数值就是:null
进制
日常生活中，经常使用十进制运算数据，但是也接触过七进制、十二进制等。那么怎么把生活中的这些数据存放在计算机中，计算机又是如何表示这些数据呢？
任何数据在计算机中都是以二进制的形式存在的。二进制早起由电信号开关演变而来。用开表示某一个数，用关表示某一个数，然后使用不同的开和关组合起来，就可以表示数据了。
一个整数在内存中一样也是二进制的。
●二进制：每一个二进制数位用0，1 ；满2进1。
●八进制：每一个八进制数位用0，1，2，3，4，5，6，7 ；满8进1。用0开头表示。
●十进制：每一个十进制数位用0，1，2，3，4，5，6，7 ，8，9 ；满10进1。 满10进1。
●十六进制：每一个十六进制数位用0，1，2，3，4，5，6，7 ，8，9，A，B，
C，D，E，F ；满16进1。 满16进1.。用0x开头表示
进制转换
既然知道计算机中存储的都是二进制数据，那么如何将生活中的十进制数据转换成计算机能够识别的二进制数数据呢
十进制转二进制：十进制转成二进制—>除以2倒取余数

二进制数转十进制数：二进制转成十进制—>按2的幂数展开并累加

进制规律
计算机中是以二进制数据的形式表示所有数据，并且在计算机中把8个二进制数位当做一组，并“字节”来表示。即：8bit = 1Byte （八个二进制数位为一个字节）。那么一个字节能表示的数据是多大呢？也就是当八个二进制数位上全部是1时能表达多大一个数据呢？

即当1个字节上全部存放的是1时，这个数据即就是255，0-255之间的任何一个正数都可以在用一个字节表示。
小技巧：对于任意一个十进制数，当要转成二进制时，也可以从上图中的128、64、32、16、8、4、2、1这些数据加起来。当有某一个数时，就说明这个二进制数位上一定存放的是1，若没有这个数，就说明这个二进制数位上一定存放的是0。

其他进制转换
发现将一个十进制数转成二进制数时，需要使用很长的01这样的数字表示，很麻烦，不利于书写和阅读，于是就想能不能把这个较长的01数字使用其他形式表示呢？
如果把一个二进制数按照每三个二进制数位为一组划分，发现这三个二进制数位数字能表示大的最大值正好为7，正好符号了八进制的表示形式。于是可以把二进制数用八进制的形式表示
二进制转八进制

负数的表示形式
对于一个负数，它的表示形式非常简单，即用这个负数所对应的正数的二进制数取反然后加1，即可得到这个负数的二进制表现形式。取反的意思是将当前二进制数位上的1变0，0变1。

掌握了Java中对常量的描述和使用，那么在生活中，使用的数据也会随时变化，应该怎么描述这些变化的数据呢？接下来学习Java中的变量。
变量的概念
变量表示内存中的一个存储区域，该区域用来不断的存放同一类型的常量数据，并可以重复使用这个区域。并且这个区域有自己的名称（变量名）和类型（数据类型）。
理解：变量就如同数学中的未知数。
定义变量的格式
数据类型 变量名 = 初始化值；
注：格式是固定的，记住格式，以不变应万变。
变量的起名
变量表示内存中的一个存储区域，这时必须给这个区域起个名字 ，才能使用。当在给变量起名时，同样需要见名知义。
例如：String name ；使用name表示这个空间名字，即说明这个空间存放的姓名。
变量使用注意
变量在使用时，必须先给变量空间存放数据，即初始化。同时变量也有自己的生命周期。
在学习变量定义时，有个问题是数据类型，什么是数据类型呢？

4.Java数据类型

在生活中，使用的数据有大有小，有整数，也有小数，同时也会使用字母，或者汉字表示特定含义。在Java中根据数据的不同特点，数据也分为不同的类型。
Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间。

整数默认：int 小数默认：double
布尔型boolean
boolean类型通常用于逻辑运算和程序流程控制
boolean 类型数据只允许取值true 或 false
boolean flag;
flag = true;
System.out.println(“flag=”+ flag);
字符型char
char型数据用来表示通常意义上得“字符”，char占2字节，的范围是[0,65535],但是前256个表示特殊字符；字符常量为用单引号括起来的单个字符。
例如：char c = ‘A’; char c2 = ‘传’; char c3=97;
java字符采用Unicode编码，可用十六进制编码形式表示。 char c1 =’\u0061’;//a
转义字符
有部分符号在Java有特殊含义，当需要使用符号自身原有的意思时，这时可以通过转义字符表示。
例如：键盘上的制表符tab键。可以使用 ‘\t’表示。
如双引号，在Java中使用双引号表示字符串，若想使用双引号本身含义，即可使用’\”’表示。
字符编码表
从前面的介绍知道计算机中所有数据都是采用二进制表示的，怎么才能把生活中的这些字符转成二进制表示呢？
为了解决这个问题，专门制作了一张码表，这张码表中就存放所有字符与整数的对应关系。
例如：
‘A’-----> 65
‘B’----->66
‘a’------>97
‘b’------>97
…
所以当把一个整型数据赋值给char类型数据时，计算机会查码表中这个整数所对应的字符是什么，然后将这个字符存放在char类型的空间中
char ch = 65 其实是将A存放在ch中
String类型
String不属于基本数据类型，但和字符有一定的联系。String是一个类，表示字符串（后面详讲）; 就是一串字符，也就是多个字符连接在一起；字符串都得使用 “” 括起来的，连接字符串使用 +
String str;
str = “西安兵马俑”;
//或 String str = “西安兵马俑”;
//字符串的连接采用 + 符号。
String s = “西安” + “兵马俑” ;
System.out.println(s);//西安兵马俑
整数类型
整型数据根据数据范围不同，需要使用不同的关键字来表示。
byte、short、int、long这四个关键字都可以在内存中开辟出存放整型数据的空间。
byte开辟1个字节的空间，short开辟2个字节空间，int开辟4个字节空间，long开辟8个字节空间。
byte b = 2; //会自动把2转为byte类型存放在b空间
short s = 3;
int i = 4;
long l = 5L; //当把一个值赋给long型空间时，需要在数值后面加L或l标注其为long类型
Java语言整型常量的四种表示形式
二进制整数，0b或0B开头，如：int a = 0B110;
十进制整数，如：int a = 17;
八进制整数，要求以0开头，如 int a = 012;
十六进制整数，要求0X或0x开头，如int a = 0x12;
Java语言的整型常量默认是int型，声明long型变量后加上‘l’或‘L’
浮点类型
double和float关键字在内存中开辟的空间可以存放小数。double开辟8个字节的空间，float开辟4个字节的空间。
Java浮点类型常量有两种表示方式：
十进制形式： 例如：3.14 ，168.0， .618
科学计数法形式： 例如：3.14e2， 3.14E2， 1000E-2
Java浮点型常量默认是double，则要声明一个常量为float型，则需在常量后加上f 或 F,
如：double pi = 3.14;//正确
float pi = 3.14F;//必须加上f，或转型 float pi3 = (float)3.14;
注意：Java里只有浮点型的变量才可以接受科学计算式结果：
int num = 314E2; //× num为int类型，不可以使用科学计数法
在学习基本数据类型时发现有些数据存储过程中会出现错误，但是有些数据存储的时候却没有任何问题。这是为什么呢？其实这些数据在存储的时候发生数据类型的转换。

5.数据类型转换

隐式类型转换
当在存储整数数据时，Java中所有的整数默认都是int类型的。所以在将-128~127之间的数据存储在byte类型空间中时，JVM会把这个int类型的数据自动转换成byte类型，然后存放在byte空间中。short同理

byte b = 2; //会自动把int类型2转为byte类型存放在b空间
short s =234; //也会把int类型234转为short类型存放在s空间
当把一个int类型的数据存放在char类型空间中时，也会发生隐式类型转换
char ch = 65; //这里会用int类型65，到编码表中查找对应的字符，然后将字符存
放在ch空间中
char ch2 = ‘A’;//直接将A字符存放在ch2空间中
注意：当把超过byte和short范围的数据给他们开辟空间存放会发生编译时错误。同样把无法在编码表中查到对应字符的数据存放到char空间也会报错

整型，字符型，浮点型的数据在混合运算中相互转换，转换时遵循以下原则：

●容量小的类型可自动转换为容量大的数据类型（类型自动提升）
●byte,short,char → int → long → float → double
●byte，short，char之间不会相互转换，他们在计算时首先会转换为int类型
强制类型转换
容量大的数据类型转换为容量小的数据类型时，要加上强制转换符，但可能造成精度的降低或溢出，使用时要格外注意
强制转换格式：
(数据类型)(被转数据);
long l = 123L;
int i = (int) l;
double d = 3.14;
float f = (float) d;
练习：

class Demo {
    public static void main(String[] args) {
        //隐式转换
        byte b = 3;
        int x = 4;
        x = x + b;//b会自动提升为int类型进行运算。
        //强制转换
        byte b = 3;
        b = b + 4;//报错
        b = (byte)(b+4);//强制类型转换，强制将b+4的结果转换为byte类型，
再赋值给b。
    }
}
class Demo {
    public static void main(String[] args) {
        byte b1=3,b2=4,b;
        b=b1+b2;
        b=3+4;
    }
}

在生活中，我们常用前面讲解的数据，进行各种运算，完成满足生活的需求。明确了常量、变量、数据类型的简单应用和转换，接下来学习在Java中如何进行各种运算。

6.算数运算符

Java中的算术运算符和生活中的算数运算基本相似
算术运算符符号

算术运算符举例
在使用算术运算时需要注意运算两侧类型：当两侧类型不统一时，运算结果和较大类型保持一致
int a = 3;
int b = 5;
int c = a + b; //加法运算
c = a * b; //乘法
c = a / b; //除法运算 结果为零 注意除法运算当两侧类型统一结果仍为运算数据
保持一致
c = a % b; //取模运算 ，即求a/b的余值
算术运算符的注意问题
如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。但被模数是负数就另当别论。
对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
“+”除字符串相加功能外，还能把非字符串转换成字符串 。“+”运算符两侧的操作数中只要有一个String类型，一个是基本数据类型时，编译成class文件后，两个操作数就被连接成了一个新的String值。
总结：
对于取模运算 m % n ：
●当 m 等于 n 时： m % n的结果为零
●当 m 大于 n 时： m % n的结果为 m / n 的余数
●当 m 小于 n 时： m % n的结果为 m
自加自减
自加（++）自减（–）运算
++：自加。对原有的数据进行+1
–：自减。对原有的数据进行-1
当在一个运算表达式中包含自加运算时，当自加符号在变量右侧时，需要先将变量的值临时保存，然后给变量空间加1，接着用临时变量空间中的值去和其他运算符进行运算。当自加符号在变量左侧时，需要先给变量空间加1，然后把加1后的值和其他运算符进行运算
int a = 4;
int b;
b = a++;
System.out.println(“a=”+a+",b="+b);
注意：自加自减运算单独存在时，放左放右是没有区别的

7.赋值运算符

赋值运算符号

●　= 赋值
●　+= 加等
●　-= 减等
●　*= 乘等
●　/= 除等
●　%= 模等
赋值号的功能是将赋值号右侧的结果存储到左侧的变量空间中
int a = 3 ; //将3存储到左侧a空间中
int b , c , d;
b = c = d = a; // 将a空间中的值分别存放到d，c，b 空间中
赋值号和算术运算符组合起来的混合运算符，它们即具有算术运算的特定，同时还具有赋值运算的特定
int a = 4;
a += 3; //相当于 a = a + 3;的运算，即把a空间中的值和3进行加法运算，把和值
从新存放到a空间中
注意：赋值号和算数运算符的混合运算属于一个运算符，不能拆分。并且这个符号会完成自动强转动作
思考：以下代码有什么区别？
short s = 3;
s=s+2;
s+=2;
说明：

●　s=s+2//编译失败，因为s会被提升为int类型，运算后的结果还是int类型。无法赋值给short类型。
●　s+=2//编译通过，因为+=运算符在给s赋值时，自动完成了强转操作

8.比较运算符

在生活中经常需要判断数据大小，相等不相等各种操作，在Java中同样也可以判断数据的大小。
比较运算符符号
大于>
大于等于>=
< 小于
<= 小于等于
相等= =
不等!=
比较运算符。运算完的结果要么true，要么false。后期学习中会根据比较的结果做出相应逻辑判断
int a = 4;
int b = 5;
boolean c ;
c = a > b;
System.out.println(b);
注1：比较运算符的结果都是boolean型，也就是要么是true，要么是false
注2：比较运算符“==”不能误写成“=”

9.逻辑运算符

当需要判断某些数据符合某个区间，比如人的年龄符合某一范围等。发现使用比较运算没法完成。Java给我们提供另外一直机制，逻辑运算。逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6
逻辑运算符号
逻辑运算符，用来连接boolean型表达式的
& 与
| 或
^ 异或
! 非
&& 短路与
|| 短路或
运算规律
int x = 7;
x>2 & x<5
x<2 | x>5
& ：两边都为true，结果是true。否则为false。
两边只要有一个false。结果必然是false。
true & true = true;
true & false = false;
false & true = false;
false & false = false;
| ：两边都为false，结果是false。否则为true。
两边只要有一个true。结果必然是true。
true | true = true;
true | false = true;
false | true = true;
false | false = false;
^ : 异或。
两边相同为false。两边不同为true。
true ^ true = false;
true ^ false = true;
false ^ true = true;
false ^ false = false;
！：非
非真为假，非假为真
!true = false;
“&”和“&&”的区别：单与时，左边无论真假，右边都进行运算；双与时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。

10.移位运算符

位运算：主要说的是二进制数位运算
运算符符号
& 按位与运算 ，运算原则：相同二进制数位上数值为1，结果为1，否则结果为0；
3 & 5 先把 3和5以二进制表示，再进行按位于运算：
十进制 　　　　　　二进制 　　　　　　　　 　　　　　结果(十进制)
3 　　　　00000000_00000000_00000000_00000011
5 　　　　00000000_00000000_00000000_00000101
­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
­­­­­­­­­­­­­­­­­­­­­­­­­­
& : 　　　　00000000_00000000_00000000_00000001 　　　 1
所以3 & 5等于 1
| 按位或运算，运算原则：相同二进制数位上数值为0，结果为0，否则结果为1；
3 | 5 先把 3和5以二进制表示，再进行按位于运算：
十进制 　　　　　　　二进制 　　　　　　　　　　　 结果(十进制)
3 　　　00000000_00000000_00000000_00000011
5 　　　00000000_00000000_00000000_00000101
­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
­­­­­­­­­­­­­­­­­­­­­­­­­
| : 　　　00000000_00000000_00000000_00000111 　　　 7
所以3 | 5等于 7.
2的0次方 + 2 的1次方 + 2的2次方 = 1 + 2 + 4 = 7
^ 按位异或，运算原则：参与运算的两个数相应位相同则结果为0，异号则为1；
十进制 　　　　　　　二进制 　　　　　　　　　　　　结果(十进制)
3 　　　　00000000_00000000_00000000_00000011
5 　　　　00000000_00000000_00000000_00000101
­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
­­­­­­­­­­­­­­­­­­­­­­­­­
^ : 　　　　00000000_00000000_00000000_00000110 　　　6
所以3 ^ 5等于 6.
~ 按位取反，运算原则：二进制数位上0变1，1变0；
十进制 　　　　　　　 二进制 　　　　　　　　　　　　结果(十进制)
5 　　　　00000000_00000000_00000000_00000101
­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
­­­­­­­­­­­­­­­­­­­­­­­­­
~ : 　　　　11111111_11111111_11111111_1111010 　　　　　­6
所以~5等于 ­6.

左移操作“<<”：将运算数的二进制码整体左移指定位数，左移之后的空使用“0”来补充，移出去的二进制数忽略不计。
9 << 2 :
十进制 　　　　　　　二进制 　　　　　　　　　　　　结果(十进制)
9 　　　　00000000_00000000_00000000_00001001
­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
­­­­­­­­­­­­­­­­­­­­­­­­­
　　　　　00000000_00000000_00000000_0000100100 　36
所以9<<2等于 36.
规律：<<：相当于给原数乘以2的倍数
右移操作“>>”：将运算数的二进制码整体右移指定位数，右移之后的空使用“符号位”来补充。移出去的二进制数忽略不计。若是正数使用“0”补充；若是负数使用“1”补充；
9 >>2 :
十进制 　　　　　　　二进制 　　　　　　　　　　　　结果(十进制)
9 　　　　00000000_00000000_00000000_00001001
­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
­­­­­­­­­­­­­­­­­­­­­­­­­
　　　　　0000000000_00000000_00000000_00001001 　　2
所以9>>2等于 2.
规律：>>：相当于给原数除以2的倍数
­6 >> 2:
十进制 　　　　　 　　二进制 　　　　　　　　　　　　结果(十进制)
­6 　　　　11111111_11111111_11111111_1111010
­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
­­­­­­­­­­­­­­­­­­­­­­­­­
　　　　1111111111_11111111_11111111_1111010
所以­6>>2等于 ­2.
无符号右移">>>"：将运算数的二进制码整体右移指定位数，右移之后的空使用“0”来补充
位运算应用
●需求1：最有效率运算2乘以8.通过位移运算。2<<3
●需求2,对两个整数变量的值进行互换(不需要第三方变量)
//通过第三方变量的形式进行置换。
int a = 3, b = 7;
int temp = a;
a = b;
b = temp;
//通过和的形式。有个弊端，两个数据较大，可能会超出int范围。
a = a + b;//a = 3 + 7;
b = a ­ b;//b = 3 + 7 ­ 7； b = 3;
a = a ­ b;//a = 3 + 7 ­ 3; a = 7;
//技巧。异或。
a = a ^ b;// a = 3 ^ 7;
b = a ^ b;// b = 3 ^ 7 ^ 7;
a = a ^ b;// a = 3 ^ 7 ^ 3;

编程练习题

1

2

3

4

5

6

7

8