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 何谓封装

封装(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;

    }

}

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

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

    }

}

结果如下：

请输入姓名：袁心

袁心 你好！

代码托管截图

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

问题：在做教材81页的程序练习时，把类定义为Clothes出现错误。

解决过程：在仔细阅读教材后知道了，在这个Field.java中，定义了两个类，一个是公开的Field类，所以文档主文档名是Field，另一个是非公开的Clothes。

问题：在自己编写程序时分不清println和printf的区别。

解决过程：在博客园中看到有的同学发布的话题，其中有关这方面的解答。

解决结果： printf：f就是format的意思，也就是格式化，是对输出文字做格式化后再显示在文本模式中。后面常用%d,%f,%b…这些格式控制符号，一般在输出变量类型比较多的时候使用，也用在需要计算机计算或判断后再输出的情形。

print：将它的参数显示在命令窗口，并将输出光标定位在所显示的最后一个字符之后。

println：将它的参数显示在命令窗口，并在结尾加上换行符，将输出光标定位在下一行的开始。相当于在print中加了一个%n换行符。当输出信息比较单一简单时，一般采用println，但println也可以用于多种变量类型的输出，中间用“+号”连接，例如System.out.println("3 + 3 = "+a) //这里假设程序中a=6，可能这个例子不算太恰当，但代码中的+前后连接了不同的类型，也可以用println输出。

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

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

正文

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