变量
一、什么是变量
示例1：什么是变量
变量的定义是： 用来命名一个数据的标识符
1949 这是一个数字，代表某年
如果要命名这个数字，在java里就会写成：
int year = 1949;
int 是数据类型，表示是整数
year 是一个标识符
= 是赋值操作符
1949 是一个数字类型的值
; 表示该行结束
year 这个标识符就是一个变量，它代表1949这个值
public class HelloWorld {
public static void main(String[] args) {
int year = 1949;
}
}
二、基本类型变量
一个变量的类型，决定了该变量可以包含什么样的值。
Java中有八种基本类型，都是Java语言预先定义好的，并且是关键字。
这八种基本类型分别是：
整型 （4种）
字符型 （1种）
浮点型 （2种）
布尔型（1种）
示例1：整型
整型变量用于存放整数
byte
short
int
long
区别在于不同类型的整型，最大值，最小值不一样。
如果试图给byte类型的变量赋值超出其范围的值，就会产生编译错误，这个需要进行类型转换。
整型数据类型
| 类型 | 缺省值 | 长度 | 数的范围 |
|---|---|---|---|
| byte | 0 | 8位 | -128~127 |
| short | 0 | 16位 | -32,768~32,767 |
| int | 0 | 32位 | -2,147,483,648~2,147,483,647 |
| long | 0 | 64位 | -9,223,372,036,854,775,808~9,223,372,036,854,775,807 |
public class HelloWorld{
public static void main(String[] args){
byte b = 1;
short s = 200;
int i = 300;
long l = 400;
/*如果试图给byte类型的变量赋予超出其范围的值，就会产生编译错误*/
byte b2 = 200;
}
}
示例2：字符型
char类型用于存放一个字符，值用单引号'表示 (双引号表示字符串)
其长度和short一样，也是16位的
只能存放一个字符，超过一个字符就会产生编译错误
public class HelloWorld{
public static void main(String[] args){
char c = '中';
//char 只能存放一个字符，超过一个字符就会产生编译错误
char c2 = '中国'; //报错
char c3 = 'ab'; //报错
}
}
示例3：浮点型
浮点数类型有两种
float 长度为32位
double 长度为64位
注意： 默认的小数值是double类型的
所以 float f = 54.321会出现编译错误，因为54.321的默认类型是 double，其类型 长度为64，超过了float的长度32
在数字后面加一个字母f，直接把该数字声明成float类型
float f2 = 54.321f,
这样就不会出错了
浮点型数据类型
| 类型 | 缺省值 | 长度 | 数的范围 |
|---|---|---|---|
| float | 0.0 | 32位 | 3.4E-038~3.4E+038 |
| double | 0.0 | 64位 | 1.7E-308~1.7E+308 |
public class HelloWorld{
public static void main(String[] args){
double d = 123.45;
//该行会出现编译错误，因为54.321是double型的
float f = 54.321;
float f2 = 54.321f;
}
}
示例4：布尔型
布尔型用于表示真假
其长度为1
boolean b1 = true;
boolean b2 = false;
分别代表真假
虽然布尔型真正存放的数据是0(false) 1(true)
但是，不能直接使用0 1 进行赋值
| 类型 | 缺省值 | 长度 | 数的范围 |
|---|---|---|---|
| boolean | false | 1位 | false,true |
public class HelloWorld {
public static void main(String[] args) {
boolean b1 = true;
boolean b2 = false;
// 虽然布尔型真正存放的数据是0(false) 1(true)
// 但是，不能直接使用0 1 进行赋值
boolean b3 = 1;
}
}
示例5：String类型
String类型其实并不是基本类型，但是它是如此广泛的被使用，常常被误以为是一种基本类型。
String类型是Immutable的，一旦创建就不能够被改变，更多的关于String的学习，请参考String。
public class HelloWorld {
public static void main(String[] args) {
String str = "Hello Java";
}
}
三、字面值
创建一个Hero对象会用到new关键字，但是给一个基本类型变量赋值却不是用new. 因为基本类型是Java语言里的一种内置的特殊数据类型，并不是某个类的对象。
给基本类型的变量赋值的方式叫做 字面值，如下所例：
float hp = 313f;
int armor = 24;
示例1：整数字面值
当以l或者L结尾的时候，一个整数字面值是long类型，否则就是int类型。 建议使用大写的L而非小写的l，因为容易和1混淆。
byte,short,int和long的值都可以通过int类型的字面值来创建。整数的字面值可以用如下四种进制来表示：
十进制: 基 10, 包含从0-9的数字，平常用的就是这种
十六进制: 基 16, 包含从0-9的数字，和从A-F的字母。
八进制: 基 8, 包含从0-7的数字
二进制: 基 2, 包含0和1。（从 JAVA7开始就可以创建 二进制的字面值了）
public class HelloWorld {
public static void main(String[] args) {
long val = 26L; //以L结尾的字面值表示long型
int decVal = 26; //默认就是int型
int hexVal = 0x1a; //16进制
int oxVal = 032; //8进制
int binVal = 0b11010; //2进制
System.out.println(oxVal);
}
}
示例2：浮点数字面值
当以f或者F结尾的时候，就表示一个float类型的浮点数，否则就是double类型（以d或者D结尾，写不写都可以）。
浮点数还可以用E或者e表示（科学计数法）
e2表示10的二次方，即100
1.234e2 = 1.234x100
public class HelloWorld {
public static void main(String[] args) {
float f1 = 123.4F;// 以F结尾的字面值表示float类型
double d1 = 123.4;// 默认就是double类型
double d2 = 1.234e2;// 科学计数法表示double
}
}
示例3：字符和字符串字面值
字符的字面值放在单引号中
字符串的字面值放在双引号中
需要注意的是，\表示转义，比如需要表示制表符，回车换行，双引号等就需要用 \t \r \n " 的方式进行
public class HelloWorld {
public static void main(String[] args) {
String name = "盖伦";
char a= 'c';
//以下是转义字符
char tab = '\t'; //制表符
char carriageReturn = '\r'; //回车
char newLine = '\n'; //换行
char doubleQuote = '\"'; //双引号
char singleQuote = '\''; //单引号
char backslash = '\\'; //反斜杠
}
}
四、类型转换
不同类型之间的数据可以互相转换，但是要满足一定的规则
示例1：转换规则
转换规则如图所示
精度高的数据类型就像容量大的杯子，可以放更大的数据
精度低的数据类型就像容量小的杯子，只能放更小的数据
小杯子往大杯子里倒东西，大杯子怎么都放得下
大杯子往小杯子里倒东西，有的时候放的下，有的时候就会有溢出
需要注意的一点是
虽然short和char都是16位的，长度是一样的
但是彼此之间，依然需要进行强制转换
public class HelloWorld {
public static void main(String[] args) {
char c = 'A';
short s = 80;
//虽然short和char都是16位的，长度是一样的
//但是彼此之间，依然需要进行强制转换
c = (char) s;
//直接进行转换，会出现编译错误
s = c;
}
}
示例2：低精度向高精度转换
long l = 50;
int i = 50;
l 是long类型的，其类型长度是64位
i 是int类型的，其类型长度是32位
所以l的精度，比i的精度要高
l = i;
把i的值赋给l， 首先l和i彼此的类型是不一样的，那么能否转换就取决于彼此的精度
这个例子，是低精度向高精度转换 是可以正常转换的
换句话说，int比较小，要放进比较大的long,随便怎么样，都放的进去
public class HelloWorld {
public static void main(String[] args) {
long l = 50;
int i = 50;
//int比较小，要放进比较大的long,随便怎么样，都放的进去
l = i;
}
}
示例3：高精度向低精度转换
byte b = 5;
int i1 = 10;
int i2 = 300;
b = i1;
b=i2;
b的类型是byte,其长度是8，最大只能放127
i1 的类型是int, 其长度是32,最大，反正就是很大了，超过127
所以， 把int类型的数据转成为byte类型的数据，是有风险的
有的时候是可以转换的，比如 b = i1 (i1=10);
有的时候不可以转换 比如 b= i2 (i2=300) 因为放不下了
编译器就会提示错误
这个时候就只能采用强制转换，强制转换的意思就是，转是可以转的，但是不对转换之后的值负责。 风险自担，后果自负
public class HelloWorld {
public static void main(String[] args) {
byte b = 5;
int i1 = 10;
int i2 = 300;
b = (byte) i1;
//因为i1的值是在byte范围之内，所以即便进行强制转换
//最后得到的值，也是10
System.out.println(b);
//因为i2的值是在byte范围之外，所以就会按照byte的长度进行截取
//i2的值是300，其对应的二进制数是 100101100
//按照byte的长度8位进行截取后，其值为 00101100 即44
b =(byte) i2;
System.out.println(b);
//查看一个整数对应的二进制的方法：
System.out.println(Integer.toBinaryString(i2));
}
}
五、命名规则
变量命名必须满足一系列的条件，不能随意命名
示例1：命名规则
变量命名只能使用字母 数字 $ _
变量第一个字符 只能使用 字母 $ _
变量第一个字符 不能使用数字
注：_ 是下划线，不是-减号或者—— 破折号
int a= 5;
int a_12= 5;
int $a43= 5;
int a434= 5;
//第一个是数字，是不行的
int 34a= 5;
示例2：使用完整的单词命名，而非缩写
在命名的时候，尽量使用完整的单词进行命名，比如name,moveSpeed，而不是使用缩写 n,m。
public class Hero {
//使用完整单词命名，易于理解
String name;
float hp;
float armor;
int moveSpeed;
}
public class Hero {
//使用缩写，不易理解
String n;
float h;
float a;
int m;
}
示例3：不能只使用关键字，但是可以包含关键字
什么是关键字
比如int, short, class 这些单词已经被java 赋予了特殊的含义，这些就是关键字。不能直接用来作为变量名
比如class
int class = 5;
class 是关键字
但是可以包含数字
比如
int class5 = 5;
public class HelloWorld {
public static void main(String[] args) {
int class5 = 5;
}
}
示例4：关键字列表1
示例5：关键字列表2
示例6：中文也是可以用来命名变量的
中文也是可以用来命名变量的
但是在实际工作中，别这么干。
public class 苍老师 {
public void 开展教学工作(){
System.out.println("雅蠛蝶");
}
public static void main(String[] args) {
苍老师 苍 = new 苍老师();
苍.开展教学工作();
}
}
六、作用域
变量处于不同的位置，有不同的名称
分别是
字段，属性
参数
局部变量
不同名称的变量，其作用域是不一样的
示例1：字段，属性，Field
当一个变量被声明在类下面
变量就叫做字段 或者属性、成员变量、Field
比如变量i,就是一个属性。
那么从第2行这个变量声明的位置开始，整个类都可以访问得到
所以其作用域就是从其声明的位置开始的整个类
public class HelloWorld {
int i = 1;
int j = i; //其他的属性可以访问i
public void method1(){
System.out.println(i); //方法1里可以访问i
}
public void method2(){
System.out.println(i); //方法2里可以访问i
}
}
示例2：参数
如果一个变量，是声明在一个方法上的，就叫做参数
参数的作用域即为该方法内的所有代码
其他方法不能访问该参数
类里面也不能访问该参数
public class HelloWorld {
public void method1(int i){ //参数i的作用域即方法method1
System.out.println(i);
}
public void method2(){
System.out.println(i); //method2 不能访问参数i
}
int j = i; //类里面也不能访问参数i
}
示例3：局部变量
声明在方法内的变量，叫做局部变量
其作用域在声明开始的位置，到其所处于的块结束位置
public class HelloWorld {
public void method1() {
int i = 5; //其作用范围是从声明的第4行，到其所处于的块结束12行位置
System.out.println(i);
{ //子块
System.out.println(i); //可以访问i
int j = 6;
System.out.println(j); //可以访问j
}
System.out.println(j); //不能访问j,因为其作用域到第10行就结束了
}
}
七、final
final 修饰一个变量，有很多种说法，比如不能改变等等
准确的描述是 当一个变量被final修饰的时候，该变量只有一次赋值的机会
示例1：在声明的时候赋值
i在第4行已经被赋值过了，所以这里会出现编译错误
public class HelloWorld {
public void method1() {
final int i = 5;
i = 10; //i在第4行已经被赋值过了，所以这里会出现编译错误
}
}
示例2：在声明的时候没有赋值
如果在声明的时候未赋值，那么可以在后面代码进行唯一的一次赋值
public class HelloWorld {
public void method1() {
final int i;
i = 10; //i在第4行，只是被声明，但是没有被赋值，所以在这里可以进行第一次赋值
i = 11; //i在第6行已经被赋值过了，所以这里会出现编译错误
}
}
示例3：final修饰其他
final 除了修饰变量，还可以修饰类，修饰方法，这些都在后续的章节展开
八、表达式
以;结尾的一段代码，即为一个表达式
步骤1：以;结尾的一段代码，即为一个表达式
表达式是由变量、操作符以及方法调用所构成的结构。如下所示：
int i = 5;
System.out.println(5);
都是表达式
public class HelloWorld {
public static void main(String[] args) {
//每一句话都是一个表达式
int i = 5;
System.out.println(5);
}
}
步骤2：；
;也是一个完整的表达式
public class HelloWorld {
public static void main(String[] args) {
//一个空;也是一个表达式
;
;
;
;
}
}
九、块
从{ 开始 到对应的} 结束，即一个块
步骤1：块
从{ 开始 到对应的} 结束，即一个块
public class HelloWorld { //类对应的块
public static void main(String[] args) { //主方法对应的块
System.out.println("abc");
}
}
浙公网安备 33010602011771号