/*
变量
基本数据类型
基本数据类型之间的转换
基本数据类型与String之间的转换
进制与进制之间的转换
变量概念
1，内存中的储存区域
2，该区域的数据可以在同一类型范围内不断变化
3，变量是程序中最基本的储存单元，包含变量类型，变量名和储存的值
变量的作用
1，用于在内存中储存数据
使用变量的注意事项
1，java中的每个变量必须先声明再使用
2，使用变量名来访问这块区域的数据
3，变量的作用域：其定义所在的一对{}中
4，变量只有在其作用域内有效
5，同一个作用域内，不能定义重名的变量
变量的使用
1，java定义变量的格式：数据类型 变量名=变量值
2，变量必须先声明再使用；
变量都定义在其作用域内，在作用域内有效。在作用域外失效；
不可以在同一个作用域内声明两个名字相同的变量；
*/
class VariableTest{
public static void main(String[] args) {
int myAge = 22；//变量定义 int 为整数型
//或者拆分为两步 第一步声明 int myAge，第二步赋值 myAge = 12
System.out.println(myAge);//变量使用,变量在经过声明和赋值后才能被使用
System.out.println(myClass);//myClass变量在下方public中声明，无法作用到本作用域
}
}
public void method(){
int myClass = 1；//在这里定义一个变量名myClass，只能用在本作用域
System.out.println(myClass);
}
/*
java定义的数据类型
java属于强类型语言，对于每一种数据都定义了明确的具体类型，并在内存中分配不同大小的内存空间。
按照数据类型分
一，基本数据类型（primitive type）
1数值型（整数型 byte short int long，浮点型float double）内存空间有小到大
2字符型 char
3布尔型 boolean
二，引用数据类型（reference type）
1类 class 字符串属于类
2接口 interface
3数组 [] array
按照声明位置不同分类
在方法体内部声明的变量为局部变量
成员变量：1，实例变量（不以static修饰）
2，类变量（以static修饰）
局部变量：1，形参（方法，构造器中定义的变量）
2，方法局部变量（在方法内部定义）
3，代码块局部变量（在代码块内定义）
整形类型：byte short int long
java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性
java 的整形常量默认为int型，声明long型常量须后加“l”或者“L”
java程序中变量通常声明为ini型，除非不足以表示较大的数，才使用long
类型 储存空间 表数范围
byte 1字节=8bit -128到127 2的8次幂为256，分配正负两侧，中间一个0
short 2字节 -2的15次幂到2的15次幂-1
int 4字节 -2的31次幂到2的31次幂-1 约21亿
long 8字节 -2的63次幂到2的63次幂-1
1MB=1024KB 1KB=1024bit
浮点型：
与整数类型类似，java浮点类型也有固定的表数范围和字段长度
不受具体操作系统的影响
浮点类型有两种表达方式：
十进制数形式：例如 5.12 512.0f .512(必须有小数点)
科学计数法形式：例如 5.12e2 512E2 100E-2
float：单精度，位数可以精确到7位有效数字，很多情况下，精度很难满足要求
double：双精度，精度是float 的两倍，通常采用此类型
java 的浮点类型常量默认为double型，声明float型常量，须后加f或者F
单精度float 占用4字节 表数范围 -3.403E38到 3.403E38 E38为10的38次幂 范围比long大
双精度double 占用8字节 表述范围 -1.798E308到1.798E308
因为浮点类型可以使用科学计数法，所以范围比整数型大
字符型：char
char类变量占用一个字符=2字节空间
java中的所有字符都使用Unicode码，所以一个字符可以储存一个字母或者汉字或者其他语言的一个字符
字符类型的三种表现形式
1，字符常量是用单引号’’ 括起来的单个字符，如char c1 = ‘a’
char c2 = ‘中’ char c3 = ‘9’
2,java中还允许使用转义字符\来将其后的字符转变为特殊字符常量
如 char c4 = ‘\n’ \n表示换行符 \表示后面的不再解释为转义，如果输出\n，书写格式为\n
3，直接使用Unicode值来表示字符型常量：如 ‘\xxxx’,其中XXXX代表
一个十六进制整数，如\u000a 表示\n
char类型是可以参与计算的，因为它都对应一个Unicode码
ASCII码
计算机内部所有数据使用二进制表示，每一个二进制位（bit）有0和1两种装填
因此8个二进制可以组合出256种状态，被称为一个字节，一个字节可以
用来表示256种不同的状态，一个状态对应一个符号，就是256个符号
20世纪60年代，美国制定一套字符编码，被称为ASCII码，一共规定了128个字符码
比如空格是32，二进制为00100000，A为65 二进制01000001。这128个符号包括不能被打出的32个控制符号
只占用一个字节的后面7位，最前面的1位统一为0
缺点，不能表示所有字符，相同编码表示的字符不一致
世界上存在多种编码方式，同一个二进制数字可以被解释称不同符号，因此打开一个文档需要知道编码方式，否则会出现乱码
Unicode码
将世界上所有的符号纳入其中，每一个符号都给予一个独一无二的编码，使用Unicode没有乱码问题。
缺点，只规定了符号的二进制代码，没有规定这个二进制代码如何储存
，无法区别Unicode与ASCII，计算机无法区分三个字节表示一个符号还是3个符号
另外英文字母只用一个字节表示，如果每个符号用三个或者四个字节规定，就会极大浪费存储空间
UTF-8编码
使用最广泛的Unicode实现方式
是变长编码方式，可以使用1-6个字节表示一个符号，根据不同符号变化字节长度
编码规则
1，对单字节UTF-8编码，最高位0，其余7位用来对字符编码，等同ASCII
2，对多字节UTF-8编码，如果包含n个字节，那么第一个字节的前n位为1，第一个字节的第n+1位为0
，该字节剩余的各位用来对字符进行编码，在第一个字节之后的所有字节，都是最高两位为10，其余6位用来对字符编码
布尔类型（boolean）
只能取两个数值之一，true或者false
用于条件判断，循环结构。
*/
class VariableTest1{
public static void main(String[] args) {
byte b1 = -128;
byte b2 = 127;
System.out.println(b1);
System.out.println(b2);
int i1 = 223242535;
long l1 = 22323232214141L;//long类型变量赋值结尾加L或者l
System.out.println(l1+1);
double d1 = 123.34234;
System.out.println(d1);
float f1 = 133.3456782F;//float类型的变量赋值结尾加f或F
System.out.println(f1);
char c1 = 'a';//定义char类型变量只能写一个字符 可以是字母数字中文特殊符号等
char c3 = 97;//char 可以直接赋值ASCII码，很少这么写
char c4 = '5';//在此处5为字符，对应一个ASCII码
int i2 = (int)c4;//强转字符5为int型
char c5;
c5 = 'g';//赋值变量的书写方式也可以分步写。
System.out.println(i2);//输出53，代表字符5的ASCII码
System.out.println(c3);
System.out.println("hello"+c1);
char c2='\n';
System.out.print("hello" + c2);
System.out.println("world");
System.out.println("\\n");
System.out.println("你是\"最\"大的");//加\后表示后面的字符不做特殊用途
boolean bb1 = false;
System.out.println(bb1);
boolean isOld = true;
if(isOld){
System.out.println("不行");
}else{
System.out.println("可以");
}
}
}
/*
String类型（字符串）变量的应用
1，String属于引用类变量类型，不属于基本数据变量类型
2，声明String类型变量时使用"",相对char变量声明使用’’。
3，String类型的值可以为单字符，也可以为空。char型中不可以为空，但可以为空格
例如char c = ‘’;编译不通过 char c = ’ ';可以编译
4,String 可以和八种基本数据类型做运算，且运算只能是连接运算，使用+号
5,String 和其他类型运算结果也是String类型。
*/
class StringTest {
public static void main(String[] args) {
System.out.println("Hello World!");
String s1 = "Hello大家好";
String s2 = "H";
String s3 = "";
System.out.println(s1);
//*************************
int number = 100;
String numberStr = "学号";
String info =numberStr + number;//加号+表示连接运算
boolean b1 =true;
String info1 = info + b1;//加号+表示连接运算
System.out.println(info1);
System.out.println(info);
// 练习1
char c = 'a';//ASCII中 a 的值是97，A的值是65
int num = 10;
String str = "hello";
System.out.println(c + num + str);//输出 107hello ，第一个加号是相加，char和int相加输出int型，第二个加号是连接，int与String连接输出String
System.out.println(c + str + num);//输出 ahello10
System.out.println(c + (num + str));//输出a10hello 括号内先运算
System.out.println((c + num) + str);//输出107hello
System.out.println(str + num + c);//输出 hello10a
System.out.println(str + 111);//输出 hello111
System.out.println(str + "world");//输出 helloworld
//System.out.println(str + world);//无法编译，world必须加""才能被认为是String类
//练习2
//输出* *的方法
System.out.println("* *");//正确
System.out.println('*' + '\t' + '*');//错误，输出char类型数值93
System.out.println('*' + "\t" +'*');//正确
System.out.println('*' + '\t' + "*");//错误 输出51*
System.out.println('*' + ('\t' + "*"));//正确
/*练习3
String str1 = 4; 无法编译，没有""
String str2 = 3.56f + "" ; 可以编译
System.out.println(str2);输出3.56
System.out.println(3 + 4 + "hello");输出7hello
System.out.println("hello" + 3 + 4);输出hello34
System.out.println('a' + 1 + "hello");输出98hello
System.out.println("hello" + 'a' + 1);输出helloa1
练习4
判断对错
1 short s = 5;
s = s - 2; 无法编译，2是int型常量
2 byte b = 3;
b = b + 4; 无法编译
b = (byte)(b + 4);可以编译，强制转换int为byte
3 char c = 'a';
int i = 5;
float d = .314f;
doule result = c + i + d;可以编译
4 byte b = 5;
short s = 3;
short t = s + b;无法编译，byte与short运算应为int型
*/
//String str1 = 123; 编译不通过
String str1 = 123 + "";//编译可以通过，整数常量int型与String运算输出String类。
System.out.println(str1);//输出123字符串,将数值转换为字符串可以用这种方式。
//int num2 = str1; 编译不通过
//int num2 = (int)str1;编译也不通过
int num2 = Integer.parseInt(str1);
System.out.println(num2);//通过Integer方法可以将String解析为int。
}
}
/*
基本数据类型之间的运算规则
只讨论7种基本数据类型变量之间的运算，不包含boolean类型
1，自动类型提升
当容量小的数据类型变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型
此时的容量大小指的是表示数的范围大小，不是占用字节的大小，比如float（4个字节） 的容量大于long（8个字节）的容量
byte–>short–>int–>long–>float–>double
byte，char，short–>int–>long–>float–>double
byte，char，short三个互相做运算时输出都是int或更大的类型
2，强制类型转换
是自动类型提升运算的逆运算
1, 需要使用强转符号（）例如long l1 = 112.9L;short s1 = （short）l1; 输出为112，只取整数部分。
2，使用强制类型转换，可能会出现精度损失。
注意
1，编码情况
long 1 = 122;也可以编译通过，会默认为int类型
long l2 = 12345673333;编译不通过，超出int范围，需要末尾加L，
float f1 = 12.3;编译失败，必须加F，因为默认为double类型。
2，编码情况2
byte b = 12;
byte b1 = b + 1;编译失败，数字1为整数型常量，默认为int型，小数型默认为double
*/
class VariableTest2{
public static void main(String[] args) {
byte b1 = 2;
int i1 = 1278;
//byte b2 = b1 + i1
//编译不通过,因为int范围大
int i2 = b1 + i1;
long l1 = b1 +i1;
System.out.println(i2);
System.out.println(l1);
float f1 = b1 + i1; //整数型数值运算结果可以定义为浮点型，系统输出自动加小数点
System.out.println(f1);
short s1 = 123;
double d1 = s1;//可以将整数型直接转换为浮点型，后面自动加小数点
System.out.println(d1);
char c1 = 'a';// a 对应的数值为97
int i3 = 10;
int i4 = c1 + i3;//char只能容纳一个字符，所以i4不能为char类型
System.out.println(i4);
}
}
class VariableTest3{
public static void main(String[] args) {
long l1=123L;//数值没有超出long范围可以不加L，也能编译，会自动转换为int类型
short s1 = (short)l1;//数值没有超出short范围，强制转换后精度没有损失。
System.out.println(s1);
double d1 = 12.9;
int i1 = (int)d1;//执行截断操作，结果只取整数部分，不是四舍五入
System.out.println(i1);//输出12，损失小数点，精度损失
int i2 = 128;
byte b1 = (byte)i2;
System.out.println(b1);//输出-128跟二进制规则有关，损失精度。
long l2=128456744453453L;
int i3 = (int)l2;
System.out.println(i3);
short s2 = (short)l2;
System.out.println(s2);
byte b2 = (byte)l2;
System.out.println(b2);
}
}
