Java学习笔记之“变量”

本文为在How2j的学习总结，只代表个人见解，如有不妥，望指出以便更正。

1. 什么是变量

变量的定义是：用来命名一个数据的标识符。

例如1949是一个数字，代表某年，在Java中我们这样命名：

int year = 1949;

int 是数据类型，表示是整数

year 是一个标识符

= 是赋值操作符

1949 是一个数字类型的值

; 表示该行结束

 

2. 变量基本类型

一个变量的类型，决定了改变量包含什么样的值。

Java中有8种基本类型，分别是：整型（4种）、字符型（1种）、浮点型（2种）、布尔型（1种）。这都是Java语言预先定义好的，并且是关键字。

2.1 整型

整型变量用于存放整数：byte、short、int、long，其区别在于不同类型的整型，最大值、最小值不一样。

注意：如果试图给byte类型的变量赋予超过其范围的值，就会产生编译错误，这个时候就要进行类型转换，参考第4节。

2.2 字符型

char类型用于存放一个字符，值用单引号' '表示 (双引号" "表示字符串)。

其长度和short一样，也是16位的；只能存放一个字符，超过一个字符就会产生编译错误。

2.3 浮点型

浮点数类型有两种：float 长度为32位，double 长度为64位

注意： 默认的小数值是double类型的，所以 float f = 54.321会出现编译错误，因为54.321的默认类型是 double，其类型长度为64，超过了float的长度32，在数字后面加一个字母f，直接把该数字声明成float类型，float f2 = 54.321f; 这样就不会出错了

2.4 布尔型

布尔（boolean）型用于表示真假，其长度为1。

虽然布尔型真正存放的数据是0（false）、1（true），但是不能直接用0 1赋值，要赋值为false和true。

2.5 String类型

String类型并不是基本类型，String类型是Immutable的，一旦创建就不能够被改变，后续将补充学习。

 

3. 变量字面值

创建一个Hero对象会用到new关键字，但是给一个基本类型变量赋值却不是用new. 因为基本类型是Java语言里的一种内置的特殊数据类型，并不是某个类的对象。

给基本类型的变量赋值的方式叫做 “字面值” 。

3.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。

3.2 浮点数字面值

当以f或者F结尾的时候，就表示一个float类型的浮点数，否则就是double类型（以d或者D结尾，写不写都可以）。

浮点数还可以用E或者e表示（科学计数法），e2表示10的二次方，即100。

1.234e2 = 1.234x100

3.3 字符和字符串字面值

字符的字面值放在单引号中，字符串的字面值放在双引号中。

需要注意的是，\表示转义，比如需要表示制表符，回车换行，双引号等就需要用 \t \r \n \" 的方式进行。

 

4. 变量类型转换

不同类型之间的数据可以相互转换，但要满足一定的规则。

4.1 转换规则

转换规则如图所示。

精度高的数据类型就像容量大的杯子，可以放更大的数据。

精度低的数据类型就像容量小的杯子，只能放更小的数据。

解读：小杯子往大杯子里倒东西，大杯子怎么都放得下
大杯子往小杯子里倒东西，有的时候放的下，有的时候就会有溢出

需要注意的一点是，虽然short和char都是16位的，长度是一样的，但是彼此之间，依然需要进行强制转换。

4.2 低精度向高精度转换

long l = 50;
int i = 50;

l 是long类型的，其类型长度是64位
i 是int类型的，其类型长度是32位
所以l的精度，比i的精度要高

l = i;

把i的值赋给l， 首先l和i彼此的类型是不一样的，那么能否转换就取决于彼此的精度
这个例子，是低精度向高精度转换 是可以正常转换的
换句话说，int比较小，要放进比较大的long,随便怎么样，都放的进去

 

4.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) 因为放不下了，编译器就会提示错误
这个时候就只能采用强制转换，强制转换的意思就是，转是可以转的，但是不对转换之后的值负责。

5. 变量命名规则

变量命名必须满足一系列的条件，不能随意命名。

• 变量命名只能使用字母 数字 $ _，变量第一个字符 只能使用 字母 $ _，变量第一个字符 不能使用数字

注：_ 是下划线，不是-减号或者—— 破折号

• 使用完整的单词命名，而非缩写

注：在命名的时候，尽量使用完整的单词进行命名，比如name,moveSpeed，而不是使用缩写 n,m。

• 不能使用关键字，但是可以包含关键字

什么是关键字，比如int, short, class 这些单词已经被java 赋予了特殊的含义，这些就是关键字。不能直接用来作为变量名。比如class，int class = 5;这个不可以。因为class 是关键字，但是可以包含数字，比如int class5 = 5;

• 关键字列表

• 关于中文命名变量

中文也是可以用来命名变量的，但是在实际工作中。。。别这么干。。。

6. 变量作用域

变量处于不同的位置，有不同的名称，分别为字段、属性，参数和局部变量。

不同名称的变量，其作用域是不一样的。

• 字段、属性、Field

