Java面向对象程序开发实战（二）

第二章   数据类型与运算符

 

2.1.1　　变量的命名

在Java中，标识符常用来为程序中的常量、变量、方法、类、接口和包命名。

1.标识符的命名规则

>标识符由字母、数字、下划线（——）或美元符号（$）组成。

>标识符的首字母以字母、下划线或美元符号开头，不能以数字开头。

>标识符的命名不能与关键字、布尔值（true、false)和null相同。

>标识符区分大小写，没有长度限制，坚持见名知义的原则。

2.关键字

关键字是Java语言保留的，为其定义了固定含义的特殊标识符。

注意：关键字全部为小写字母，程序员不能将关键字定义为标识符，否则会出现编译错误。

Java定义的48个常用关键字。

关键字属于保留字，在 Java 中具有特殊的含义，比如说 public、final、static、new 等等，它们不能用来作为变量名。为了便于你作为参照，我列举了 48 个常用的关键字，你可以瞅一瞅。

1. abstract： abstract 关键字用于声明抽象类——可以有抽象和非抽象方法。

2. boolean： boolean 关键字用于将变量声明为布尔值类型，它只有 true 和 false 两个值。

3. break： break 关键字用于中断循环或 switch 语句。

4. byte： byte 关键字用于声明一个可以容纳 8 个比特的变量。

5. case： case 关键字用于在 switch 语句中标记条件的值。

6. catch： catch 关键字用于捕获 try 语句中的异常。

7. char： char 关键字用于声明一个可以容纳无符号 16 位比特的 Unicode 字符的变量。

8. class： class 关键字用于声明一个类。

9. continue： continue 关键字用于继续下一个循环。它可以在指定条件下跳过其余代码。

10. default： default 关键字用于指定 switch 语句中除去 case 条件之外的默认代码块。

11. do： do 关键字通常和 while 关键字配合使用，do 后紧跟循环体。

12. double： double 关键字用于声明一个可以容纳 64 位浮点数的变量。

13. else： else 关键字用于指示 if 语句中的备用分支。

14. enum： enum（枚举）关键字用于定义一组固定的常量。

15. extends： extends 关键字用于指示一个类是从另一个类或接口继承的。

16. final： final 关键字用于指示该变量是不可更改的。

17. finally： finally 关键字和 try-catch 配合使用，表示无论是否处理异常，总是执行 finally 块中的代码。

18. float： float 关键字用于声明一个可以容纳 32 位浮点数的变量。

19. for： for 关键字用于启动一个 for 循环，如果循环次数是固定的，建议使用 for 循环。

20. if： if 关键字用于指定条件，如果条件为真，则执行对应代码。

21. implements： implements 关键字用于实现接口。

22. import： import 关键字用于导入对应的类或者接口。

23. instanceof： instanceof 关键字用于判断对象是否属于某个类型（class）。

24. int： int 关键字用于声明一个可以容纳 32 位带符号的整数变量。

25. interface： interface 关键字用于声明接口——只能具有抽象方法。

26. long： long 关键字用于声明一个可以容纳 64 位整数的变量。

27. native： native 关键字用于指定一个方法是通过调用本机接口（非 Java）实现的。

28. new： new 关键字用于创建一个新的对象。

29. null： 如果一个变量是空的（什么引用也没有指向），就可以将它赋值为 null。

30. package： package 关键字用于声明类所在的包。

31. private： private 关键字是一个访问修饰符，表示方法或变量只对当前类可见。

32. protected： protected 关键字也是一个访问修饰符，表示方法或变量对同一包内的类和所有子类可见。

33. public： public 关键字是另外一个访问修饰符，除了可以声明方法和变量（所有类可见），还可以声明类。main() 方法必须声明为 public。

34. return： return 关键字用于在代码执行完成后返回（一个值）。

35. short： short 关键字用于声明一个可以容纳 16 位整数的变量。

36. static： static 关键字表示该变量或方法是静态变量或静态方法。

37. strictfp： strictfp 关键字并不常见，通常用于修饰一个方法，确保方法体内的浮点数运算在每个平台上执行的结果相同。

38. super： super 关键字可用于调用父类的方法或者变量。

