It's our wits that make us men.

Java学习笔记(3)变量

Posted on By Xc L

什么是变量

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

1949 这是一个数字,代表某年 如果要命名这个数字,在Java里就会写成:

int year = 1949;

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

year是一个标识符

=是赋值操作

1949是一个数字类型的值

` ; `表示该行结束

year这个标识符就是一个变量,它代表1949 这个值

public class HelloWorld{
	public static void main(String){
		int year = 1949;
	}
}

基本变量类型

一个变量的类型,决定了该变量可以包含什么样的值。

Java中有 8 种基本类型,都是Java语言预先定义好的,并且是关键字。、

这 8 种基本类型分别是: 整型 (4种)

字符型 (1种)

浮点型 (2种)

布尔型 (1种)

整型

整型变量用于存放整数 byte

short

int

long

区别在于不同类型的整型,最大值,最小值不一样

如果试图给byte类型的变量赋予超出其范围的值,就会产生编译错误,这个时候就需要进行类型转换

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;
  }
}

字符型

char类型用于存放一个字符,值用单引号'表示(双引号表示字符串) 其长度和short一样,也是16位的 只能存放一个字符,超过一个字符就会产生编译错误

public class HelloWorld{
    
  public static void main(String[] args){
      char c = '中';
      //char 只能存放一个字符,超过一个字符就会产生编译错误
      char c2 = '中国'; //报错
      char c3 = 'ab'; //报错
 
  }
}

浮点型

浮点数类型有两种

float长度为 32 位

double长度为 64 位

注意:默认的小树枝是double类型的

所以float f = 54.321会出现编译错误,因为54.321的默认类型是double,其长度为64,超过了float的长度32位。在数字后面**加一个字母 f **,直接把该数字声明成float类型。

float f2 = 54.321f 这样就不会出错了

public class HelloWorld{
	public static void main(String[] args){
		double d = 123.45;

		//该行会出现编译错误,因为54.321是double类型的
		float f = 54.321;

		float f2 = 54.321f;
	}
}

布尔型

布尔型用于表示真假 其长度为1

boolean b1 = true;
boolean b2 = false;

分别代表真假

虽然布尔型真正存放的数据时 0(false) ,0(true)

但是,不能直接使用 0,1进行赋值

public class HelloWorld{
	public static void main(String[] args){
	boolean b1 = true;
	boolean b2 = false;

	//虽然布尔型真正存放的数据是0(false)1(true)
	//但是,不能直接使用0,1进行赋值
	boolean b3 = 1;//这是错的不能执行
	
	}
}

String类型

String类型其实并不是基本类型,但是它是如此广泛的被使用,常常被误以为一种基本类型。

String类型是Immutable的,一旦被创建就不能够被改变。

public class HelloWorld{
	public static void main(String[] args){
		String str = "Hello Java";
	}
}

变量类型-练习

分别为如下值,找到合适的类型来定义

3.14

2.769343

365

12

‘吃’

false

“春眠不觉晓”

比如3.14就使用double

double a = 3.14;

double b = 2.76943;
int c = 365;
short d = 12;
char e = '吃';
boolean f = false;
String g = "春眠不觉晓";

字面值

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

给基本类型的变量赋值的方法叫做字面值,如下所例:

float hp = 313f;
int armor = 24;

整数字面值

当以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.(从java 7开始可以创建二进制的字面值了)

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);
	}
}

浮点数字面值

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

浮点数还可以用E或者e表示(科学计数法)

e2表示10 的二次方,即100

1.234e2表示1.234 x 100

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
	}
}

字符和字符串字面值

字符的字面值放在单引号中

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

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

public class HelloWorld{
	public static void main(String[] args){
		String name = "盖伦";
		char = 'c';

		//以下为转义字符
		char tab = '\t'; //制表符
		char carriageReturn = '\t'; //回车
		char newLine = '\n'; //换行
		char doubleQuote = '\"'; //双引号
		char singleQuote = '\''; //单引号
		char backslash = '\\'; //反斜线
	}
}

练习-字面值

定义如下变量 ,然后为每种不同类型的变量赋予合法的字面值

byte b;

short s;

int i;

long l;

float f;

double d;

char c;

String str; 比如

b = 12;

如果写成如下就会报错,是非法的

byte b = 250;

解析:

byte b = 127;
short s = 128;
int i = 152354;
long l = 15648465165L;
float f = 12.5F;
double d = 12.5;
char c = 'c';//char c = '\\';
String str = "Hello World";

类型转换

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

转换规则

转换规则如图所示

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

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

小杯子往大杯子里到东西,大杯子怎么都放得下 大杯子往小杯子里倒东西,有时候放的下,有时候就会溢出来

需要注意的一点是 虽然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;
		
	}
}

低精度向高精度转换

long l = 50;
int i = 50;

l 是long类型的,其类新的长度是64位

i 是int类型的,其类型长度是32位的

所以l的精度比i的精度要高

l = i; 把i的值赋给l,这个是低精度向高精度转换,是可以正常转换的 换句话说,int比较小,要放进比较大的long,随便怎么样都放得进去

