023_046 第二章数据类型和计算

最新推荐文章于 2021-11-08 22:23:18 发布

kobeno1love

最新推荐文章于 2021-11-08 22:23:18 发布

阅读量304

点赞数 1

分类专栏： JAVA 尚学堂 300集文章标签： JAVA 语法

本文链接：https://blog.csdn.net/kobeno1love/article/details/89502446

版权

尚学堂同时被 3 个专栏收录

10 篇文章 0 订阅

订阅专栏

300集

10 篇文章 0 订阅

订阅专栏

JAVA

9 篇文章 0 订阅

订阅专栏

1.注释

目的：方便阅读，提高可读性。
处理：Java编译器编译时自动跳过注释语句。（注释不会出现在字节码文件中）
分类：单行注释、多行注释和文档注释。
- 单行注释：使用“//”开头，“//”后面的单行内容均为注释。
- 多行注释：以“/* ” 开头以 “ * /”结尾，在“/* ”和“ */”之间的内容为注释，我们也可以使用多行注释作为行内注释。但是在使用时要注意，多行注释不能嵌套使用。
- 文档注释：以“/** ”开头以“*/”结尾，注释中包含一些说明性的文字及一些JavaDoc标签（后期写项目时，可以生成项目的API）
代码示例



/**
 * 用来测试注释的用法（包含：多行注释、单行注释、文档注释）
 * @author Kobeno1love
 *
 */
public class TestComment {

	/**
	 * 这是程序的入口
	 * @param args 参数
	 */
	public static void main(String[] args/* args是参数名，可以更改 */) {
		System.out.println("测试注释！");	//这是打印语句...
		
	}
	
	/*
	 我是多行注释！
	 我是多行注释！
	 我是多行注释！
	 我是多行注释！
	 */
}

2.标识符

作用：给变量、类、方法以及包进行命名的。
命名规范
- 必须以字母、下划线_、美元符号$开头。
- 其他部分可以是字母、下划线 “_” 、美元符号 “$” 和数字的任意组合。
- Java表示符大小写敏感，且长度无限制。
- 标识符不可以是Java关键字。
使用规范
- 表示类名的标识符：每个单词的首字母大写，如Man，GoodMan
- 表示方法和变量的标识符¹：第一个单词小写，从第二个单词开始首字母大写，我们称之为“驼峰原则”，如eat(),eatFood()
代码示例


/**
 * 测试标识符的用法
 * @author Kobeno1love
 *
 */
public class TestIdentifer {

	//能力是练出来的，不是看书看出来的，对于初学者来说，再简单的代码也一定要敲一下！
	public static void main(String[] args) {
		int a123 = 1;
		//int 123abc = 2;		//数字不能开头
		int $a = 3;
		int _abc = 4;
		//int -abc = 5;		//“-”不能命名
		//int #abc = 6;		//“#”不能命名
		int 年龄 = 18;		//可以使用汉字，但是一般不建议
		
		//int class = 2;	//关键字不能作为标识符
	}
}

3.关键字/保留字

4.变量

4.1 本质

可操作的存储空间，位置确定，内部值不确定。可通过变量名访问，操纵存储空间的存储值。
要素：变量名、变量类型和作用域。
声明：
- 类型：每个变量必须有类型，类型可以是基本类型，也可以是引用类型。
- 变量名：必须是合法标识符。
- 变量声明：必须是完整的语句，必须以分号结束。
代码示例


/**
 * 测试变量
 * @author Kobeno1love
 *
 */
public class TestVariable {
	public static void main(String[] args){
		int age;
		age = 18;
		int salary = 3000;
		//变量需要声明，并且初始化后才能使用
		int wang = 13;
		System.out.println(wang);
	}
}

4.2 变量分类

