人生不如意之事十有八九，在最好的年纪要努力充实自己，莫等空悲切白了少年头，而是要及时当勉励，岁月不待人。
1.内存中存储的一个存储区域。
2.该存储区域内的数据在同一类型范围内不断变化。
3.变量是程序中最基本的存储单元，包含变量类型，变量名称和存储的值。
简单来说变量就好比我们注册淘宝是要填写的用户名，手机号，密码，年龄等。这些填写完后提交到程序中进行处理，这些数据保存在相应的变量中，进行一些处理，所以我们填写的每一个称呼都是一个变量，程序中都会有相应的变量来与之对应。
变量的作用：用于在内存中存储数据。
使用变量要注意：
java中使用变量必须先声明，再使用。
使用变量名来访问这块区域的数据。
变量的作用域为其所在的一对花括号{}里面。
变量只有在其作用域内才有效。
在同一个作用域内不能定义重复的变量。
变量使用
变量的定义格式：数据类型 变量名 = 变量值；
public class Stujava {
public static void main(String[] args) {
//定义变量
int a = 12 ;
//运行结果
System.out.println(a);
}
}
运行结果
12
相对来说，我们直接定义变量不赋值运行，程序会报错：未给变量进行初始化操作。
如果在同一作用域内定义重复的变量也会报错：该变量已经定义。
对于每一种数据都定义了明确的数据类型，在内存中分配不同的大小空间。
根据数据类型可分为：基本数据类型变量和引用数据类型变量。
基本数据类型有8中，分为4类：
字符型：char 。 char型通常意义上是占用2字节，字符常量默认使用单引号( ’ ’ )括起来，如：char a1 = ‘a’。还可以使用Unicode值来表示字符型常量。
整型：byte,short,int,long。有固定的表数范围和字段长度，不受操作系统的影响，保证java的可移植性。整型常量默认为int型，声明Long型常量后加“l”或“L”。变量通常声明为int型，除非不足以表示较大的数，才使用long。
bit是计算机中最小的存储单位，byte:计算机中基本存储单元。
浮点型：float,double。浮点型默认常量为double型，声明float型常量要加“f”或“F”。
布尔型：boolean。用于逻辑计算，只有true和false两种结果。
public class Test01 {
public static void main(String[] args) {
//定义char类型，通常使用''，内部写一个字符，还可以声明一个字符，转义字符，或者直接使用Unicode值来表示字符型常量。
char a1 = 'a';
char c1 = '\t';//空格
char c2 = '\n';//换行
char c3 = '\u0043';
System.out.println("char类型输出========="+a1);
System.out.println("char类型输出========="+c1+"123");
System.out.println("char类型输出========="+c2+"456");
System.out.println("char类型输出========="+c3);
//定义double类型
double d1 = 12.1;
System.out.println("double类型输出========="+d1+1);
//定义float类型变量时，变量要以“f”或“F”结尾，不然变量会默认是double类型。
float f1 = 13.123f;
System.out.println("float类型输出=========="+f1);
//定义byte类型变量,范围是(-128~127)
byte b1 = 10;
byte b2 = -128;
//byte b3 = 128;//编译不通过
System.out.println("byte类型输出========="+b1+"\t"+b2);
//定义long，short，int类型变量，必须以“l”或“L”结尾。整数通常默认为int类型。
//long l1 = 123456789012;//定义变量long型，位数不超过int的范围是正常的，一旦超过int的范围且没有加“l”或“L”就会报错。
long l1 = 123;//没有报错是因为它为int类型，然后又把int类型转化为long类型。
long l2 = 1234453453789l;
short s1 = 134;
int i1 = 234;
System.out.println("long类型输出"+l2);
System.out.println("short类型输出"+s1);
System.out.println("int类型输出"+i1);
//定义boolean类型变量，只能取两个值中的一个，true或false
boolean bl1 = true ;
System.out.println("boolean类型输出"+bl1);
}
}
运行结果
char类型输出=========a
char类型输出========= 123
char类型输出=========
456
char类型输出=========C
double类型输出=========12.11
float类型输出==========13.123
byte类型输出=========10 -128
long类型输出1234453453789
short类型输出134
int类型输出234
boolean类型输出true
数据类型转换
数据类型转换分为：自动类型转换和强制类型转换。只用7种数据类型转换，Boolean数据类型不参与类型转换，因为它只有true和false两个值。
自动类型转换：
public class Test02 {
public static void main(String[] args) {
byte b1 = 12;
int i1 = 100 ;
//byte b2 = b1 + i1;//编译不通过
int i2 = b1 + i1;
long l2 = b1 + i1;
double d2 = b1 + i1;
System.out.println(i2);
System.out.println(l2);
System.out.println(d2);
char c1 = 'a';//c1的值为97,通过ASCII码可以得知c1的值。
short s1 = 3;
//short s2 = c1 + s1;//编译不通过
int i3 = s1 + c1;
System.out.println(i3);
byte b2 = 3;
//char c2 = c1 + b2;//编译不通过
//byte b3 = s1 + b2;//编译不通过
}
}
运行结果：
112
112
112.0
100
容量小的的数据类型的变量与容量大的数据类型变量做运算时，结果自动提升为容量大的数据类型。
当byte，char，short三中类型做运算时，结果为int型。
说明：此时的容量大小指的是：表示数的范围的大小。
注：整型常量默认为int型。
浮点型常量默认为double型。
强制类型转换：大的数据类型转换为小的数据类型称之为强制转换。
小数据类型 变量 = (小数据类型) 大数据类型值;
注意：强制类型转化需要使用强转符()，强制转换可能会导致精度损失。
public class Test03 {
public static void main(String[] args) {
double d1 = 12.3;
int i6 = (int)d1;//四舍五入，会导致精度损失。
System.out.println(i6);
long l1 = 123l;//没有精度损失
short s6 = (short)l1;
System.out.println(s6);
int i7 = 128;//精度损失
byte b6 = (byte) i7;//因为数值128已经超出了byte的数值范围了，所以会造成精度损失。
System.out.println(b6);
}
}
运行结果
12
123
-128
引用数据类型分为3类：类，接口，数组。 基本数据类型之外的变量都是引用数据类型。
String类型：String不属于基本数据类型，它是引用数据类型，它是：字符串。属于3中引用数据类型中的类。
1.在程序中声明String类型时要使用：“”。
2.String类型可以和8种基本数据类型做运算，且运算只能为连接运算，使用连接符：“+”。
3.运算的结果要为String类型。
public class Test03{
public static void main(String[] args) {
String s1 = "hello";
System.out.println(s1);
int number = 1000;
String s2 = "学号是：";
String str = s2 + number;//+是连接符
System.out.println(str);
}
}
运行结果
hello
学号是：1000
除此之外，java中的变量还有局部变量，成员变量。
成员变量包含：实例变量（全局变量），类变量（静态变量）。
实例变量：无static修饰。通过对象名.变量名访问。只要对象被当做引用，实例变量就存在。
静态变量：有static修饰。通过类名.变量名或对象名.变量名访问。其生命周期取决于类的生命周期，类存在它就存在，类被销毁其随之销毁。
public class TestClass {
String name = "张三";//实例变量
int age = 18;//实例变量
static final String s1 = "123456"; //静态变量
static String s2 = "3453453453";//静态变量
public static void main(String[] args) {
//创建类
TestClass tc = new TestClass();
//调用实例变量
System.out.println(tc.name);
System.out.println(tc.age);
//调用静态变量
System.out.println(tc.s1);
System.out.println(tc.s2);
}
}
运行结果
张三
18
123456
3453453453
局部变量包含：形参，方法局部变量。代码块局部变量。
形参（方法参数变量）：在整个方法内有效。
方法内定义（方法局部变量）： 从定义这个变量开始到方法结束这一段时间内有效。
代码块局部变量（代码块局部变量）：从定义这个变量开始到代码块结束这一段时间内有效。
public class TestClass {
public static void main(String[] args) {
int a = 12;//局部变量
System.out.println(a);
test1("zhangsan");
}
public static void test1(String name){//形参
System.out.println("name: "+name);
{//局部代码块
int s = 123;
System.out.println(s);
}
}
}
运行结果
12
name: zhangsan
123
注意：
成员变量：随着类创建对象而出现，随着对象被回收而消失。
局部变量：当方法被调用时才出现，随着方法执行结束而消失 。
在方法体内部声明的变量称为局部变量。
在方法体外，类体内声明的变量称为成员变量 。
结束语：
感谢大家的阅读。
如果有不足之处，请指出，小生在此感谢大家；