Java数据类型总结

1.1.1 数据类型初阶

1、JAVA定义了基本数据类型、引用数据类型和自定义类型。

2、基本数据类型：

类型	占用空间	取值范围
byte（字节性）	1字节
short（短整型）	2字节
int（整形）	4字节
long（长整型）	8字节
float（单精度）	4字节
double（双精度）	8字节
char（字符型）	1字节
boolean（布尔型）	1或4字节	float,true

3、计算机存储数据分为以下三种空间类型：寄存器，栈空间，堆空间

• Java不能直接控制和处理寄存器空间，能直接控制和处理的是栈空间和堆空间
• Java虚拟机为每一个运行在内存中Java程序都分配相应的栈空间和堆空间

4、栈空间

• 栈空间存储数据的效率高
• 栈中的数据按“先进后出”的方式管理，即先进入栈空间的数据放在下面，后进入栈空间的数据放在上面，出栈的时候后进入栈空间的数据先出栈，先进入栈空间的数据后出栈。
• 栈空间存储空间较小，不能存放大量的数据。

5、堆空间

• 堆空间存放数据效率最低
• 数据存放的位置随机分配
• 堆空间存储数据的空间大，能存放大容量的数据。包括：数组，字符串，对象和集合的大数据。

1.1.2 什么是变量和为什么使用变量

• 变量就是可变的量（数据可随时修改）
• 常量就是不可变的量（常量中的数据只有一次赋值，以后只能使用不能修改）
• 字面量：Java的变量和常量中存放的具体的数据称为字面量。
  eg：整形的字面量有1,2,3,4,5，字符串的自变量有a,b,c。

为什么使用变量?

