20145312 《Java程序设计》第三周学习总结

20145312 《Java程序设计》第三周学习总结

学习笔记

Chapter 4

4.1类与对象

4.1.1 定义类

1.以服饰设计为例，类定义用class关键词，建立衣服实例要用new关键词。在Java术语中，叫参考名称、参考变量或叫参考。

2.在Clothes类中，定义了color与size两个变量，叫作定义两个值域成员或定义两个对象数据成员。

代码如下：

class Clothes{ //定义Clothes类
    String color;
    char size;
}
public class Field {
    public static void main(String[] args){
        Clothes sun=new Clothes();
        Clothes spring=new Clothes();//建立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);//显示个别对象的数据成员值
    }
}
/*
在这个Field.java中，定义了两个类，一个是公开的Field类，所以文档主文档名是Field，另一个是非公开的Clothes。
/*

结果如下：

sun(red,s)
spring(green,M)

3.定义构造函数，建立对象同时指定数据成员值。

代码如下：

class Clothes2{
    String color;
    char size;
    Clothes2(String color,char size){ //定义构造函数
        this.color=color; //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 );
    }
}
/*
在这个例子中，定义新建对象时，必须传入两个自变量给string类型的color参数和char类型的size参数，
而构造函数中，由于color参数与数据成员color同名，不能用color=color表示，要使用this表示，
将color参数的值指定给这个对象（this）的color成员。
 */

结果如下：

sun(red,S)
spring(green,M)

4.1.2 使用标准类

1.Java SE提供了标准API，这些API就是由许多类组成的，直接取用标准类，省去重新打造基础的需求。

2.使用java.util.Scanner

代码如下：

import java.util.Scanner;//告诉编译程序接下来想偷懒
public class Guess {
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);//建立SScanner实例
        int number=(int)(Math.random() *10);
        int guess;
        do{
            System.out.print("猜数字（0~9）:");
            guess=scanner.nextInt();//取得下一个整数
        }while(guess!=number);
        System.out.println("猜中了...XD");
    }
}
/*
一开始用import编译，不用每次输入java.util.Scanner。Scanner 的nextInt()方法会尝试剖析输入的下一个字符串为int类型。如果想取得用户输入的整行文字，使用nextLine()。
*/

结果如下：

猜数字（0~9）:4
猜数字（0~9）:7
猜中了...XD

3.使用java.math.BigDecimal得到更好的精确度。

代码如下：

import java.math.BigDecimal;
public class DecimalDemo {
    public static void main(String[] args){
        BigDecimal operand1=new BigDecimal("1.0");
        BigDecimal operand2=new BigDecimal("0.8");
        BigDecimal result=operand1.subtract(operand2 );
        System.out.println(result);
    }
}
/*
BigDecimal提供plus(),subtract(),multiply(),divide()等方法，可以进行加、减、乘、除等运算
 */

结果如下：

0.2

4.利用BigDecimal比较相等的例子。

代码如下：

import java.math.BigDecimal;
public class DecimalDemo2 {
    public static void main(String[] args){
        BigDecimal op1=new BigDecimal("0.1");
        BigDecimal op2=new BigDecimal("0.1");
        BigDecimal op3=new BigDecimal("0.1");
        BigDecimal result=new BigDecimal("0.3");
        if(op1.add(op2) .add(op3).equals(result)){
            System.out.println("等于0.3");
        }
        else{
            System.out.println("不等于0.3");
        }
    }
}
/*
由于BigDecimal的add()等方法都会返回代表运算结果的BigDecimal，所以就直接利用返回的BigDecimal再调用add()方法，最后再调用equals()比较两个BigDecimal实质上是否相同，所以有了a.add(b).add(c).equals(result)的写法。
 */

结果如下：

等于0.3

4.1.3 对象指定与相对性

1.当=用于基本类型时，是将值复制给变量，当用于基本类型时，是比较两个变量存储的值是否相同。

2.在操作对象时，=是将某个名片绑到某个对象，而是用在比较两个名牌是否绑到同一个对象。而！=正好相反，是比较两个名牌是否没参考同一对象。

