J2SE 必知必会（二）

算法（algorithm）：描述的是要解决的问题，所要执行的动作及这些动作执行的顺序，可以帮助程序员在编写程序前做一个规划。

算法可以使用自然语言来描述可则是使用伪代码来描述，比如下面是描述的一个求圆的面积的算法过程：

1，  读入半径

2，  利用公式计算面积：面积 = 半径×半径×π

3，  显示面积

在写代码的时候要把算法翻译成为程序，每一个类都是以类声明开始的，所以一般来说我们可以把上面的算法写为如下的一个结构：

publicclass ComputeArea {

    publicstaticvoid main(String[] args) {

       //1,读入半径

      

       //2,计算面积

      

       //3,显示面积

    }

}

这个程序在从键盘读入半径，这时就有两个问题

1， 读取半径

2，  把半径存储到程序中

为了要存储半径，在程序中要声明一个变量，这个变量就指定了在程序中用于存储数据和计算结果的内存位置，每个变量都有自己的名字以便来访问它的内存位置

对于变量的命名一般要使用可读的名字而不是简单的使用x,y等，在上面的例子中我们可以使用radius表示半径，area表示面积，这是针对我们自己的便于理解而定义的名字，而对于编译器它并不知道这个名字是什么，这个时候我们要为名称加上一定的数据类型来告诉编译器这个变量能放些什么值。

Java提供简单数据类型来表示整数、浮点数、字符、布尔类型，这些类型都称为基本数据类型，如下就声明了两个变量

double radius;

double area;

publicclass ComputeArea {

    publicstaticvoid main(String[] args) {

       double radius;

       double area;

      

       //1,读入半径

       radius = 20.0;

      

       //2,计算面积

       area = radius*radius*3.1415926;

      

       //3,显示面积

       System.out.println("The area for the circle of radius:"+radius+" is "+area);

    }

}

如上就是我们手动给radius赋的一值进行计算的程序过程

在这里radius,area分别对应了这两个变量的内存位置，每个变量都会有类型、名字、大小和值

关于（+）号的意义：

一是，作为加法来用

二是，连接两个字符串，当如果其中有一个非字符串与一个字符串进行+号连接时会首先把非字符串的转为字符串然后再进行连接

虽然对于语句是可以跨行的但对于字符串是不可以跨行的如果要分行写的话则使用字符串进行连接的写法及分成多个字符串进行连接

如何从控制台读取输入？

使用Scanner类可以读取从控制台输入的数据

Java中使用System.out来表示标准输出设备（显示器），System.in表示标准输入设备（键盘）Java是不直接支持控制台输入的，但是可以使用Scanner类来创建它的对象来读取来自

System.in的输入

Scanner input = new Scanner(System.in);

这里new Scanner(System.in);表示的是创建一个Scanner类型对象.

接下来可以计用这个对象相应的方法来完成任务

nextByte()  : 读取一个byte类型的整数

nextShort() : 读取一个short类型的整数

nextInt()    : 读取一个int类型的整数

nextLong()   : 读取一个long类型的整数

nextFloat()  : 读取一个float类型浮点数

nextDouble() : 读取一个double类型的整数

next()        : 读取一个字符串，这个字符串在空白字符之前结束

nextLine()    : 读取一行文本（发按下回车键作为读取结束）

那么对于上面的程序我们可以读入一个double类型的半径值nextDouble(),如是程序为如下：

import java.util.Scanner;

publicclass ComputeArea {

    publicstaticvoid main(String[] args) {

       double radius;

       double area;

       //创建一个Scanner对象

       Scanner input = new Scanner(System.in);

       //1,读入半径

       System.out.print("Enter a number for radius: ");

       radius = input.nextDouble();

      

       //2,计算面积

       area = radius*radius*3.1415926;

      

       //3,显示面积

       System.out.println("The area for the circle of radius:"+radius+" is "+area);

    }

}

 

Scanner类在包java.util里在程序的开头要导入import java.util.Scanner;这样编译器在读到创建一个对象的时候才知道去哪里去找这个类