39. switch： switch 关键字通常用于三个（以上）的条件判断。

40. synchronized： synchronized 关键字用于指定多线程代码中的同步方法、变量或者代码块。

41. this： this 关键字可用于在方法或构造函数中引用当前对象。

42. throw： throw 关键字主动抛出异常。

43. throws： throws 关键字用于声明异常。

44. transient： transient 关键字在序列化的使用用到，它修饰的字段不会被序列化。

45. try： try 关键字用于包裹要捕获异常的代码块。

46. void： void 关键字用于指定方法没有返回值。

47. volatile： volatile 关键字保证了不同线程对它修饰的变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。

48. while： 如果循环次数不固定，建议使用 while 循环。
    
    

使用标识符命名时，遵循见名知义原则和驼峰命名法。

见名知义原则：是指在使用标识符命名时，要使用能反映被定义者的含义或作用的字符。这样，其他人在阅读代码是通过名称就可以对朝鲜有所理解。

eg:定义姓名是使用name、定义年龄时使用age,一看便能知道其代表的含义，是推荐的用法。

驼峰命名法：就是当使用标识符命名时，如果有一个或多个单词连接在一起，第一个单词以小写字母开始，第二个单词及后续每一个单词的首字母都采用大写字母，这样的变量名看上去就像驼峰一样此起彼伏，故因此得名。eg:fileUnti、fileName、dataManager、studentInfo。

 

2.1.2　　Java中的注释

作用：注释是程序开发人员和程序阅读者之间交流的重要手段，是对代码的解释和说明，好的注释可以提高软件的可读性，减少软件的维护成本。

1.单行注释

单行注释指的是只能书写在一行的注释，是最简单的注释类型，用于对代码进行简单的说明。当只有一行内容需要注释时，一般使用单行注释。快捷键：ctrl+/。可以自动产生单行注释。

单行注释的语法格式：

//单行注释

单行注释以“//”开头，“//”后面的内容都被认为是注释。

注意：1.单行注释不会被编译。2.“//” 不能放到被解释代码的前面，否则这行代码会被注释掉。

2.多行注释

多行注释一般用于说明比较复杂的内容，如复杂的程序逻辑和算法的实现原理等。当有多行内容需要被注释时，一般使用多行注释。快捷键：ctrl+shift+/。可以生成多行注释。

多行注释的语法格式：

/*

*个人简历信息输出

*/

>多行注释以“/*”开头，以“*/”结尾。

>“/*”和“*/”之间的内容都被认为是注释。

提示：注释简单来说就是一种说明，不能被当做语句执行、即可以增强代码的可读性，又可以为自己理清思路。

3.文档注释

如果想为程序生成像官方API帮助文档一样的文件，可以在编写代码时使用文档注释。使用JDK提供的javadoc命令，将代码中的文档注释提取出来，可自动生成一份HTML格式的API帮助文档，其风格与官方API帮助文档完全一样，省去了枯燥、繁琐的手动编写帮助文档的工作。

 输入/** ,点击“Enter”，自动根据参数和返回值生成注释模板.

文档注释的语法格式如下：

/**

*文档注释

*/

>文档注释以“/**”开头，以“*/”结尾。

>每个注释包含一些描述性的文本及若干个文档注释标签。

>文档注释标签一般以“@”为前缀。

常用Java注释标签（Java comment tags）

@author  作者

适用范围：文件、类、方法

（多个作者使用多个@author标签标识，java doc中显示按输入时间顺序罗列。）

例： @author Leo. Yao

 

@parameter  输入参数的名称  说明

适用范围：方法

例：* @param str the String用来存放输出信息。

 

@return 输出参数说明

适用范围：方法

例：     * @return    <code>true</code>执行成功;

                   <code>false</code>执行失败.

@since JDK版本

用于标识编译该文件所需要的JDK环境。

适用范围：文件、类

例：     @since JDK1.6

 

@version 版本号

用于标识注释对象的版本号

适用范围：文件、类、方法

例：     * @version 1.0

@throws 异常

标识出方法可能抛出的异常

适用范围：方法

 

2.1.3　　数据类型

