201871010110 - 李华 《面向对象程序设计（java）》第二周学习总结

第一部分：理论知识学习部分

一.简单的Java程序应运程序

1.标识符0标识符由字母、下划线、美元符号和数字组成，且第一个符号不能为数字。

  标识符可用作：类名、对象名、变量名、方法名、数组名、文件名等

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

二.注释

注释Java有三种注释的方式：1.注释内容由//一直到此行结束。

                                               2./*和*/定义一个注释块。

                                               3./**开始，*/结束这种注释方法可用来自动产生文档。

三.数据类型

1.数据类型Java是一种强类型语言。这意味着每一个变量必须声明一种为类型。

  Java共有8种基本类型   -整数类型（int、short、long、byte）-浮点类型（float、double）-字符类型（char）-布尔类型（boolean）
2.整数类型整型常量表示：十进制，八进制，十六进制，二进制

   整型变量的数据类型分为四种：int short long byte，Java中整数的范围与运行Java代码的机器无关且Java中没有unsigned类型。

 

                                              int型   ，变量定义：int x;int height,age;定义同时可赋值：intheight=180,age=20;对于int型变量，内存分配个4字节，占32位
                                              short型  ，变量定义：short h;short m,n;定义同时可赋值:shortm=12,n=20;对于short型变量，内存分配2个字节，占16位，
                                              long型  ，变量定义：long sum;long I,j.k;定义同时可赋值：longsum=343435L;对于long型变量，内存分配8个字节，占64位
                                              byte型  ，变量定义：byte w;byte x,y,z;定义同时可赋值：bytex=12,y=24,z=36;对于byte型变量，内存分配个1字节，占8位
3.浮点类型Java中有两种浮点类型：float double

 

   浮点常量的表示：小数表示，科学计数

   表示溢出和出错的三种特殊的浮点常量：正无穷大——Double.POSITIVEINFINITY负无穷大——Double.NEGATIVE_INFINITYNaN

   float型有效小数位数为6~7，变量的定义float x;floatx1,x2,x3，定义时赋初值floatx1=12.23f,x2=32.00f,x3，对于float型变量内存分配4个字节，占32位
   double型有效小数位数为15，变量定义double d;doubled1,d2,d3，定义时可以赋初值doubled1=12.23,d2=32.00d,d3;对于double型变量内存分配8个字节，占64位。

4.字符类型常量‘a’、‘A’、‘8’、‘?'。变量定义char q;char c,type,cat;定义同时可赋值char c=‘a ',type,cat;19
  字符集：Java采用unicode字符编码集，该编码集16位，含有65536个字符。

  Unicode(统一码、万国码)是一个编码规范，转义字符-前缀lu表示Unicode值，而十六进制的4位数字则表明具体是哪个Unicode字符。
5.布尔类型常量true、false变量的定义boolean x;boolean x,y;定义同时可赋值booleanx=true,y=false;在Java中，布尔值和整数不能相互转换

 

四.变量

1.变量在Java中，每一个变量属于一种类型。在声明变量时，变量所属的类型位于变量名之前。-double salary;-int vacationDays;-long earthPopulation;-boolean done;在Java中，一行可以声明多个变量。逐一声明每一个变量可以提高程序的可读性。
2.变量初始化一个变量声明后，必须通过赋值语句对它进行明确的初始化——永远不要使用一个未初始化的变量值。在Java中，可以在代码的任何位置进行变量声明。变量的声明尽可能地靠近变量第一次使用的地方，这是一种良好的程序编写风格。在Java中，不能在同一作用域内声明两个同名的变量

 

五.运算符

1.各种运算符：与面向对象运算相关Java提供的一个特别运算符new-这是一个用来创建对象的运算符。Java另外一个特别运算符Instanceof-返回一个布尔值来指出某个对象是否是一个特定类或者是它的子类的一个实例。
2.需注意运算符的优先级与结合性优先级操作符结合性
3.数学函数与常量数学函数包含在Math类中。-幂函数-三角函数-指数函数及它的反函数等Java还提供了两个常量。-Math.PI-Math.E若不想在数学方法名和常量名前加前缀Math.”，可在源文件顶部加上以下代码即可。
4.强制类型转换强制类型转换的语法：（目标类型） 变量。

 

