Java实训【FUNDAMENTAL】-语言基础学习笔记（2）

变量：存数的

声明：----在银行开了个帐户

int a; // 声明一个整型的变量，名为a
int b,c,d; // 声明三个整型的变量，名为b, c, d
// int a; // 编译错误，变量不能同名

初始化：----给帐户存钱

int a = 250; // 声明整型变量a并赋值为250
int b; // 声明整型变量b
b = 250; // 给变量b赋值为250

使用：----使用的是帐户里面的钱

对变量的操作就是对它所存的那个数的操作

int a = 5;
int b = a + 10; // 取出a的值5，加10后，再赋值给变量b
System.out.println(b); // 输出变量b的值15
System.out.println("b"); // 输出b，双引号中的原样输出
a = a + 10; // 在a本身基础之上增10
System.out.println(a); // 15

变量在用之前必须声明并初始化

System.out.println(m); // 编译错误，变量m未声明
int m;
System.out.println(m); // 编译错误，变量m未初始化

命名

• 只能包含字母、数字、_和$符，并且不能以数字开头
• 严格区分大小写
• 不能使用关键字
• 允许中文命名，但不建议，建议“英文的见名知意”、“驼峰命名法”

八种基本数据类型

byte, short, int, long, float, double, boolean, char

int：

整型，4个字节，-21个多亿到21个多亿

• 整数直接量默认为int类型，但不能超范围，若超范围则发生编译错误
• 两个整数相除，结果还是整数，小数位无条件舍弃(不会四舍五入)
• 整数运算时若超范围，则发生溢出(溢出不是错误，但是需要避免的)

long：

长整型，8个字节，很大很大很大

• 长整型直接量需在数字后加L或l
• 运算时若有可能溢出，建议在第1个数字后加L

double：

浮点型，8个字节，很大很大很大

• 浮点数直接量默认为double型，若想表示float需在数字后加F或f
• double和float型数据参与运算时，有可能会发生舍入误差

boolean：

布尔型，1个字节

• 只能取值为true或false

char：

字符型，2个字节

• 采用的是Unicode字符集编码格式，一个字符对应一个码
  表现的形式为字符char，但实质上是码int(0到65535)
  (ASCII码: ‘a’ - 97 ‘A’ - 65 ‘0’ - 48)
• 字符直接量必须放在单引号中，只能有一个
• 特殊符号需通过\来转义

基本数据类型间的转换

数据类型从小到大依次为：byte, short, int, long, float, double
char

两种方式

• 自动/隐式类型转换：小类型到大类型
• 强制类型转换：大类型到小类型
  语法： (要转换成为的数据类型)变量
  强转有可能溢出或丢失精度

两点规则

• 整数直接量可以直接赋值给byte,short,char，但不能超出范围
• byte, short, char型数据参与运算时，系统会一律先转为int再运算

 byte b1 = 5;
byte b2 = 6;
byte b3 = (byte) (b1 + b2); 

常见错误：

1) int a = 5;
  int a = 8; // 编译错误，变量不能同名
2) int a;
  System.out.println(a); // 编译错误，变量a未初始化
3) int 1a; // 编译错误，不能以数字开头
4) long a = 10000000000; // 编译错误，100亿默认int类型，但超int范围了
5) char ch = '10'; // 编译错误，只能有1个字符
6) char ch = 14;   // 不是所有码所对应的字符都是可以正常输出显示的
  System.out.println(ch); // 乱七八糟的东西
7) char ch = '\'; // 编译错误，\为特殊字符，需转义
8) long a = 25L;
  int b = a; // 编译错误，大到小必须强制类型转换
  int b = (long) a; // 编译错误，将a强转为long没有任何意义
9) double a = 56.987;
  int b = (int) a;
  System.out.println(b); //输出56，后面的.987被舍弃了
10) short s1 = 5;
    short s2 = 6;
    short s3 = s1 + s2; // 编译错误，需强转 

代码部分：

VarDemo.java

package day02;
/**
 * 变量的演示
 * @author Katrina
 */
public class VarDemo {

