一、标识符
Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符。凡是自己可以起名字的地方都叫标识符。
1、标识符命名规则
定义合法标识符规则（必死）：
- 由26个英文字母大小写，0-9 ，_或 $ 组成
- 数字不可以开头。
- 不可以使用关键字和保留字，但能包含关键字和保留字。
- Java中严格区分大小写，长度无限制。
- 标识符不能包含空格。
2.标识符命名规范
标识符的命名规范（死得快或者混的惨）：
在起名字时，为了提高阅读性，要尽量有意义，“见名知意”
- 包名：多单词组成时所有字母都小写：xxxyyyzzz
- 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
- 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
- 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
二、关键字、保留字、特殊值
关键字、保留字和特殊值：全部小写（50+3）
（1）关键字：在Java中被赋予的特定含义的单词。
基本数据类型相关（8个）：byte、short、int、long、float、double、char、boolean
流程控制语句相关（10个）：if、else、switch、case、default、break、for、while、do、continue
判断某个对象是否是某种类型的实例对象运算符：instanceof
定义类：class
创建类的对象：new
包相关：package、import
权限修饰符：public、protected、（缺省）、private
继承类：extends
定义接口：interface
实现接口：implements
当前对象：this
父类引用：super
表示无返回值：void
结束方法：return
定义枚举：enum
其他修饰符：abstract、static、final、native
异常处理：try、catch、finally、throws、throw
多线程同步和安全：synchronized、volatile
和IO序列化相关：transient
和单元测试相关：assert
其他：strictfp（strictfp 关键字可应用于类、接口或方法。如果你想让你的浮点运算更加精确，严格遵守FP-strict的限制,符合IEEE-754规范，而且不会因为不同的硬件平台所执行的结果不一致的话，可以用关键字strictfp.
）
（2）保留字：在Java中注册但还未使用
goto、const
（3）特殊值：true、false、null
三.变量
变量的作用：保存数据
变量的本质：内存的一块存储区域
变量的三要素：数据类型、变量名、变量值
- 数据类型：决定内存大小，可以存什么值
- 变量名：如何访问这块存储区域
- 变量值：里面存储的数据
声明变量：数据类型 变量名;
变量赋值：变量名 = 变量值;
声明变量和变量的赋值可以同时进行，也可以分开进行。但是在变量被访问之前，必须有值。
例如：数据类型 变量名 = 变量初始值;
变量的使用：通过变量名来访问这块存储区域
要求：
- 变量必须先声明后使用
- 变量再使用之前必须有初始值
- 变量有作用域
/*
变量：
某个值在程序中不同的地方都在使用，那么这个值就用一个变量保存。可以使用变量名来代表这个值。
变量本质对代表内存的一块存储区域。
变量的三要素：
1、变量名
比喻：房主，地址
2、数据类型（决定区域的大小，决定里面存的是什么类型的值）
比喻：面积，用途
3、变量值
比喻：里面的内容
如何使用变量？
1、变量必须先声明后使用
声明变量的格式：
数据类型 变量名;
例如：int age;
int num;
double score;
2、变量的使用之前，还必须初始化
变量赋值的格式：
变量名 = 变量值;
变量的声明和初始化可以在同一个语句完成。
例如：int age = 18;
3、变量有作用域
从声明处开始，到它所属的}结束
同一个作用域中不能重复声明
（1）同一个作用域中，一个变量声明一次
（2）同一个作用域变量不能重名
*/
class BianLiang{
public static void main(String[] args){
//声明变量
int age;
//变量的赋值，第一次赋值叫做初始化
age = 18;
System.out.print("现在年龄：" + age);
System.out.print("明年的年龄：" + (age+1));
}
/*
//age超过作用域
public static void test(){
System.out.print("现在年龄：" + age);
}
*/
}
四.数据类型
哪些地方需要数据类型：变量（形参属于局部变量）、返回值
变量的数据类型
基本数据类型（8种）：
整型：byte（1个字节）short（2个字节）int（4个字节，整数的默认类型）long（8个字节）
字节byte：1个字节，-128~127
短整型short：2个字节，-32768~32767
浮点型：float（4个字节）double（8个字节，小数的默认类型）
字符型：char（2个字节）
布尔型：boolean（只有两个值true和false）
引用数据类型：
类（class）/接口（interface）----String字符串
数组（[]）
泛型（<>）
注意：
Java的整型常量默认为 int 型，如果想要表示某个整数值是long型时，需要在值后面加L或l。java程序中变量常声明为int型，除非不足以表示大数，才使用long
Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。float可以保证十进制科学计数法小数点后6位有效精度和第7位的部分精度。double可以保证十进制科学计数法小数点后15位有效精度和第16位的部分精度。
字符型的值必须使用单引号，只能而且必须存储单个字符，不能是空单引号。例如：’a’、’\n’、’\u5c1a’。字符型使用Unicode编码（ASCII，特殊字符，中文、日文、韩文…）
String是引用数据类型，String的常量值必须使用双引号。单独的双引号也是一个字符串值。
/*
Java的数据类型：
（1）基本数据类型（8种）
（2）引用数据类型：类、数组、接口...
一、基本数据类型（8种）
bit：位，计算机中只有0和1，最小的存储单位
byte：字节，一个字节 = 8 位
1、数值型
（1）整型（整数）
byte：字节 1个字节 -128~127
short：短整型 2个字节 -32768~32767
int：整型（默认类型）4个字节
long：长整型 8个字节
特殊：long类型的数字后面需要加L或l
（2）浮点型（小数）
float：单精度浮点型（4个字节）
科学记数法：356.78 3.5678*10^2
大约是：小数点后6~7位
特殊：float类型的数字后面需要加F或f
double：双精度浮点型（8个字节）默认类型
大约是：小数点后15~16位
2、字符型
char：字符型 2个字节 因为Java中所有的字符都使用Unicode字符集
Java中每一个字符，都有一个唯一的Unicode编码值。
可以存储一个字母，一个汉字，一个其他的字符
字符类型的值要使用单引号引起来''
字符串类型的值要使用双引号引起来""
char c = 'a';
char s = '女';
char line = '\n';//转义字符
char tab = '\t';
char d = '\b';
char b = '\'';
char b = '\"';
char c = '\u5c1a';//Unicode编码值的十六进制形式
3、布尔型，逻辑型
boolean：只有两个值，true和false
*/
class LeiXing{
public static void main(String[] args){
byte b = 127;
System.out.println("b = " + b);//""中的内容原样输出
long num = 123456789012345678L;
System.out.println("num=" + num);
float f = 3.1F;
System.out.println("f=" + f);
double d = 3.1415926531234;
System.out.println("d=" + d);
//char gender = '女';
//String sex = "女";
//System.out.print("a\tb\nc\b");
char c = '尚';//char c = '\u5c1a';
System.out.print(c);
boolean beautiful = false;
if(beautiful){
System.out.println("柴老师是大美女");
}else{
System.out.println("柴老师是大大美女");
}
}
}
变量的运算之数据类型之间的转换
/*
基本类型的转换：
（1）自动类型转换
byte,short,char --> int -->long --> float --> double
1个字节，2个字节，2个字节 4个字节 8个字节 4个字节 8个字节
说明：
byte,short,char之间是互不转换的，包括byte+byte等运算也会变成int
boolean和谁都不转
String类型的数据与任意类型的数据“+”拼接后结果都是String字符串
ASCII码：
小写字母a：97
小写字母b：98
大写字母A：65
大写字母B：66
数字0：48
数字1：49
（2）强制类型转换
double --> float --> long -->int -->byte,short,char
需要强制类型转换符()
注意：强制类型转换可能损失精度或溢出
*/
class TypeChange{
public static void main(String[] args){
byte b = 127; //把127赋值给b，存储到b变量中
int num = b; //把变量b中的值复制一份给num，也是说把变量b中的值赋值给num
System.out.println("b = " + b);
System.out.println("num = " + num);
char c = 'a';//Unicode编码值，兼容ASCII码
int letter = c;
System.out.println("c = " + c);//a
System.out.println("letter = " + letter);//97
byte b1 = 1;
byte b2 = 2;
byte b3 = (byte)(b1 + b2);
System.out.println("b3 = " + b3);
char c1 = 'a';
char c2 = (char)(c1 + 1);
System.out.println("c2 = " + c2);
double d = 10.56;
int a = (int)d;
System.out.println("a = " + a);//损失精度
int age = 130;
byte bb = (byte)age;//溢出
System.out.println("bb = " + bb);
}
}
五.进制
1.进制
public class JinZhi{
public static void main(String[] args){
//最终打印的结果是十进制
System.out.println("十进制：" + 10);
System.out.println("二进制：" + 0B10);
System.out.println("八进制：" + 010);
System.out.println("十六进制：" + 0X10);
}
}
1.二进制与十进制之间的转换
2.二进制 八进制 十六进制互转
2.原码、反码、补码
所有数字在计算机底层都以二进制形式存在。一个数在计算机中的二进制表示形式, 叫做这个数的机器数。机器数是带符号的，在计算机用一个数的最高位存放符号, 正数为0, 负数为1。
Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位；当是long类型时，二进制默认占64位，第64位是符号位。
因为机器数是带符号的，因此机器数与一个数的“二进制值”还是有区别的。
计算机以补码的形式保存所有的整数。
正数的原码、反码、补码都相同
负数的补码是其反码加1。
六、运算符
运算符：
1、算术运算符
2、赋值运算符
3、比较运算符（关系运算符）
4、逻辑运算符
5、条件运算符
6、位运算符
表达式：操作数+运算符
1.算数运算符
（1）加、减、乘、除：+、-、*、/ 除：当两个整数相除时，只保留整数部分
（2）取模（求余数）：%
取模：被模数%模数，当模数有负号时，会被忽略
（3）+：作为单目运算时表示正数 与其他基本数据类型计算时当做加法用
当与字符串String类型进行运算时表示连接，计算结果是字符串String类型
（4）-：作为单目运算符时表示负数
与其他基本数据类型计算时当做减法用
（5）++，-- 自增和自减
++在前，变量先自增，然后参与其他运算，在后，变量的值先参与其他运算，然后变量本身在自增 --类似
/*
算术：arithmetic
一、算术运算符
（1）加：+
（2）减：-
（3）乘：*
（4）除：/
特殊：如果是两个整数相除，结果只保留整数部分
（5）取余，取模：% 被模数%模数
特殊：模数的负号被忽略
（6)在JAVA中：+ 还表示拼接
只要+两边有一个是字符串，那么就是拼接，结果仍然是字符串
a + "+"：a变量的值 拼接上 “+”符号 23+
（7）正号 +
（8）负号 -
（9）自增 ++
对于自增变量本身来说，++在前或在后都一样，自增变量都要加1
i++或++i，i就是自增变量
对于表达式来说，i++和++i不一样的，++在前，先自增，再进行其他运算，++在后，先进行其他运算，然后再自增
（10）自减 --
同自增
*/
class SuanShu{
public static void main(String[] args){
int a = 23;
int b = 12;
System.out.println(a + "+" + b + "=" + (a+b));
int sum = a + b;
System.out.println(a + "+" + b + "=" + sum);
int sub = a - b;
//System.out.println(a + "-" + b + "=" + a-b);//错误，原因是a + "-" + b + "=" + a的结果是字符串，字符串不能进行减法
System.out.println(a + "-" + b + "=" + (a-b));
System.out.println(a + "-" + b + "=" + sub);
int mul = a * b;
System.out.println(a + "*" + b + "=" + a*b);
System.out.println(a + "*" + b + "=" + mul);
//整数相除，只保留整数部分
int div = a / b;
System.out.println(a + "/" + b + "=" + a/b);
System.out.println(a + "/" + b + "=" + div);
double d = (double)a/b;//先把a的类型进行转换，转换成double类型，然后再和b相除
System.out.println(a + "/" + b + "=" + d);
int yu = a % b;
System.out.println(a + "%" + b + "=" + yu);
System.out.println("------------------特殊的取模----------------------");
System.out.println(5%2);//1
System.out.println(-5%-2);//-1
System.out.println(-5%2);//-1
System.out.println(5%-2);//1
System.out.println("------------------负号----------------------");
int num1 = 12;
int num2 = -num1;
System.out.println("num2=" + num2);
System.out.println("------------------自增----------------------");
int i = 0;
System.out.println("自增之前i=" + i);
i++;
System.out.println("自增第一次之后i=" + i);
++i;
System.out.println("自增第二次之后i=" + i);
int j = ++i;//把i自增1，然后结果赋值给j，或者说，先算++i，然后再赋值
System.out.println("自增第三次之后i=" + i);
System.out.println("j="+j);
int k = i++;//先算赋值，把i的值赋值给k，i原来是3，把3赋值给k，然后i在自增1，i变成4
System.out.println("自增第四次之后i=" + i);
System.out.println("k="+k);
//面试题：陷阱题
i = i++;//先赋值，把i原来的值重新赋值给i，不变，然后i自增，但是这个自增后的值没有在放回变量i的位置
System.out.println("自增第五次之后i=" + i);
}
}
练习1
public class TestSign{
public static void main(String[] args){
int i1 = 10;
int i2 = 20;
int i = i1++;//把i1自增之前的值赋值给i，然后i1再自增1
System.out.print("i="+i);//10
System.out.println("，i1="+i1);//11
i = ++i1;//把i1自增之后的值赋值给i
System.out.print("i="+i);//12
System.out.println("，i1="+i1);//12
i = i2--;//把i2自减之前的值赋值给i，然后i2自减1
System.out.print("i="+i);//20
System.out.println("，i2="+i2);//19
i = --i2;//把i2自减之后的值赋值给i，先自减再赋值
System.out.print("i="+i);//18
System.out.println("，i2="+i2);//18
}
}
练习2
练习:
随意给出一个三位数，打印显示它的个位数，十位数，百位数的值。
格式如下：
数字xx的情况如下：
个位数：
十位数：
百位数：
例如：
数字153的情况如下：
个位数：3
十位数：5
百位数：1
class TestBaiShiGe{
public static void main(String[] args){
int num = 153;
int bai = num / 100;//因为两个整数相除，只保留整数部分
int ge = num % 10;
//int shi = num / 10 % 10;//num / 10得到15，然后15%10得到5
int shi = num % 100 / 10;//num%100得到53，然后53/10得到5
System.out.println("num的");
System.out.println("百位是：" + bai);
System.out.println("十位是：" + shi);
System.out.println("个位是：" + ge);
}
}
2.赋值运算符
/*
赋值：assign
最基本的赋值运算符：=
Java中赋值，永远是把等号=右边的赋值给左边的变量。
右边如果是常量值，那么就把常量的值直接赋值给左边的变量；
右边如果是变量，那么就把变量的值直接赋值给左边的变量；
右边如果是表达式，那么就把表达式的运算结果直接赋值给左边的变量；
扩展的赋值运算符：
+=，-=，*=，/=，%=
注意：
（1）+=等，中间是不能有空格的，即不能写成 + =
（2）如果结果的类型与左边的变量不在一样时，隐含了强制类型转换
*/
class FuZhi{
public static void main(String[] args){
int a = 10;//把10赋值给a
int b = a; //把a的值赋值给b
int c = a + b;//把a+b的运算结果赋值给c
//20 = a;//错误的
System.out.println("-------------------------------");
byte b1 = 1;
byte b2 = 127;
//b2 = b1 + b2;//右边的结果是int类型，需要强制类型转换
b2 += b1;//把左边的变量的值 + 右边的变量的值，结果再赋值给左边的变量，如果计算的结果是升级后的结果，会强制类型转换
System.out.println("b1=" + b1);
System.out.println("b2=" + b2);
System.out.println("-------------------------------");
int i = 2;
int j = 3;
j *= i + 1;//等价于 j = j * (i+1);
System.out.println("i=" + i);
System.out.println("j=" + j);
System.out.println("-------------------------------");
int m = 2;
int n = 3;
n *= m++;// (1)n = n * m; (2)m++;
System.out.println("m=" + m);//对于自增变量来说，++在前还是在后都要自增1
System.out.println("n=" + n);
System.out.println("-------------------------------");
int x = 2;
int y = 3;
y *= ++x;// (1)++x; (2)y = y * x;
System.out.println("x=" + x);//对于自增变量来说，++在前还是在后都要自增1
System.out.println("y=" + y);
System.out.println("-------------------------------");
i = 1;
i *= 0.1;//把double类型强制转换成int
System.out.println(i);//0
i++;
System.out.println(i);//1
}
}
3.逻辑运算符逻辑运算符
/*
逻辑：logic,logical
逻辑运算符：
(1)逻辑与：&
表示&左右两边的条件要同时成立
true & true 结果才为true
true & false 结果为false
false & true 结果为false
false & false 结果为false
(2)逻辑或： |
表示|左右两边的条件只要有一个成立就可以
false | false 结果为false
false | true 结果为true
true | false 结果为true
true | true 结果为true
(3)逻辑非：!
!false 结果为true
!true 结果为false
(4) 逻辑异或：^
^左右两边的条件的结果相反时为true
true ^ true 结果为false
true ^ false 结果为true
false ^ true 结果为true
false ^ false 结果为false
(5)短路与：&&
表示&&左右两边的条件要同时成立
true && true 结果才为true
true && false 结果为false
false && true 结果为false
false && false 结果为false
同逻辑与&有所不同：当&&左边的表达式为false时，右边的表达式不看了
(6)短路或：||
表示||左右两边的条件只要有一个成立就可以
false || false 结果为false
false || true 结果为true
true || false 结果为true
true || true 结果为true
和逻辑或|有所不同：当||左边的表达式为true时，右边的表达式不看了
二元运算符：运算符需要两个操作数
a + b， a * b， a = b， a > b，...
一元运算符： 运算符需要一个操作数
++，--，正号，负号
i++，+a
*/
class Logic{
public static void main(String[] args){
//成绩
int score = -75;
//如果成绩在80~90之间，我们显示成绩良好
//80<=score<=90
/*错误
if(80 <= score <= 90){
System.out.println("良好");
}
*/
if(score>=80 & score<=90){
System.out.println("良好");
}
//如果成绩小于0或大于100，我们显示超过合理的成绩范围
if(score<0 | score>100){
System.out.println("超出成绩范围");
}
System.out.println("------------------------------------");
System.out.println(true & true);//true
System.out.println(true & false);//false
System.out.println(false & true);//false
System.out.println(false & false);//false
System.out.println("------------------------------------");
System.out.println(true | true);//true
System.out.println(true | false);//true
System.out.println(false | true);//true
System.out.println(false | false);//false
System.out.println("------------------------------------");
int num = 100;
boolean flag = num<100 | num>100;
System.out.println("flag = " + flag);
if(!flag){
System.out.println("num等于100");
}
System.out.println("------------------------------------");
System.out.println(true ^ true);//false
System.out.println(true ^ false);//true
System.out.println(false ^ true);//true
System.out.println(false ^ false);//false
System.out.println("------------------------------------");
int i = 0;
int j = 1;
if(i>0 && ++j > 1){
i = 20;
}
System.out.println("i=" + i);
System.out.println("j=" + j);
}
}
练习1
练习1
public class LogicExer1{
public static void main(String[] args){
int x = 1;
int y = 1;
//x==2 ,x++ false x = 2 左边为false
//右边继续
//++y y==2 y=2 y==2成立 右边为true
//整个条件还是false
if(x++==2 & ++y==2){
x =7;
}
System.out.println("x="+x+",y="+y);//x=2,y=2
}
} public class LogicExer2{
public static void main(String[] args){
int x = 1,y = 1;
//x==2,x++ 左边条件为false，x=2
//因为短路与，右边不算
//整个条件为false
if(x++==2 && ++y==2){
x =7;
}
System.out.println("x="+x+",y="+y);//x=2,y=1
}
}
public class LogicExer3{
public static void main(String[] args){
int x = 1,y = 1;
//x==1,x++ 左边为true，x=2
//因为是逻辑与,右边继续
//++y, y==1 y=2 右边为false
//条件true | false，最终为true
if(x++==1 | ++y==1){
x =7;
}
System.out.println("x="+x+",y="+y);//x=7,y=2
}
}
public class LogicExer4{
public static void main(String[] args){
int x = 1,y = 1;
//x==1,x++ 左边为true，x=2
//因为是短路或，左边为true，右边就不看了
//整个条件为true
if(x++==1 || ++y==1){
x =7;
}
System.out.println("x="+x+",y="+y);//x=7,y=1
}
}
4、关系运算符
/*
比较：compare
关系：relation
比较运算符又称为关系运算符：
1、大于：>
2、小于：<
3、大于等于：>=(中间不能有空格)
4、小于等于：<=
5、是否等于：==
6、是否不等于：!=
条件判断时，常常使用比较运算符
比较运算符的表达式的结果只有两种：true或false，即结果是一个boolean值
*/
class BiJiao{
public static void main(String[] args){
int age = 19;
System.out.println(age >= 18);
System.out.println(age < 18);
System.out.println("------------------------------");
System.out.println(age == 18);//比较运算符的表达式，结果是true
System.out.println(age = 18);//赋值表达式，结果是18
boolean result = false;
if(result = true){
//变成了一个赋值表达式
System.out.println("条件成立");
}
System.out.println("result="+result);
/*
编译错误(age=18)不是比较表达式，结果也不是true或false，条件只能是布尔值
if(age = 18){
System.out.println("刚刚成年");
}
*/
/*
if(age>=18){
System.out.println("欢迎进入成人世界！");
}else{
System.out.println("未成年不允许进入！");
}
*/
}
}
5.三元运算符
三元运算符：格式 条件表达式?表达式1:表达式2
注意条件表达式结果必须是布尔类型
当条件表达式的结果为true,那么整个三元运算符的结果就取表达式1的结果，否则就取表达式2的结果
案例：求两个数最大值
求三个数最大值
//找出三个整数中的最大值
public class FindMax{
public static void main(String[] args){
int x = 3;
int y = 2;
int z = 5;
int max = x>=y ? x : y;
//运行到这里，max中存的是x,y中较大者
max = max >= z ? max : z;
System.out.println("max = " + max);
}
}
6.位运算符
public class BitOperator{
public static void main(String[] args){
int a = 8;
//a的二进制：24个零 0000 1000
//a<<2
//24个零 0010 0000
System.out.println(a << 2);
//a的二进制：24个零 0000 1000
//a>>2
//24个零 000000 10
System.out.println(a >> 2);
int b = -8;
//b的二进制：
//原码 1 23个0 0000 1000
//反码：1 23个1 1111 0111
//补码：1 23个1 1111 1000
//左移b<<2，右边补0
//1 23个1 1110 0000 补码
//反码：1 23个1 1101 1111
//原码：1 23个0 0010 0000 -32
System.out.println(b << 2);
//b的二进制：
//原码 1 23个0 0000 1000
//反码：1 23个1 1111 0111
//补码：1 23个1 1111 1000
//右移：b>>2，左边补什么，看最高位，
//补码：1 23个1 111111 10
//反码：1 23个1 111111 01
//原码：1 23个0 0000 0010 -2
System.out.println(b >> 2);
//无符号右移
//b的二进制：
//原码 1 23个0 0000 1000
//反码：1 23个1 1111 0111
//补码：1 23个1 1111 1000
//无符号右移：b >>> 2,不看最高位，左边直接补0
//00 1 23个1 1111 10
System.out.println(b >>> 2);
System.out.println("-----------------------------");
//a的二进制：24个零 0000 1000
//b的二进制：
//原码 1 23个0 0000 1000
//反码：1 23个1 1111 0111
//补码：1 23个1 1111 1000
//24个零 0000 1000 & 1 23个1 1111 1000
//24个零 0000 1000 -》 8
System.out.println(a & b);
//24个零 0000 1000 | 1 23个1 1111 1000
//1 23个1 1111 1000 ->-8
System.out.println(a | b);
//24个零 0000 1000 | 1 23个1 1111 1000
//24个1 1111 0000补码
//反码：24个1 1110 1111
//原码：1 23个0 0001 0000 -》 -16
System.out.println(a ^ b);
//a的二进制：24个零 0000 1000
//~a
//24个1 1111 0111补码
//反码：24个1 1111 0110
//原码：1 23个0 0000 1001
System.out.println(~a);
}
}