局部变量、成员变量和静态变量。
局部变量（local variable）
- 方法或语句内部定义的变量。生命周期是从声明位置开始到方法或语句执行完毕为止。
- 必须先声明、初始化（赋初值）再使用。
成员变量（也叫实例变量 member variable）
- 方法外部、类的内部定义的变量。
- 从属于对象，生命周期伴随对象始终。
- 如若不自行初始化，会自动初始化为该类型的默认初始值。

数据类型	初始值
int	0
double	0.0
char	‘\u0000’
boolean	false

静态变量（类变量 static variable）
- 使用static定义。
- 从属于类，生命周期伴随类始终，从类加载到卸载。
代码示例


/**
 * 测试变量
 * @author Kobeno1love
 *
 */
public class TestVariable {
	
	int a;		//成员变量，成员变量会自动被初始化
	static int size;	//静态变量，从属于类
	
	public static void main(String[] args){
	
		{
			int age;		//局部变量，从属于语句块；		
			age = 18;
		}				
		int salary = 3000;	//局部变量，从属与方法

//		System.out.println(wang);			//变量需要声明，并且初始化后才能使用
		
		int i;
//		int j = i + 5;	//编译报错，变量还未被初始化
		
	}
}

5.常量

通常指一个固定的值：如1、2、3，‘a’、‘b’，true、false，"helloWorld"等
Java语言中利用关键字final来定义一个常量。
常量一旦被初始化后不能在更改其值。
代码示例


/**
 * 测试常量
 * @author Kobeno1love
 *
 */
public class TestConstant {
	public static void main(String[] args) {
		int age = 8;
		
		final String NAME = "Kobeno1love";
		
		final double PI = 3.14;
		//PI = 3.15;	//编译错误，不能再次被赋值！
		double r = 4;
		double area = PI * r * r;
		double circle = 2 * PI * r;
		System.out.println("area = " + area);
		System.out.println("cicle = " + circle);
	}
}

6.基本数据类型（primitive data type）

6.1 数值型

byte、short、int、long、float、double

类型	占用空间	表数范围
byte	1字节	-2⁷ ~ 2⁷-1 (-128 ~ 127)
short	2字节	-2¹⁵ ~ 2¹⁵-1 (-32768 ~ 32767)
int	4字节	-2³¹ ~ 2³¹-1 (-2147483648 ~ 2147483647) 约21亿
long	8字节	-2⁶³ ~ 2⁶³-1

Java整型常量的四种表示形式
- 十进制：99，-500， 0
- 八进制：要求以0开头，015
- 十六进制：要求0x 或 0X，0x15
- 二进制：要求以0b 或 0B开头，0b01110011
- Java语言的整型常数默认为int型，声明long型常量可以后加‘l’ 或 ‘L’ 。
- 代码示例


/**
 * 测试基本数据类型
 * @author Kobeno1love
 *
 */
public class TestPrimitiveDataType {
	public static void main(String[] args) {
		//测试整型变量
		int a = 15;
		int b = 015;	//以0开头是八进制
		int c = 0x15;	//以0x开头是16进制
		int d = 0b1101;	//以0b开头是二进制
		
		System.out.println("a = "+ a);
		System.out.println("b = "+ b);
		System.out.println("c = "+ c);
		System.out.println("d = "+ d);
		
		byte age = 30;
		short salary = 30000;
		int population = 20000000;	//整型常量默认是int类型
		long globalPopulation = 740000000l;	//后面加L就是这是一个long类型的常量		
	}
}

显式结果

6.2 浮点型变量/常量

- 带小数的数据在Java中称为浮点型。

类型	占用存储空间	表数范围	精度
float	4字节	-3.403E38 ~ 3.403E38	7位有效数字
double	8字节	-1.798E308 ~ 1.798E308	float 的两倍

浮点数不精确，不能直接用于比较。
- 使用BigDecimal比较浮点数。
- 代码示例

import java.math.BigDecimal;

/**
 * 测试浮点型
 * @author Kobeno1love
 *
 */