标识符：

在程序中我们可以看到radius,area,input,main这样的都是出现在程序中事物的名字，这样的名字称为标识符，所有的标识符有如下的规则：

1， 是由字母、数字、下划线和美符号组成的字符序列

2， 不能以数字开头

3， 不能是保留的关键字

4， 不能是true,false,null

5， 可以是任意长度

注意Java是区分大小写的因而对于area,Area,arEa都是不同的标识符

不要以$开头作为标识符虽然是合法的但常常它会出现在机器自动产生的源代码中

变量：

在程序中使用变量来存储使用到的数据，它们称为变量是因为它们的值是可能会被改变的

声明变量：告诉编译器根据数据类型为变量分配合造的存储空间

datatype variableName;

比如：int count;

      double radius;

如果是几个变量为同一类型是可以同时为它们进行声明的

datatype variable1,variable2,…,variablen;

比如：int i,j,k;

注意：习惯上变量是使用小写字母来表示，如果一个变量由多个单词组成的话则会把除第一个单词名的所有单词首字母大写

变量通常都是有初始值的，可以一步完成变量的声明和初始化

int count = 1;

这个就相当于是

int count;

count = 1;

当然也可以对相同类型的变量在一起进行声明并初始化

int i = 1,j=2;

注意在赋值给变量之前一定要先声明变量，在方法中声明的变量在使用它们之前一定要先初始化

赋值语句和赋值表达式：

声明变量之后可以使用赋值语句给它进行赋值，在Java当中使用=号进行赋值

variable = expression;(变量 = 表达式;)

这里的表达式就涉及到值、变量和运算符的本个运算，它们组合在一起行成一个新的值

int x = 1;//声明并初始化一个变量

double radius = 1.0;//声明并初始化一个变量

x = 5*(3/2)+3*2; //这是对变量x进行赋值

x = y+1;//对x进行赋值

area = radius*radius*3.14159;//对area变量进行赋值

变量也可以用在表达式当中

x = x + 1;//x+1的结果赋值给x

要给一个变量进行赋值对于变量名一定要在运算符的左边比如1=x;这个是错误的

对于表达式 x = 2*x-1在数学意义上来说的话它是一个等式，而在Java当中它是一个赋值表达式，把=号右边的表达式计算的结果赋给左边的变量x

在赋值语句中，左边变量的数据类型必须要与右边的值的数据类型兼容，如果不兼容的话必须使用强制类型转换要不然的话则会报错。

常量：一个变量的值是可以在程序执行的过程中发生变化的，但是对于常量表示在程序运行过程中不会被改变的永久数据，在上面的程序当中π是一个常量，如果在程序中常常要使用到但有不想每次输入相同的值3.14159，则可以声明一个常量来代替它

final datatype CONSTANTNAME = value;

常量必须在同一条语句中进行声明和赋值，单词final是声明常量的关键字，加入常量后的程序为：

import java.util.Scanner;

publicclass ComputeArea {

    publicstaticvoid main(String[] args) {

       double radius;

       double area;

       //声明一个常量来代表π

       finaldoublePI = 3.14159;

       //创建一个Scanner对象

       Scanner input = new Scanner(System.in);

       //1,读入半径

       System.out.print("Enter a number for radius: ");

       radius = input.nextDouble();

      

       //2,计算面积

       area = radius*radius*PI;

      

       //3,显示面积

       System.out.println("The area for the circle of radius:"+radius+" is "+area);

    }

}

按照习惯常量一般写为全大写以与一般的变量相区别

使用常量的好处：

1， 不必在程序中重复的输入同一个值

2， 如果在程序中逻辑要修改一个常量的值只要在源代码中声明的常量处进行一次修改即可

3， 可以给常量赋一个描述性的名字这样可以提高程序的可读性

Java中数据类型：

每一个数据类型都有它的取值范围，编译器会根据每个变量或常量的数据类型来分配内存空间

byte       8位符号整数

short      16位带符号整数

int         32位带符号整数

