java学习第二章-数据类型和运算符（仅做个人学习笔记用）

2.1注释

 单行注释：  使用“//”开头，“//”后面的单行内容均为注释。

多行注释：   以“/*”开头以“*/”结尾，在“/*”和“*/”之间的内容为注释，我们也可以使用多行注释作为行内注释。但是在使用时要注意，多行注释不能嵌套使用。

文档注释：   以“/**”开头以“*/”结尾，注释中包含一些说明性的文字及一些JavaDoc标签(后期写项目时，可以生成项目的API)

2.2标识符

标识符是用来给变量、类、方法以及包进行命名的，如Welcome、main、System、age、name、gender等。标识符需要遵守一定的规则：

标识符必须以字母、下划线_、美元符号$开头。

标识符其它部分可以是字母、下划线“_”、美元符“$”和数字的任意组合。

Java 标识符大小写敏感，且长度无限制。

标识符不可以是Java的关键字

标识符的使用规范：

表示类名的标识符：每个单词的首字母大写，如Man, GoodMan

表示方法和变量的标识符：第一个单词小写，从第二个单词开始首字母大写，我们称之为“驼峰原则”，如eat(), eatFood()

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

2.2java中的关键字/保留字

Java关键字是Java语言保留供内部使用的，如class用于定义类。 关键字也可以称为保留字，它们的意思是一样的，我们不能使用关键字作为变量名或方法名。

Java中的关键字/保留字
abstract	assert	boolean	break	byte	case
catch	char	class	const	continue	default
do	double	else	extends	final	finally
float	for	goto	if	implements	import
instanceof	int	interface	long	native	new
null	package	private	protected	public	return
short	static	strictfp	super	switch	synchronized
this	throw	throws	transient	try	void
volatile	while

2.4.1变量的本质

 Java是一种强类型语言，每个变量都必须声明其数据类型。变量的数据类型决定了变量占据存储空间的大小。

变量作为程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。变量在使用前必须对其声明, 只有在变量声明以后，才能为其分配相应长度的存储空间。

注意事项

每个变量都有类型，类型可以是基本类型，也可以是引用类型。

变量名必须是合法的标识符

变量声明是一条完整的语句，因此每一个声明都必须以分号结束

 2.4.2变量的分类

从整体上可将变量划分为局部变量、成员变量(也称为实例变量)和静态变量。

局部变量、成员变量、静态变量的区别
类型	声明位置	从属于	生命周期
局部变量	方法或语句块内部	方法/语句块	从声明位置开始，直到方法或语句块执行完毕，局部变量消失
成员变量 (实例变量)	类内部，方法外部	对象	对象创建，成员变量也跟着创建。对象消失，成员变量也跟着消失；
静态变量 (类变量)	类内部，static修饰	类	类被加载，静态变量就有效；类被卸载，静态变量消失。

局部变量(local  variable)：

方法或语句块内部定义的变量。生命周期是从声明位置开始到到方法或语句块执行完毕为止。局部变量在使用前必须先声明、初始化(赋初值)再使用。

public void test() {
   int i;
   int j = i+5 ; // 编译出错，变量i还未被初始化 
} 
  
public void test() {
   int i;
   i=10;
   int j = i+5 ; // 编译正确
}

 

成员变量（也叫实例变量  member variable）：

 方法外部、类的内部定义的变量。从属于对象，生命周期伴随对象始终。如果不自行初始化，它会自动初始化成该类型的默认初

实例变量的默认初始值
数据类型	实始值
int	0
double	0.0
char	‘\u0000’
boolean	false

public class Test {
    int i;
}

 

 静态变量（类变量 static variable）：

使用static定义。 从属于类，生命周期伴随类始终，从类加载到卸载。如果不自行初始化，与成员变量相同会自动初始化成该类型的默认初始值，如上面表所示。

/**
 * 测试变量
 * 
 * @author 
 *
 */
public class TestVariable {
 
    int a;            //成员变量, 从属于对象； 成员变量会自动被初始化
    static  int  size;   //静态变量，从属于类
     
    public static void main(String[] args) {
 
        {
            int age;        //局部变量，从属于语句块；
            age = 18;
        }
         
        int salary = 3000;    //局部变量，从属于方法
 
        int gao = 13;
        System.out.println(gao);
 
        int i;
    //    int j = i + 5; // 编译出错，变量i还未被初始化
         
    }
}

2.5常量（Constant）

常量通常指的是一个固定的值，例如：1、2、3、’a’、’b’、true、false、”helloWorld”等。