答：计算机的高级语言普遍使用变量来管理内存中的存储数据。
[外链图片转存失败(img-WV96rKnQ-1564108637948)(https://raw.githubusercontent.com/1021859082/Image-Hosting/master/jikexueyuan/Andorid/为什么使用变量.png)]

变量管理引用类型的数据

[外链图片转存失败(img-8eNOCZbS-1564108637949)(https://raw.githubusercontent.com/1021859082/Image-Hosting/master/jikexueyuan/Andorid/变量管理引用类型的数据示意图.png)]

1.1.3 变量的命名、定义和初始化

1、变量的命名

• 首字母是英文字母，$或下划线，由字母、数字、下划线组成；
• 变量的命名遵循见名知义的原则；
• Java变量名不用中文；
• 变量名首字母建议不用大写字母；
• 用驼峰命名法命名多个单词组成的变量名，例如：sumScore；
• 变量名不要使用Java关键字。

2、定义变量

每个变量必须属于一种数据类型。

类型　变量名1,变量2，······，变量n；

示例：

byte score; //保存单科分数
short age; //保存年龄
int sumScore; //保存总分
long fileSize; //保存文件长度
float x,y;
double result; //保存运算结果
char sex; //保存性别
boolean isContinue; //表示是否继续
String name;

3、变量的初始化

age=23;
score=70+5;
i=10/5;
result=Math.pow(2,5)+3.5;
sex='男';
isContinue=true;
name="张"+"大飞";

1.1.4 如何使用变量（一）：用变量简化计算

【示例-1】保存中间结果，用分步骤计算简化复杂运算

计算
(sqrt(20)+sqrt(10)/sqrt(20)-sqrt(10))=

要求：显示结果保留小数点后1位，即对小数点后第2位四舍五入。运算结果如下图所示：

[外链图片转存失败(img-IFPwn3Hu-1564108637950)(https://raw.githubusercontent.com/1021859082/Image-Hosting/master/jikexueyuan/Andorid/运算结果.png)]

code:

package com.jikexueyuan.ch01;

public class Text01 {
	public static void main(String[] args) {
//		((sqrt(20)+(sqrt(10))/((sqrt(20)-(sqrt(10))
		//使用变量输出
		
		double sqrt20=Math.sqrt(20);
		double sqrt10=Math.sqrt(10);
		double result=(sqrt20+sqrt10)/(sqrt20-sqrt10);
		result=Math.round(10*result)/10.0;
		System.out.println("((sqrt(20)+(sqrt(10))/((sqrt(20)-(sqrt(10))="+result);
		
		//直接公式输出
		System.out.println("((sqrt(20)+(sqrt(10))/((sqrt(20)-(sqrt(10))="+
				Math.round(10*(Math.sqrt(20)+Math.sqrt(10))/(Math.sqrt(20)-Math.sqrt(10)))/10.0);
	}
}

1.1.5 如何使用变量（二）：用变量保存多种类型的数据

【示例-2】不同类型的变量存放对应类型的数据，变量的值可以该改变。

[外链图片转存失败(img-ugnyUL0L-1564108637950)(https://raw.githubusercontent.com/1021859082/Image-Hosting/master/jikexueyuan/Andorid/运算结果2.png)]

code:

package com.jikexueyuan.ch02;

public class Text02 {
	public static void main(String[] args) {
		String name = "张飞";
		short age = 35;
		char sex = '男';
		String type = "豪放";
		System.out.println("嗨，大家好！俺叫"+name+",今年"+age+"岁，俺是一个"+type+"的"+sex+"士");
		
		name = "王菲";
		age = 32;
		sex = '女';
		type = "文静";
		System.out.println("嗨，大家好！俺叫"+name+",今年"+age+"岁，俺是一个"+type+"的"+sex+"士");
	}
}

作业：

code:

package com.jikexueyuan.practice;

public class Practice01 {
	public static void main(String[] args) {
		String brand = "小米";
		String system = "android";
		short cores = 2;
		float price = 1999.0f;
		String explanation = "手机品牌：";
		System.out.println(explanation+brand);
		explanation = "操作系统：";
		System.out.println(explanation+system);
		explanation = "CPU数：";
		System.out.println(explanation+cores);
		explanation = "价格：";
		System.out.println(explanation+price);
	}
}

1.1.6 变量的作用域

1. Java用一对大括号作为语句块的范围，称为作用域。
2. 作用域中的变量不能重复定义。
3. 离开作用域，变量所分配的内存空间将被JVM回收。

1.1.7 基本数据类型的包装类

Java为基本数据类型提供了对应的类，这些类称作包装类。如下表所示：

包装类的类型	说明
Byte类	byte类型的包装类
Short类	short类型的包装类
Integer类	int类型的包装类
Long类	long类型的包装类
Float类	float类型的包装类
Double类	double类型的包装类
Character类	char类型的包装类
Boolean	boolean类型的包装类

为什么要使用包装类？

1. 包装类封装了一些很使用的方法和变量。例如Byte.MIN_VALUE是Byte类中的一个常量，存放了byte类型数据的最小值。
2. 包装类在集合中用来定义集合元素的类型。

包装类的常用方法和常量

Integer包装类：

1. Integer.MIN_VALUE：int类型的最小值：-2^³¹
2. Integer.MAX_VALUE：int类型的最大值：2^³¹-1
3. int　Integer.parseInt(Stringslnteger);
   　作用：讲字符串类型的整数转换为int类型的数据。
4. String　Integer.toBinaryString(int value);
   　作用：将十进制数转换为二进制，返回结果String类型。
5. String　Integer.toHexString(int value);
   　作用：讲十进制数转换为十六进制，返回结果String类型。

Long包装类：

1. Long.MIN_VALUE：long类型的最小值
2. Long.MAX_VALUE：long类型的最大值
3. long　Long.parseLong(String sLong);
   　作用：将字符型类型的整数转换为long类型的数据。
4. String　Long.toBinaryString(long value);
   　作用：讲十进制数转换为对应的二进制数，该方法返回的结果是String类型。
5. String　Long.toHexString(long value);
   　作用：讲十进制数转换为十六进制，返回结果String类型。

Double类

1. Double.MAX_VALUE：double类型的最大值
2. Double.MIN_VALUE：double类型的最小值
3. double　Double.parseDouble(String sDouble);
   　作用：将字符串类型的浮点数转换为double类型的数据。

实现方式：

package com.lenovo.text;

public class Text01 {
	public static void main(String[] args) {
		
		//Integer包装类
		//输出int类型最小值和最大值
		System.out.println(Integer.MIN_VALUE+"~"+Integer.MIN_VALUE);
		//将字符串类型的整形转换为int类型的数据
		System.out.println(Integer.parseInt("12"));
		//将十进制转换为二进制，返回结果为String类型
		System.out.println(Integer.toBinaryString(16));
		//将十进制转换为十六进制，返回结果为String类型
		System.out.println(Integer.toHexString(16));
		
		//Long包装类
		//输出long类型的最小值和最大值
		System.out.println(Long.MIN_VALUE+"~"+Long.MAX_VALUE);
		//将字符型类型的整数转换为long类型的数据
		System.out.println(Long.parseLong("51"));
		//将十进制转换为二进制，返回结果为String类型
		System.out.println(Long.toBinaryString(16));
		//将十进制转换为十六进制，返回结果为String类型
		System.out.println(Long.toHexString(16));
		
		//Double包装类
		//输出Double类型的最小值和最大值
		System.out.println(Double.MIN_VALUE+"~"+Double.MIN_VALUE);
		//将字符串类型的浮点数转换为double类型的数据
		System.out.println(Double.parseDouble("15.6"));
	} 
}

运行结果：

1.1.8 二进制补码

1. 计算机系统的内部以二进制形式存储数据
2. 在Java程序中输入的十进制的数据都会被自动转换为二进制，Java内部也都会以二进制进行数值运算，但返回的结果是十进制。

补码规则

1. 在计算机系统中，数值一律用二进制的补码来存储。
2. 二进制的最高位是符号位，0表示正数，1表示负数。
3. 整数的值是其本身，负数的值是最高位（符号位）不变，其它位逐位取反，再加1。 (进制转换参考表格)
   例如：(1101)₂
   　　　 0010　逐位取反
   　　 　0011　加1
   　　　(1101)₂=-3
4. 两数相加，若最高位（符号位）有进位，则进位被舍弃。

为什么使用补码

1. 可以将符号位和其他位统一处理；
2. 最高位不再表示数值，而是作为符号位，正好将数值折半，即一半是0至正数，一半是负数。
   例如：

• 4位二进制数共有16个数，用补码表示，则一半是0-7，一半是-1~-8。
• 8位二进制数共有256个数，用补码表示，则一半是0~127，一半是 -1~-128.

3. 减法也可按加法来运算：
   例如：7-3，可以表示为7+(-3),二进制表示为：
   　０１１１　　７
   ＋１１０１　－３
   —————————　　
   　０１００　　４

补码运算的特征

1. 计算机中正数和负数的关系是取反加一。
   【示例】：在四位二进制数中，已知3的二进制值是0011，若要求-3，则
   　　００１１　　３
   　　１１００　　逐位取反
   　　１１０１　　＋１
   　　　则－３的二进制值是１１０１
2. 补码运算是封闭的：运算结果保留在补码范围之内，超范围就溢出。
   【示例】四位二进制的补码运算中，请计算5+4的结果。
   　０１０１　　５
   ＋０１００　　４
   —————————
   　１００１　－７
3. 4位二进制补码最多能表示2⁴(16)个数，数的范围是-8~7
4. 8位二进制补码最多能表示2⁸(256)个数，数的范围是-128~127
5. 16位二进制补码最多能表示2¹⁶(65536)个数，数的范围是-32768~32767
6. 32位二进制补码最多能表示2³²个数，数的范围是-2³¹~2³¹-1

补码运算的原理

正数+负数=模
模：某种类型数据的总数，例如：

• 4位二进制数的模是2⁴=16
• 8位二进制数的模是2⁸=256
• 16位二进制数的模是2¹⁶=65536
• 32位二进制数的模是2³²

【示例】在4位二进制中，7+(-7)=16
　００１１
＋１００１
—————————
１００００

因此，负数=模-正数，这就是逐位取反加1的原因。
　　-7=16-7
　１００００
－００１１１
———————
　０１００１

1.1.9 数据类型进阶：整数类型

1. Java有四种整数类型：byte、short、int和long。
2. Java默认整数计算的结果是int类型。
3. 整数的字面量是int类型。
4. 若字面量超过int类型的最大值，则字面量是long类型，那么后面要用L（或l）表示该值是long类型。
   【示例】将字面量30亿赋值给一个long类型的变量：
   long longValue=3000000000L;
5. Java底层byte和short按照32位(int类型)计算。

【示例1】

[外链图片转存失败(img-3bXE3oVA-1564108637951)(https://github.com/1021859082/Image-Hosting/blob/master/Text07（1）.png?raw=true)]
报错分析：由于Java运算保存结果为int类型，由于b2被定义为byte类型，因此会报错。
修改意见：
1.添加强制类型转换运算符"byte()"。

2.改变b2的数据类型为int类型。
[外链图片转存失败(img-Rontos1j-1564108637952)(https://raw.githubusercontent.com/1021859082/Image-Hosting/master/jikexueyuan/Andorid/Text07（2）.png)]

【示例2】

[外链图片转存失败(img-RzDoDaEC-1564108637953)(https://raw.githubusercontent.com/1021859082/Image-Hosting/master/jikexueyuan/Andorid/Text07（3）.png)]

【示例3】

[外链图片转存失败(img-anA737Np-1564108637953)(https://raw.githubusercontent.com/1021859082/Image-Hosting/master/jikexueyuan/Andorid/Text07（4）.png)]

1.1.10 数据类型进阶：浮点类型

1. 浮点类型用于表示小数的数据类型。
2. 浮点数原理：也就是二进制科学计数法。
3. Java的浮点类型有float和double两种。
4. Java默认浮点类型计算的结果是double类型，字母量也就是double类型。
   若要给float类型的变量赋字面量的值，则要在字面量后面加F（或f）
   【示例】float f=5.3；将会出现编译错误，正确的赋值是：float f=5.3f;

浮点类型的科学计数法

1. 十进制浮点数科学计数法： 219345 = 2.19345*(10^5)
2. 二进制浮点数科学计数法：10111 = 1.0111*(2^100)
   以2.19345*(10^5)为例介绍如下概念：
   尾数：2.19345
   指数：5
   基数：10

float类型

1. float类型共32位，1位为符号位，指数8位，尾数23位。
2. float的精度是32位（既能精确表达23位的数，超过就被截取了）。
   小数是尾数长度来表示精确度的，比如pi=3.1415的精度是4位。
3. float存储数据的范围大于int类型，但精度比int要小，因为int精度是31位。

double类型

1. double类型，1位符号位，11位指数，52位尾数。
2. double范围远远大于long，但double精度不如long（long存储数据的位数是63位）。

浮点运算的特点

浮点运算就是实数运算，由于计算机只能存储整数，所以实数就是约数，这样浮点运算很慢的而且会有误差。

【示例】浮点运算误差，如下代码所示:

结论：

1. 浮点运算时是以约数进行运算的，因此在做数值运算时，尽量使用整形运算，这样运算精确度高，速度快。
2. 在进行浮点值的比较时，一定不要使用"="进行运算，比较时要使用范围值进行比较。（→分之结构）

1.1.11 数据类型进阶：字符类型

1. char类型的字面量可以是一个英文字母、字符或一个汉字，并且由单引号包括。
   例如：‘A’ ‘3’ ‘a’ ‘\n’
2. Java底层使用一个16位的整数来处理字符类型，该数值是一个字符的Unicode编码值。

Unicode编码

1. Unicode编码是全球范围内的编码方法。
2. Unicode编码的英文部分与ASC||码兼容(ASC||表示范围0~128)，同时英文字符和数字是连续编码的。
3. Java在处理char类型的数据时，在底层是按Unicode码来处理的。
4. 编码是什么？
   计算机硬件系统只能用0和1表述数，我们人为地做了规定，某个数还可以表示一个字符。
   例如：65表示的字符是A

【示例1】编写Java代码在控制台打印出Unicode码从0~127的所有字符：

public class Text10 {
	public static void main(String[] args) {
		for(int i=0;i<=127;i++) {
			System.out.println((char)i+"="+i);
		}
	}
}

1.1.12 数据类型进阶：转义符

转义字符是"/"，通过转义字符，可表示一些特殊的字符。
例如：

• \n表示回车
• \t表示制表位字符，一个制表符表示向右跳8-10个字符
• \\n表示\
• \'表示单引号
• \"表示双引号
• \u4e2d表示Unicode编码对应的字符（汉字：中）。（4e2d位16进制）

【示例】

package com.jikexueyuan.ch02;

public class Text11 {
	public static void main(String[] args) {
		System.out.print('\u4e2d'+":");
		System.out.println(4*Math.pow(16, 3)+14*Math.pow(16, 2)+2*16+13);
		System.out.println((char)20013+":20013");
		System.out.println("我和\n你不在一行呦");
		System.out.println("\t我在这里显示呦");
		System.out.println("System.out.println(\"双引号也显示出来啦\")");
	}
}

运行结果：

1.1.13 数据类型进阶：布尔类型

1. 什么是布尔类型？
   Boolean类型用来表示肯定或否定两种可能。
2. 为什么使用布尔类型？
   布尔类型常用在分支语句、循环语句中。
3. Boolean类型的值有两个：

• true：表示肯定意义
• false： 表示否定意义

4. 布尔变量的定义
   boolean isPass;
5. 布尔变量的初始值
   boolean isPass=true;
   isPass=59>=60;

1.1.14 小类型向大类型转换

不同的类型的数据经常出现相互转换的现象
例如：
　byte b1=5;
　byte b2=b1+10;

小类型向大类型的转换

1. 小类型向大类型的转换会自动完成，即不需要程序员编写额外的代码，由JVM负责。
   提示：自动类型转换也叫“隐式类型转换”。
2. 自动转换的规则：符号位会自动扩展，负数补1，正数补0。
3. 自动类型转换包含以下情况：
   (1)byte→short→int→long→float→double
   (2)int和char类型的数据在某些情况下可以自动相互转换。
4. 整数到浮点数转换会损失精确度。

1.1.15 小类型向大类型转换（2）

1. 小类型向大类型转换一般是安全的。
2. 当小类型的精度高于大类型时要注意精度丢失的风险。

1.1.16 大类型向小类型转换

1. 大类型向小类型转换称为强制类型转换，简称强转。
   例如：

byte b=5;
b=(byte)(b+10);
b=%+10//无需类型转换  
//Java对于明显能得出结果的运算，在编译期间直接进行计算

强制类型转换语法：(要转换的类型的关键字)转换类型

2. 强制类型转换时，要注意边界数风险问题

---

【示例1】大类型转换小类型时，源数据的数据位变为目标数据的符号位。

int i =129;
byte b =(byte)i; 
//变量b的值时多少？

分析：由于字节型最大值为127，129超出了字节型的最大值，所以要进行补码运算。
补码运算过程：

10000001=129  
01111111 逐位取反加一
-127

【示例2】大类型的数据超过了小类型的位数示例

int i=257;
byte b=(byte)i;
//变量b的值是多少？
1,0000,0001=257

1.1.17 int类型与char类型的转换

Java对char类型的数据在底层是按int类型来处理的。

1. int类型与char类型在赋值时可自动转换

【示例1】

package com.jikexueyuan.ch02;

public class Text15 {
	public static void main(String[] args) {
		char c=65;
		int i='B';
		System.out.println(c+","+i);
	}
}

输出结果：
A,66

2. 字符类型的数据可进行数值计算

【示例2】

package com.jikexueyuan.ch02;

public class Text16 {
	public static void main(String[] args) {
		char c='A';
		int i=c+1;
		c=(char) (c+1);
		System.out.println(c+":"+i);
	}
}

输出结果：B:66

1.1.18 通过args数据获取数据

通过main方法的args数据可以从控制台获取一组字符串数据。

【案例】

package com.jikexueyuan.ch02;

public class Text17 {
	public static void main(String[] args) {
		int a=Integer.parseInt(args[0]);
		int b=Integer.parseInt(args[1]);
		System.out.println(a+"+"+b+"="+(a+b));
		System.out.println(a+"-"+b+"="+(a-b));
		System.out.println(a+"*"+b+"="+(a*b));
		System.out.println(a+"/"+b+"="+(a/b));
	}
}

输入值：
[外链图片转存失败(img-H7adABaw-1564108637954)(https://raw.githubusercontent.com/1021859082/Image-Hosting/master/jikexueyuan/Andorid/1.1.18.png)]

运行结果:

20+5=25  
20-5=15  
20*5=100  
20/5=4

1.1.19 通过Scanner从控制台获取数据

1. Scanner 类用于扫描从控制台输入的数据，可以接收字符串和基本数据类型的数据。
2. Scanner类位于java.util.Scanner包中。

Scanner类的常用方法

1. String next();
   　作用：接收控制台输入的一个字符串。 以空格或回车作为输入的结束，因此不能输入空格作为字符串接受。

2. String nextLine();
   　作用：接收控制台输入的一个字符串。 以回车作为输入的结束，因此可以接受空格作为字符串的一部分。

3. int nexInt();
   　作用：接收控制台输入的一个int类型的数据。

4. double nextDouble();
   　作用：接收控制台输入的一个double类型的数据。

5. boolean nextBoolean();
   　作用：接收控制台输入的一个boolean类型的数据。

6. 输入char类型的数据
   Scanner类没有提供直接输入char类型的方法，可以通过charAt()方法从next()或nextLine()获取输入的字符。

   char String.charAt(int index);
   　作用：从字符串中获取指定下表的字符，下标从0开始。
   　例如：“abc”.chartAt(0)的结果时a.
   　例如：“abc”.charAt(1)的结果是b.
   　例如：next().char(0); 从控制台获取第一个字符。

Scanner类实现步骤

步骤1 创建Scanner类的一个对象
示例： Scanner scanner=new Scanner(System.in);

步骤2 通过scnner调用next等方法，接受控制台输入的数据。
示例:

import java.util.Scanner; //导入Scanner工具包
    public class ScannerT{
        public static void main(String[] args) {
            Scanner s = new Scanner(System.in); //创建Scanner对象
            String str = s.next();  //将控制台的数据返回给Str
            System.out.println(str);    //输出Str中的数据
    }
}

1.1.20 控制台输入数据的案例

【示例】从控制台输入多种类型的数据
通过控制台输入一个人的姓名、性别、年龄、身高和性格，然后让该人和大家做自我介绍。

package com.jikexueyuan.ch02;
import java.util.Scanner;	

//由于eclipse对中文支持不佳，因此预先保留字符串：李逵 粗狂的 男
public class Text18 {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("姓名：");
		String name=scanner.next();
		System.out.println("年龄：");
		int age=scanner.nextInt();
		System.out.println("性别：");
		char sex=scanner.next().charAt(0);
		System.out.println("身高：");
		double height=scanner.nextDouble();
		System.out.println("性格：");
		String type=scanner.next();
		System.out.println("大家好，我是"+name+",我今年"+age+"周岁，我身高"+height+"米,是一名"+type+"的"+sex+"士。");
	}
}

输出结果：

姓名：
李逵
年龄：
30
性别：
男
身高：
1.8
性格：
豪放的
大家好，我是李逵,我今年30周岁，我身高1.8米,是一名豪放的的男士。

1.1.21 变量相关算法：自增、自减、自乘、自除

• 自增是一个变量在原有的基础上再增加指定值。
• 自减是一个变量在原有的基础上再减去指定值。
• 自乘是一个变量在原有的基础上再乘以指定值。
• 自除是一个变量在原有的基础上再除以指定值。

1. 整形变量的自增：

int i=0;
i=i+1;

2. 字符串类型的自增

String space="";
spcae=sppace+" ";

3. 自增运算的简写形式：

1. 先加一：++i

int i=1  
System.out.println(++i)输出结果是2，变量i的值是2
String space="";
space+=" ";

2.后加一：i++

int i=1;
System.out.println(i++)输出结果是1，变量i的值是2

4. 自增n

自增n:i+=n
等效于：i=i+n
示例：i+=5

5.自减n

先减1：–i

int i=1;
System.out.println(--i);//输出结果是0，变量i的值是0

后减1：i–

int i=1;
System.out.println(i--);//输出结果是1，变量i的值是0

自减n：i-=n

等效于: i=i-n

6.自乘n

自乘n：i*=n

等效于：i=i*n

7.自除n

自除n：i/=n

等效于：i=i/n

1.1.22 变量相关算法：交换两个变量值

两个变量值互换是基本的算法，在排序等算法中应用。

已知：

int a=100;
int b=10;

交换两个变量值，使得a=10，b=100

错误代码：

a=b;
b=a;

正确代码：

int c=a;
a=b;
b=c;

不借助第三个变量，仅在两个变量之间交换值。

步骤1 a=a+b;
结果：a=a+b,b=b
步骤2 b=a-b;
结果：a=a+b,b=a
步骤3 a=a-b;
结果：a=b,b=a

1.1.23 Java的错误类型

程序的错误分为编译器语法错误、运行期异常错误和运行期逻辑错误。

1. 编译期语法错误可以借助Eclipse的帮助方便地定位错误，并进行修改。
2. 运气期异常，系统会提示错误的类型和出错的位置
3. 逻辑错误是指程序可以编译运行，但程序执行的结果却不是预期的效果。

1.1.24 Debug调试

1. 调试时查找、解决软件中逻辑错误代码（称为bug：软件臭虫）的重要手段，是软件开发中必须可少的环节。
2. 调试也是学习、研究其他人编写的代码的一个很好的手段。
3. eclipe提供了Debug功能。
4. 断点是在源代码的可执行部分的指定行设置一个标志，在调试运行方式下，程序运行到断电标志处会自动暂停，等待下一步操作。
5. 通过设置断点可以快速执行断点之前的代码，然后在断点处暂停，这时可以换个命令运行的方式来运行程序，查找程序中的逻辑错误。
6. 断点设置时程序员怀疑错误代码的附近位置，即对出错位置的定性分析，是一个大概位置。

1.1.25 Debug案例