4.2 基本类型打包器

4.2.1 打包基本类型

1.要让基本类型想对象一样操作，可以使用Long,Integer,Double,Float,Byte,

Boolean 等类来打包基本类型。

2.这类所谓的打包器提供对象实例作为“壳”，将基本类型打包在对象中。

代码如下：

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));
    }
}
/*
操作Integer的doubleValue()将打包值以double类型返回，这样就会在double空间中做相除，结果就会显示3.33333333...。Integer提供CompareTo()方法，可与另一个Integer值相比较，如果打包值相同就返回0，小于CompareTo()传回对象打包值就返回-1，否则就返回1.
 */

结果如下：

3
3.3333333333333335
-1

4.2.2 自动装箱、拆箱

1.除了使用new建立基本类型打包器外，从J2SE 5.0之后提供了自动装箱。

代码如下：

public class IntegerDemo2 {
    public static void main(String[] args){
        Integer data1=10;
        Integer data2=20;
        System.out.println(data1.doubleValue()/3);
        System.out.println(data1.compareTo(data2));
    }
}

结果如下：

3.3333333333333335
-1

2.自动拆箱就是自动取出打包器中的基本形态信息。例如：

Integer wrapper=10;//自动装箱

Integer foo=wrapper;//自动拆箱

4.3 数组对象

4.3.1 数组基础

1.在java中声明数组并初始值，如下：

int[] scores={88,65,45,78,97,23,41,35,66};

想要依次取出数组中的每个值，可以用for循环。

代码如下：

public class Score {
    public static void main(String[] args){
        int[] scores={88,81,84,76,95,91,93,74,73,98};
        for(int i=0;i<scores.length;i++){
            System.out.printf("学生成绩：%d%n",scores[i]);
        }
    }
}

结果如下：

学生成绩：88
学生成绩：81
学生成绩：84
学生成绩：76
学生成绩：95
学生成绩：91
学生成绩：93
学生成绩：74
学生成绩：73
学生成绩：98

2.二维数组使用两个索引存取数组元素。例如，声明数组来储存XY坐标位置要放的值，代码如下：

public class XY {
    public static void main(String[] args) {
        int [][] cords={{1,2,3},{4,5,6}};
        for(int x=0;x<cords.length;x++){
             for(int y=0;y<cords[x].length;y++){
                  System.out.printf("%2d",cords[x][y]);
             }
            System.out.println();
        }
    }
}
/*
由于二维数组有两个维度，必须先通过cords.length得知有几列，
对于每一列再利用cords[x].length知道有几个元素。
 */

结果如下：

 1 2 3
 4 5 6

4.3.2 操作数组对象

1.如果事先不知道元素值，只知道元素个数，可以使用new 关键词指定长度来建立数组。在java中，new一定是建立对象。使用new建立数组后，每个索引元素会有默认值。例如，将每个学生的成绩默认为60分起，代码如下：

public class Score3 {
    public static void main(String[] args) {
        int[] scores=new int[10];
        for(int score:scores){
            System.out.printf("%2d",score);
        }
        System.out.println();
        Arrays.fill(scores,60);
        for(int score:scores){
            System.out.printf("%3d",score);
        }
    }
}

结果如下：

 0 0 0 0 0 0 0 0 0 0
 60 60 60 60 60 60 60 60 60 60

2.可以利用二维数组建立不规则矩阵。代码如下：

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的一维数组
        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();
        }
    }
}
/*
New int[2][]仅提供第一个[]数组，这表示arr参考对象会有两个索引，但暂时参考至null。
*/

结果如下：

 1 2 3 4 5
 1 2 3

3.类类型建立数组。用new关键词建立数组：

Integer[] scores=new Integer[3];

这个片段的每个索引都是Ineger类型。代码如下：

public class IntegerArray {
    public static void main(String[] args){
        Integer[] scores=new Integer[3];
        for(Integer score:scores){
            System.out.println(score);
        }
        scores[0]=new Integer(99);
        scores[1]=new Integer(87);
        scores[2]=new Integer(65);
        for(Integer score:scores){
            System.out.println(score);
        }
    }
}

