20155326刘美岑2016-2017-2《Java程序设计》第三周学习总结

教材学习内容总结

基本类型和类类型

• 基本类型：第三章中讲述的那几种，short、long、int、byte、double、char、boolean等这些。
• 类类型：指class类型，把一些基本的类型和方法整合到一起，体现出了类的封装特性，便于实现模块化。

对象和类

• 使用Java撰写程序几乎都在使用对象，要产生对象必须先定义类，类是对象的设计图，对象是类的实例。

定义类

• 类定义时使用class关键词，建立实例要使用new关键词。引用书上例子：衣服的型号与颜色

• 代码和运行结果如下：

• 程序示例

        class Clothes
        {
            String color;
            char size;
        }        public class Field
        {
            public static void main(String[] args)
            {
            Clothes sun = new Clothes();
            Clothes spring = new Clothes();
            sun.color = "red";
            sun.size = 'S';
            spring.color = "green";
            spring.size = 'M';
            System.out.printf("sun(%s,%c)%n",sun.color,sun.size);
            System.out.printf("spring(%s,%c)%n",spring.color,spring.size);
            }
        }

-运行结果

使用class关键字定义类，在Field.java中定义了两个类，一个是非公开的Clothes类，另一个是公开（public）的Field类（文档中的主文档名必须与公开类名称一致）。Clothes类中定义了color和size两个变量，叫作定义两个值域成员或定义两个数据对象成员。Clothes sun = new Clothes()为将sun名称参考至新建对象，其中Clothes sun叫作声明参考名称、参考变量或直接叫参考，=是指定，new关键字是建立对象实例。有几个类就会产生几个.class文档。

使用标准类：

• 标准API可以省去撰写程序时重新打造基础的需求，包名为java开头的类表示标准API提供的类。
• java.util.Scanner取得用户输入

  （1）、使用java.util.Scanner，将字符转化为整数。

• 代码和运行结果如下：

//使用标准类
    package cc.openhome;
import java.util.Scanner;public class Guess {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);//建立Scanner实例
        int number=(int)(Math.random()*10);
        int guess;        do {
            System.out.print("猜数字(0~9):");
            guess = scanner.nextInt();//取得下一个整数
        }while(guess!=number);
        System.out.println("猜中了...XD");
    }
}

结果截图：

• 在java中，当通过newScanner(System.in)创建一个Scanner，控制台会一直等待输入，直到敲回车键结束，把所输入的内容传给Scanner，作为扫描对象。Scanner对每个基本类型，都会有个对应的nextxxx（）方法，如果直接取得上一个字符串（以空格或换行分隔），则使用next（），如果想取得用户输入的整行文字，则使用nextLine（）（以换行分隔）

  （2）、使用java.math.BigDecimal,得到更好的精确度。

• 代码和运行结果如下：

  

• 创建BigDecimal的方法之一是使用字符串，BigDecimal在创建时会剖析传入字符串，以默认精度进行接下来的运算。BigDecimal提供有plus（）、subtract（）、multiply（）、divide（）等方法，可以进行加减乘除等运算，这些方法都会返回代表运算结果的BigDecimal。

对象指定与相等性

• 当用于基本类型时，=是将值复制给变量，==是比较两个变量存储的值是否相同。
• 当用于类类型时，=是用在指定参考名称参考某个对象，==是用在比较两个参考名称是否参考同一对象。
• 代码和运行结果如下：

  package cc.openhome;import java.math.BigDecimal;public class Compare {    public static void main(String[] args) {        BigDecimal a=new BigDecimal("0.1");        BigDecimal b=new BigDecimal("0.1");        BigDecimal c=a;        System.out.println(a==b);        System.out.println(a==c);        System.out.println(a.equals(b));    }}

• 程序中使用a==b，就是在问，a名牌绑的对象是否就是b名牌绑的对象？答案“不是”。程序中使用a.equals(b),就是在问，a名牌绑的对象与b名牌绑的对象，实际上内涵值是否相同，答案“是”。

