20155306 2006-2007-2 《Java程序设计》第3周学习总结

教材学习内容总结

第四章认识对象

4.1 类与对象

定义类

1.先在程序中定义类：

 Clothes{
 String color;
 Char size;
 }//定义color和size两个对象数据成员

2.新建一个对象,并且将c1名称参考至新建对象

CLothes c1 = new Clothes();

类分为公开类和非公开类，一个原始码中可以有多个类定义，但只能有一个公开类，但，且文档中的主文档名必须与公开类名称相同。（只要有一个类定义，就会编译产生一个.class文件）

标准类

java.util.Scanner:Scanner

nextInt（）方法会看标准输入中，有没有输入下一个字符串（以空格或换行分隔），将其剖析为int或其他nextByte（）型等等，直接取得上一个字符串使用next()，取得整行文字nextLine()（以换行分隔）

import java.util.Scanner;

    public class Guess {
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        int number = (int)(Math.random() * 10);
        int guess;

        do{
            System.out.print("猜数（0 ~ 9）：");
            guess = scanner.nextInt();
        }while(guess != number);

        System.out.println("猜中了！");
    }
}

java.math.BigDecimal

以默认精度，提供plus()、subtract()、multiply()、divide()可以进行加减乘除运算，都会返回运算结果

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

对象制定与相等性

用于基本类型时：=将值复制给变量；==比较两个变量储存的值是否相同；

用于操作对象时：=指定参考名称参考某个对象用在操作对象；==比较两个参考名称是否参考同一对象
equals():用于操作对象，比较两对象的值是否相同

4.2 基本类型包装

Java中分为两个类型系统为基本类型与类类型。将基本类型打包在对象之中，将基本类型当作对象来操作，可以使用（Wrapper）：Long、Integer、Double、Float、Boolean、Byte来打包基本类型。

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(wrapper2.compareTo(wrapper2));
    }
}

自动装箱、拆箱

Integer wrapper =10;//自动装箱
int foo = wrapper;//自动拆箱

自动拆装箱是编译程序蜜糖，不能让变量参考至空对象又对之进行操作，也不能超过打包器的值域范围
无论两个变量打包的值位于哪个范围，只要变量打包的值相同，equals()比较的结果就会是true

4.3 数组对象

Java中，数组就是对象，而不是单纯的数据结合。

依次取出数组中每个值的方法，一种是for循环:

public class Score {
    public static void main(String[] args){
        int[] scores = {88,81,74,68,78,76,77,85,95,93};
        for(int i = 0; i < scores.length; i++){
            System.out.printf("学生分数：%d %n",scores[i]);
        }
    }
}

增强式for循环:

public class EnhanceScore {
    public static void main(String[] args){
    int[] scores = {88,81,74,68,78,76,77,85,95,93};
    for(int score : scores){
        System.out.printf("学生分数：%d %n",score);
    }
}
}

声明二维数组,要使用两个索引来存取数组元素:

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]);
            }
        }
    }
}

增强for循环:

public class EnhanceXY {
    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("%d",value);
            }
            System.out.println();
        }

    }
}

利用java.util.Arrays的fill()方法来设定新建数组的元素值:

import java.util.Arrays;

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

数组复制

基本方法是另行建立新数组，使用System.arraycopy()，五个参数：来源数组、来源起始索引、目的数组、目的起始索引、复制长度。
Array.copyof()方法不用另行建立新数组，浅层复制

浅层复制：c1每个索引处所参考的对象，也给c2每个索引来参考，用在类类型声明的数组时，都是执行浅层复制，比如：System.arraycopy()，Array.copyof()

深层复制：实际上c1每个索引参考的对象会被复制，分别指定给c2每个牵引。

4.4 字符串对象

字符串是打包字符数组的对象
是以“”包括的字符串，只要内容完全相同，则只会建立一个String实例，并在字符串池中维护。
字符串对象一旦建立，就无法更改对象中的任何内容。使用“+”连接字符串可以产生新的String实例

第五章对象封装

5.1 何谓封装