1.Java中的数据类型

Java是强类型语言，在定义变量前需要声明数据类型，在Java中主要分为两种数据类型：基本数据类型和引用数据类型。

 

（1）基本数据类型用于存储简单类型的数据，比如说，int、long、byte、short 用于存储整数，float、double 用于存储浮点数，char 用于存储字符，boolean 用于存储布尔值。

 

不同的基本数据类型，有不同的默认值和大小，来个表格感受下。

 

数据类型	默认值	大小
boolean	false	1比特
char	'\u0000'	2字节
byte	0	1字节
short	0	2字节
int	0	4字节
long	0L	8字节
float	0.0f	4字节
double	0.0	8字节

8种基本类型 

一、4种整型 
    byte      1字节           -128——127 

    short     2 字节         -32,768 —— 32,767 

    int       4 字节          -2,147,483,648 ——2,147,483,647（超过20亿） 

    long      8 字节   -9,223,372,036,854,775,808——9,223,372,036854,775,807 

    注释：java中所有的数据类所占据的字节数量与平台无关，java也没有任何无符号类型 

二、 2种浮点类型 
    float    4 字节         32位IEEE 754单精度（有效位数 6 – 7位） 

    double   8 字节         64位IEEE 754双精度（有效位数15位） 

三、1种Unicode编码的字符单元 
    char    2 字节          整个Unicode字符集 

四、1种真值类型 
boolean    1 位             True或者false 

 

 

（2）引用数据类型用于存储对象（null 表示没有值的对象）的引用，String 是引用类型的最佳代表，比如说 String name = "张三"。

 

3种引用类型 

类class 

接口interface 

数组array 

一、类Class引用 

可以是我们创建的，这里我不多讲，主要是讲解几个java库中的类 

Object ：Object是一个很重要的类，Object是类层次结构的根类，每个类都使用Object作为超类，所有对象（包括数 

               组）都实现这个类的方法。用Object可以定义所有的类 

              如： 

              Object object= new Integer(1); 来定义一个Interger类 

               Integer i=(Integer) object;     在来把这个Object强制转换成Interger类 

String ：String类代表字符串，Java 程序中的所有字符串字面值（如"abc"）都作为此类的实例来实现。检查序列的单 

               个字符、比较字符串、搜索字符串、提取子字符串、创建字符串副本、在该副本中、所有的字符都被转换为                      大 写或小写形式。 

Date ：Date表示特定的瞬间，精确到毫秒。Date的类一般现在都被Calendar 和GregorianCalendar所有代替 

Void ：Void 类是一个不可实例化的占位符类，它保持一个对代表 Java 关键字 void 的 Class 对象的引用。 

同时也有对应的Class如：Integer  Long  Boolean  Byte  Character  Double  Float   Short 

二、接口interface引用 

可以是我们创建的，这里我不多讲，主要是讲解几个java库中的接口interface 

List<E>：列表 ，此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引 

（在列表中的位置）访问元素，并搜索列表中的元素。List 接口提供了两种搜索指定对象的方法。从 

性能的观点来看，应该小心使用这些方法。在很多实现中，它们将执行高开销的线性搜索。 List 接 

口提供了两   种在列表的任意位置高效插入和移除多个元素的方法。 

add() : 在列表的插入指定元素。 

remove()：移除列表中指定位置的元素。 

             get(int index)：返回列表中指定位置的元素。 



Map<K,V>： 

K - 此映射所维护的键的类型 

V - 映射值的类型 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。 

put(K key,V value)：将指定的值与此映射中的指定键关联（可选操作）。如果此映射以前包含一个该键的  

                   映  射 关系，则用指定值替换旧值（当且仅当，返回 true 时，才能说映射 m 包含键 k 的映射关系）。  remove(Object key)如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。更确切地讲，如果此 映射包含从满足(key==null ? k==null :key.equals(k))的键 k 到值 v 的映射关系，则移除该映射关系。（该映                        射最多只能包含一个这样的映射关系。） get(Object key)：返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。 

这里我们主要是用String List Map Object 是最常用Number ArrayList<E> Arrays等 

可以查考jdk的api 

这些类和接口在 