基本类型打包

• 基本类型打包器主要目的是将基本类型打包在对象之中，就像是将基本类型当作对象操作。

  基本类型打包器都是归类于java.lang包中。

  Integer提供compareTo()方法，可与另一个Integer对象进行比较，如果打包值相同就返回0，小于就返回-1，大于就返回1。

  可用Number类来自动装箱。

  null代表一个特殊对象，任何类声明的参考名称都可以参考至null，表示该名称没有参考至任何对象实体。

• 代码和运行结果如下：

package cc.openhome;public class IntegerDemo {
    public static void main(String[] args) {
        int data1=10;
        int data2=20;
        Integer wrapper1=new Integer(data1);
        Integer wrapper2=new Integer(data2);
        System.out.println(data1/3);
        System.out.println(wrapper1.doubleValue()/3);
        System.out.println(wrapper1.compareTo(wrapper2));
    }
}

数组

• 数组打印：数组就像是一个有很多小隔间的容器，每个小隔间可以放入一个元素，例如在数组中存入六个数字，并打印出来

• 代码和运行结果如下：

//不规则二维数组package cc.openhome;public class IrregularArray {    public static void main(String[] args) {
        int[][] arr=new int[2][];//声明arr参考的对象会有两个索引
        arr[0]=new int[]{1,2,3,4,5};//arr[0]是长度为5 的一维数组，想在new数组中一并指定初始值，不必指定数组长度。
        arr[1]=new int[]{1,2,3};//arr[1]是长度为3的一维数组。
        for(int[] row:arr){
            for(int value:row){
                System.out.printf("%2d",value);
            }
            System.out.println();
        }
    }}

• 数组复制：System.arraycopy()的五个参数分别是来源数组、来源起始索引、目的数组、目的起始索引、复制长度。Arrays.copyOf()可以建立新数组，第二个参数是指定建立的新数组长度。

• 代码和运行结果如下：

package cc.openhome;import java.util.Arrays;public class CopyArray {    public static void main(String[] args) {
        int[] scores1={88,81,74,68,78,76,77,85,95,93};
        int[] scores2=Arrays.copyOf(scores1,scores1.length);
        for(int score:scores2){
            System.out.printf("%3d",score);
        }
        System.out.println();
        scores2[0]=99;//不影响score1参考的数组对象
        for(int score:scores1){
            System.out.printf("%3d",score);
        }
        System.out.println();
        for(int score:scores2){
            System.out.printf("%3d",score);
        }
    }
}

• 浅层复制：仅将每个索引处所参考的对象给复制的参考，并没有复制出对象。
• 深层复制：连同对象一同复制，必须自行操作。

字符串对象：

• 由字符组成的文字符号称为字符串。由于在java中是对象，所以可以使用length()取得字符串长度，使用charAt()指定取得字符串中某个字符，索引从0开始，使用toUpperCase将原本小写的字符串内容转为大写的字符串内容。字符串的本质是打包字符数组的对象，是java.lang.String类的实例。length()是取得字符串长度，charAt()是取得字符串中某个字符，toUpperCase()是将原本小写的字符串内容转为大写的字符串内容。用 "" 写下的字符串称为字符串常量，使用 + 连接字符串会产生新的String实例。以""包括的字符串，只要内容相同（序列、大小写相同），无论在程序代码中出现几次，JVM都只会建立一个String实例，并在字符串池中维护。

  用""写下的字符串称为字符串常量。

• 代码和运行结果如下：

package cc.openhome;import java.util.Scanner;public class Sum {    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        long sum=0;
        long number=0;
        do{
            System.out.print("输入数字: ");
            number=Long.parseLong(scanner.nextLine());
            sum+=number;
        }while(number!=0);
        System.out.println("总和："+sum);
    }
}

封装

• 封装可以理解为把方法封在类中，用打时候可以直接拿，就好比你要上学，类就是书包而方法就是书，要用方法打时候直接从书包中拿书就行。
• 代码和运行结果如下：