public class TestPrimitveData2 {
	public static void main(String[] args) {
		float a = 3.14F;
		double b = 6.28;
		double c = 628E-2;
		
		System.out.println("c = "+ c);
		
		//浮点数是不精确的，一定不要用于比较！
		float f = 0.1f;
		double d = 1.0/10;
		System.out.println(f==d);	//结果为false
		
		float d1 = 423432423f;
		float d2 = d1 + 1;
		
		//浮点数是不精确的，一定不要用于比较！
		if(d1==d2) {
			System.out.println("d1==d2");
		}else {
			System.out.println("d1!=d2");
		}
		
		System.out.println("################################");
		//使用精确浮点运行，推荐：BigDecimal
		BigDecimal bd = BigDecimal.valueOf(1.0);
		  bd = bd.subtract(BigDecimal.valueOf(0.1));
		  bd = bd.subtract(BigDecimal.valueOf(0.1));
		  bd = bd.subtract(BigDecimal.valueOf(0.1));
		  bd = bd.subtract(BigDecimal.valueOf(0.1));
		  bd = bd.subtract(BigDecimal.valueOf(0.1));
		  System.out.println(bd);	//0.5
		  System.out.println(1.0 - 0.1 - 0.1 - 0.1 - 0.1 - 0.1);	//0.5000000000000001
		  
		  BigDecimal bd2 = BigDecimal.valueOf(0.1);
		  BigDecimal bd3 = BigDecimal.valueOf(1.0/10.0);
		  System.out.println(bd2.equals(bd3));
	}
}

运行结果

6.3 字符型（文本型）

Java中使用单引号来表示字符常量。‘ A’表示一个字符，“ A”表示含有一个字符的字符串。
char 类型用来表示在Unicode编码中的字符。占用2个字节，可允许有65536个字符。
代码示例


/**
 * 测试字符类型
 * @author Kobeno1love
 *
 */
public class TestPrimitiveDataType3 {
	public static void main(String[] args) {
		char a = 'T';
		char b = '王';
		char c = '\u0061';
		System.out.println("c代表 " + c);
		
		//转义字符
		System.out.println(""+'a'+'\n'+'b');
		System.out.println(""+'a'+'\t'+'b');	
		System.out.println(""+'a'+'\''+'b');
		
		//String就是字符序列
		String d = "abc";
	}
}

6.4 boolean 类型变量/常量

有两个常量值，true 和 false。
在内存中占一位（不是一个字节）。
不能使用 0 或非0 整数替代 true 和 false，这点和 C 语言不同。
boolean 类型用来判断逻辑条件，一般用于程序流程控制。
代码示例


/**
 * 测试字符类型和布尔类型
 * @author Kobeno1love
 *
 */
public class TestPrimitiveDataType3 {
	public static void main(String[] args) {
		char a = 'T';
		char b = '王';
		char c = '\u0061';
		System.out.println("c代表 " + c);
		
		//转义字符
		System.out.println(""+'a'+'\n'+'b');
		System.out.println(""+'a'+'\t'+'b');	
		System.out.println(""+'a'+'\''+'b');
		
		//String就是字符序列
		String d = "abc";
		
		//测试布尔类型
		boolean man = true;
		
		if(man) {	//极其不推荐 man==true
			System.out.println("男性");
		}
	}
}

7.运算符（operator）

7.1 算术运算符

二元运算符（两个操作数才能完成的运算）：+、-、*、/、%
- 整数运算：两个操作数有一个为long，结果为long。两个都不是long，结果为int。
- 浮点运算：两个操作数有一个为double，结果为double。两个都是float，结果为float。
- 取模运算：操作数一般为整数，可以浮点数。结果是“余数”，“余数”符号和左边操作数相同。
- 代码示例


/**
 * 测试运算符
 * @author Kobeno1love
 *
 */