java.lang ：提供利用 Java 编程语言进行程序设计的基础类。 

和 

java.unit：包含 collection 框架、遗留的 collection 类、事件模型、日期和时间设施、国际化和各种实用工具类（字                         符串标记生成器、随机数生成器和位数组）。

 

2.常量

Java中的常量指在程序运行中值不能改变的量。

 

Java常量是什么？

 

JAVA常量就是在程序中固定不变的值，是不能改变的数据。例如数字1、字符“a”、浮点数3.2等。在Java中，常量包括整型常量、浮点数常量、布尔常量、字符常量等。

 

1、整型常量

 

整型常量是整数类型的数据，有二进制、八进制、十进制和十六进制4种表示形式具体表示形式如下。

 

二进制：由数字0和1组成的数字序列。在JDK7.0中允许使用字面值来表示二进制数，前面要以0b或0B开头，目的是为了和十进制进行区分，如0b01101100、0B10110101。

 

八进制：以0开头并且其后由0~7范围内(包括0和7)的整数组成的数字序列，如0342。

 

十进制：由数字0~9范围内(包括0和9)的整数组成的数字序列。如198。

 

十六进制：以0x或者0X开头并且其后由0~9、A~F(包括0和9、A和F)组成的数字序列，如0x25AF。

 

需要注意的是，在程序中为了标明不同的进制，数据都有特定的标识，八进制必须以0开头，如0711，0123;十六进制必须以0x或0X开头，如0xaf3、0Xff;整数以十进制表示时，第一位不能是0，0本身除外。例如十进制的127，用二进制表示为011111八进制表示为017，用十六进制表示为0x7F或者0X7F。

 

 

2、浮点数常量

 

浮点数常量就是在数学中用到的小数，分为foat单精度浮点数和double双精度浮点数两种类型。其中，单精度浮点数后面以F或f结尾，而双精度浮点数则以D或d结尾。当然，在使用浮点数时也可以在结尾处不加任何的后缀，此时虚拟机会默认为double双精度浮点数。浮点数常量还可以通过指数形式来表示。具体示例如下：

 

1	2e3f 3.6d 0f 3.84d 5.022e+23f

 

3、字符常量

 

字符常量用于表示一个字符，一个字符常量要用一对英文半角格式的单引’’号引起来，它可以是英文字母、数字、标点符号以及由转义序列来表示的特殊字符。具体示例如下：

 

1	‘a’ ‘1’ ‘&’ ‘\r’ ‘\u0000’

 

上面的示例中，’\u00’表示一个空白字符，即在单引号之间没有任何字符。之所以能这样表示，是因为Java采用的是Unicode字符集，Unicode字符以\u开头，空白字符在Unicode码表中对应的值为’\u0000’。

 

4、字符串常量

 

字符串常量用于表示一串连续的字符，一个字符串常量要用一对英文半角格式的双引号””引起来，具体示例如下：

 

1	“HelloWorld" “123" "We come \n XXX" "”

 

一个字符串可以包含一个字符或者多个字符，也可以不包括任何字符，即长度为零。

 

5、布尔常量

 

布尔常量即布尔型的两个值true和false，该常量用于区分一个事物的真与假。

 

6、null常量

 

null常量只有一个值null，表示对象的引用为空。

 

3.变量

变量是在程序运行中其值可以改变的量，它是Java程序的一个基本存储单元。

变量的语法格式：

[访问修饰符] 变量类型 变量名 [=初始值]；

>"变量类型"可从数据类型中选择。

>“变量名”是定义的名称变量，要遵循标识符命名规则。

>中括号中的内容为初始值，是可选项。

 

4.数据类型转换

不同的基本数据类型之间进行运算时需要进行类型转换，除布尔类型外，所有基本数据类型进行运算时都要考虑类型转换，主要应用在算数运算时和赋值运算时。

 

彻底理解Java中的基本数据类型转换（自动、强制、提升）

自动类型转换

自动类型转换是指：数字表示范围小的数据类型可以自动转换成范围大的数据类型。

如：

long l = 100;

int i = 200;
long ll = i;

具体自动转换如如下图所示。