六.字符串

1.字符串Java字符串是Unicode字符的序列，它是组织字符的基本数据结构，用法类似于字符数组。有内置的字符串类型，在标准Java类库中提供了一个Java预定义类String。

   程序中需要用到的字符串可以分为两大类：-创建之后不会再做修改和变动的不可变字符串String类；-创建之后允许再做更改和变化的构建字符串StringBuilder类。

 

七.输入输出

1.读取输入通过控制台进行输入时，需要构造一个Scanner对象，并与“标准输入流”System.in关联。-Scannerin=newScanner(System.in);-例3-2InputTest.javap55任务：测试InputTest.javaScanner类定义在java.util包中，因此使用时需将相应的包加载进来
2.文件输入与输出要想对文件进行读取，就需要一个用File对象构造一个Scanner对象。要想写入文件，就需要构造一个PrintWriter对象，在构造器中，需要需提供文件名。

 

八控制语句（程序控制流程由这些控制语句确定）

1.if、switch、for、while、do-while

2.Package语句和import语句

九.大数值

a)如果基本的整型和浮点型数据无法达到要求的精度，可以使用java.math包中的两个类， BigInteger和BigDecimal。

b)这两个类可以操作任意长的数字：BigInteger类实现了任意精度的整数运算， BigDecimal实现了任意精度的浮点运算

十.数组

1.数组是一种数据结构，它是有序数据的集合。数组中的每一个元素的数据类型都是相同的。

2.数组的声明：一维数组格式    数组元素类型    数组名字[];    数组元素类型[]  数组名字；

二维数组格式：数组元素类型    数组名字[][];    数组元素类型[][]   数组名字；其中数据类型可以为java中的任意类型，包括基本类型和复合类型。也可用定义的类来声明数组；

java在数组声明时并不为数组分配内存，在java中，数组是独立的类，有自身的办法。

3.数组的创建

数组声明后，要用new运算符为其分配内存空间，分配内存空间时必须指明数组的长度。

格式：数组名字=new  数组元素类型[个数]

第二部分：实验部分

1、实验目的与要求

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

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

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

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

2、实验内容和步骤

实验1：java风格九九乘法表程序互评（总分10分）

评分要求：结合评分程序的运行情况，给出评分程序成绩，满分5分，每个错误扣1分，扣至0分为止；

评分者每发现一个正确的错误，本人实验1得分加1分，最高加5分。

已评！

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

String s1=“Hello!”;

String s2=“World”;

String s3=s1+s2;

编写代码如下：

package example1;

 

public class test2 {

 

    public static void main(String[] args) {  //程序入口

        // TODO Auto-generated method stub

        String s1="Hello!";            //定义了一个String，名为s1,并将字符串Hello赋值给s1

        String s2="World";             //定义了一个String，名为s2，并将字符串World赋值给s2

        String s3=s1+s2;               //定义了一个String，名为上，并将s1+s2的值赋给s3

        System.out.println(s3);        //输出s3的值

    }

 

}

程序运行截图如下：

　　

实验3：更改实验2中s1、s2、s3为StringBuilder类对象，观察程序运行结果并与实验2结果进行对比，理解String类对象与StringBuilder类对象的区别。

程序代码如下：

package message;

public class Message {

	public static void main(String[] args) {
		StringBuilder s1=new StringBuilder("Hello!");   //在字符串构建器StringBuilder中创建一个新的StringBuilder
		StringBuilder s2=new StringBuilder("world");
		StringBuilder s3=new StringBuilder();
		s3.append(s1);
		s3.append(s2);       //用StringBuilder将s1和s2拼接起来
        System.out.println(s3);

	} 

}

　　程序运行截图如下：

由实验可知，更改实验2中s1、s2、s3为StringBuilder类对象，实验结果相同；

String类对象与StringBuilder类对象的区别：

string 对象时恒定不变的，stringBuider对象表示的字符串是可变的。当修改字符串信息时，此时不许创建对象，可以使用stringBuilder对象。

String 对象是不可改变的。每次使用 System.String 类中的方法之一时，都要在内存中创建一个新的字符串对象，这就需要为该新对象分配新的空间。

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

