package cn.temptation;
public class Sample01 {
public static void main(String[] args) {
System.out.println("第一个例子");
}
}
package cn.temptation;
public class Sample02 {
public static void main(String[] args) {
// Java的基本数据类型
// 分为四大类，共八种数据类型
/* 占用字节数
* 1、整数类型
* byte： 字节类型 1 -128~127
* short： 短整型 2
* int： 整型 4
* long： 长整型 8
*
* 2、浮点数类型
* float： 单精度类型 4
* double： 双精度类型 8
*
* 3、字符类型
* char： 字符类型 2
*
* 4、布尔类型
* boolean： 布尔类型 1
*/
// 变量：在程序执行过程中发生变化的量
// 思考：为什么要使用变量？全部都使用常量行不行？
// System.out.println(123);
// System.out.println(123);
// System.out.println(123);
// 现在要进行修改，不要显示123了，要显示456，那么需要把前面使用常量123的地方全部改为常量456
// System.out.println(456);
// System.out.println(456);
// System.out.println(456);
// 注意：使用变量是一种思想：通过封装变化来达到拥抱变化的结果，即在变化时，只需要修改变量赋值的地方，不需要修改变量使用的地方
// int i = 123;
// 变化时，只要修改变量赋值的地方
// int i = 456;
// 把变量使用的地方 和 变量赋值的地方 分离开
// System.out.println(i);
// System.out.println(i);
// System.out.println(i);
// 定义变量的格式：
// 数据类型 变量名 = 初始化的值;
byte i = 3;
System.out.println(i);
short j = 4;
System.out.println(j);
int k = 123;
System.out.println(k);
// Java中书写整型数字，不加说明，默认认为是int类型
// The literal 12345678901 of type int is out of range
// long m = 12345678901;
// 要使用long类型，需要在数字后添加大写的L 或是 小写的l（因为小写的l和数字1容易混淆，所以使用大写的L）
long m = 12345678901L;
System.out.println(m);
// Java中书写浮点书数字，不加说明，默认认为是double类型
// Type mismatch: cannot convert from double to float
// float x = 123.456;
// 要使用float类型，需要在数字后添加大写的F 或是 小写的f（为了保持风格的一致，所以使用大写的F）
float x = 123.456F;
System.out.println(x);
double y = 987.654;
System.out.println(y);
// 字符类型使用单引号把字符包含其中
char z = 'a';
System.out.println(z);
// 布尔类型有两个特殊值：true 和 false
boolean flag1 = true;
boolean flag2 = false;
System.out.println(flag1);
System.out.println(flag2);
}
}
package cn.temptation;
public class Sample03 {
// int i = 123;
public static void main(String[] args) {
// 使用变量的注意事项：
/*
* 1、作用范围（作用域）：通过大括号来划定作用范围，变量不在该大括号内且没有其他的范围描述时，是无法使用的
* 2、在同一作用域下，变量不能重复命名
* 3、变量的初始化值：
* 变量没有初始化就直接使用会语法出错
* 要不在声明变量的时候就进行变量的初始化；要不就在使用的时候进行初始化
*/
// int i = 123;
// 在主函数之外定义int类型的变量i，在主函数中（大括号）中无法访问到
// Cannot make a static reference to the non-static field i
// System.out.println(i);
// int i = 3;
// System.out.println(i);
// Duplicate local variable i
// int i = 4;
// System.out.println(i);
// 只对变量进行声明但是不赋值
// int i;
// 对只声明但是不赋值的变量直接使用
// The local variable i may not have been initialized
// System.out.println(i);
// 先做声明
// int i;
// 在使用前进行赋值
// i = 5;
// 再使用变量，这样没有语法问题
// System.out.println(i);
// 声明变量时并对变量进行初始化赋值（初始化）
// int i = 2;
// 如下写法语法没有问题，但是不建议这样写（可读性差）
// int i = 2; int j = 3;
// System.out.println(i);
// System.out.println(j);
// 如下写法也可以，但是不推荐这样写
// int i = 2, j = 3;
// System.out.println(i);
// System.out.println(j);
// 在一行语句中对多个变量进行声明是可以的，并且多个变量之间使用英文的逗号分隔开
int i, j;
// 在一行语句中对于声明好的多个变量进行赋值，不能使用英文的逗号分隔开进行赋值，而只能使用英文的分号分隔开进行赋值
// Syntax error on token ",", ; expected
// i = 2, j = 3;
i = 2; j = 3;
// 上句等价于
i = 2;
j = 3;
System.out.println(i);
System.out.println(j);
}
}
package cn.temptation;
public class Sample04 {
public static void main(String[] args) {
// 两个int类型的变量做加法
// int i = 2;
// int j = 3;
// int result = i + j;
// System.out.println(result);
// byte类型的变量 和 int类型的变量做加法
// byte i = 2;
// int j = 3;
// int result = i + j;
// System.out.println(result);
// int类型的变量 和 int类型的变量做加法，得到的结果赋值给一个byte类型的变量
// int i = 2;
// int j = 3;
// Type mismatch: cannot convert from int to byte
// 赋值号右侧两个int类型的变量相加，得到的结果还是一个int类型的结果，把这个int类型的结果赋值给byte类型的变量，提示类型不匹配
// byte result = i + j;
// System.out.println(result);
// byte类型的变量 和 int类型的变量做加法，得到的结果赋值给一个byte类型的变量
// byte i = 2;
// int j = 3;
// Type mismatch: cannot convert from int to byte
// 赋值号右侧byte类型的变量 和 int类型的变量相加，得到的结果还是一个int类型的结果（类型提升），把这个int类型的结果赋值给byte类型的变量，提示类型不匹配
// byte result = i + j;
// System.out.println(result);
// 解决类型不匹配错误的方法：
/*
* 1、将结果的数据类型改为范围大的数据类型
* 2、使用强制类型转换，注意可能会发生精度丢失的问题
* 联想一下：小碗盛米，大锅里的米比较少的时候，倒入小碗中是没有问题的；大锅里的米比较多的时候，倒入小碗里就有问题了
*/
// 强制类型转换的格式：(要转换为的数据类型)(被转换的数据内容);
int i = 2;
int j = 3;
byte result = (byte)(i + j);
System.out.println(result);
}
}
package cn.temptation;
public class Sample05 {
public static void main(String[] args) {
// 字面量常量整数不加说明，默认是int类型
// byte i = 127;
// System.out.println(i);
// byte i = (byte)127;
// System.out.println(i);
// Type mismatch: cannot convert from int to byte
// byte j = 130;
// System.out.println(j);
byte j = (byte)130;
System.out.println(j); // -126
}
}
/*
* 原码、反码 和 补码
* 规则：
* 1、正数的原码、反码和补码都相同
* 2、负数的反码和原码符号位相同，其他位取反；负数的补码 = 负数的反码 + 1;
* 3、计算机在进行运算时，使用的是补码，最终显示出来的是原码
*
* int类型的正整数130的原码：0000 0000 0000 0000 0000 0000 1000 0010
* int类型的正整数130的反码：0000 0000 0000 0000 0000 0000 1000 0010
* int类型的正整数130的补码：0000 0000 0000 0000 0000 0000 1000 0010
*
* 强制类型转换做了截取
*
* byte类型的 补码：1000 0010 最高位是符号位
* byte类型的 反码：1000 0001
* byte类型的 原码：1111 1110 -126
*/
package cn.temptation;
public class Sample06 {
public static void main(String[] args) {
double i = 123.45;
System.out.println(i);
// 在单精度浮点数后添加F 和 对单精度浮点书进行强制类型转换为float类型，效果一致
// float j = 987.65F;
float j = (float) 987.65;
System.out.println(j);
}
}
package cn.temptation;
public class Sample07 {
public static void main(String[] args) {
// 定义两个byte类型的变量
// byte i = 2;
// byte j = 3;
// Type mismatch: cannot convert from int to byte
// 使用加号进行加法计算时，对于比int类型范围小的数据类型进行了类型提升
// byte result = i + j;
// byte result = (byte) (i + j);
// System.out.println(result);
// 第11行使用byte类型的变量相加提示语法错误，第16行使用int类型的字面量常量相加没有语法错误
byte result = 2 + 3;
// Type mismatch: cannot convert from int to byte
// byte result = 2 + 126;
System.out.println(result);
// 注意：
// 变量相加，先看变量的数据类型是否有问题
// 常量相加，先看结果是否在被赋值的变量的数据类型范围内
}
}
package cn.temptation;
public class Sample08 {
public static void main(String[] args) {
// char字符类型 和 整型存在转换的关系
System.out.println('a'); // a
char i = 'b';
System.out.println(i); // b
// 把字符'c' 和 int类型的数字1做加法，加出来的结果赋值给char类型的变量j
// 因为j的数据类型为char字符类型，所以输出的结果还是字符
char j = 'c' + 1;
System.out.println(j); // d
// 字符类型和int类型做加法，得到的结果是int类型
System.out.println('c' + 1); // 100
// 字符类型和int类型做加法，得到的结果是int类型
System.out.println('B' + 'e' + 'i' + 'J' + 'i' + 'n' + 'g' + 2008); // 2672
// 字符类型和字符类型做加法，得到的结果是int类型
System.out.println('B' + 'e' + 'i' + 'J' + 'i' + 'n' + 'g'); // 664
// 布尔类型不参与加法运算
// The operator + is undefined for the argument type(s) boolean, int
// System.out.println(true + 1);
// boolean flag = false;
// The operator + is undefined for the argument type(s) boolean, int
// System.out.println(flag + 1);
}
}