实线表示自动转换时不会造成数据丢失，虚线则可能会出现数据丢失问题。

自动转换也要小心数据溢出问题，看下面的例子。

int count = 100000000;
int price = 1999;
long totalPrice = count * price;

编译没任何问题，但结果却输出的是负数，这是因为两个 int 相乘得到的结果是 int, 相乘的结果超出了 int 的代表范围。这种情况，一般把第一个数据转换成范围大的数据类型再和其他的数据进行运算。

int count = 100000000;
int price = 1999;
long totalPrice = (long) count * price;

另外，向下转换时可以直接将 int 常量字面量赋值给 byte、short、char 等数据类型，而不需要强制转换，只要该常量值不超过该类型的表示范围都能自动转换。

强制类型转换

强制类型转换我们再清楚不过了，即强制显示的把一个数据类型转换为另外一种数据类型。

如：

short s = 199;
int i = s;// 199

double d = 10.24;
long ll = (long) d;// 10

以上的转换结果都在我们的预期之内，属于正常的转换和丢失精度的情况，下面的例子就一样属于数据溢出的情况。

int ii = 300;
byte b = (byte)ii;

300 已经超出了 byte 类型表示的范围，所以会转换成一个毫无意义的数字。

类型提升

所谓类型提升就是指在多种不同数据类型的表达式中，类型会自动向范围表示大的值的数据类型提升。

把上面的溢出的例子再改下。

long count = 100000000;
int price = 1999;
long totalPrice = price * count;

price 为 int 型，count 为 long 型，运算结果为 long 型，运算结果正常，没有出现溢出的情况。

提示：不仅基本数据类型可以进行类型转换，存在继承关系的引用数据类型也可以进行自动类型转换和强制类型转换。

Java Scanner类的方法及用法

Scanner类简介

Java 5添加了java.util.Scanner类，这是一个用于扫描输入文本的新的实用程序。它是以前的StringTokenizer和Matcher类之间的某种结合。由于任何数据都必须通过同一模式的捕获组检索或通过使用一个索引来检索文本的各个部分。于是可以结合使用正则表达式和从输入流中检索特定类型数据项的方法。这样，除了能使用正则表达式之外，Scanner类还可以任意地对字符串和基本类型(如int和double)的数据进行分析。借助于Scanner，可以针对任何要处理的文本内容编写自定义的语法分析器。

Scanner类的常用方法1

其实上图的意思就是，比如：nextlnt():只读取int值，就是只能读取整数类型的数据，如果输入了非整型的数据（浮点型字符串等）就会报错。
nextFloat（）、nextDouble（）这些也是以此类推，只能读取符合该类型的数据。

此处重点讲一下next()和nextLine()的区别

next():只读取输入直到空格。它不能读两个由空格或符号隔开的单词。此外，next()在读取输入后将光标放在同一行中。(next()只读空格之前的数据,并且光标指向本行)

nextLine():读取输入，包括单词之间的空格和除回车以外的所有符号(即。它读到行尾)。读取输入后，nextLine()将光标定位在下一行。

代码演示：

public class Text {
	public static void main(String []args) {
		Scanner input = new Scanner(System.in);
		System.out.println("请输入一个字符串(中间能加空格或符号)");
		String a = input.nextLine();
		System.out.println("请输入一个字符串(中间不能加空格或符号)");
		String b = input.next();
		System.out.println("请输入一个整数");
		int c;
		c = input.nextInt();
		System.out.println("请输入一个double类型的小数");
		double d = input.nextDouble();
		System.out.println("请输入一个float类型的小数");
		float f = input.nextFloat();
		System.out.println("按顺序输出abcdf的值：");
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
		System.out.println(f);
	}
}

运行结果：

请输入一个字符串(中间能加空格或符号)
我爱祖国！
请输入一个字符串(中间不能加空格或符号)
ILoveChina
请输入一个整数
520
请输入一个double类型的小数
12.26e3
请输入一个float类型的小数
3.1415926
按顺序输出abcdf的值：
我爱祖国！
ILoveChina
520
12260.0
3.1415925

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16

Scanner类的常用方法2

代码演示：