public class Message

{

public static void main(String[] args)

{

if (args[0].equals(“-h”)) System.out.print(“Hello”);

else if(args[0].equals(“-g”)) System.out.print(“goodbye,”);

for(int i=1;i<args.length;i++)

System.out.print(“  ”+args[i]);

System.out.println(“!”);

}

}

程序代码如下：

package message;

public class Message {

	public static void main(String[] args) {
		 if (args[0].equals("-h")) System.out.print("Hello");
		    else if(args[0].equals("-g")) System.out.print("goodbye,");
		  for(int i=1;i<args.length;i++)
		    System.out.print(""+args[i]);
		  System.out.println("!");

	}

}

　　

程序运行截图如下：

通过 调试运行此程序， 可知java应用程序命令行参数的用法：

Java中的命令行参数原来是通过主函数的参数实现的，且主函数的参数个数以及参数的类型其实并没有限制，在Java的基础知识中可知道，数组中存储的对象类型必须一致，所以即使是参数中写入的是数字也会按照String的类型进行强制数据类型转换。

实验5：Eclipse环境下导入第3章示例程序InputTest.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运行此程序，结合程序运行结果，理解代码中Scanner类对象用法，掌握java控制台输入方法。

程序代码如下：

import java.util.*;

/**
 * This program demonstrates console input.
 * @version 1.10 2004-02-10
 * @author Cay Horstmann
 */
public class InputTest
{
   public static void main(String[] args)
   {
      Scanner in = new Scanner(System.in);

      // get first input
      System.out.print("What is your name? ");
      String name = in.nextLine();

      // get second input
      System.out.print("How old are you? ");
      int age = in.nextInt();

      // display output on console
      System.out.println("Hello, " + name + ". Next year, you'll be " + (age + 1));
   }
}

　　

程序运行截图如下：

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

程序代码如下：

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Scanner;
import java.util.Arrays;

public class WriteReadFileTest {

	/**
	 * @param args
	 * @throws FileNotFoundException
	 */
	public static void main(String[] args) throws FileNotFoundException {

		//写入文件演示
		PrintWriter out = new PrintWriter("myfile.txt");
		out.println("姓名 高数 Java 数据结构 平均成绩 总成绩");
		out.println("张三 20 30 40 0 0");
		out.println("李四 50 60 70 0 0");
		out.close();//切记，输出完毕，需要close

		//读入文件演示
		Scanner in = new Scanner(new File("myfile.txt"));//为myfile.txt这个File创建一个扫描器in
		int number = 1;//行号
		while(in.hasNextLine()){//判断扫描器是否还有下一行未读取，该循环把文件的每一行都读出
			String line = in.nextLine();//读出myfile.txt的下一行
			System.out.println("第"+(number++)+"行的内容" +"="+line);

			Scanner linescanner = new Scanner(line);//对每一行的内容建立一个扫描器
			linescanner.useDelimiter(" ");//使用空格作为分隔符
			String name = linescanner.next();
			String math = linescanner.next();
			String java = linescanner.next();
			String ds = linescanner.next();
			String avg = linescanner.next();
			String total = linescanner.next();
			System.out.println("name="+name+" math="+math+" java="+java+" ds="+ds+" avg"+avg+" total="+total);
		}
		in.close();//读入完毕，最后需要对其进行close。	

 }
}

　　

程序运行截图如下：

文件myfile.txt的内容：

实验7：按照实验5的操作步骤，导入第3章3-3——3-4示例程序，掌握两个程序循环控制结构的用途。

程序代码如下：3-3

import java.util.*;

/**
 * This program demonstrates a <code>while</code> loop.
 * @version 1.20 2004-02-10
 * @author Cay Horstmann
 */
public class Retirement
{
   public static void main(String[] args)
   {
      // read inputs
      Scanner in = new Scanner(System.in);

      System.out.print("How much money do you need to retire? ");
      double goal = in.nextDouble();

      System.out.print("How much money will you contribute every year? ");
      double payment = in.nextDouble();

      System.out.print("Interest rate in %: ");
      double interestRate = in.nextDouble();

      double balance = 0;
      int years = 0;

      // update account balance while goal isn't reached
      while (balance < goal)
      {
         // add this year's payment and interest
         balance += payment;
         double interest = balance * interestRate / 100;
         balance += interest;
         years++;
      }

      System.out.println("You can retire in " + years + " years.");
   }
}