结果如下：

null
null
null
99
87
65

4.3.3 数组复制

1.要做数组复制，基本做法是另行建立新数组。可以使用System.arraycopy()的方法，用原生方式复制每个索引元素。还有更方便的Arrays.copyOf()的方法，代码如下：

import java.util.Arrays;
public class CopyArray {
    public static void main(String[] args){
        int[] scores1={88,81,75,69,74,34,54,27,98,96};
        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);
        }
    }
}

结果如下：

 88 81 75 69 74 34 54 27 98 96
 88 81 75 69 74 34 54 27 98 96

2.对于类类型声明的数组则要注意参考的行为，代码如下：

class Clothes3{
    String color;
    char size;
    Clothes3(String color,char size){
        this.color=color;
        this.size=size;
    }
}
public class ShallowCopy {
    public static void main(String[] args){
        Clothes3[] c1={new Clothes3("red",'L'),new Clothes3("blue",'M')};
        Clothes3[] c2=new Clothes3[c1.length];
        for(int i=0;i<c1.length;i++){
            c2[i]=c1[i];
        }
        c1[0].color ="yellow";
        System.out.println(c2[0].color);
    }
}
/*
实际上循环中仅将c1每个索引处所参考的对象，也给c2每个索引来参考，并没有实际复制出Clothes3的对象，叫作复制参考，称这个行为是浅层复制。如果要连同对象一起复制的话要自行复制。
 */

结果如下：

yellow

3.连同对象一起复制，要自行操作。代码如下：

class Clothes4{
    String color;
    char size;
    Clothes4(String color,char size){
        this.color=color;
        this.size=size;
    }
}
public class DeepCopy {
    public static void main(String[] args){
        Clothes4[] c1={new Clothes4("red",'L'),new Clothes4("blue",'M')};
        Clothes4[] c2=new Clothes4[c1.length];
        for(int i=0;i<c1.length;i++){
            Clothes4 c=new Clothes4(c1[i].color,c1[i].size);//自行复制元素
            c2[i]=c;
        }
        c1[0].color="yellow";
        System.out.println(c2[0].color);
    }
}

结果如下：

red

4.4 字符串对象

4.4.1 字符串基础

1.建立字符串

String name=”justin”; //建立String实例

System.out.println(name); //显示justin

System.out.println(name.length()); //显示长度为6

System.out.println(name.charAt(0)); //显示第一个字符j

System.out.println(name.toUpperCase()); //显示JUSTIN

2.将字符串剖析为基本类型

如：将number剖析为int整数：Integer.parseInt(number)

下面这个范例可以让用户输入整数，输入0后会计算所有整数总和并显示。

代码如下：

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.printf("输入整数：");
            number=Long.parseLong(scanner.nextLine());
            sum+=number;
        }while(number!=0);
        System.out.println("总和："+sum);
    }
}

结果如下：

输入整数：2
输入整数：4
输入整数：6
输入整数：3
输入整数：0
总和：15

Chapter 5 对象封装

5.1 何谓封装

1. 封装(Encapsulation)实际上是使用方法(Method)将类的数据隐藏起来，控制用户对类的修改和访问数据的程度,隐藏对象细节,将对象当作黑箱进行操作。通过构造方法（构造函数）封装初始化流程，代码如下：

class CashCard {
    String number;
    int balance;
    int bonus;
    CashCard(String number,int balance,int bonus){
        this.number=number;
        this.balance=balance;
        this.bonus=bonus;
    }
}

1. 通过成员方法（函数）封装操作，代码如下：

public class CashApp {
    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);
        }
    }
}

5.2 类语法细节

5.2.1 public权限修饰

1.如果没有声明权限修饰的成员，只有在相同包的类程序代码下才可以直接存取，也就是“包范围权限”。如果想在其他包的类程序代码中存取某包的类或对象成员，则该类或对象成员必须是公开成员，在java中要使用public加以声明。

5.2.2 关于构造函数

1.特点：（1） 函数名与类名相同 ；（2）不用定义返回值类型； （3）不可以写return语句。