long       64位带符号整数

float      32位  IEEE754 单精度浮点数

double     64位  IEEE754 双精度浮点数

IEEE754:美国电气电子工程师协会通过的一个标准，用于在计算机上表示符点数

注意如果赋值的变量的值太大至于无法存储时会出现上溢出，Java是不会报关于上溢出的警告或是错误的，所以在使用的时候如果接近给定类型的最大范围时就一定要小心上溢出的错误

而对于下溢出当浮点数太小接近0时而不能被存储时，会产生下溢Java会近似的认为是0所以通常对于下溢出是不须考虑的

数值运算符：

数值数据类型的运算符包括标准的算术运算符：+、-、*、/、%

当除法的操作数都是整数的时候其结果也会是整数，小数部分会被舍去

运算符%会求得除法运算的余数，左边是被除数，右边是除数，只有当被除数是负数的时其结果才是负数

下面的例子就是计算一个以秒为单位的数值，它的时间值（多少小时，多少分钟，剩下多少秒）

import java.util.Scanner;

publicclass DisplayTime {

    publicstaticvoid main(String[] args) {

       Scanner input = new Scanner(System.in);

      

       //1,读取时间

       System.out.print("请输入时间(单位：秒)：");

       long time = input.nextLong();

       //2,把时间换算为对应的时分秒

       int hour , minutes , seconds ;

       hour = 0;

       if(time>=3600){

           hour = (int)time/60/60;

       }

       long remaSeconds1 = time-hour*3600;

       minutes = 0;

       if(remaSeconds1>=60){

           minutes = (int)remaSeconds1/60;

       }

        seconds = (int)remaSeconds1%60;

       //3,显示换算后的结果

       System.out.println(time +" seconds is "+hour+"小时"+minutes+"分"+seconds+"秒");

    }

}

对于运算符+、-可以是一元的也可以是二元的，一元操作符只可以有一个操作数，二元操作符有两个操作数

对于-号，-5是一个一元操作符，表示对5取负数，4-5这是一个二元操作符表示从4中减去5

注意：只要是涉及浮点运算的时候都是近似的，因为这些数没有以绝对准确的精度来进行存储整数计算可以得到精确的运算结果是因为整数在内存中可以精确的存储

数值直接量：

直接量是指在程序中直接出现的常量值

如下面的34、0.305都是直接量

int numberOfYears = 34;

double weight = 0.305;

整型直接量：

与整型变量相匹配，可以把整型直接量赋值给整型变量，如果直接量太大的话则会出现编译错误上溢出的错误

整型直接量默认是int型的，为了表示一个long型的直接量则要在直接量后加上一个L或是l以注明是long型的如21232332422345L

而且要注意的就是在Java当中如果直接量超出民范围则一定要加上L要不然会报错

默认的情况下整型的直接量是一个十进制的整数，可表示成为八进制数则要在前面加上前导0以标明，如要表示为十六进制数则要在前面加上0x或0X

浮点型直接量：

默认情况下是double类型的，比如5.0表示的是double型而不是float型，如果要表示为float型则要在直接量后面加上F/f，也可以在后面加上D/d明确表示是double型

浮点数的科学计数法：

计数的方法如下：1.23456e+2相当于是1.234*10^2

float、double都是用来表示带小数点的数为什么要把它们称为浮点数是因为这些数都是以科学计数的方法的形式来存储的可以把它的小数点移到任意的位置比如67.8可以表示为6.78e1也可以表示为67.8e0

Java表达式：

用Java编写数值表达式就是使用Java运算符对算术表达式进行直接的翻译

尽管Java是有自己的后台计算表达式的方法，但是Java表达式的结果和它对应的算术表达式的计算结果是一样的。因而是可以把算术运算规则应用在计算Java表达式上，首先执行的是圆括号中的运算，圆括号是可以嵌套的先计算内层的再计算外面的，接下来执行乘法、除法、求余，并且对于同一级的运算按从左到右来运算，最后执行加法减法运算。

