201871010113-刘兴瑞《面向对象程序设计（java）》第二周学习总结

 

项目	内容
这个作业属于哪个课程	<任课教师博客主页链接>    https://www.cnblogs.com/nwnu-daizh/
这个作业的要求在哪里	<作业链接地址> https://www.cnblogs.com/nwnu-daizh/p/11435127.html
作业学习目标	1.学习第三章理论知识内容和完成实验 2.掌握Java基本知识 3.掌握数据类型，变量 ， 4.学会使用Java运算符构造各类表达式 5.掌握Java Application输入输出 6.掌握Java流程控制技术（分支、循环） 7.掌握Math类、String类的用法 8.区别Java语言和C语言的异同

 

第一部分：结合Java和C基础语法的异同比较，总结本周理论知识 

 在本周的理论知识学习中，我们学习了八个小部分：基本知识 ，数据类型， 变量 ，运算符，类型转换字符串，输入输出和控制流程。

 (1)基本知识：

　　标识符由字母、下划线、美元符号和数字组成，且第一个符号不能为数字。标识符可用作：类名、对象名、变量名、方法名、数组名、文件名等。

　　Java标识符和C语言的不同在于Java语言可以用美元符号做标识符，在Java语言中标识符可以用作类名和对象名

　　关键字就是Java语言中已经被赋予特定意义的一些单词。常见有：class、public、try、catch、if、float、import、void等。关键字不做变量名。

 　  Java有C语言没有的关键字：class,public,try,catch,import。

       Java语言有三种注释方式：  //  （注释内容由//一直到此行结束） /*和*/    （定义一个注释块）   /**开始，*/结束   （ 这种注释方法可用来自动产生文档）

       C语言没有第三种注释。

 (2)数据结构：