package cc.openhome;class CashCard{    String number;
    int balance;
    int bonus;
    CashCard(String number,int balance,int bonus){
        this.number=number;
        this.balance=balance;
        this.bonus=bonus;
    }
}public class CardApp {    public static void main(String[] args) {
        CashCard[] cards={
                new CashCard("A001",500,0),
                new CashCard("A002",300,0),
                new CashCard("A003",1000,1),
                new CashCard("A004",2000,2),
                new CashCard("A005",3000,3)        };
        for(CashCard card:cards){
            System.out.printf("(%s,%d,%d)%n",card.number,card.balance,card.bonus);
        }
    }
}

函数

• 函数又称方法，是定义在类中的具有特定功能的一段独立的小程序。

• 构造函数时若要将某参数的值指定给同名参数时，要使用this表示。

  代码如下：

• 格式：

    修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2,...)
    {
    执行语句;
    return 返回值;
    }
  

• 返回值类型函数运行后结果的数据类型，return结束函数，返回值返回给调用处，形式参数变量，存储调用函数时传递给函数的实际参数，实际参数传递给形式参数的具体数值。

• 不用返回值的函数可以用void声明。

• 程序示例

        class Clothes2
        {
            String color;
            char size;
            Clothes2(String color, char size)
            {
                this.color=color;
                this.size=size;
            }
        }        public class Field2
        {
            public static void main(String[] args)
            {
                Clothes2 sun = new Clothes2("red",'S');
                Clothes2 spring = new Clothes2("green",'M');
                System.out.printf("sun(%s,%c)%n",sun.color,sun.size);
                System.out.printf("spring(%s,%c)%n",spring.color,spring.size);
            }
        }

打包

• 使用Long、Integer、Double、Float、Boolean、Byte等类来打包基本类型，将基本类型当作对象操作。J2SE5.0后可以自动装箱、拆箱。

数组

• 是同一类型数据的集合，是一个容器。它会自动从0开始编号。
• 格式：

  元素类型[] 数组名=new 元素类型[元素个数或数组长度];

  元素类型[] 数组名=new 元素类型[]{元素,元素,…};

  元素类型[] 数组名={元素,元素,…};

• 数组一被定义即有默认初始值。

增强式for循环

       for(int score:scores)
        {
        System.out.printf("学生分数：%d %n",scores);
        }

二维数组

       public class XY
        {
             public static void main(String[] args)
             {
                  int[][] cords={
                                {1,2,3},
                                {4,5,6}
                                };
                 for(int[] row : cords)
                {
                    for(int value : row)
                    {
                        System.out.printf("%2d",value);
                    }
                    System.out.println();
                }            }
         }

static类：

被声明为static的成员，不会让个别对象拥有，而是属于类，被声明为static的方法，是将类名称作为名称空间，可以通过类名称和"."运算符来调用static。

由于static成员是属于类，而非个别对象，所以在static成员中使用this，会是一种语意上的错误。

静态变量必须在初始化之前进行赋值，否则会报错。静态方法通常都是被经常使用的方法，不需要每次都重新实例化，提高工作效率。

• 代码和运行结果如下：

package cc.openhome;//static应用import java.util.Scanner;import static java.lang.System.in;import static java.lang.System.out;public class ImportStatic {    public static void main(String[] args) {
        Scanner scanner=new Scanner(in);
        out.print("请输入姓名：");
        out.printf("%s 你好! %n",scanner.nextLine());
    }
}

不定长度自变量、内部类与传值调用：

• 类中定义类，称为内部类。可以定义在类区块中。

  要使用不定长度自变量，声明参数列时要在类型关键字后加上…，方法上声明的不定长度参数必须是参数列最后一个。

  Java中只有传值调用。

代码调试中的问题和解决过程

课本上的代码敲上去之后在终端却运行不了，出现了下图中的错误。但是在IDEA中却可以运行。