在Java语言中，主要是利用关键字final来定义一个常量。 常量一旦被初始化后不能再更改其值。

声明格式为：

1	final  type  varName = value;

    public static void main(String[] args) {
        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("circle = " + circle);
    }
}

为了更好的区分和表述，一般将1、2、3、’a’、’b’、true、false、”helloWorld”等称为字面常量，而使用final修饰的PI等称为符号常量。

变量和常量命名规范：

1、所有变量、方法、类名：见名知意

2、类成员变量：首字母小写和驼峰原则:  monthSalary

3、局部变量：首字母小写和驼峰原则

4、常量：大写字母和下划线：MAX_VALUE

5、类名：首字母大写和驼峰原则:  Man, GoodMan

6、方法名：首字母小写和驼峰原则: run(), runRun()

2.6基本数据类型(primitive data type)

Java是一种强类型语言，每个变量都必须声明其数据类型。 Java的数据类型可分为两大类：基本数据类型（primitive data type）和引用数据类型（reference data type）。

Java中定义了3类8种基本数据类型

数值型－ byte（1）、 short（2）、int（4）、 long（8）、float（4）、 double（8）

字符型－ char（2）

布尔型－boolean （1Bit）

注意事项

引用数据类型的大小统一为4个字节，记录的是其引用对象的地址！

2.6.1整型变量/常量

整型用于表示没有小数部分的数值，它允许是负数。整型的范围与运行Java代码的机器无关，这正是Java程序具有很强移植能力的原因之一。与此相反，C和C++程序需要针对不同的处理器选择最有效的整型。

整型数据类型
类型	占用存储空间	表数范围
byte	1字节（8位）	-27 ~   27-1（-128~127）【2的7次方】
short	2字节	-215 ~   215-1（-32768~32767）【2的15次方】
int	4字节	-231 ~   231-1 (-2147483648~2147483647)约21亿【2的31次方】
long	8字节	-263 ~   263-1【2的63次方】

Java 语言整型常量的四种表示形式

十进制整数，如：99, -500, 0

八进制整数，要求以 0 开头，如：015

十六进制数，要求 0x 或 0X 开头，如：0x15

二进制数，要求0b或0B开头，如：0b01110011

 Java语言的整型常数默认为int型，声明long型常量可以后加‘ l ’或‘ L ’ 。

long a = 55555555;  //编译成功，在int表示的范围内(21亿内)。
long b = 55555555555;//不加L编译错误，已经超过int表示的范围。
long b = 55555555555L;//无错

 

2.6.2浮点型变量/常量

带小数的数据在Java中称为浮点型。浮点型可分为float类型和double类型。

浮点型数据类型
类型	占用存储空间	表数范围
float	4字节	-3.403E38~3.403E38
double	8字节	-1.798E308~1.798E308

float类型又被称作单精度类型，尾数可以精确到7位有效数字，在很多情况下，float类型的精度很难满足需求。而double表示这种类型的数值精度约是float类型的两倍，又被称作双精度类型，绝大部分应用程序都采用double类型。浮点型常量默认类型也是double。

Java浮点类型常量有两种表示形式

十进制数形式，例如:3.14       314.0      0.314 

科学记数法形式，如314e2      314E2      314E-2

 

 

 

2.6.3字符型变量/常量

字符型在内存中占2个字节，在Java中使用单引号来表示字符常量。例如’A’是一个字符，它与”A”是不同的，”A”表示含有一个字符的字符串。

char 类型用来表示在Unicode编码表中的字符。Unicode编码被设计用来处理各种语言的文字，它占2个字节，可允许有65536个字符。

Unicode具有从0到65535之间的编码，他们通常用从’\u0000’到’\uFFFF’之间的十六进制值来表示（前缀为u表示Unicode） 

 Java 语言中还允许使用转义字符 ‘\’ 来将其后的字符转变为其它的含义。

转义符	含义	Unicode值
\b	退格（backspace）	\u0008
\n	换行	\u000a
\r	回车	\u000d
\t	制表符（tab）	\u0009
\“	双引号	\u0022
\‘	单引号	\u0027
\\	反斜杠	\u005c

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

}

---

2.6.4 boolean类型变量/常量

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

---

 

2.7运算符

算术运算符	二元运算符	+，-，*，/，%
	一元运算符	++，--
赋值运算符		=
扩展运算符		+=，-=，*=，/=
关系运算符		>，<，>=，<=，==，!=  instanceof
逻辑运算符		&&，||，!，^
位运算符		&，|，^，~ ， >>，<<，>>>
条件运算符		? :
字符串连接符		+