　　3-4代码

import java.util.*;

/**
 * This program demonstrates a <code>do/while</code> loop.
 * @version 1.20 2004-02-10
 * @author Cay Horstmann
 */
public class Retirement2
{
   public static void main(String[] args)
   {
      Scanner in = new Scanner(System.in);

      System.out.print("How much money will you contribute every year? ");
      double payment = in.nextDouble();

      System.out.print("Interest rate in %: ");
      double interestRate = in.nextDouble();

      double balance = 0;
      int year = 0;

      String input;

      // update account balance while user isn't ready to retire
      do
      {
         // add this year's payment and interest
         balance += payment;
         double interest = balance * interestRate / 100;
         balance += interest;

         year++;

         // print current balance
         System.out.printf("After year %d, your balance is %,.2f%n", year, balance);

         // ask if ready to retire and get input
         System.out.print("Ready to retire? (Y/N) ");
         input = in.next();
      }
      while (input.equals("N"));
   }
}

　　

程序运行截图如下：

实验8：按照实验5的操作步骤，导入第3章3-5示例程序，理解抽奖概率计算算法。

程序代码如下：

import java.util.*;

/**
 * This program demonstrates a <code>for</code> loop.
 * @version 1.20 2004-02-10
 * @author Cay Horstmann
 */
public class LotteryOdds
{
   public static void main(String[] args)
   {
      Scanner in = new Scanner(System.in);

      System.out.print("How many numbers do you need to draw? ");
      int k = in.nextInt();

      System.out.print("What is the highest number you can draw? ");
      int n = in.nextInt();

      /*
       * compute binomial coefficient n*(n-1)*(n-2)*...*(n-k+1)/(1*2*3*...*k)
       */

      int lotteryOdds = 1;
      for (int i = 1; i <= k; i++)
         lotteryOdds = lotteryOdds * (n - i + 1) / i;

      System.out.println("Your odds are 1 in " + lotteryOdds + ". Good luck!");
   }
}

　　

程序运行截图如下：

在运行过程中， 该程序用来计算抽奖中奖的概率，应用了for循环，计算了如下公式的值：n*(n-1)*(n-2)*...*(n-k+1)/(1*2*3...*k)

第三部分 实验总结

在经过实验之后，将需要注意的知识点做一总结，细节知识需要作为重点记忆。
Java有8种数据类型，其中4种整型、2种浮点类型、1种用于表示Unicode编码的字符单元的字符类型char和1种用于表示真值的boolean类型。float类型的数值有一个后缀F或者f，如1.23f，没有后缀的话就默认为double。

有三种特殊的浮点数值：正无穷大，负无穷大，NaN

这三种数值是用于表示溢出和出错情况的，例如一个正浮点数除以0的结果为正无穷大（Infinity），而负浮点数除以0的结果为负无穷大（-Infinity）。计算0.0/0或者负数的平方根结果为NaN。
正无穷大通过Double或FLoat的POSITIVE_INFINITY表示；正无穷大通过Double或FLoat的NEGATIVE_INFINITY表示；正无穷大通过Double或FLoat的NaN表示。需要注意的是所有正无穷大数值都是一样的，所有负无穷大数值都是一样的，但是NaN不与任何数值相等，即便是自身也不相等，要判断一个特定值是否是NaN只能用Double.isNaN方法。

在Java中，利用关键字final指示常量，一次。一旦被赋值之后，就不能够再更改了。

boolean类型值有两个 true 和false,Java中boolean和整形两者之间不能相互转换，数据之间进行运算时需要注意运算符的先后 顺序。

字符串包含两类：创建之后不会再做修改和变动的不可变字符串String类；-创建之后允许再做更改和变化的构建字符串StringBuilder类。在编写程序的过程中也要注意文件的输入与输出。

总之，通过这一章的学习对java有了更清楚的理解，知识点在程序中的应运也更加重要。