下面的程序用来把华氏温度转为摄氏温度（公式：c = (5/9)(f-32)）

import java.util.Scanner;

 

publicclass FahrenheitToCelsius {

    publicstaticvoid main(String[] args) {

       //1,获得输入的华氏温度

       Scanner input = new Scanner(System.in);

       System.out.print("请输入华氏温度：");

       double fahrenheit = input.nextDouble();

   

       //2,进行计算得到摄氏温度

       double celsius = (5.0/9.0)*(fahrenheit-32);

      

       //3,显示输出转换结果

       System.out.println("华氏温度："+fahrenheit+"转为摄氏温度结果是："+celsius);

    }

}

这个小程序中有一点要注意的就是：对于除法而言整数相除的结果会是整数，这样的话我们在套用公式的时候一定要写成（5.0/9.0）或是（5.0/9）而不是（5/9）如果直接使用后者的话则完全使公式的结果变味，所以在使用整数除法时一定要考虑到这一点

显示当前时间：

显示当前GMT(格林威治标准时间)的程序，它的格式是：小时：分钟：秒

System类中的方法currentTimeMillis返回从GMT1970年1月1日00：00：00开始到当前时刻的毫秒数

所以我们的算法可以如下：

1， 得到当前的毫秒数

2， 通过总毫秒数/1000得到总的秒数

3， 通过总毫秒数%60得到当前的秒数

4， 通过总的秒数/60得到当前的总分钟数

5， 通过总的分钟数%60得到当前的分钟数

6， 通过总分钟数/60得到当前的总小时数

7， 通过总小时数%24则行到当前的小时数

 

import java.util.TimeZone;

publicclass ShowCurrentTime {

    publicstaticvoid main(String[] args) {

       //1，得到当前的总毫秒数

       long totalMilliseconds = System.currentTimeMillis();

      

       //2,通过总毫秒数/1000得到当前的总秒数

       long totalSeconds = totalMilliseconds/1000;

      

       //3，通过总秒数%60得到当前的秒数

       long currentSecond = totalSeconds%60;

      

       //4，通过总的秒数/60得到当前的总分钟数

       long totalMinues = totalSeconds/60;

      

       //5，通过当前的总分钟数%60得到当前的分钟数

       long currentMinute = totalMinues%60;

      

       //6,通过当前的总分钟数/60得到当前的总小时数

       long totalHours = totalMinues/60;

      

       //7,通过总小时数%24得到当前的小时数

       long currentHour = totalHours%24;

      

       //8,显示输出当前的格林威治时分秒

       System.out.println("当前格林威治时间是："+currentHour+":"+currentMinute+":"+currentSecond+"GMT");

       //上面我们获得了标准的格林威治时间，要获得当前的时区的时间则要如下：

        //1,得到当前时区

       TimeZone time = TimeZone.getDefault();

       //2,得到当前的时区与标准时区的偏移量（注意这个偏移量是用毫秒表示的）/3600/1000得到在什么区

       int zone = time.getRawOffset()/3600/1000;

       //3，对于上面计算的格林威治时间中小时加上这个偏移量，分钟、秒是不会变的

       System.out.println("当前时区系统时间"+"("+time.getDisplayName()+")："+(currentHour+zone)+":"+currentMinute+":"+currentSecond);

      

    }

}

调用System.currentTimeMillus()会返回一个long型的整数，这个整数是与1970年1月1日00:00:00与当前时间的毫秒的差值

TimeZone time = TimeZone.getDefault();这个是获得当前时区对象

int zone = time.getRawOffset();取得当前时区与标准时区之前的毫秒差值

简捷运算：

经常会出现变量的当前值被使用、修改然后再重新赋给当前变量的情况这个时候可以使用赋值运算来完成

比如：i = i+8 ;可以简化为i += 8;

除了加法赋值运算符还有-=、*=、/=、%=

注意对于赋值运算符两个符号之间是不可以有空格的

除了上面的这些简捷运算符还有两个就是：++、--，它们又分为前置运算和后置运算