2.作用： 给对象进行初始化。

3.注意：（1） 默认构造函数的特点。（2） 多个构造函数是以重载的形式存在的。

代码如下：

class Some
{
    void someMethod(int i)
    {
        System.out.println("int 版本被调用");
    }
    void someMethod(Integer integer)
    {
        System.out.println("Integer 版本被调用");
    }
}
public class Overload
{
    public static void main(String[] args)
    {
        Some s = new Some();
        s.someMethod(1);
    }
}

结果如下：

int 版本被调用

5.2.3 this关键字

1.特点：this代表其所在函数所属对象的引用。 换言之：this代表类对象的引用。

2.当在函数内需要用到调用该函数的对象时，就用this。代码如下：

class Other{
    {
        System.out.println("对象初始区块");
    }
    Other()
    {
        System.out.println("Other() 构造函数");
    }
    Other(int o )
    {
        this();
        System.out.println("Other(int o ) 构造函数");
    }
}
public class ObjectInitialBlock
{
    public static void main(String[] args)
    {
        new Other(1);
    }
}

结果如下：

对象初始区块
Other() 构造函数
Other(int o ) 构造函数

5.2.4 static关键字

1.用于修饰成员（成员变量和成员函数）。被修饰后的成员具备以下特点：（1）随着类的加载而加载；（2）优先于对象存在；（3）被所有对象所共享；（4）可以直接被类名调用；

2.使用注意：（1）静态方法只能访问静态成员；（2）静态方法中不可以写this，super关键字；（3）主函数是静态的。

import 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());
    }
}

结果如下：

请输入姓名：袁心
袁心 你好！

代码托管截图

教材学习中的问题和解决过程

1. 问题：在做教材81页的程序练习时，把类定义为Clothes出现错误。
   
   解决过程：在仔细阅读教材后知道了，在这个Field.java中，定义了两个类，一个是公开的Field类，所以文档主文档名是Field，另一个是非公开的Clothes。
2. 问题：在自己编写程序时分不清println和printf的区别。
   
   解决过程：在博客园中看到有的同学发布的话题，其中有关这方面的解答。
   
   解决结果： printf：f就是format的意思，也就是格式化，是对输出文字做格式化后再显示在文本模式中。后面常用%d,%f,%b…这些格式控制符号，一般在输出变量类型比较多的时候使用，也用在需要计算机计算或判断后再输出的情形。
   
   print：将它的参数显示在命令窗口，并将输出光标定位在所显示的最后一个字符之后。
   
   println：将它的参数显示在命令窗口，并在结尾加上换行符，将输出光标定位在下一行的开始。相当于在print中加了一个%n换行符。当输出信息比较单一简单时，一般采用println，但println也可以用于多种变量类型的输出，中间用“+号”连接，例如System.out.println("3 + 3 = "+a) //这里假设程序中a=6，可能这个例子不算太恰当，但代码中的+前后连接了不同的类型，也可以用println输出。

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

1. 问题：在编写教材109页的练习时，不理解运行结果的含义，代码如下：

public class Average {
    public static void main(String[] args){
        long sum=0;
        for(String arg:args){
            sum+=Long.parseLong(arg);
        }
        System.out.println("平均："+(float)sum/args.length);
    }
}

结果如下：

平均：NaN

解决过程：未解决。

其他（感悟、思考等，可选）

感悟与思考：在看教材4、5章时，明显感觉到了java语言的独特魅力，它是一种面向对象的语言，因此在看教材或编程序是，要牢牢把握对象的特征，每一步都是为了服务对象，所以要深刻了解的对象特性才能理解语句间的逻辑关系。上周我是在把教材都理解的基础上再进行编程练习，这样既耽误时间，而且理解起来也比较困难，这周我采取边读教材边练习的方法，在练习的同时能帮助我更好的理解知识点，并加深记忆。我从中明白了，学习方法不是一尘不变的，要在实践的过程中不断摸索更高效的途径，从而找到适合自己的学习方法。

学习进度条

参考资料

• Java学习笔记(第8版)
• 《Java学习笔记(第8版)》学习指导
• ...