public class HelloWorld{
	public static void main(String[] args){
		long l = 50;
		int i = 50;

		//int比较下,要放进比较大的long,随便怎么样都放得下
		l = i;
		
	}
}

高精度向低精度转换

byte b = 5;
int i1 = 10;
int i2 = 300;
b = i1;
b = i2;

b的类型是byte,其长度是8,最大只能放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));
	}
}

类型转换-练习

short a = 1;

short b = 2;

那么a+b是什么类型

答案是:int类型 a和b相加前要先自动转换成int类型,所以相加的结果也是int类型


命名规则

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

命名的规则

变量命名**只能使用字母、数字、$、_(下划线) **

变量的第一个字符**只能使用 字母、 $ 、 _(下划线) ; 不能使用 数字

int a = 5;
int a_12 = 5;
int $a43 = 5;
int a434 = 5;

//变量第一个是数字,是不行的
int 34a = 5;

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

在命名的时候,尽量使用完整的单词进行命名,比如 name, moveSpeed, 而不是n, m .

public class Hero{
	//使用完整的单词命名,易于理解
	String name;
	float hp;
	float armor;
	int moveSpeed;
	
}

不能只使用关键字,但可以包含关键字

什么是关键字

比如 int,short,class这些单词已经被java赋予了特殊的含义,这些就是关键字。并不能直接用来作为变量名

比如class

int class = 5;

class是关键字。但是可以包含关键字,比如

int class5 = 5;

public class HelloWorld{
	public static void main(String[] args){
		int class5 = 5;//可以包含关键字,但不可以用关键字直接命名
	}
}

注意:中文也可以命名变量(但不要这么做)

关键字列表


(变量)作用域

变量处在不同的位置,有不同的名称

分别是

  • 字段,属性

  • 参数

  • 局部变量

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

字段,属性,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
	}

}

参数

如果一个变量,是生命在一个方法上的,就叫做参数

参数的作用域即为该方法内的所有代码

其他方法不能访问该参数,类里面也不能访问该参数

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
}

局部变量

声明在方法内的变量,叫局部变量

其作用域在声明开始的位置,到其所处于的块结束位置

public class HelloWorld{
	public void method1(){
		int i = 5; //其作用范围从声明的第3行开始,到其所处于的块结束11行位置
		System.out.println(i);
		{  //子块
			System.out.println(i); //可以访问i
			Int j = 6;
			System.out.println(j); //可以访问j
		}
		System.out.println(j); //不能访问j,因为其作用域到第9行就结束了
	}
}

练习-作用域

属性的作用域在方法中,参数的作用域也在方法中,如果属性和参数命名相同了的话? 那么到底取哪个值?

public class HelloWorld {
    int i = 1; //属性名是i
    public void method1(int i){ //参数也是i
        System.out.println(i);
    }
     
    public static void main(String[] args) {
        new HelloWorld().method1(5);
        //结果打印出来是 1还是5?
    }
}

答案是:5 在main方法中,调用了method1方法并且传值为5,程序在运行时修改了HelloWorld类中method1方法中的i值


final

final修饰一个变量,有很多种说法,比如不能改变等等

准确的描述是: 当一个变量被final修饰的时候,该变量只有一次赋值的机会

在声明的时候赋值

i在第4行已经被赋值过了,所有这里会出现编译错误

public class HelloWorld{
	public void method1(){
		final int i = 5;

		i = 10;//i在第4行已经赋值过了,所以这里会出现编译错误
		
	}
}

在声明的时候没有赋值

如果在声明的时候未赋值,那么可以在后面代码进行唯一的一次赋值

public class HelloWorld{
	public void method1(){
		final int i;
		i = 10;//i在第3行,只是被声明,但没有被赋值,所以在这里可以进行第一次赋值
		i = 11;//i在第4行已经被赋值过了,所以这里会出现编译错误
	}
}

final修饰其他

final除了修饰变量,还可以修饰类,修饰方法,这些都可以在后续的章节展开

练习-final

如果final修饰的是参数,能否在方法里给这个参数赋值?

public class HelloWorld{
	public void method1(final int j){
		j = 5;//这个能否执行?
	}
}

答案:不能。方法规定j只能被赋值1次,对j赋值的话,相当于j在被调用前已经赋值,调用方法时无法再赋值。


表达式(什么是Java的表达式)

以 ; 结尾的一段代码,即为一个表达式

以 ` ; `结尾的一段代码,即为一个表达式

表达式由变量、操作符以及方法调用所构成的结构。如下所示

int i =5;
System.out.println(5);

都是表达式

public class HelloWorld{
	public static void main(String[] args){
		//每一句话都是一个表达式
		int i = 5;
		System.out.println(5);
	}
}

` ; `也是一个完整的表达式

public class HelloWorld{
	public static void main(String[] args){
		//一个空 ; 也是一个表达式
		;
		;
		;
		;
	}
}

块(什么是Java的块)

从 { 开始,到对应的 } 结束,即一个块

块

从 { 开始,到对应的 } 结束,即一个块

public class HelloWorld{ //类对应的块
	public static void main(String[] args){ //主方法对应的块
		System.out.println(5);
	}
}