---

 

2.7.1算数运算符

算术运算符中+，-，*，/，%属于二元运算符，二元运算符指的是需要两个操作数才能完成运算的运算符。其中的%是取模运算符，就是我们常说的求余数操作。

　　二元运算符的运算规则：

　　整数运算：

　　1. 如果两个操作数有一个为Long, 则结果也为long。

　　2. 没有long时，结果为int。即使操作数全为short，byte，结果也是int。

　　浮点运算：

　　3. 如果两个操作数有一个为double，则结果为double。

　　4. 只有两个操作数都是float，则结果才为float。

　　取模运算：

　　1.其操作数可以为浮点数,一般使用整数，结果是“余数”，“余数”符号和左边操作数相同，如：7%3=1，-7%3=-1，7%-3=1。

　　算术运算符中++，--属于一元运算符，该类运算符只需要一个操作数。

/**
 * 测试算数运算符
 * @author 
 *
 */
public class TestOperator01 {
	public static void main(String[] args) {
		/*
		byte a = 1;
		int b = 2;
		long b2 = 3;
		//byte c = a+b;//报错
		//int d = b+b2;//报错
		
		float f1 = 3.14f;//不加f也会报错，因为默认Double类型
		float d = b+b2;
		
		//float f2 = f1+6.4;//报错，6.4位Double类型
		
		//取余
		System.out.println(9%5);
		*/
		
		
		//测试自增和自减
		int a = 3;
		int b = a++;
		System.out.println("a="+a+"\nb="+b);//a=4,b=3
		a = 3;
		b = ++a;
		System.out.println("a="+a+"\nb="+b);//a=4,b=4
		
		
		
	}
}

---

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

运算符	用法举例	等效的表达式
+=	a += b	a = a+b
-=	a -= b	a = a-b
*=	a *= b	a = a*b
/=	a /= b	a = a/b
%=	a %= b	a = a%b

                int a = 3;
		int b = 4;
		a+=b;//a=a+b
		System.out.println("a="+a+"\nb="+b);//a=7,b=4
		a=3;
		a*=b+3;//a=a*(b+3);
		System.out.println("a="+a+"\nb="+b);//a=21,b=4

---

2.7.3关系运算符

关系运算符用来进行比较运算，关系运算的结果是布尔值：true/false；

运算符	含义	示例
==	等于	a==b
!=	不等于	a!=b
>	大于	a>b
<	小于	a<b
>=	大于或等于	a>=b
<=	小于或等于	a<=b

=是赋值运算符，而真正的判断两个操作数是否相等的运算符是==。

==、!= 是所有（基本和引用）数据类型都可以使用

> 、>=、 <、 <= 仅针对数值类型（byte/short/int/long,  float/double。以及char）

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

---

 

 2.7.4逻辑运算符

 逻辑运算的操作数和运算结果都是boolean值。

运算符		说明
逻辑与	&( 与)	两个操作数为true，结果才是true，否则是false
逻辑或	|(或)	两个操作数有一个是true，结果就是true
短路与	&&( 与)	只要有一个为false，则直接返回false
短路或	||(或)	只要有一个为true， 则直接返回true
逻辑非	!（非）	取反：!false为true，!true为false
逻辑异或	^（异或）	相同为false，不同为true

短路与和短路或采用短路的方式。从左到右计算，如果只通过运算符左边的操作数就能够确定该逻辑表达式的值，则不会继续计算运算符右边的操作数，提高效率。 

 

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

---

 2.7.5位运算符

位运算符	说明
~	取反
&	按位与
|	按位或
^	按位异或
<<	左移运算符，左移1位相当于乘2
>>	右移运算符，右移1位相当于除2取商

 

1. &和|既是逻辑运算符，也是位运算符。如果两侧操作数都是boolean类型，就作为逻辑运算符。如果两侧的操作数是整数类型，就是位运算符。

2. 不要把“^”当做数学运算“乘方”，是“位的异或”操作。

 

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

---

2.7.6字符串连接符

 “+”运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串然后再进行连接。

/**
 * 字符串连接符
 * @author niu
 *
 */
public class TestOperator05 {
	public static void main(String[] args) {
		String a="3";
		int b=4;
		int c=5;
		System.out.println(a+b+c);//345，因为有字符串a在，所以加号就是连接符
		System.out.println(b+c+a);//93
		
		char d='a';
		System.out.println(d+4);//101=97(ASCII值)+4
	}
}

---

2.7.7条件运算符

 

语法格式：

1