　　整数类型：int (4字节 占32位，-2³¹~2³¹-1,十六进制前缀0x或0X 八进制前缀0 二进制前缀0b或0B），short (2字节 占16位，-2¹⁵ ~2¹⁵-1） ，long (8字节 占64位，-2⁶³~2⁶³-1，后缀L或l） ，byte (1字节 占8位，-2⁷~2⁷-1） 定义整数类型时可以同时赋值

                        C语言中没有byte类型，Java中没有unsigned类型，Java中整数的范围与运行Java代码的机器无关。

　　浮点类型：float（4字节 占32位，后缀F或f），double（8字节 占64位，后缀D或d）。浮点类型无法接受舍入误差，定义时可以赋初值。

　　　　　　　表示溢出和出错的三种特殊的浮点常量：正无穷大——Double.POSITIVE_INFINITY  ，负无穷大——Double.NEGATIVE_INFINITY  ，NaN（非数字）——Double.NaN

　　字符类型：char，定义时可以赋初值。字符集: Java 采用unicode字符编码集，该编码集16位，含有65536个字符。Unicode(统一码、万国码)是一个编码规范，为解决传统字符编码方案局限产生，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求。

　　转义字符：前缀\u表示Unicode值，而十六进制的4位数字则表明具体是哪个Unicode字符。

　　布尔类型：boolean，定义时可赋值。在Java中，布尔值和整数不能相互转换。

 (3)变量：

　　在Java中，每一个变量属于一种类型。在声明变量时，变量所属的类型位于变量名之前。一行可以声明多个变量。逐一声明每一个变量可以提高程序的可读性。

　　变量初始化：一个变量声明后，必须通过赋值语句对它进行明确的初始化——永远不要使用一个未初始化的变量值。在Java中，可以在代码的任何位置进行变量声明。变量的声明尽可能地靠近变量第一次使用的地方。不能在同一作用域内声明两个同名的变量。

　　常量的定义：使用关键字final来指示常量。习惯上常量名都用大写：final double CM_PER_INCH=2.54；关键字final表示只能对变量赋一次值，其值一旦设定，便不能改。在Java中，经常希望某个常量可以在一个类中的多个方法中使用，通常将这些常量称为类常量。可以使用关键字static final声明一个类常量（class constants）。类常量定义在main方法的外围。

 (4)运算符：

　　特别运算符：new-创建对象的运算符，Instanceof-返回布尔值来指出某个对象是否是一个特定类或者是它的子类的一个实例。

　　数学函数与常量：数学函数包括在Math类中，Java还提供了两个常量：Math.PI , Math.E。若不想在数学方法名和常量名前加前缀，可在源文件顶部加上以下代码：import static java.lang.Math.*;

　　自增自减运算符：n++，n--，++n，--n。

 (5)类型转换：

　隐式类型转换：大多数的数值转换是遵循优先级的关系自动完成的。转换原则如下：如果两个操作数中有一个是double类型的，则另一个将会转换成double类型。否则，如果两个操作数中有一个是float类型的，另一个将会转换成float类型。否则，如果两个操作数有一个是long类型的，另一个将会转换成long类型。否则，两个操作数都将转换成int类型。

　　

　强制类型转换：强制类型转换的语法：（目标类型）变量名   在进行强制类型转换时，当心丢失数据。

 (6)字符串：

　　Java字符串是Unicode字符的序列，它是组织字符的基本数据结构，用法类似于字符数组。有内置的字符串类型，在标准Java类库中提供了一个Java预定义类String。在Java中，字符串被当作对象来处理。程序中需要用到的字符串可以分为两大类–创建之后不会再做修改和变动的不可变字符串String类；创建之后允许再做更改和变化的构建字符串StringBuilder类。

　　字符串常量：使用“”定义字符串。Java会自动为字符串常量生成一个String类的对象，所以可以直接初始化String对象。

　　String类：String类对象创建后不能修改。

　　子串：用String类的substring方法可以提取字符串中的子串。格式：substring(int startpoint); substring(int start, int end) 。

　 串连接：当连接一个字符串和一个非字符串时，后者将被转换成字符串。

　　获取字符串的长度：使用String 类中的length()方法可以获取一个字符串的长度。

　　检测字符串是否相等 ：可以使用equals方法检测两个字符串是否相等。一定不能使用“==”运算符检测两个字符串是否相等！这个运算符只能够确定两个字符串是否放置在同一位置上。

　　字符串检索：可以用String类中的方法：indexOf(string s)，indexOf(String s, int startpoint)。

(7)输入输出：

　　读取输入：通过控制台进行输入时，需要构造一个Scanner对象，与“标准输入流”System.in关联。 Scanner in = new Scanner(System.in); 

       nextLine方法将输入一行，使用nextLine方法是因为在输入行中有可能含有空格。读取一个单词就调用 String firetName = in.next();读取整型，调用nexrInt方法，浮点数调用nextDouble方法。

　　格式化输出：使用System.out.print(x)将数值x输出到控制台上，这条命令将以x对应的数据类型所允许的最大非0数字位数打印输出x。

　　文件输入输出：要想对文件进行读取，就需要一个用 File对象构造- 个Scanner对象，如下所示:Scanner in = new Scanner(new File("myfile.txt"));如果文件名中包含反斜杠符号，就要记住在每个反斜杠之前再加一个额外的反斜杠。要想写入文件，就需要构造- 个PrintWriter对象: PrintWriter out = new PrintWriter("myfile.txt");

 (8)控制流程：

　　块作用域：块是指由一对大括号括起来的若干条简单的Java语句。快决定了变量的作用域。一个快可以嵌套在另一个块中。 

 　  条件语句：if，if-else。用法和C语言一样。

　　循环：while语句，do-while语句，for语句，用法和C与语言相似。

第二部分：实验部分

实验名称：实验二 Java基本程序设计（1）

1.  实验目的：

（1）进一步熟悉命令行和IDE两种方式下java程序开发的基本步骤；

（2）掌握Eclipse集成开发环境下导入Java源程序的过程；

（3）掌握Java语言构造基本程序的数据类型、变量、运算符、各类表达式、输入输出、流程控制的基本语法；

（4）掌握Math类、String类、StringBuilder类的用法。

3. 实验步骤与内容：

实验1 ：Java风格九九乘法表程序互评

实验2 ：编写包含以下代码片段的java应用程序，输出字符串类对象s3的值

String s1=“Hello!”;

String s2=“World”;

String s3=s1+s2;

 程序代码如下：

 1 package json;
 2 
 3 public class Plus {
 4 
 5     public static void main(String[] args)//程序入口
 6     {
 7         // TODO Auto-generated method stub
 8         String s1 = "Hello!";//定义了一个String,名为s1
 9         String s2 = "world";
10         String s3 = s1+s2; //将s1+s2赋值给s3
11         System.out.print(s3);
12     }
13 
14 }

程序运行结果如图：

实验3 ：更改实验2中s1,s2为StringBuilder类对象，观察程序运行结果并与实验2结果进行对比。

程序代码如下：

 1 package json;
 2 
 3 public class Plus1 {
 4 
 5     public static void main(String[] args)//程序入口
 6     {
 7         // TODO Auto-generated method stub
 8         StringBuilder s1 = new StringBuilder("Hello!");//定义了一个StringBuilder,名为s1
 9         StringBuilder s2 = new StringBuilder("world");
10         StringBuilder s3 = new StringBuilder() ;
11         s1.append(s2);//添加s2给s1
12         s3.append(s1);
13         System.out.print(s3);
14     }
15 
16 }

程序运行结果如图：

 String类对象是创建后不可修改和变动的不可变字符串，StringBuilder类对象是创建后允许做更改和变化的字符串。实验的要求是与实验2的结果做对比，所以我试过大多数StringBuilder类的方法，发现append()类似于添加，因此我用append()将s2添加到s1里面，又将s1添加到s3里。得到了最后的输出结果。后来我查了一下appen()方法，append()是往动态字符串数组添加，相当‘+’号。String类对象与StringBuilder类对象的区别是String类改变时相当于生成新的String，再改变对象引用。而StringBuffer 类对 StringBuffer 对象本身进行操。

实验4 ：在命令行方式下调试运行程序，理解java应用程序命令行参数的用法。

 实验步骤：(1)新建一个文件，重命名为Message.java。

  　　　　  (2)打开笔记本，复制粘贴代码并保存。将文件复制到D盘。

　　　　　 (3)按键Windows+R,输入cmd。输入d: 转入d盘。

　　　　　 (4)输入javac Message.java,回车。输入java Message -h.

 程序代码如下:

 

 1 package json;
 2 
 3 public class Message {
 4 
 5     public static void main(String[] args) {
 6         // TODO Auto-generated method stub
 7         if (args[0].equals("-h")) //判断数组args[0]是否与与-h相等,相等输出Hello
 8             System.out.print("Hello");
 9         else if(args[0].equals("-g")) 
10             System.out.print("goodbye,");
11       for(int i=1;i//定义一个变量，初始化为1，当i的长度小于数组长度时进行循环
12         System.out.print("  "+args[i]);
13       System.out.println("!");
14     }
15 
16 }

 实验结果如图：

 

实验5 java程序导入

 (1)新建java project如下图:

   

  (2)选择File->import->File ystem->Next，打开文件导入窗口如下图，点击上方Browse选择导入源程序并选中，点击下方Browse选择源程序导入位置为新项目InputTest/src位置后，点击finish完成导入。

 

 (3) 打开InputTest项目src文件夹的缺省包，双击InputTest.java在IDE源程序编辑区打开文件。

(4)右键单击InputTest.java文件名打开快捷菜单，选择Run as->java application运行此程序。

  程序代码如下：

 1 import java.util.*;
 2 
 3 /**
 4  * This program demonstrates console input.
 5  * @version 1.10 2004-02-10
 6  * @author Cay Horstmann
 7  */
 8 public class InputTest
 9 {
10    public static void main(String[] args)
11    {
12       Scanner in = new Scanner(System.in);
13 
14       // get first input
15       System.out.print("What is your name? ");
16       String name = in.nextLine();
17 
18       // get second input
19       System.out.print("How old are you? ");
20       int age = in.nextInt();
21 
22       // display output on console
23       System.out.println("Hello, " + name + ". Next year, you'll be " + (age + 1));
24    }
25 }

  运行结果如下图：

 

 读取输入：Scanner in = new Scanner(System.in);

 nextLine方法将输入一行，使用nextLine方法是因为在输入行中有可能含有空格。

 读取一个单词就调用 String firetName = in.next();

 读取整型，调用nexrInt方法，浮点数调用nextDouble方法。

实验6  导入WriteReadFileTest.java示例程序，运行程序并理解程序代码,观察项目文件夹下文件myfile.txt的内容，掌握文件的输入输出操作。

 程序代码如下：

 1 import java.io.File;
 2 import java.io.FileNotFoundException;
 3 import java.io.PrintWriter;
 4 import java.util.Scanner;
 5 import java.util.Arrays;
 6 
 7 public class WriteReadFileTest {
 8 
 9     /**
10      * @param args
11      * @throws FileNotFoundException 
12      */
13     public static void main(String[] args) throws FileNotFoundException {
14 
15         //写入文件演示
16         PrintWriter out = new PrintWriter("myfile.txt");
17         out.println("姓名 高数 Java 数据结构 平均成绩 总成绩");
18         out.println("张三 20 30 40 0 0");
19         out.println("李四 50 60 70 0 0");
20         out.close();//切记，输出完毕，需要close
21         
22         
23         //读入文件演示
24         Scanner in = new Scanner(new File("myfile.txt"));//为myfile.txt这个File创建一个扫描器in
25         int number = 1;//行号
26         while(in.hasNextLine()){//判断扫描器是否还有下一行未读取，该循环把文件的每一行都读出
27             String line = in.nextLine();//读出myfile.txt的下一行
28             System.out.println("第"+(number++)+"行的内容" +"="+line);
29             
30             Scanner linescanner = new Scanner(line);//对每一行的内容建立一个扫描器
31             linescanner.useDelimiter(" ");//使用空格作为分隔符
32             String name = linescanner.next();
33             String math = linescanner.next();
34             String java = linescanner.next();
35             String ds = linescanner.next();
36             String avg = linescanner.next();
37             String total = linescanner.next();
38             System.out.println("name="+name+" math="+math+" java="+java+" ds="+ds+" avg"+avg+" total="+total);
39             linescanner.close();
40         }
41         in.close();//读入完毕，最后需要对其进行close。    
42 
43  }

程序运行结果如图“

 运行之后在项目文件夹下文件myfile.txt：

要想对文件进行读取，就需要一个用 File对象构造- 个Scanner对象，如下所示:Scanner in = new Scanner(new File("myfile.txt"));如果文件名中包含反斜杠符号，就要记住在每个反斜杠之前再加一个额外的反斜杠。

要想写入文件，就需要构造- 个PrintWriter对象: PrintWriter out = new PrintWriter("myfile.txt");

实验7 ：导入第3章3-3——3-4，掌握两个程序循环控制结构的用途。

 3.3程序代码如下：

 1 import java.util.*;
 2 
 3 /**
 4  * This program demonstrates a while loop.
 5  * @version 1.20 2004-02-10
 6  * @author Cay Horstmann
 7  */
 8 public class Retirement
 9 {
10    public static void main(String[] args)
11    {
12       // read inputs
13       Scanner in = new Scanner(System.in);
14 
15       System.out.print("How much money do you need to retire? ");
16       double goal = in.nextDouble();
17 
18       System.out.print("How much money will you contribute every year? ");
19       double payment = in.nextDouble();
20 
21       System.out.print("Interest rate in %: ");
22       double interestRate = in.nextDouble();
23 
24       double balance = 0;
25       int years = 0;
26 
27       // update account balance while goal isn't reached
28       while (balance < goal)//while循环先判断条件是否满足，满足执行循环体，不满足跳出循环
29       {
30          // add this year's payment and interest
31          balance += payment;
32          double interest = balance * interestRate / 100;
33          balance += interest;
34          years++;
35       }
36 
37       System.out.println("You can retire in " + years + " years.");
38    }
39 }

程序运行结果如图：

 

 3-4程序代码如下：

 1 import java.util.*;
 2 
 3 /**
 4  * This program demonstrates a do/while loop.
 5  * @version 1.20 2004-02-10
 6  * @author Cay Horstmann
 7  */
 8 public class Retirement2
 9 {
10    public static void main(String[] args)
11    {
12       Scanner in = new Scanner(System.in);
13 
14       System.out.print("How much money will you contribute every year? ");
15       double payment = in.nextDouble();
16 
17       System.out.print("Interest rate in %: ");
18       double interestRate = in.nextDouble();
19 
20       double balance = 0;
21       int year = 0;
22 
23       String input;
24 
25       // update account balance while user isn't ready to retire
26       do
27       {
28          // add this year's payment and interest
29          balance += payment;
30          double interest = balance * interestRate / 100;
31          balance += interest;
32 
33          year++;
34 
35          // print current balance
36          System.out.printf("After year %d, your balance is %,.2f%n", year, balance);
37 
38          // ask if ready to retire and get input
39          System.out.print("Ready to retire? (Y/N) ");
40          input = in.next();
41       }
42       while (input.equals("N"));//do-while循环先循环一次，再判断条件。
43    }
44 }

运行结果如下图：

 

实验8  导入第3章3-5示例程序，理解抽奖概率计算算法。

 程序代码如下：

 1 import java.util.*;
 2 
 3 /**
 4  * This program demonstrates a for loop.
 5  * @version 1.20 2004-02-10
 6  * @author Cay Horstmann
 7  */
 8 public class LotteryOdds
 9 {
10    public static void main(String[] args)
11    {
12       Scanner in = new Scanner(System.in);
13 
14       System.out.print("How many numbers do you need to draw? ");
15       int k = in.nextInt();
16 
17       System.out.print("What is the highest number you can draw? ");
18       int n = in.nextInt();
19 
20       /*
21        * compute binomial coefficient n*(n-1)*(n-2)*...*(n-k+1)/(1*2*3*...*k)
22        */
23 
24       int lotteryOdds = 1;
25       for (int i = 1; i <= k; i++)
26          lotteryOdds = lotteryOdds * (n - i + 1) / i;
27 
28       System.out.println("Your odds are 1 in " + lotteryOdds + ". Good luck!");
29    }
30 }

 程序运行如下：

 

4. 实验总结：

在第一个实验中，我意识到了我的不足。在写九九乘法表的代码中，因为eclipse会自动生成开头的结尾，所以我只写了里面的循环体。在这个试验后我加深了这方面的学习。

在第二个实验中，结合第三个实验，我理解了String类对象与StringBuilder类对象的区别。并且尝试了一些常用的String类和StringBuilder类的方法。

在第四个实验中，学会了在命令行传递参数，并且在助教的讲解下知道了怎么在eclipse的运行环境下传参。如图：在运行中找到运行配置

在第五个实验中，我学会了在eclipse环境下导入程序。虽然不知道为什么实验室可以一次就成功而在自己的电脑上就一堆的问题，但是最后成功了。

在第六个实验中，学习了文件的输入输出。读写文件是以流的形式读写，因此在最后应该关闭流。对文件进行读取，要一个用 File对象构造- 个Scanner对象，写入文件，要构造- 个PrintWriter对象: 具体的我在实验六后有介绍。

在第七个实验中，加深了对三种循环的理解，Java语言的循环是和C语言没有太大差别的。三种循环的具体使用我在理论知识有介绍。

同时也学会了抽奖概率的算法。