public class TestOperator01 {
	public static void main(String[] args) {
/*		byte a = 1;
		int b =2;
		long b2 = 3;
//		byte c = a + b;	//运算结果为int，不符合byte型
//		int c2 = b2 + b;	//运算结果为long，不符合int型

		float f1 = 3.14f;	//浮点常量默认为double，不符合float型
		float d = b + b2;
		
//		float d2 = f1 + 6.2;	//运算结果为double，不符合float型
		
		System.out.println(-9%5);
*/
		//测试自增和自减
		int a = 3;
		int b = a++;	//执行完后b=3，先给b赋值，再自减
		System.out.println("a="+a+"\nb="+b);
		a = 3;
		b = ++a;	//执行完后，c=4，a先自增，再给c赋值
		System.out.println("a="+a+"\nc="+b);
		
		
		
	}

}

7.2 赋值及其扩展赋值运算符

代码示例


/**
 * 测试运算符
 * @author Kobeno1love
 *
 */
public class TestOperator01 {
	public static void main(String[] args) {
/*		byte a = 1;
		int b =2;
		long b2 = 3;
//		byte c = a + b;	//运算结果为int，不符合byte型
//		int c2 = b2 + b;	//运算结果为long，不符合int型

		float f1 = 3.14f;	//浮点常量默认为double，不符合float型
		float d = b + b2;
		
//		float d2 = f1 + 6.2;	//运算结果为double，不符合float型
		
		System.out.println(-9%5);
*/
/*		//测试自增和自减
		int a = 3;
		int b = a++;	//执行完后b=3，先给b赋值，再自减
		System.out.println("a="+a+"\nb="+b);
		a = 3;
		b = ++a;	//执行完后，c=4，a先自增，再给c赋值
		System.out.println("a="+a+"\nc="+b);
	*/
		
		int a = 3;
		int b = 4;
		a+= b;	//相当于a=a+b;
		System.out.println("a="+a+"\nb="+b);
		a = 3;
		a*= b+3;	//相当于a=a*(b+3)
		System.out.println("a="+a+"\nb="+b);
		
	}

}

7.3关系运算符

代码示例


/**
 * 测试关系运算符
 * @author Kobeno1love
 *
 */
public class TestOprerator02 {
	public static void main(String[] args) {
		int a = 3;
		System.out.println(a==3);
		System.out.println(a!=3);
		System.out.println(a<5);
		
		char b = 'a';
		char b2 = 'c';
		
		System.out.println((int)b);
		System.out.println(0+b);
		System.out.println(0+b2);
		System.out.println(b<b2);
	}
}

7.4 逻辑运算符

操作数和运算结果都是boolean值。
代码示例


/**
 * 逻辑运算符
 * @author Kobeno1love
 *
 */
public class TestOprator03 {
	public static void main(String[] args) {
		boolean b1 = true;
		boolean b2 = false;
		System.out.println(b1&b2);
		System.out.println(b1|b2);
		System.out.println(b1^b2);
		System.out.println(!b2);
		
		//短路
//		int c = 3/0;
		boolean b3 = 1>2&&2<(3/0);	//短路与，第一个操作数为false，则不需要再计算后面的操作数
		System.out.println(b3);
		
	}
}

7.5 位运算符

左移运算符<<，左移一位相当于乘以2。
右移运算符>>，右移一位相当于除以2。
代码示例


/**
 * 位运算符
 * @author Kobeno1love
 *
 */
public class TestOperator04 {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;
		System.out.println(a&b);
		System.out.println(a|b);
		System.out.println(a^b);
		System.out.println(~a);
		
		//移位运算
		int c = 3<<2;
		System.out.println(c);
		System.out.println(12>>1);
	}

}

7.6 字符串连接符

“+”左右两端有一个为字符串时，+为字符串连接符。
代码示例


/**
 * 字符串连接符
 * @author Kobeno1love
 *
 */
public class TestOperator05 {
	public static void main(String[] args) {
		String a = "3";
		int b = 4;
		int c = 5;
		char d = 'a';
		System.out.println(a+b+c);	//"3"+4="34","34"+5="345"
		System.out.println(b+c+a);	//4+5=9,9+"3"="93"
		System.out.println(d+4); //97+4=101
		
	}
}

