JAVA基础复习day02
文章目录
关键字
1.概念
关键字--在java中具有特殊功能的单词
53个关键字，全部都是小写
const、goto(新的jdk版本中算作关键字)
标识符
1.概念
标识符--在java中可以自定义的名称
2.组成范围
a.各国常见文字 b.数字(0~9) c.特殊符号（_、$（慎用---内部类使用））
3.命名规则
不能出现关键字、不能以数字开头
在组成范围内的内容且遵守命名规则的是符合java语法的标识符（合法）
4.驼峰命名法（是在标识符合法的基础上）
1.类名/接口名---XxxYyyZzz
2.方法名/变量名---xxxYyyZzz
3.包名（包是用来区分同名类）
单级---xxx cn
多级---xxx.yyy.zzz duji.cn.day02
5.见名知意
注释
注释—用于解释说明的文字(不参与程序的执行)
格式
单行注释—//注释内容
多行注释—/注释内容/(可以嵌套单行注释不能嵌套多行注释）
文档注释—/*注释内容/(可以通过javadoc命令生成解释说明的文档打开index.html
javadoc 文件名.java
index.html
常量
概念
程序运行过程中不发生改变的值
分类(字面值常量和自定义常量)
字面值常量：
整数常量 1000、1871
小数常量 1.1 、0.345
字符串常量 "12" "asdad"
字符常量 '3' 'd'
布尔常量 true false
空常量 null
自定义常量(wait 面向对象)
整数表示方式
二进制 binary
由0和1表示的数据 以0b开头的数据就是二进制数据 0b1000
八进制 octal OCT
由0~7表示数据 以0开头的数据就是8进制数据 01010 == 十进制520
十进制 decimal DEC
由0~9表示数据 默认
十六进制 hexadecimal HEX
由0~9, a-f(不区分大小写)表示数据 以0x开头的数据是十六进制数据
进制的转换
其他进制转换成十进制
二进制 1010 十进制 1**0
=1*2`3+**0*2`2+1*2`1+0*2`0=10
十六进制 522 十进制 1314
=5*16·2+2*16`1+2*16`0=1314
项：每位数
基数：X进制 基数就是X
权：从右往左由0开始依次编号
总结规律：
项乘以基数为底的权次幂之和
十进制转成其他进制
十进制 15 八进制 17
余数
15/8=1········7 ↑
1/8=1·········1 ↑
十进制 21 八进制 15
21/16=1·······5 ↑
1/16=0·········1 ↑
总结规律
除基取余，直到商为0，余数翻转
任意进制之间的转换
X进制转换十进制数据再把十进制数据转换成对应Y进制
拆分组合
八进制 12 1 2
二进制 001010 001 010
十六进制 6a 6 a
二进制 01101010 0110 1010
有符号的数
计算机上所有的数据在底层都是以二进制数据的补码形式来表示
有符号的数
| 原码：符号位来表示正负，0代表正数，1代表负数 |
|---|
| 原码 | 符号位 | 数值位 |
|---|---|---|
| 5 | 0 | 0000101 |
| -5 | 1 | 0000101 |
| 反码：正数的原码和反码保持一致，负数的反码是在原码的基础上符号位不变，数值位1变0，0变1 |
|---|
| 反码 | 符号位 | 数值位 |
|---|---|---|
| 5 | 0 | 0000101 |
| -5 | 1 | 1111010 |
| 补码：正数的原、反、补、皆一致，负数是在反码的基础上末尾加1 |
|---|
| 补码 | 符号位 | 数值位 |
|---|---|---|
| 5 | 0 | 0000101 |
| -5 | 1 | 1111011 |
小数
绝大部分的小数二进制是无线位数
变量
概念
在程序运行过程中可以改变的值
可以存储单个数据的容器
定义变量
数据类型 变量名=初始化值；
数据类型：限制数据变化范围
变量名：区分其他变量
初始化：给变量赋值
数据类型
数据类型分为俩种(基本数据类型和引用数据类型[类、接口、数组])
| 基本数据类型(4类8种) | 占用空间(字节) | 范围 |
|---|---|---|
| 整数型 | ||
| byte字节型 | 1 | -128~~~127(-27 ~27-1) |
| short短整型 | 2 | -32768~~~32767(-215~ 215-1) |
| int整型 | 4 | -231~ 231-1 |
| long长整型 | 8 | -263~263-1 |
| 浮点型 | ||
| float单精度 | 4 | -e38~e38(e是10) |
| double双精度 | 8 | -e308~e308 |
| 布尔型 | ||
| true | ||
| false | ||
| 字符型 | ||
| char | 2 | 0~65535 |
引用数据类型[类、接口、数组]
java是一门强类型语言，要求java中所有的数据都要有数据类型的表示。
Char
char c =‘中’
码表
文字转成底层数字—编码 文字转成底层数字的规则—码表
ASCII（阿斯克码表 占用一个字节）---ISO8859-1（西欧码表 占用一个字节）
BIG5（繁体中文--占用2个字节） GB2312（简体中文--占用2个字节）
GBK（国标码 占用2个字节）
Unicode（编码体系 UTF-8（占用3个字 节）、UTF-16（占用2个字节）、UTF-32等等
ASCII码表
所有的完整码表默认兼容西欧码表
char c =“中”；以u8进行编码，底层占用3个字节
char c =‘a’；以u8进行编码，底层占用1个字节
转义字符
‘\t’—制表符空格 ‘\r’—回车 ‘\n’—换行
变量定义
注意：
1.在java中初始化进行赋值时如果给定的是整数那么这个整数的类型默认是int类型
2.在整数后面加上L/l,此时整数类型指定为了long类型
3.在java中初始化进行赋值时如果给定的是小数那么这个小数的类型默认是double类型
4.在整数后面加上F/f,此时整数类型指定为了float类型
5.变量的定义分为声明和初始化俩个过程
6.变量在哪定义在哪使用`
class JavaDemo{
public static void main(String[] args) {
//定义int类型的变量
int i=1;
//给定的是变量名称但是操作的是变量值
System.out.println(i);
//定义long类型的变量
long l=234628348734L;
System.out.println(l);
//定义float类型的变量
float f=2.12F;
//如果变量没有被操作，那么变量可以先不给值
int i1;//声明
i1=1;//初始化
System.out.println(i1);
}
}类型转换
byte a =1 ;,int b =2;
a+b=int 3;
变量的操作：
类型转换
类型提升（默认 从小到大）
byte-short、char-int-long-float-double
byte、short、char无论做任何操作都会类型提升为int类型
强制类型转换
目标类型 名称 =（目标类型）数据；
可能会出现一些意想不到的数
class Demo{
public static void main(String[] args) {
//定义变量
byte a=1;
int b=2;
byte c=a+b;//不兼容的类型: 从int转换到byte可能会有损失
//说明byte和short之间有类型提升
byte b=1;
short s=b；
System.out.println(s);//1
//把字符转成对应的编码值再赋值给short变量
//如果字符转成的编码值大于short的范围就不能正常赋值
short s='达';//97
//'0'---48 'A'---65 'a'---97
//把数字通过编码转成对应的字符再赋值给char变量
char c=99;//'b'
//没有类型提升，short类型的取值范围包含负数但是字符不能出现负数
short s=1; char c=s;/*错误: 不兼容的类型: 从short转换到char可能会有损失*/
//char和int之间有类型提升
char c='1';
int i=c;
System.out.println(i);//49
//int和long之间有类型提升
int i=1;
long l=i;
System.out.println(l);//1
//long和float之间有类型提升
//从整型到浮点型进行类型提升时可能会出现精度丢失问题
long l=13456287343L;
float f=l;
System.out.println(f);//1.34562877E10
//float和double之间有类型提升
float f=1.1F;
double d=f;
System.out.println(d+" "+f);//1.100000023841858 1.1
//byte,char,short底层的类型就是int类型
byte b1=1,b2=2;
short s=2;
char c=3;
byte c =b1+b2;//不兼容的类型: 从int转换到byte可能会有损失
//强制把int类型转成byte类型
byte b3=(byte)(b1+b2);
System.out.println(b3);//3
//小数强制类型转成整数时可能会出现舍弃
float f=4.99993476F;
int i=(int)f;
System.out.println(i); //4
//当等号右边所有参与运算的数据都是常量
//那么在编译时期会进行优化直接计算结果再把结果赋值给变量
byte bbb=128-1;//127
//byte范围(-128~127)
int b=128;
byte bb=(byte)b;
System.out.println(bb); //-128
}
}
/*
00000000 00000000 00000000 10000000 int 128 补码
转成byte类型
10000000 byte 补码 负数
11111111 byte 反码 负数 (1000 0000减1)
10000000 byte 原码 负数--- -0
-0 规定表示对应类型的最小值 是[-128（特殊认为可以把最高位既当做符号位也当做数值位）]
*/
运算符
算术运算符
+、-、*、/、%、++、--
++、--
单独运算
参与运算
如果++出现在操作数的后面，先赋值再自加1
如果++出现在操作数的前面，先自加1再赋值
如果--出现在操作数的后面，先赋值再自减1
如果--出现在操作数的前面，先自减1再赋值
class SuanShuDemo{
public static void main(String[] args) {
//操作 +
//功能---求和、字符串连接符
int a=1;
int b=2;
System.out.println(a+b);//3
System.out.println(a+b+'a');//100
//数值类型变量遇到字符型数据，先把字符型转成对应的编码值，再进行运算
System.out.println(1.0+2.34+'a');//100
System.out.println(a+'b'+b);//101
//字符串常量遇到任意类型数据都是拼接
System.out.println(a+"a"+b);//1a2
System.out.println(a+b+"a");//1a2
//操作 -
//小数不精确
System.out.println(2.1-1.9);//0.20000000000000018
//操作 /
int c=6;
int d=4;
int e=6.0;
int f=4.0;
//如果参与运算的都是整数,结果一定是整数
//如果参与运算的有小数,结果就是小数
System.out.println(c/d);//1
System.out.println(e/d);//1.5
System.out.println(c/f);//1.5
System.out.println(e/f);//1.5
//整数不能除0
System.out.println(1/0);//ArithmeticExceptiom---算术异常
//小数可以除0
//infinity(正无穷大)
//-infinity(负无穷大)
System.out.println(1.0/0);//infinity
System.out.println(0.0/0);//NaN ---Not A Number(和本身都不相等)
//操作%
//%左边的正负决定了结果的正负
System.out.println(1%2);//1
System.out.println(-1%2);//-1
System.out.println(1%-2);//1
System.out.println(-1%-2);//-1
//操作++ --
int a=3;
int b=(a++)+(++a)+(a--)+(--a);
//b=3+5+5+3
//a=4 5 4 3
System.out.println(b);//16
System.out.println(a);//3
//++ -- 针对byte、short以及char含有强制类型转换
byte c=127;
c++
System.out.println(c);// int 128 (byte)--- -128
short b=32767;
b++;
System.out.println(b);//-32768
赋值运算符
赋值运算符= （把右边的值赋值给左边）
扩展赋值运算符（强制类型转换）
+=、-=、*=、/=、%=、&=(按位与等)、 |=(按位或等)
^=(按位异或等)、>>=(右移等)、<<=(左移等)、>>>=(无符号右移等)
class FuZhiDemo{
public static void main(String[] args) {
byte a=1;
a+=4;//a=a+4;//+= int 5（byte）---5
System.out.println(a);// 5
// java不允许出现连等定义
//int a=b=c=4;
//java允许连等赋值
int a=3;
int b=a+=a-=a+=7;
//b=a+=a-=a=a+7-10
//b=a+=a-=10
//b=a+=a=a-10- -7
//b=a+=-7
//b=a=a-7- -4
System.out.println(a);//-4
System.out.println(b);//-4
}
}比较(关系)运算符
比较（关系）运算符 (结果一定是布尔值)
==、>、<、>=、<=、!=
a>b>c a>b&b>c
class BiJiaoDemo{
public static void main(String[] args) {
System.out.println(1==2);//false
System.out.println(1>=2);//false
System.out.println(1<=2);//true
System.out.println(1!=2);//true
}
}逻辑运算符
逻辑运算符 (连接左右俩边布尔值)a>b>c a>b&b>c
&、|、^(异或)、!(非)、&&(双与)、 ||(双或)、 ||(双或)
总结：
&:遇见false就是false
|:遇见true就是true
^: 相同则false，不同则true (吸铁石)
!: 取反(false变true，true变false 奇数个非结果取反，偶数个非结果不变)
&&:(双与)和&的运算规律一致如果&&左边是false右边不执行---短路效果
||:(双或)和|的运算规律一致如果||左边是true右边不执行---短路效果
如果||出现在&&左边且||左边布尔值为true
||会把后面所有内容一并短路掉
class LuoJiDemo{
public static void main(String[] args) {
int a=1;
int b=2;
int c=3;
//操作&
System.out.println("操作&");
System.out.println((a>b)&(b>c));//false&false false
System.out.println((a>b)&(b<c));//false&true false
System.out.println((a<b)&(b>c));//true&false false
System.out.println((a<b)&(b<c));//true&true true
System.out.println("----------------------");
//操作|
System.out.println("操作|");
System.out.println((a>b)|(b>c));//false|false false
System.out.println((a>b)|(b<c));//false|true true
System.out.println((a<b)|(b>c));//true|false true
System.out.println((a<b)|(b<c));//true|true true
System.out.println("----------------------");
//操作^
System.out.println("操作^");
System.out.println((a>b)^(b>c));//false^false false
System.out.println((a>b)^(b<c));//false^true true
System.out.println((a<b)^(b>c));//true^false true
System.out.println((a<b)^(b<c));//true^true false
System.out.println("----------------------");
//操作!
System.out.println("操作!");
System.out.println(!(!(!(a>b))));//false true
System.out.println("----------------------");
//操作&&
System.out.println("操作&&");
System.out.println((a>b)&&(b>c));//false&&false false
System.out.println((a>b)&&(b<c));//false&&true false
System.out.println((a<b)&&(b>c));//true&&false false
System.out.println((a<b)&&(b<c));//true&&true true
System.out.println("--------------------");
//a=1 b=2 c=3
//如果||出现在&&左边且||左边布尔值为true, ||会把后面所有内容一并短路掉
System.out.println(true||(a++>b)&&(b<c++));//true
System.out.println(a);//1
System.out.println(c);//3
位运算符
针对二进制数据的补码形式做运算
&(按位与)、|(按位或)、^(按位异或)、~(按位取反)、
>>(右移)、<<(左移)、>>>(无符号右移)
class WeiDemo{
public static void main(String[] args) {
int a=2;
//操作&
System.out.println(a&3);//2
//操作|
System.out.println(a|3);//3
//操作^
System.out.println(a^3);//1
//操作~
System.out.println(~a);//-3
/*
操作&(遇0则0） 任意整数&1=1 就是奇数，结果是0，就是偶数
任意整数&正数---- 结果一定是正数
00000000 00000000 00000000 00000010 int 2 补码
00000000 00000000 00000000 00000011 int 3 补码
-----------------------------------
00000000 00000000 00000000 00000010 2 补码
)*/
/*
操作|(遇1则1） 任意整数|0---- 结果还是本身
任意整数|负数---- 结果一定是负数
00000000 00000000 00000000 00000010 int 2 补码
00000000 00000000 00000000 00000011 int 3 补码
-----------------------------------
00000000 00000000 00000000 00000011 3 补码
)*/
/*
操作^(相同则0，不同则1） 任意整数|0---- 结果还是本身
任意整数|负数---- 结果一定是负数
00000000 00000000 00000000 00000010 int 2 补码
00000000 00000000 00000000 00000011 int 3 补码
-----------------------------------
00000000 00000000 00000000 00000001 1 补码
)*/
/*
操作~（每一位按位取反）
00000000 00000000 00000000 00000010 int 2 补码
-----------------------------------
11111111 11111111 11111111 11111101 负数 补码
11111111 11111111 11111111 11111100 负数 反码
10000000 00000000 00000000 00000011 负数 原码-3*/
/**
一个整数和另外一个整数按位异或俩次，结果还是本身
*/
class WeiDemo2{
public static void main(String[] args) {
int a=5;
int b=6;
System.out.println(a^b^a);//6 a^a 0^b
System.out.println(b^a^b);//5 b^b 0^a
}
}>>(右移)：如果是正数，右移几位就要在最左边（高位）补上几个0；如果是负数，右移几位就要在最左边（高位）补上几个1.
<<（左移）：无论正负数，左移几位就要在最右边（低位）补上几个0
>>>(无符号右移)：无论正负数，右移几位就要在最左边（高位）补上几个0
class WeiDemo1{
public static void main(String[] args) {
int a=8;
int b=8;
int c=-8;
//操作>>
//8/2`2=2
//数据/2`移动位数
System.out.println(a>>2);//2
System.out.println(-9>>2);//-3
//操作<<
//8*2`2=2
//数据*2`移动位数
System.out.println(a<<2);//32
操作>>>结果一定是正数
System.out.println(b>>>2);//2
System.out.println(c>>>2);//1073741882
/*
00000000 00000000 00000000 00001000 int 8 补码
操作>>
[00]00000000 00000000 00000000 000010(00)
00000000 00000000 00000000 00000010 2 补码
*/
/*
10000000 00000000 00000000 00001001 int -9 补码
11111111 11111111 11111111 11110110 反码
11111111 11111111 11111111 11110111 补码
11111111 11111111 11111111 11111101 补码 >>2
11111111 11111111 11111111 11111100 反码
10000000 00000000 00000000 00000011 补码 -3
*/
/*
操作<<
(00)000000 00000000 00000000 00001000[00] int 8 补码
00000000 00000000 00000000 00100000 32 补码
*/
/*
操作>>>
[00]00000000 00000000 00000000 000010(00) int 8
00000000 00000000 00000000 00000010 2 补码
负数>>>
10000000 00000000 00000000 00001000 int -8
11111111 11111111 11111111 11110111 反码
11111111 11111111 11111111 11111000 补码
00111111 11111111 11111111 11111110 补码 >>>2
00111111 11111111 11111111 11111110 反码
00111111 11111111 11111111 11111110 原码 1073741822
无符号右移后为正数
*/
}
}三目（元）运算符
三目（元）运算符 (结果一定会返回一个值)
~a(一目)
a+b(二目)
格式:布尔表达式？表达式值1：表达式值2；
执行过程
先去计算出布尔表达式的值，如果是true表明执行表达式1返回值1，
如果是false执行表达式2返回值2。
class SanMuDemo{
public static void main(String[] args) {
//获取俩个整数的最大值
int a=4;
int b=5;
//俩个表达式值可以不一样。但是要保证两个类型的最大范围在接受值类型范围之内
int max=a>b?"a":b;
System.out.println(a>b?"a":b);//如果没有接受值俩个表达式的类型不受限制
//获取三个整数的最大值
int a=3,b=4,c=5;
/*
int d=a>b?a:b;
int max=c>d?c:d;
System.out.println(max);
//三目嵌套
System.out.println(a>b?(a>c?a:c):(b>c?b:c));
System.out.println();
*/
}
}运算符优先级（从高到低）
()、!、算术运算符、关系运算符、逻辑运算符、赋值运算符
() ~ ++ -- ! * / % + - << >> >>> 关系逻辑 &| ^ 三元赋值
234
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