++var：表达使用使用var加1后的值

var++: 表达式使用var原来的值，var的值还是会自加1

--var: 表达式使用var减1后的值

var--: 表达式使用var原来的值，var的值还是会自减1

如果是单独对一个变量使用++、--则前置和后置是没有影响的因为最后这个变量都自增或自减了1，但如果把它放到表达式当中则会能区别

比如：

int i = 10;

int newNum = 10 * i++;

这个时候newNum = 10 * i++相当于 10*i->newNum;然后则进行 i = i+1;

如果是如下：

int i = 10;

int newNum = 10 * (++i);

这个时候newNum = 10 * (++i)相当于  i = i+1;计算后的结果再与10相乘的结果赋给newNum

自增、自减运算可以用于所有的整型和浮点型，这些运算常常用在循环结构中用来控制循环执行的次数

数值类型转换：

Java中总是可以把一个数值赋给支持更大数值范围类型的变量，例如可以把一个long型变量转为一个float类型的变量。

如果不进行类型转换则是不可以把一个值赋给较小类型的变量

类型转换操作是把一种数据类型转为另一种数据类型的操作小类型à大类型（类型拓宽）

大类型à小类型（类型缩小）

类型缩小是需要显示进行的，这是因为Java的安全机制规定必须这样以免出现上溢出

类型转换的语法要求目标类型放在括号中，紧跟其后的是要转换的变量或值

例如：System.out.println((int)1.7);

在这种中有一种转换一定要注意就是System.out.println((double)1/2);

与System.out.println(1/2);

这两种输出到控制台的结果分别是0.5与0

还有一个要注意：

double d = 4.5;

int i = (int)d;

这个时候i的值是4，但要注意的就是d仍然是一个double类型的值4.5

如下程序输出一个税值，如果是小数保留两位小数其它的舍弃

import java.util.Scanner;

 

publicclass SalesTax {

    publicstaticvoid main(String[] args) {

       Scanner input = new Scanner(System.in);

       //常量税率

       finaldouble tax = 0.06;

      

       //1,输入营业额

       System.out.print("请输入营业额：");

       double purchaseAmount = input.nextDouble();

      

       //2，计算得到税值,把税值传为保留为2位小数不进行四舍五入

       double taxAmount = purchaseAmount*tax;

       System.out.println(taxAmount);

       /*先进行乘以100并转为整数则把小数点向后移两位并把后面的小数位都舍弃

        * 结果再除以一个double型的100.0转为double类型的结果

       */

       taxAmount = (int)(taxAmount*100)/100.0;

      

       //3，输出结果

       System.out.println("得到税值是："+taxAmount);

      

    }

}

这里要注意的就是taxAmount = (int)(taxAmount*100)/100.0;

它先把结果乘以100并转为整数，则把两小数点外的小数数值都舍弃了再除以100.0这里一定要注意不要除100，因为这里要进行一个隐式的转回为double类型

还有一点要注意的就是类型转换类型优先级比乘法要高所以要把（taxAmount*100）用括号括起来

计算代款支付额的问题：

贷款总额*月利率

计算月支付额的公式如下：

月支付额=

                                                     

1
1 -

 

（1+月利率）^年数*12

                                                

 

 

 

 

（1+月利率）^年数*12这个的计算必须要用到Math类中的方法pow(a,b);

算法过程：

1，  提示用户输入年利率、年数、贷款总额

2，  利用年利率获得月利率

3，  使用公式计算月支付额

4，  显示月支付额和总支付额

 

import java.util.Scanner;

 

