当需要在程序中记录单个数据内容时，则声明一个变量即可，而声明变量的本质就是在内存中申请一个存储单元，由于该存储单元中的是数据内容可以发生改变，因此得名为“变量”。
由于存放的数据内容大小不一样，导致所需存储单元的大小不一样，在Java语言中使用数据类型加以描述，为了便于下一次访问还需要给该变量指定一个名字，用于记录该变量对应的存储单元。
1.2变量的声明方式 数据类型 变量名 = 初始值;其中 = 初始值可以省略，但“;”不可以省略
public class VarTest {
public static void main(String[] args){
// 1.声明一个变量并初始化 数据类型 变量名 = 初始值;(也可以写成 数据类型 变量名; 不写初始值，但是为了防止出现问题，尽量加上初始值)
int age = 20;
// 2.打印变量的数值 "+"字符串连接符 用于将两边的内容连接/拼接起来结果还是字符串
System.out.println("age =" + age); // age = 18
System.out.println("---------------------------------------");
// 3.使用变量的注意事项
// 3.1 使用变量之前需要声明
// Sysem.out.println("name =" + name); //错误：找不到符号
// 3.2使用变量之前需要初始化
// String name;
// System.out.pritnln("name =" + name); //错误：可能尚未初始化变量name
String name = "SunForm";
System.out.println("name =" + name); // name = SunFrom
// 3.3变量不能重复声明
//int age = 17; // 错误：已在方法中定义声明了变量age
}
}
2.标识符的命名法则（笔试）
1、由数字、字母、下划线以及$等组成，其中数字不能开头。(结合下面代码3.1.7)
2、不能使用Java语言的关键字，所谓关键字就是Java语言 用于表示特殊含义的单词。
3、区分大小写，长度没有限制但不宜过长。
4、尽量做到见名知意，支持中文但不推荐使用。
5、标识符可以给 类/变量/属性/方法/包 起名字。
案例题目 *提示用户从键盘输入自己的姓名和年龄信息并打印出来拿到题目之后先读题干，滤清思路，规划好做题步骤，最后再写代码。
不要一拿到题目就盲目去做，否则就会造成事倍功半的结果！
分析：
1、声明两个变量名：姓名、年龄；
2、提示用户从键盘输入姓名和年龄信息并放到已声明的两个变量中；
3、将变量的数值打印出来。
初稿：
//导入java目录中util目录的Scanner类
import java.util.Scanner;
public class VarIOTest {
public static void main(String[] args){
// 1.声明两个变量名用于记录姓名和年龄信息
String name;
int age;
// 2.提示用户从键盘输入姓名和年龄信息并放入到变量中
System.out.println("请输入您的姓名和年龄信息：");
// 创建一个扫描器来扫描键盘输入的内容 System.in代表键盘输入
Scanner sc = new Scanner(System.in);
//通过扫描器读取一个字符串数据放入变量name中
name = sc.next();
//通过扫描器读取一个整数数据放入变量age中
age = sc.nextInt();
// 3.打印变量的数值
System.out.println("name =" + name);
System.out.println("age =" + age);
}
}
优化版：
//导入java目录中util目录的Scanner类
import java.util.Scanner;
public class VarIOTest01 {
public static void main(String[] args){
// 1.声明两个变量名用于记录姓名和年龄信息
//String name;
//int age; //先声明、相当于占了两个空柜子而不用（代码本身不为错）
// 2.提示用户从键盘输入姓名和年龄信息并放入到变量中 变量随时使用随时声明
System.out.println("请输入您的姓名和年龄信息：");
// 创建一个扫描器来扫描键盘输入的内容 System.in代表键盘输入
Scanner sc = new Scanner(System.in);
//通过扫描器读取一个字符串数据放入变量name中
String name = sc.next();
//通过扫描器读取一个整数数据放入变量age中
int age = sc.nextInt();
// 3.打印变量的数值 尽可能减少重复的代码
//System.out.println("name =" + name);
//System.out.println("age =" + age);
System.out.println("name =" + name + ",age =" + age);
}
}
官方库的使用
1、JDK中带有大量的API类，是有Java系统带来的工具库，这些工具数以万计！是Java官方程序员的技术积累。
2、使用这些类可以大大简化编程，提高开发效率。
3、具体的API类功能，可以参阅Java的参考手册
2.1常用的进制1、在日常生活中采用十进制数据的描述，逢十进一，十进制权重是：10^0、10^1、10^2、…
2、在计算机的底层采用0和1组成的二进制序列进行数据的描述，逢二进一，二进制的权重是：2^0、2^1、2^2…
3、二进制中的最高位（最左边）用于代表号位，若该位是0则表示非负数，若该为是1则表示负数。
4、八进制和十六进制其实都是二进制的简写。
2.2进制之间的转换 2.2.1.正十进制转换为二进制的方式a.除二取余法，使用十进制整数不断地除以2去除余数，直到商为0时将余数逆序排序。
以十进制整数25为例，将其转化为二进制方法如下：
b.拆分法，将十进制整数拆分为若干个二进制权重的和，有该权重下面写1，否则写0。
以十进制整数25为例：
2.2.2正二进制转换为十进制的方式a.加权法，使用二进制中的每个数字乘以当前位置的权重在累加起来。
2.2.3.负十进制转换为二进制的方式a.现将十进制的绝对值转换为二进制，然后进行按位取反再加1。
以十进制-25为例：
2.2.4负二进制转换为十进制的方式a.先减1再按位取反，合并为十进制整数后添加符号。
2.3单个字节表示的整数范围（重中之重）在计算机中单个字节表示八位二进制位，其中最高位（最左边）代表符号位，使用0代表非负数，使用1代表负数，具体表示的整数范围如下：
3.整数类型3.1.
*Java语言中描述整数数据的类型有：byte、short、int、long,如果没有特殊要求推荐使用int类型
*其中byte类型在内存空间中占1个字节，表示范围是：-2^7 ~ 2^7-1
（非特殊要求使用此类型，可能内存空间范围不够）
*其中short类型在内存空间中占2个字节，表示范围是：-2^15 ~ 2^15-1
（非特殊要求使用此类型，可能内存空间范围不够）
*其中int类型在内存空间中占4个字节，表示范围是：-2^31 ~ 2^31-1
（非特殊要求推荐此类型，日常使用内存空间足够）
*其中long类型在内存空间中占8个字节，表示范围是：-2^63 ~ 2^63-1
（非特殊要求不推荐此类型，是因为此类型空间太大，容易造成损耗空间或者空间浪费）
整数类型的编程
动手尝试，丰衣足食
3.1.1
DOS命令结果：
3.1.2
DOS命令结果：
小结：250这样直接写出的整数数据叫做直接量/常量/字面值 默认为int类型
3.1.3
DOS命令结果：
3.1.4
DOS命令结果：
3.1.5
public class IntTest {
public static void main(String[] args){
// 1.声明一个byte类型的变量并初始化
byte b1 = 25;
//byte b1 = 250;//错误: 不兼容的类型: 从int转换到byte可能会有损失 250这样直接写出的整数数据叫做直接量/常量/字面值 默认为int类型
// 2.打印变量的数值
System.out.println("b1 = " + b1); //b1 = 25
System.out.println("-----------------------------------------");
// 3.声明一个short类型变量并初始化
short s1 = 250;
//short s1 = 250250; // 错误: 不兼容的类型: 从int转换到short可能会有损失
System.out.println("s1 = " + s1); //s1 = 250
System.out.println("-----------------------------------------");
// 4.声明一个int类型变量并初始化
int i1 = 250250;
System.out.println("i1 = " + i1); //i1 = 250250
}
}
DOS命令结果：
总结：若非特殊要求推荐使用int类型
3.1.6
public class IntTest {
public static void main(String[] args){
// 1.声明一个byte类型的变量并初始化
byte b1 = 25;
//byte b1 = 250;//错误: 不兼容的类型: 从int转换到byte可能会有损失 250这样直接写出的整数数据叫做直接量/常量/字面值 默认为int类型
// 2.打印变量的数值
System.out.println("b1 = " + b1); //b1 = 25
System.out.println("-----------------------------------------");
// 3.声明一个short类型变量并初始化
short s1 = 250;
//short s1 = 250250; // 错误: 不兼容的类型: 从int转换到short可能会有损失
System.out.println("s1 = " + s1); //s1 = 250
System.out.println("-----------------------------------------");
// 4.声明一个int类型变量并初始化
//int i1 = 250250;
int i1 = 2502501234;
System.out.println("i1 = " + i1); //i1 = 250250
}
}
DOS命令结果：
*在Java程序中直接写出的整数数据叫做直接量/字面值/常量，默认为int类型。
若希望表达更大的直接量，则在直接量的后面加上 l 或者 L，推荐L,因为 l和1比较像。
3.1.7
public class IntTest {
public static void main(String[] args){
// 1.声明一个byte类型的变量并初始化
byte b1 = 25;
//byte b1 = 250;//错误: 不兼容的类型: 从int转换到byte可能会有损失 250这样直接写出的整数数据叫做直接量/常量/字面值 默认为int类型
// 2.打印变量的数值
System.out.println("b1 = " + b1); //b1 = 25
System.out.println("-----------------------------------------");
// 3.声明一个short类型变量并初始化
short s1 = 250;
//short s1 = 250250; // 错误: 不兼容的类型: 从int转换到short可能会有损失
System.out.println("s1 = " + s1); //s1 = 250
System.out.println("-----------------------------------------");
// 4.声明一个int类型变量并初始化,若描述比long类型还大的数据则使用java.math.BigInteger类型
int i1 = 250250;
//int i1 = 2502501234L; // 错误: 整数太大 默认为int类型，这个数据自身已经出错
System.out.println("i1 = " + i1); //i1 = 250250
System.out.println("-----------------------------------------");
// 5.声明一个long类型变量并初始化,若描述比long类型还大的数据则使用java.math.BigInteger类
long g1 = 2502501234L;
System.out.println("g1 = " + g1); // g1 = 2502501234L
}
}
DOS命令结果：
结合上面 2.标识符命名法则 1. 中的标识符不能用数字开头命名，原因是如果标识符命名为如3.1.7代码段中的2502501234L，编译器就会分不清2502501234L是标识符还是直接量。可能有小伙伴想在把L换成M就可以了可是这样就会标识符的命名变得和随意，如果程序员技术不是太好，就会造成不易读解的后果。与其，让新手，生手犯错不如Java就直接规定标识符命名不能以数字开头，因此，Java具有安全性
笔试题目01
public class IntTest {
public static void main(String[] args){
// 笔试题目：请问下面的代码是否有错？ 若有请说明原因
int i2 = 25;
byte b2 = i2;
System.out.println("b2 = " + b2);
}
}
DOS命令结果：
答：错误: 不兼容的类型: 从int转换到byte可能会有损失
4.浮点类型4.1. Java语言中用于描述小数数据的类型：float 和 double ，推荐double类型。
4.2. 其中float类型在内存空间占4个字节，叫做单精度浮点数，可以表示7位有效数字，范围：-3.403E38 ~ 3.403E38。（E38表示10^38）
4.3. 其中double类型在内存空间占8个字节，叫做双精度浮点数，可以表示15位有效数字，范围：-1.798E308 ~ 1.798E308 。（E308表示10^308）
4.4. Java程序中小数数据叫做直接量，默认为double类型，若希望表达float类型的直接量，则需要在直接量后面加上 f或者F。
4.5.float类型的使用，初稿：
public class DoubleTest {
public static void main(String[] args) {
// 1.声明一个float类型的变量并初始化
float f1 = 3.1415926;
// 2.打印变量的数值
System.out.println(" f1 = " + f1 );
}
}
DOS命令的结果：
错误: 不兼容的类型: 从double转换到float可能会有损失。
更改后：
public class DoubleTest {
public static void main(String[] args) {
// 1.声明一个float类型的变量并初始化
float f1 = 3.1415926F; // 错误: 不兼容的类型: 从double转换到float可能会有损失 ,小数数据叫做直接量。
// 2.打印变量的数值
System.out.println(" f1 = " + f1 ); // f1 = 3.1415925 一般是7位有效数字
}
}
DOS命令的结果：
4.6.double类型的使用
public class DoubleTest {
public static void main(String[] args) {
// 1.声明一个float类型的变量并初始化
float f1 = 3.1415926F; // 错误: 不兼容的类型: 从double转换到float可能会有损失 ,小数数据叫做直接量。
// 2.打印变量的数值
System.out.println(" f1 = " + f1 ); // f1 = 3.1415925 一般是7位有效数字
System.out.println("----------------------------------");
// 3.声明一个double类型的变量并初始化
double d1 = 3.1415926;
System.out.println(" d1 = " + d1 );
}
}
DOS命令的结果：
5.布尔类型：
5.1. Java语言中用于描述真假信息类型有：boolean, 数值只有true和false。
5.2. 布尔类型在内存空间中所占大小没有明确规定，可以认为是1个字节。
5.3
public class BooleanTest {
public static void main(String[] args){
// 1.声明一个boolean类型的变量并初始化
boolean b1 = true;
// 2.打印变量的数值
System.out.println(" b1 = " + b1 );
}
}
DOS命令的结果：
5.4
public class BooleanTest {
public static void main(String[] args){
// 1.声明一个boolean类型的变量并初始化
boolean b1 = true;
// 2.打印变量的数值
System.out.println(" b1 = " + b1 ); // b1 = true
System.out.println("----------------------------------");
// 3.修改变量b1的数值 = 赋值运算符，用于将 = 右边的数据赋值给左边的变量， 覆盖变量中原来的数值
b1 = false;
System.out.println(" b1 = " + b1 ); // b2 = false
}
}
DOS命令的结果：
5.5
public class BooleanTest {
public static void main(String[] args){
// 1.声明一个boolean类型的变量并初始化
boolean b1 = true;
// 2.打印变量的数值
System.out.println(" b1 = " + b1 ); // b1 = true
System.out.println("----------------------------------");
// 3.修改变量b1的数值 = 赋值运算符，用于将 = 右边的数据赋值给左边的变量， 覆盖变量中原来的数值
b1 = false;
System.out.println(" b1 = " + b1 ); // b2 = false
System.out.println("----------------------------------");
b1 = 1; // 错误: 不兼容的类型: int无法转换为boolean
System.out.println(" b1 = " + b1 );
}
}
DOS命令的结果：
6.字符类型
6.1. java语言中描述单个字符的数据类型：char类型。如：'a'、'中'等级。
6.2. 其中char类型在内存空间中占2个字节并且，没有符号位，表示的范围是：
0 ~ 65535 ，由于现实生活中很少有数据能够内单个字符描述，因此以后的开发中更多的使用有多单个字符串起来组成的字符串，使用String类型加以描述，如：“hello”、“SunFrom”等。
6.3. 计算机的底层只识别0和1组成的而进制序列，对于字符串'a'这样的图案来说不满足该规则，因此该数据无法直接在计算机中存储，但现实生活中在这样的图案数据需要计算机存储，为了使得该数据能够存储起来就可以给该数据指定一个编号，然后将编号存储起来即可，该编号就叫做ASCII。
6.4
public class CharTest {
public static void main(String[] args){
// 1.声明一个char类型的变量并初始化
char c1 = 'a';
// 2.打印变量的数值
System.out.println(" c1 = " + c1); // c1 = a
}
}
DOS命令的结果：
6.5
public class CharTest {
public static void main(String[] args){
// 1.声明一个char类型的变量并初始化
char c1 = 'a';
// 2.打印变量的数值
System.out.println(" c1 = " + c1); // c1 = a
System.out.println("对应的编号是：" + (int)c1); // 表示将char类型的c1强制转换为int类型并打印
System.out.println("------------------------------------------------------------------------");
// 3.声明一个char类型的变量并初始化
char c2 = 98;
// 4.打印变量的数值
System.out.println(" c2 = " + c2 );
System.out.println(" c2 = " + (int)c2 );
}
}
DOS命令的结果：
ASCII对照表
6.6. 需要掌握的ASCII有：'0' - 48 、'A' - 65 、'a' - 97 、空格 - 32 、 换行 - 10 .
6.7.Java字符类型采用Unicode字符集编码。Unicode是世界通用的定长字符集，所有的字符都是16位。
*
编程实现字符类型的使用
*/
public class CharTest {
public static void main(String[] args){
// 5.使用Unicode字符集来表示一下我的名字 阿离 对应的编号是： u963fu79bb
char c3 = 'u963f';
char c4 = 'u79bb';
System.out.println("我的名字是： " + c3 + c4);
}
}
DOS命令的结果：
ASCII字符集仅供美国使用，Unicode字符集可供全球使用。
……
6.8.特殊字符的使用
DOS命令的结果：
7. 基本数据类型之间的转换7.1.其中自动类型转换主要指从小类型到大类型之间的转换。
7.2.其中强制类型转换主要指从大类型到小类型之间的转换，语法格式如下:
目标类型 变量名 = （目标类型）原类型变量名；
public class TransfromTest {
public static void main(String[] args){
// 1.声明两个变量并初始化
byte b1 = 18;
short s1 = 30;
// 2.打印变量的数值
System.out.println("b1 = " + b1);
System.out.println("s1 = " + s1);
System.out.println("-------------------------------------------------------------------");
// 3.实现自动类型之间的转化
// 表示将变量b1的数值赋值给s1，并将覆盖变量s1中原来的数值，相当于从byte类型到short类型的转换，从小到大，自动转换
s1 = b1;
System.out.println("b1 = " + b1);
System.out.println("byte类型转化成short类型后的结果是："); // 从byte到short，从小到大，自动转换
System.out.println("s1 = " + s1);
System.out.println("-------------------------------------------------------------------");
// 4.实现强制类型之间的转化
// 表示将变量s1的数值赋值给b1，并将覆盖变量b1中原来的数值，相当于从short类型到byte类型的转换，从大到小，强制转换
b1 = (byte)s1;
System.out.println("b1 = " + b1);
System.out.println("short类型转化成byte类型后的结果是："); // 从short到byte，从大到小，强制转换
System.out.println("s1 = " + s1);
s1 = 128; // 有意加改行代码 128 => 0000 0000 1000 0000 => 0111 1111 => 1000 0000 => 128 => -128
b1 = (byte)s1;
System.out.println("b1 = " + b1); // b1 = -128
System.out.println("s1 = " + s1); // s1 = 128
}
}
DOS命令的结果：
强转有风险，操作需谨慎！
总结：
