day_03

1. 数据类型
   1.1 本质
   就是规定占用内存空间的大小,用位和字节表示
   1.2 分类
   数据类型 :
   基本数据类型
   数值型
   整数型
   Byte
   Short
   Int
   long
   浮点型
   Float
   double
   字符型
   Char
   布尔型
   Boolean
   引用数据类型
   类
   数组
   接口

1.3 进制
Java中没有办法直接表示二进制

	// 十进制表示法
	int i_1 = 10;
	// 八进制表示法
	int i_2 = 012;
	// 八进制 每位最多到7
	// int i_3 = 019;

	// 十六进制表示法
	int i_4 = 0x1f;

	// 双引号 是字符串,里面的数据不会被解释,所以 i_4 是找不到内存中的0x1f的
	System.out.println("i_4");
	System.out.println(i_4);
	// 以十六进制展示
	System.out.println(Integer.toHexString(i_4));

1.4 类型使用
1.4.1 整数型
short s_1 = 123;
byte b_1 = 123;
int i_5 = 2147483647;

	// java中整数默认为 int(整型)
	// 所以 以下这个代码,是进行了自动类型转换,把int值复制给long类型
	long l_1 = 2147483647;
	// 超过int上限 报错
	// long l_2 = 2147483648 ;
	
	// 如何声明long的值, 加 L/l  建议 L ,因为避免 l和1不容易区分
	long l_3 = 1232167864124L;
	
	// 最大值 : 9223372036854775807
	System.out.println(Long.MAX_VALUE);

1.4.2 浮点型

double d_1 = 1.2;
// 因为默认是double,所以 float声明必须要加F/f才可以
float f_1 = 1.2f;

	// 强制类型转换为float
	float f_2 = (float) 1.34;
	System.out.println(f_2);

1.4.3 字符型

• char 字符型 用 英文单引号表示 ‘’ 并且 只能有一个字符
• char = 2 byte = 16 bit
• 字符 --> 整数 --> 二进制
• 最初的ASCII编码

•  'a'  97
  

•  'b'  98
  

•  'A' 65
  

•  'B' 66
  

•  '0' 48
  

•  '1' 49
  

采用unicode编码

	char c_1 = 'a';
	char c_2 = '2';
	char c_3 = '张';
	char c_4 = ' ';
	System.out.println((int)c_1);
	System.out.println((int)c_3);
	
	// 测
	char c_5 = '\u6D4B';
	System.out.println(c_5);

• 转移符

•  把有意义字符转换为无意义字符
  

• 比如 char用 ‘’ 单引号表示 并且 只能出现一个字符 ,如果我想输入 ’ 单引号 怎么办? 转义

•  java 中 \ 表示转移符 	
  

•  \t : 制表符
  

•  \\ : 转义转移符
  

•  \r\n : 换行符
  
  
   char c_1 = '\'';
   char c_2 = '\\';
   char c_3 = '\t';
   System.out.println(c_1);
   System.out.println(c_2);
   System.out.println('\n');
   System.out.println(c_3);
  

1.4.4 布尔型

• boolean 不是 bool

• 1 只有两个值 : true/false,没有 1和0

• 2 默认值为false

• 3 不参与任何类型转换

• 4 占用1字节,全是0表示false, 0000001表示true

• 一般用于流程控制或者逻辑判断

   boolean b_1 = false;
   boolean b_2 = true;
   // 不能转换
   // boolean b_3 = (boolean)1;
   
   if (b_2) {
   	System.out.println("为真");
   }else{
   	System.out.println("为假");
   }
  

1.5 类型转换

• 类型转换
• 1 8种基本数据类型,除了boolean以外,都可以进行转换
• 2 低精度向高精度 是自动转换
• 3 高精度向低精度 是强制转换
• 自动类型转换
• byte --> short --> int --> long --> float --> double

•  			char -->
  

• 其他就需要强制转换

•  强制转换有可能损失精度,造成数据不准确
  
  
   byte b1 = 1;
   short s1 = b1;
   int i1 = s1;
   // char c1 = s1;
   char c1 = '1';
   i1 = c1;
   // s1 = c1;
   long l1 = c1;
   float f1 = l1;
   // l1 = f1;
   
   byte b2 = (byte) 131;
   System.out.println(b2);
   
   int i2 = 10;
   byte b3 = (byte) i2;
   System.out.println(i2);
   
   // 混合运算
  

1.6 混合运算

	// 混合运算
	// 当一个运算中出现多个类型的值的时候,结果一定是最大类型
	
	int i_1 = 10;
	long l_1 = 10;
	long b_1 = i_1+l_1;
	// byte  , short , char , int 四种中任意一种或多种进行运算,结果都是int类型
	int b_2 = b3+s1;

1.7 小结
Float,char,boolean三个的使用
自动转换和强制转换
转移符
混合运算

2. 变量

2.1 常量
常量 : 整个程序生命周期中,值不能更改

字面量/直接量:也是有数据类型的, 整数默认int,小数默认double
Final

	// final 修饰的  不可更改
	final int i1 = 1;
	// i1 = 2;
	System.out.println(1);

2.2 变量
可以更改的量,可以再程序执行中对值进行更改
可以复用

2.2.1 全局变量
什么是全局变量的概念 : 允许在类之外创建变量,和类同级别,那么所有的类都可以直接访问该变量,不需要二次引用
所谓二次引用,就是没有使用 . 操作符 xxx.xxxxx
首先 java不允许在类之外创建变量,但是可以将一个类的变量设置为public static修饰的,那么其他类就可以通过 该类的类名.变量名 来进行访问
全局变量的确定 : 安全性较差,容易命名冲突