publicclass ComputeLoan {

    publicstaticvoid main(String[] args) {

       //1,提示用户输入年利率、年数、贷款额

       Scanner input = new Scanner(System.in);

       System.out.print("请输入年利率比如8.25：");

       doubleannualInterestRate = input.nextDouble();

       System.out.print("请输入年数：");

       int numberOfYear = input.nextInt();

       System.out.print("请输入贷款的金额:");

       double loanAmount = input.nextDouble();

      

       //2，得到月利率

       double monthlyInterestRate =annualInterestRate/12/100;

      

       //3，计算月支付额、总支付额

       double monthlyPayment = loanAmount*monthlyInterestRate/(1

              -1/Math.pow(1+monthlyInterestRate, numberOfYear*12));

       double totalPayment = monthlyPayment*12*numberOfYear;

      

       //4，显示输出结果

       System.out.println("月支付额为："+(int)(monthlyPayment*100)/100.0);

       System.out.println("总支付额为："+(int)(totalPayment*100)/100.0);

    }

}

注意这里用到了Math类为什么不用导入Math类呢？这是因为Math在java.lang包中，而这个包是所有类都已被隐式导入的。因而是无须显示导入Math类的

字符型数据类型及运算：

字符型数据用来表示单个字符，字符型直接量用单引号括起来，这里不要与字符串的直接量搞混了字符串的是用双引号括起来的

统一码和ASCII码：

在计算机的内部使用二进制数，一个字符在计算机中是以0和1构成的序列的形式来存储，把字符映射成为二进制形式的过程称为编码（encoding）字符有多种编码方式

Java是支持统一码（Unicode），统一码是由统一码协会建立的一种编码方案，它支持世界不同语言的可书写文本的交换、处理、显示。统一码一开始被设计成为16比特的字符编码，基本数据类型 char本身就能利用这个设计思路来提供一种能存放任意字符的简单数据类型，这样的16比特的编码只能产生的字符65536个，还是不足以表示全球的所有字符，因而统一码标准扩展为1112064个字符，它们存为补充字符

一个16比特位统一码占两个字节，用\u开头的4位十六进制数表示，范围从\u0000到\uFFFF

比如中文“欢迎”需两个字符，表示为统一码为”\u6b22\u8fce”

下面程序序显示两个中文字符和二个希腊字母

import javax.swing.JOptionPane;

 

publicclass DisplayUnicode {

    publicstaticvoid main(String[] args) {

       JOptionPane.showMessageDialog(null,"\u6b22\u8fc \u03b1\u03b3",

"\u6b22\u8fce Welcome",

              JOptionPane.INFORMATION_MESSAGE);

    }

}

注意如果系统中没有安装中文字体，是无法看到中文字符的

大多数的计算机使用的是ASCII码（美国标准信息交换码），它是表示所有的大小写字母、数字、控制字符的7位编码码Unicode包括了ASCII从’\u0000’到’\u0077’对应128个ASCII字符所以下面的两个是等价的

char letter = ‘A’;

char letter = ‘\u0041’;

注意对于自增自减运算符也可以用在char类型变量上，运算后会得到之前或是之后的一个统一码字符

转义序列：

Java中定义转义字符序列来表示特殊字符，对于转义字符使用\开头，后面跟一个对编译器而言且有特殊意义的字符

\b     退格

\t     Tab键

\n     换行符号

\f     进纸

\r     回车符

\\     表示\本身

\’     单引号

\”     双引号

char型数据可以转换成任意一种数值类型，反之亦然，可以把一个整数转为一个char类型数据但是要注意这样转换了后则只保留这个数据的低16位其余部分会忽略

比如char ch = (char)0xAB0041;

执行上面的语句相当于char ch = ‘\u0041’;

如果是把一个浮点数转为一个字符型时，首先会把这个浮点数转为int类型然后把这个转换后的int数据转为一个char类型数据

当把一个char型数据转换成为一个数值类型时，这个字符的统一码就是被转换为一个特定的数值。比如：int i = (int)’A’;

这个时候i的值就是65

如果转换结果适用于目标变量，就可以使用隐式转换方式，否则则要使用显示方式进行转换

因为’a’的统一码是97它是在一个字节的范围内的，所以就可以使用隐式方式进行转换

byte b = ‘a’;

int i = ‘a’;

但是因为统一码\uFFF4不适用一于一个字节范围则下面的转换是不正确的

byte b = ‘\uFFF4’;这个时候要进行显示的转换而写为byte b = (byte)’\uFFF4’;