x ? y : z

 其中 x 为 boolean 类型表达式，先计算 x 的值，若为true，则整个运算的结果为表达式 y 的值，否则整个运算结果为表达式 z 的值。

/**
 * 条件运算符（三元运算符）
 * @author 
 *
 */
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));
	}
}

---

2.7.8运算符优先级的问题

优先级	运算符	类	结合性
1	()	括号运算符	由左至右
2	!、+（正号）、-（负号）	一元运算符	由左至右
2	~	位逻辑运算符	由右至左
2	++、--	递增与递减运算符	由右至左
3	*、/、%	算术运算符	由左至右
4	+、-	算术运算符	由左至右
5	<<、>>	位左移、右移运算符	由左至右
6	>、>=、<、<=	关系运算符	由左至右
7	==、!=	关系运算符	由左至右
8	&	位运算符、逻辑运算符	由左至右
9	^	位运算符、逻辑运算符	由左至右
10	|	位运算符、逻辑运算符	由左至右
11	&&	逻辑运算符	由左至右
12	||	逻辑运算符	由左至右
13	? :	条件运算符	由右至左
14	=、+=、-=、*=、/=、%=	赋值运算符、扩展运算符	由右至左

不需要去刻意的记这些优先级，表达式里面优先使用小括号来组织！！

逻辑与、逻辑或、逻辑非的优先级一定要熟悉！（逻辑非>逻辑与>逻辑或）。如：

a||b&&c的运算结果是：a||(b&&c)，而不是(a||b)&&c 

---

 2.8.1自动类型转换

自动类型转换指的是容量小的数据类型可以自动转换为容量大的数据类型。如图所示，红色的实线表示无数据丢失的自动类型转换，而虚线表示在转换时可能会有精度的损失。

 可以将整型常量直接赋值给byte、 short、 char等类型变量，而不需要进行强制类型转换，只要不超出其表数范围即可。

/**
 * 测试类型转化,容量小的向容量大的转化
 * @author 
 *
 */
public class TestTypeConvert {
	public static void main(String[] args) {
	int a=324;
	long b=a;
	double d=b;
	//a=b;//报错，b的类型大于a的类型
	
	//long e=3.23f;//报错，float虽然四字节，long八字节，但是float范围比long大
	float f=234324L;//不报错
	
	//特例
	byte b2=123;//byte范围是-128~+127
	
	}
}

---

 2.8.2强制类型转换

强制类型转换，又被称为造型，用于显式的转换一个数值的类型。在有可能丢失信息的情况下进行的转换是通过造型来完成的，但可能造成精度降低或溢出。

语法格式：

1

(type)var

 运算符“()”中的type表示将值var想要转换成的目标数据类型。

当将一种类型强制转换成另一种类型，而又超出了目标类型的表数范围，就会被截断成为一个完全不同的值。

不能在布尔类型和任何数值类型之间做强制类型转换。

        //强制转换
	double x=3.14;
	int nx=(int)x;
	char c='a';
	int d=c+1;
	System.out.println(nx);//3
	System.out.println(d);//98
	System.out.println((char)d);//b
	
	//强制转换超出了表数范围
	int y=300;
	byte by=(byte)y;
	System.out.println(by);//值为44

---

2.8.3基本类型转化时常见错误和问题

操作比较大的数时，要留意是否溢出，尤其是整数操作时。

/**
 * 转换出错
 * @author 
 *
 */
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);//total1=-1474836480
		//返回的total1仍然是负数。默认是int，因此结果会转换成int值，再转换成long。但是已经发生了数据丢失
		long total1 = money*years;
		System.out.println("total1="+total1);//total1=-1474836480
		//返回的total2正确，先将一个引子变成long，整个表达式发生提升。全部用long来计算
		long total2=money*((long)years);
		System.out.println("total2="+total2);//total2=20000000000
		
		long total3 = 34L*3223*years*223423;
		System.out.println("total3="+total3);//total3=489662783720
	}
}

 

---

2.9简单的键盘输入输出

import java.util.Scanner;
/**
 * 测试获得键盘输入
 * @author 
 *
 */
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);
	}

}

结果：

请输入名字：
bab
请输入你的爱好：
打球
请输入你的年龄：
66
$$$$$$$$
bab
打球
66

 

---

第二章作业

一、选择题

1、CD//public属于关键字，标识符不可以以数字开头

2、C

3、A

4、AB

5、AB

二、简答题

1、.Java是一种强类型语言，说明Java的数据类型分类。答：