所以 java引入了包概念,引用一个变量的时候必须通过该包和类才能访问
2.2.2 变量定义/声明

• 变量声明 :

•  数据类型  变量名 ;
  

• 变量定义 :

•  数据类型 变量名 =  赋值	
  

•  数据类型划分内存空间  给空间命名  赋值(把数据保存到空间中)
  

• 域 :

•  空间范围,内存空间的划分
  

•  一个 {} 大括号 就是一个作用域,变量不能超过向上碰到的第一个大括号,但是向下可以穿透域中嵌套的所以子大括号
  

Int i = 10;

int a=3,b=2,c=10;
2.2.3 变量分类

• 变量分类 :

•  局部变量 : 方法内部声明的变量是局部变量
  

•  静态变量 : 类体中使用static修饰的变量是静态变量
  

•  成员变量 : 类体中没有使用static修饰的变量是成员变量
  

2.2.4 变量调用

•  局部变量 : 当前方法中,声明之后,直接写变量名调用即可
  

•  静态变量 : 类名.静态变量名/当前类中调用当前类的静态变量时,类名可以省略,编译之后,JVM会自动补齐为类名调用
  

•  成员变量 : 对象引用.成员变量名
  
   System.out.println(x1);
   System.out.println(_02_Var.x1);
   _02_Var aa = new _02_Var();
   System.out.println(aa.x);
  

2.2.5 默认值

• 局部变量没有默认值,必须先初始化赋值之后 才能使用
• 静态变量和成员变量 有默认值

•  	整型 : 0  , 浮点型 : 0.0 , 布尔型 : false , 字符型 : \u0000 , 引用类型 : null
  

2.2.6 变量优先级
变量可以重名吗?
静态变量和成员变量 不能同名
但是局部变量和 静态变量/成员变量 是可以同名的
也就是说 有一个局部变量 i 那么 还可以再创建一个 静态变量/成员变量 i

如果静态变量和局部变量重名,那么优先使用局部变量
如果就想使用静态变量的话,可以使用类名来区分

static int age = 18;
public static void main(String[] args) {
	int age = 22;
	System.out.println(_04_Var.age);
}

3. 操作符
   3.1 算数运算符

• 运算操作符 +,-,*,/,% ++,–

• 运算符优先级 单目/单元运算符优先级最高 > 双目 > 三目

• i++ 和 ++i 的区别

   int a = 10;
   int b = 3;
   System.out.println(a + b);
   System.out.println(a - b);
   System.out.println(a * b);
   System.out.println(a / b);
   System.out.println(a % b);
  
   double d1 = 0.1;
   double d2 = 0.2;
   // 0.30000000000000004
   // 注意 不要使用小数做比较
   System.out.println(d1 + d2);
  
   System.out.println("----------------------");
   // ++ : 把值取出,+1,再放回去
   int k = 100;
   // 只要是单独出现,不管k在前还是k在后,都一样,原数+1即可
   // k++;
   // ++k;
   
   // 201 如果是 k++ ,就会申请一块临时空间,把k中的值先保存到临时空间中,然后k++的这个k 就指向临时空间中的值
   // 然后计算++ , 计算完++ 后,继续后续操作 100+k
   // 如果是 ++k 那么 k 就不需要指向临时空间了
   
   // k++ : k使用的是++之前的值
   // ++k : k使用的是++之后的值
   // 但是 ++ 优先级 大于 双目和三目
   k = k++ +k;
   System.out.println(k);
   
   int w = 10;
   w = w++ * w;
   System.out.println(w);
   
   int m = 10;
   int e = 2+m++;
   System.out.println(e);
   System.out.println(m);
   
   int p= 2;
   p = 2 + p++ + ++p + p++ + ++p;
  

// p = 2 + 2 + ++p + p++ + ++p; p=3
// p = 2 + 2 + 4 + 4 + 6; p=6
System.out.println§;

	int x = 10;
	x = 10 + x++ + ++x +(10 * x++) + ++x;

// x = 10 + 10 + 12 +120 + 14; x=14
System.out.println(x);

	int i = 10;
	i= i++ + (i +1);
	System.out.println(i);

3.2 关系运算符

• 关系运算符

•  运算结果 是 boolean型  (true/false),可以叫布尔型表达式
  

• = < <=

• == : = 是赋值操作,java中 判断相等 使用 ==

•  	如果是基本类型,比较值的大小
  

•  	如果是引用类型,比较内存地址
  

• != : 不等于
• 常用于流程控制

3.3 位运算符

• 位运算

•  &  位与  , 两边都是true 结果才是true,也可以两边是数字
  

•  |  位或 一边为true 结果就为true
  

•  ! 位非,取反   !true 就是false   , !false 就是true
  

•  ^ 异或  ,两边不一样就是true
  

•  ~ 按位非,转换为二进制,然后 每位取反
  

• 逻辑 比较

•  && : 短路与,切 , 如果 第一个就为假,第二个表达式就不执行了,结果为假
  

•  || : 短路或,或,如果第一个为真,第二个就不执行了
  

• : 右移运算符(考虑符号位,符号位不移动,正数就是正数,负数就是负数)

•  	8 >> 2
  

•  		0000000 10  转换为二进制,然后符号位之后补两个0,最右边删除两位
  

•  	右移  8 >> n  就等于 8 / 2^n
  

•  	如果是 -8 >>2  就是补1  
  

• << : 左移运算符(不考虑符号位),向最左边补0

• : 右移运算符(不考虑符号位)

•  	如果是正数  和>> 没有区别,因为最前面都是0
  

•  	但是负数就不一样了, >> 只会在符号位之后补1 , 而 >>> 在符号位之前 补0
  

•  	所以 -1 >>> 1 就成了  2147483647