注意所有数值运算符都可以用在char类型操作数上。如果另一个操作数是一个数字或是字符则char型操作数会被自动转成一个数字，如是另一个操作数是一个字符串则这个字符会与这个字符串进行相连接。

比如：int i = ‘2’+’3’;

这个时候i的值会是’2’的统一码值+’3’的统一码值的和

int j = 2+’a’;

这个时候j的值会是2加上’a’的统一码值的结果

注意对于System.out.println()来说它会自己找到最为合适的类型在控制台上进行输出，如果要输出为其它的类型则要进行相应的显示转换。比如：

char ch = ‘a’;

int i = 97;

System.out.println((int)ch);--à这个会输出97

System.out.println((char)i);--à这个会输出 a

 

String类型：

char类型只能表示一个字符，为了表示一串字符，使用称为String(字符串)的类型

比如：String message = “Welcome to Java”;

String不是一种基本数据类型，它是Java类库中预定的一个类

对于字符串可以使用（+）进行两个字符串进行连接

String s = “My name is ”+”xiaoxie”;

如果两个操作数之中有一个不是字符串进行+时则会把那个不是字符串的转为字符串然后进行连接得一个整体的字符串

String s1 = “My age is ”+28;

如果两个都不是字符串则是进行相应的计算

String sal = “I have ”+(2+3)+”firends”;这里（2+3）会计算为5再与字符进行连接

字符串进行连接的时候也可以使用加法赋值运算符比如：

String message = “Welcome to Java”;

message += “and Java is fun”;

这个时候message变为”Welcome to Java and Java is fun”

如果想在控制台读取输入的字符串可以使用Scanner类对象的next()方法，next()会读取以空白字结束的字符串(‘ ’、’\t’、’\f’、’\r’或’\n’)

所以如果要读取如下的一个控制台输入”Welcom to Java”

则要三次调用next()方法每次分别读取Welcom、 to 、Java

在读取控制台输入的时候使用nextLine()可以一次性读入一行文本，以按下回车作为一行结束标识符

所以如果要读取上面的”Welcom to Java”则可以使用nextLine()这样会把这整个一行读到一个字符串中

注意：为了避免输入错误，不要在nextByte(),nextShort(),nextInt()，nextLong(),nextDouble(),nextFloat()和next()后使用nextLine()

程序设计的风格及文档：

风格：表示了程序源代码的外观，把整个程序写在一行当然也会正确的编译和运行，但这样的程序风格是不正常的，可读性是很差的。

文档：它是嵌在程序中作为解释性评注和注释的一个结构体

适当的注释和注释风格：

在程序的开头写一个摘要，主要解释一下这个程序是做什么的、主要特点及用的独特技术

在较大的程序中还要使用注释主要是介绍每一个主要步骤并解释每一个难以读懂的地方

Java中除了//、/*…*/这两种注释之外还有一种文档注释/**…*/

文档注释可以被JDK的javadoc命令提取出来放入一个html文件中，它可以用来注释整个类或整个方法，这些注释要放在类或是方法头的前面

命名习惯：

1， 使用小写字母来命令变量和方法，如果一个名字有多个单词则把它们连在一起，除第一个单词名其它的每个单词首字母大写

2， 类名中每个单词的首字母大写

3， 对于常大写所有字母

写源代码时注意适当的缩进和空白会使用程序更加的清晰、易懂，便于调试

关于程序设计错误：

错误可以分为三类：语法错误、运行错误、逻辑错误

在编译过程中产生的错误称为语法错误，语法错误是由代码结构体中的错误引起的，这些错误编译器会帮你检测到容易修改。注意一个错误可能会引起很多行的错误所以我们从最上面的错误进行调试处理完一人错误后进行编译一次再处理其它的错误

引起程序非正常中断的错误称为运行错误

当程序没有按预期的方式执行则称为逻辑错误

对于编译错误在编译过程中编译器会告知在哪一行引起错误容易找到错误，运行错误也会在中断后在控制输出错误产生的位置因而也不难找到错误所在，而逻辑错误是最难发现的错误