public class inputInformation {
	public static void main(String args[]) {
		Scanner scan = new Scanner(System.in);	//构造Scanner类的对象scan，接收从控制台输入的信息
		System.out.println("请输入你的姓名");
		String name = scan.nextLine();//接收一个字符串，可以加除Enter以外的所有符号，包括空格和Tab
		System.out.println("请输入你的ID");
		String ID ;
		while(scan.hasNextLine()) {// hasNextLine()方法判断当前是否有输入，当键盘有输入后执行循环
			if(scan.hasNextInt()) {// 判断输入的值是否为整数类型，当为整数类型时执行循环
				ID = scan.nextLine();
				System.out.println("你输入的姓名为："+name);
				System.out.println("你输入的ID为："+ID);
				break;
			}else {
				System.out.println("请输入数字哦！");
				ID = scan.nextLine();
				continue;
			}
		}
	}
}

运行结果如下：

请输入你的姓名
西地那非
请输入你的ID
q764323221
请输入数字哦！
764323221


2.2.1　　常用运算符

运算符是一种“功能”符号，用以通知 Java 进行相关的运算，Java 语言中常用的运算符可分为如下几种：

算数运算符、赋值运算符、比较运算符、逻辑运算符、条件运算符。

一、算数运算符

Java 中常用的算术运算符：加法    +          求余    %

                                    减法    -           自增1   ++

                                    乘法    *           自减1   --

                                    除法    /

其中，自增和自减运算符只能用于操作变量，不能直接用于操作数值或常量。例如 5++ 、 8-- 等写法都是错误的。且++ 和 -- 既可以出现在操作数的左边，也可以出现在右边，但结果是不同滴。

例子1：int a=6;                                                                   例子2：int a=6;

          int b=++a;//先让a执行自增，在将值赋给变量b                           int b=a++;  //先将值赋给变量b，然后在执行自增

          System.out.println(“a=”+a);                                                System.out.println(“a=”+a);

          System.out.println("b="+b);       输出结果：a=6,b=6              System.out.println("b="+b);       输出结果：a=6,b=5

二、赋值运算符

赋值运算符是指为变量或常量指定数值的符号。如可以使用 “=” 将右边的表达式结果赋给左边的操作数。

Java 支持的常用赋值运算符，如下表所示：

三、比较运算符

比较运算符用于判断两个数据的大小，例如：大于、等于、不等于。比较的结果是一个布尔值（ true 或 false ）。

Java 中常用的比较运算符如下表所示：

注意：

1、  > 、 < 、 >= 、 <= 只支持左右两边操作数是数值类型

2、  == 、 != 两边的操作数既可以是数值类型，也可以是引用类型

例子：

  int a=16;
  double b=9.5;
  String str1="hello";
  String str2="imooc";
  System.out.println("a等于b：" + (a == b) );                  运行结果：a等于b:false
  System.out.println("a大于b：" + (a > b) );                                   a大于b：true
  System.out.println("a小于等于b：" + (a <= b) );                           a小于等于b：false
  System.out.println("str1等于str2：" + (str1 == str2) );                 str1等于str2：false

四、逻辑运算符

逻辑运算符主要用于进行逻辑运算。Java 中常用的逻辑运算符如下表所示：

注意：当使用逻辑运算符时，我们会遇到一种很有趣的“短路”现象。

比如：( one > two ) && ( one < three ) 中，如果能确定左边 one > two 运行结果为 false , 则系统就认为已经没有必要执行右侧的 one < three 啦。

同理，在( one > two ) || ( one < three ) 中，如果能确定左边表达式的运行结果为 true , 则系统也同样会认为已经没有必要再进行右侧的 one < three 的执行啦！

五、条件运算符

条件运算符（ ? : ）也称为 “三元运算符”。

语法形式：布尔表达式 ？ 表达式1 ：表达式2

运算过程：如果布尔表达式的值为 true ，则返回 表达式1 的值，否则返回 表达式2 的值

例子：String str=(8>5)? "8大于5”：“8不大于5”

        System.out.println(str);                           运行结果：8大于5

六、运算符的优先级

所谓优先级，就是在表达式中的运算顺序。Java 中常用的运算符的优先级如下表所示：