7.7条件运算符

x?y:z
代码示例


/**
 * 条件运算符（三元运算符）
 * @author Administrator
 *
 */
public class TestOperator06 {
	public static void main(String[] args) {
		int score = 80;
		int x = -100;
		String type = score<60?"不及格":"及格";
		System.out.println(type);
		if(score<60) {
			System.out.println("不及格");
		}else {
			System.out.println("及格");
		}
		System.out.println(x>0?1:(x==0?0:-1));
	}

}

7.8运算符优先级问题

8类型转化

8.1自动类型转化

容量小的数据类型可以自动转化为容量大的数据类型。（占用字节数）
不能超出其表数范围。
代码示例


/**
 * 测试类型转化
 * @author Kobeno1love
 *
 */
public class TestTypeConvert {
	public static void main(String[] args) {
		int a = 123;
		long b = a;
		double d = a;
//		a = b;
//		long e = 3.23f;
		float f = 234323L;
		
		//特例
		byte b2 = 123;
		
	}

}

8.2 强制类型转化

(type) var
代码示例


/**
 * 测试类型转化
 * @author Kobeno1love
 *
 */
public class TestTypeConvert {
	public static void main(String[] args) {
/*		int a = 123;
		long b = a;
		double d = a;
//		a = b;
//		long e = 3.23f;
		float f = 234323L;
		
		//特例
		byte b2 = 123;
	*/
		double x = 3.94;
		int nx = (int)x;	//值为3
		char c = 'a';
		int d = c+1;
		System.out.println(nx);
		System.out.println(d);
		System.out.println((char)d);
		
	}

}

8.3 基本类型转化常见问题

操作比较大的数时，注意是否会溢出。
变量名不要和数字混淆。1与l
代码示例


/**
 * 测试类型转换常见问题
 * @author Kobeno1love
 *
 */
public class TestTypeConvertError {
	public static void main(String[] args) {
		int money = 1000000000;	//10亿
		int years = 20;
		//返回的total是负数，超过了int的范围
		int total = money * years;
		System.out.println("total="+total);
		//返回的total仍然是负数，默认是int，因此运算表达式的结果会转换成int值，再转成long，但是已经发生了数据丢失
		long total1 = money * years;
		System.out.println("total1="+total1);
		//返回的total2正确，先将一个因子变long，整个表达式发生提升，全部用long来计算
		long total2 = money * ((long)years);
		System.out.println("total2="+total2);
		
		//命名问题
		int l =2;	//分不清是L还是1
		long a = 23451l;	//建议使用大写L
		System.out.println(l+1);
	}

}

9. 使用Scanner获得键盘的输入

代码示例


import java.util.Scanner;
/**
 * 测试获得键盘输入
 * @author Kobeno1love
 *
 */
public class TestScanner {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入名字；");
		String name = scanner.nextLine();
		System.out.println("请输入你的爱好：");
		String favor = scanner.nextLine();
		System.out.println("请输入你的年龄:");
		int age = scanner.nextInt();
		
		System.out.println("####################");
		System.out.println(name);
		System.out.println(favor);
		System.out.println(age);
		
	}

}

Java不采用通常语言使用的ASCII字符集，而是采用Unicode这样标准的国际字符集。因此，这里字母的含义不仅仅是英文，还包括汉字等等。但是不建议大家使用汉字来定义标识符！ ↩︎

kobeno1love

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
023_046 第二章数据类型和计算

懒人目录1.注释2.标识符3.关键字/保留字4.变量5.常量6.基本数据类型（primitive data type）1.注释目的：方便阅读，提高可读性。处理：Java编译器编译时自动跳过注释语句。（注释不会出现在字节码文件中）分类：单行注释、多行注释和文档注释。单行注释：使用“//”开头，“//”后面的单行内容均为注释。多行注释：以“/* ” 开头以 “ * /”结尾，在“/* ...
复制链接

扫一扫