逻辑错误也称为bug，查找和改正错误的过程也称为调试，调试可以使用各种方法一步一步的找到bug所在的位置，可以手工跟踪（读程序）的方式来找错，也可以在各个关键的位置来插入相应的输出语句来观察逻辑错误产生的原因，对于大型程序来说最为有效的方法还是使用调式工具来找到bug所在

从输入对话框中获得输入：

可以从控制台获得输入，还有一种方法是从输入对话框中获得输入可以调用方法JOptionPane.showInputDialog()

比如：JOptionPane.showInputDialog(“Enter an input:”);

其中Enter an Input:就是一个提示文本，在下面有一个文本输入框，下面会有两个按钮一个”OK”接受输入并关闭对话框，”Cancel”关闭没有输入的输入框

输入值后这个方法在点了OK后会返回一个字符串

这个方法有很多重载方式最为常用的是下面两种：

JOptionPane.showInputDialog(x);

这种中就有一个字符串参数就是对话框中的提示字符串，其它的都是按照默认显示

JOptionPane.showInputDialog(null,x,y,JOptionPane.QUESTION_MESSAGE);

这个方法第一个参数是指明其父窗口一般为null

第二个参数：指定了输入框中的提示字符串

第三个参数：指定了对话框的标题

第四个参数：指定了在输入框中显示一个图标比如上面的就是显示一个？号的图标

注意：对于输入对话框中返回的是输入的一个字符串，这个时候比如输入123则这个方法会返回”123”这个时候在程序处理中如果要按数值来处理则要把这个字符串转为一个字值

把一个字符串转为整型数值

int intValue = Integer.parseInt(intString);

把一个字符串转为一个double类型的数值则

double doubleValue = Double.parseDouble(doubleString);

对于Integer、Double类都是在java.lang包中的，它们是自动导入的

对于计算代款问题的GUI程序：

import javax.swing.JOptionPane;

 

publicclass ComputeLoanUsingInputDialog {

    publicstaticvoid main(String[] args) {

       //输和年利率

       String annualInterestRateString = JOptionPane.showInputDialog("请输入年利率比如8.25：");

      

       //把这个方法返回的字符串转为一个double类型的数值

       double annualInterestRate = Double.parseDouble(annualInterestRateString);

      

       //通过年利率计算出月利率

       double monthlyInterestRate = annualInterestRate/12/100;

      

       //输入贷款的年数

       String numberOfYearsString = JOptionPane.showInputDialog("请输入贷款的年数：");

      

       //把返回的年数的字符串转为一个int型的数值

       int numberOfYears = Integer.parseInt(numberOfYearsString);

      

       //输入贷款的数量

       String loanString = JOptionPane.showInputDialog("请输入贷款的数额：");

      

       //把返回的贷款数额字符串转为一个double类型的数值

       double loanAmount = Double.parseDouble(loanString);

      

       //计算月支付额、总支付额

       double monthlyPayment = loanAmount*monthlyInterestRate/(1

              -1/Math.pow(1+monthlyInterestRate, numberOfYears*12));

       double totalPament = monthlyPayment*12*numberOfYears;

      

       //格式化保持如果为小数保留两个小数点

       monthlyPayment = (int)(monthlyPayment*100)/100.0;

       totalPament = (int)(totalPament*100)/100.0;

      

       String output = "月支付额为："+monthlyPayment+"\n总支付额为："+totalPament;

      

       //使用消息对话框把最后的结果显示出来

       JOptionPane.showMessageDialog(null, output,"还款结果",JOptionPane.INFORMATION_MESSAGE);

    }

}

这里使用JOptionPane的showInpuDialog()与使用Scanner对象的nextXXX()是一样方便的，只是前都总返回的字符串需要进行相应的转为需要的类型，而后则根据调用方法的不同得到不同的类型的输入置。前者要显示的时候调用showMessageDialog(),而后则是使用Systme.out.println()在控制台显示结果。