封装实际上使用方法将类的数据隐藏起来，隐藏对象细节，将对象当作黑箱操作，用户不用再需要重复撰写对象初始化流程
在类中定义方法，如果不用返回值，方法名称前可声明void，方法若会返回值，必须在方法前声明返回值的类型
-不想让用户直接自由存取类私有数据，使用private定义；private可以用在方法或构造函数声明。声明为private的成员表现为类私有，用户无法在其他类的程序代码中直接存取。

5.2 类语法细节

三个权限修饰：public、private、 protected
定义方法时也可以重载，类似功能的方法名称虽然一致，但是根据传递的自变量类型不同，会调用相应的方法。
除被声明static的地方外，this关键字可以出现在类中的任何地方。
this()代表调用另一个构造函数，根据调用时给的自变量类型与个数定调用哪个函数，只能出现在构造函数的第一行。
被声明为static的成员，不用每个对象各自拥有，表示它属于类，通过类名称.static成员取得static成员；static方法或区块中，不能调用非static方法或区块。
要使用不定长度自变量，声明参数列时要在类型关键字后加...,且方法上声明的不定长度参数必须是参数列最后一个，使用两个不定长度参数列是不合法的。

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

问题一
在增强for循环时的语法，为什么要换成 for(int score : scores)的形式，有什么具体的意义吗?

解答：通过百度，查阅资料知道原来是这样的形式：

增强for(part1:part2){part3};
part2中是一个数组对象,或者是带有泛性的集合.
part1定义了一个局部变量,这个局部变量的类型与part2中的对象元素的类型是一致的.
part3当然还是循环。

问题二：在书中我们看到：对于基本类类型而言，“”用来是比较两个变量存储的值是否相同，，在类类型中，比较参考名是否参考同一对象。在自动拆箱和装箱中，为什么可以直接用“”来比较i1，i2，而且还可以用equals（）？
解答：没有解答

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

问题1
在敲书上代码的时候，出现了下图这样的问题。后来发现是自己同时点开两个程序，把public的类名写错了，与文件名不符合。

代码托管

代码提交过程截图：
- 运行 git log --pretty=format:"%h - %an, %cd : %s" 并截图
代码量截图：
- 运行 find src -name "*.java" | xargs cat | grep -v ^$ | wc -l 并截图

上周考试错题总结

填空：Linux Bash中，查找当前目录中前天创建的Java文件的命令是（find . –name *.java -ctime 2）
填空：~0b1011的十进制值是（-12）
Java中, 数字235.00的类型是float. （X）也可能是double型。 float x = 4.0则会报错，需要如下写法：
float x = 4.0f或者float x = (float)4.0
其中4.0f后面的f只是为了区别double，并不代表任何数字上的意义
填空：0x10%9 的结果是（ 7 ）
填空：0x10&9 的结果是（0）
先把十六进制的数字写成二进制，再进行运算，在转化为十六进制。

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

考试前一晚把书好好又看了一遍，但是做题还是不行。感觉自己看书学习很难抓到那些小细节，对考点不敏感。很久没有这样自己去学一本书了，能力有点欠缺，但我相信长久下来，一定会有所进步的。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	20/20	1/2	15/15	完成JDK、IDEA下载，并且可以简单操作
第二周	150/200	1/2	18/20	开始可以撰写简单的代码，了解了一些常用的语法
第三周	327 /400	1/2	26/25	更深入认识类与对象，以及对象的封装，时间紧，任务重，需敲大量代码来熟练
尝试一下记录「计划学习时间」和「实际学习时间」，到期末看看能不能改进自己的计划能力。这个工作学习中很重要，也很有用。
耗时估计的公式
：Y=X+X/N ，Y=X-X/N，训练次数多了，X、Y就接近了。

参考：软件工程软件的估计为什么这么难，软件工程估计方法

计划学习时间:20小时
实际学习时间:26小时
改进情况：这周任务重，需要自己更钻研，更细致地去研究课本。
有空多看看现代软件工程课件软件工程师能力自我评价表

参考资料

posted on 2017-03-12 21:45 20155306 阅读(196) 评论(3) 编辑收藏举报

刷新页面返回顶部

20155306