Java是一种强类型语言，每个变量都必须声明其数据类型。 Java的数据类型可分为两大类：基本数据类型（primitive data type）和引用数据类型（reference data type）。

Java中定义了3类8种基本数据类型

数值型－ byte、 short、int、 long、float、 double

字符型－ char

布尔型－boolean 

引用数据类型的大小统一为4个字节，记录的是其引用对象的地址！

2、 i++和++i的异同之处。答：

i++，先赋值再加1

++i，先加1再赋值

3、运算符||和|的异同之处。答：

逻辑或（|）：两个操作数有一个是true，结果就是true；

短路或（||）：只要有一个为true，则直接返回true。

4、.Java中基本数据类型转换的规则。答：

自动类型转换指的是容量小的数据类型可以自动转换为容量大的数据类型；

 可以将整型常量直接赋值给byte、 short、 char等类型变量，而不需要进行强制类型转换，只要不超出其表数范围即可；

红色的实线表示无数据丢失的自动类型转换，而虚线表示在转换时可能会有精度的损失。

 三、编码题

1、输入圆形半径，求圆形的周长和圆形的面积，并将结果输出。

import java.util.Scanner;
/**
 * 作业第二章1题
 * @author niu
 *
 */
public class ZuoYe201 {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入圆的半径：");
		float R = scanner.nextFloat();
		float C = 2*3.14F*R;
		float S = 3.14F*R*R;
		
		System.out.println("该圆的半径为R="+R);
		System.out.println("该圆的周长为C="+"2*3.14*"+R+"="+C);
		System.out.println("该圆的面积为S="+"3.14*"+R+"*"+R+"="+S);
		
	}		
}

结果：

请输入圆的半径：
12.5
该圆的半径为R=12.5
该圆的周长为C=2*3.14*12.5=78.5
该圆的面积为S=3.14*12.5*12.5=490.625

2、 银行利率表如下表所示，请计算存款10000元，活期1年、活期2年，定期1年，定期2年后的本息合计。

 

java.math.BigDecimal;
/**
 * 作业第二章2题，用BigDecimal
 * @author 
 *
 */
public class ZuoYe202_2 {
	public static void main(String[] args) {
		BigDecimal Money = BigDecimal.valueOf(10000);
		BigDecimal Hqck = BigDecimal.valueOf(0.0035);
		BigDecimal Dq_3Month = BigDecimal.valueOf(0.011);
		BigDecimal Dq_6Month = BigDecimal.valueOf(0.013);
		BigDecimal Dq_12Month = BigDecimal.valueOf(0.015);
		BigDecimal Dq_24Month = BigDecimal.valueOf(0.021);
		BigDecimal Year = BigDecimal.valueOf(2);
		
		BigDecimal Money_HqOneYear = Money.multiply(Hqck);
		BigDecimal Money_DqOneYear = Money.multiply(Dq_12Month);
		BigDecimal Money_HqTwoYear = Money.multiply(Hqck.multiply(Year));
		BigDecimal Money_DqTwoYear = Money.multiply(Dq_24Month.multiply(Year));
		
		System.out.println("本金："+Money);
		System.out.println("活期一年本金总计："+Money+Money_HqOneYear);
		System.out.println("定期一年本金总计："+Money+Money_DqOneYear);
		System.out.println("活期两年本金总计："+Money+Money_HqTwoYear);
		System.out.println("定期两年本金总计："+Money+Money_DqTwoYear);
	}

}

结果：

本金：10000
活期一年本金总计：1000035.0000
定期一年本金总计：10000150.000
活期两年本金总计：1000070.0000
定期两年本金总计：10000420.000

3、 某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。结果如图所示。

import java.util.Scanner;
/**
 * 作业第二章3题
 * @author 
 *
 */
public class ZuoYe203 {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int a;//申请四位的变量
		int b;
		int c;
		int d;
		int f;//交换时用
		
		System.out.println("请输入一个4位正整数：");
		int number = scanner.nextInt();
		
		d = number%10;//求得个位数
		c = number/10%10;//求得十位数
		b = number/100%10;//求得百位数
		a = number/1000%10;//求得千位数
		
		d = (d+5)%10;
		c = (c+5)%10;
		b = (b+5)%10;
		a = (a+5)%10;
		
		f = a;//个位和千位换位置
		a = d;
		d = f;
		
		f = b;//十位和百位换位置
		b = c;
		c = f;
		
		number = a*1000+b*100+c*10+d;//求得最后要输出的数
		
		System.out.println(number);
	}

}

结果：

请输入一个4位正整数：
1357
2086