	public static void main(String[] args) {
		// 1.变量的声明：-在银行开帐户
		int a; // 声明一个整型变量，名为a
		int b, c, d; // 声明三个整型的变量，名为b, c, d
		// int a; //编译错误，变量不能同名

		// 2.变量的初始化：----给帐户存钱
		int e = 250; // 声明整型变量e并赋值为250
		int f; // 声明整型变量f
		f = 250; // 给变量f赋值为250

		// 3.变量的使用：----使用的是帐户里面的钱
		int g = 5;
		int h = g + 10; // 取出g的值5，加10后，再赋值给变量h
		System.out.println(h); // 输出变量h的值15
		System.out.println("h"); // 输出h，双引号中的原样输出
		g = g + 10; // 在g本身基础之上增10
		System.out.println(g); // 15

		// System.out.println(i); //编译错误，变量i未声明
		int i;
		// System.out.println(i); //编译错误，变量i未初始化

		// 4.命名:
		int a1, a_5$, _3c, $8;
		// int a*b; // 编译错误，不能包含*号等特殊符号
		// int 1a; // 编译错误，不能以数字开头
		int aa = 5;
		// System.out.println(Aa); // 编译错误，严格区分大小写
		// int class; // 编译错误，不能使用关键字
		int 年龄; // 允许中文命名，但不建议
		int age; // 建议"英文的见名知意"
		int score, myScore, myJavaScore; // 建议"驼峰命名法"
	}

}

DataTypeDemo.java

package day02;
/**
 * 基本数据类型的演示
 * @author Katrina
 */
public class DataTypeDemo {
	
	public static void main(String[] args) {
		// 基本类型间的转换:
		byte b1 = 5;
		byte b2 = 6;
		byte b3 = (byte) (b1 + b2);
		
		System.out.println(2+2); // 4
		System.out.println(2+'2'); // 52，2加上'2'的码50
		System.out.println('2'+'2'); // 100，'2'的码50，加上'2'的码50
		
		/* 晚课 */
		/*
		int a = 5;
		long b = a; // 自动类型转换
		int c = (int) b; // 强制类型转换
		
		long d = 25; // 自动类型转换
		double e = 25; // 自动类型转换
		
		long f = 10000000000L;
		int g = (int) f;
		System.out.println(g); // 1410065408，强转有可能发生溢出
		double h = 25.987;
		int i = (int) h;
		System.out.println(i); // 25，强转有可能丢失精度
		*/
		
		/*
		// 5.char:字符型，2个字节
		char c1 = '女'; // 字符女
		char c2 = 'f'; // 字符f
		char c3 = '6'; // 字符6
		char c4 = ' '; // 空格符
		// char c5 = 女;  // 编译错误，字符直接量必须放在单引号中
		// char c6 = ''; // 编译错误，必须有字符
		// char c7 = 'ab'; // 编译错误，只能有一个字符
		
		char c8 = 97; // 0到65535之间
		System.out.println(c8); // a，输出时会依据c8的类型来输出
		char c9 = '\'';   
		System.out.println(c9); // '
		*/
		
		
		/*
		// 1.int:整型，4个字节，-21个多亿到21个多亿
		int a = 25; // 25为整数直接量，默认为int类型
		// int b = 10000000000; // 编译错误，100亿默认int类型，但超出范围了
		System.out.println(5 / 2); // 2
		System.out.println(2 / 5); // 0
		System.out.println(5 / 2.0); // 2.5
		int c = 2147483647; // int的最大值
		c = c+1;                 
		System.out.println(c); // -2147483648
		
		// 2.long:长整型，8个字节，很大很大很大
		// long d = 10000000000; // 编译错误，100默认为int类型，但超出int范围了
		long e = 10000000000L; // 长整型直接量需在数字后加L
		long f = 1000000000 * 2 * 10L;
		System.out.println(f); // 200亿
		long g = 1000000000*3*10L;
		System.out.println(g); // 溢出了
		long h = 1000000000L * 3 * 10;
		System.out.println(h); // 300亿
		*/
		
		/*
		// 3.double:浮点型，8个字节，很大很大很大
		double a = 3.14; // 3.14为浮点数直接量，默认double型
		double b=3.0,c=2.9;
		System.out.println(b-c); // 0.10000000000000009
		
		// 4.boolean:布尔型，1个字节
		boolean d = true;  // true为布尔型直接量
		boolean e = false; // false为布尔型直接量
		// boolean f = 25; // 编译错误，布尔型只能赋值为true或false
		*/
	}
	
}