当一个变量被声明在类下面，变量就叫做字段或者属性、成员变量、Field。

其作用域就是从声明位置开始的整个类。

• 参数

当一个变量是声明在一个方法上的，就叫做参数。

参数的作用域即为该方法内的所有代码。其他方法不能访问该参数，类里面也不能访问该参数。

• 局部变量

当一个变量是声明在方法内的，就叫做局部变量。

其作用域在声明开始的位置，到其所属的块的结束位置。

7. final变量

final修饰一个变量时，表示该变量只有一次赋值机会。

注：final除了可以修饰变量，还可以修饰类，修饰方法，后续补充。

8. 变量表达式

• 以；结尾的一段代码，即为一个表达式。
• 表达式是由变量、操作符以及方法调用所构成的结构。
• ；也是一个表达式。

9. 变量块

以 { 开始到对应的 } 结束，即为一个块。

public class Variable {
	public static void main(String[] args) {
		//什么是变量
		int year = 1949;
		
		//变量基本类型
	    byte b = 1;
	    short s = 200;
	    int i = 300;
	    long l = 400;
	    
	    /*如果试图给byte类型的变量赋予超出其范围的值，就会产生编译错误 */
	    byte b2 = 200;
	    
	    char c = '中';     //char 只能存放一个字符，超过一个字符就会产生编译错误
	    char c2 = '中国';  //报错
	    char c3 = 'ab';   //报错
	    
	    double d = 123.45;
	    
	    //该行会出现编译错误，因为54.321是double型的
	    float f = 54.321;
	    
	    float f = 54.321f;
	    
	    boolean b1 = true;
	    boolean b2 = false;
	    
	    //虽然布尔型真正存放的数据是0（false）1（true）
	    //但是，不能直接使用0 1进行赋值
	    boolean b3 = 1;
	    
	    //String类型
	    String str = "Hello world";
	    
	    //作业
		//分别为给出值找到合适的类型来定义
		//3.14,2.769343,365,12,吃
		float a = 3.14f;
		double b = 2.769343;
		int c = 365;
		int d = 12;
		char e = '吃';
		boolean f = false;
		String str = "不可描述";
		System.out.println("单精度浮点型：a = "+a);
		System.out.println("双精度浮点型：b = "+b);
		System.out.println("整数型：c = "+c);
		System.out.println("整数型：d = "+d);
		System.out.println("字符型：e = "+e);
		System.out.println("布尔型：f = "+f);
		System.out.println("字符串型：str = "+str);
		
		//字面值
		long val = 26L;  //以L结尾的字面值表示long型
		int decval = 26;  //默认就是int型
		int hexval = 0x1a;  //16进制
		int oxval = 032;    //8进制
		int binval = 0b11010;  //2进制
		
		float f1 = 123.4f;  //以f结尾的字面值表示float类型
		double d1 = 123.4;  //默认就是double类型
		double d2 = 1.234e2;  //科学计数法表示double
		
		//以下是转义字符
		char tab = '\t';  //制表符
		char carriageReturn = '\r';  //回车
		char newLine = '\n';  //换行
		char doubleQuote = '\"';  //双引号
		char singleQuote = '\'';  //单引号
		char backslash = '\\';    //反斜杠
		
		//作业
		byte b = 30;
		short s = 230;
		int i = 122;
		long l = 230L;
		float f = 2.13f;
		double d = 2.13;
		char c = '泽';
		String str = "xiaopangzi";
		
		//类型转换
		char c = 'A'; 
		short s = 80;
		
		//虽然short和char都是16位，长度是一样的
		//但是彼此之间，依然需要进行强制转换
		c = (char)s;
		//直接进行转换，会出现编译错误
		s = c;
		
		long l = 50L;
		int i = 50;
		//int比较小，要放比较大的long，随便怎么样，都放的进去
		l = i;
		
		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);
		
		//作业
		short a = 1;
		short b = 2;
		short c;
		c = (short)(a+b);
		System.out.println(c);
		
		new Variable().method6(5);    //结果打印出来是5，强龙不压地头蛇	
	}
	
	//变量作用域
	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
	}
	public void method3(int k) {    //参数k的作用域即方法method3
		System.out.println(k);   //方法3中可以访问k	
	}
	public void method4() {    
		System.out.println(k);   //方法4不能访问k
	}
	public void method5() {    
		int m = 5;   //其作用范围是从声明的第140行，到其所处于的块结束148行位置
		System.out.println(m);
		{              //子块
			System.out.println(m);  //可以访问m
			int n = 6;
			System.out.println(n);   //可以访问n	
		}
		System.out.println(n);     //不能访问n，因为其作用域到第10行就结束了
		}
	
	//作业
	int q = 1;    //属性名是q
	public void method6(int q) {  //参数也是q
		System.out.println(q);	
	}
	
	public void method7() {
        final int i = 5;
        i = 10; //i已经被赋值过了，所以这里会出现编译错误
	}
	
}