20145231第三周学习笔记

20145231 《Java程序设计》第3周学习总结

教材学习内容总结

基本概念：

类类型：Java两个数据类型系统之一，另一个为基本类型；

类：具有相同属性和行为的一组对象的集合，用于组合各个对象所共有操作和属性的一种机制；

对象:存在的具体实体，具有明确的状态和行为；

类与对象的关系：类定义可以视为一个具有类似特性与共同行为的对象的模板，可用来产生对象；类的产生，是从少数实例，推广到大量相似的实例抽象化过程；类是对象的设计图，对象是类的实例，生成对象要先定义类；

新建对象：使用new关键词，同时要声明参考名称，将该名称参考至新建对象；

了解并熟悉标准类：可使用import，写出需要用到的类名称，通过建立实例、调用函数实现所需功能；

打包基本类型：将基本类型当做对象操作，使用基本类型目的在于效率，而对象本身可以携带更多信息；

数组在Java中在是对象，数组是用来收集数据，是具有索引的数据结构，撰写代码时将[]放在类型关键词之后；

代表建立数组对象的类由JVM动态产生，可以将int[]这样的写法，看作类名称，根据int[]而声明的变量即为参考名称；

用类类型建立的数组，将类型关键词从int、double等换为类名称并将每个索引参考至类类型初始值null；

数组复制：可使用for循环结构，也可以使用System.arraycopy()方法，System.arraycopy()的五个参数分别是来源数组、来源起始索引、目的数组、目的起始索引、复制长度；

字符串：打包字符数组的对象，可使用+号连接字符串；

将字符串剖析为基本类型：eg：Byte.parseByte(number)；

使用javac没有-encoding选项时，会使用操作系统默认编码；

实现对象初始化流程的封装是通过构造函数；方法封装了操作对象的流程；Java中还可以使用private封装对象的私有数据成员；封装的主要目的：隐藏对象细节，将对象当做黑箱进行操作；

想在其他包的类程序代码中存取某包的类或对象成员，则该类或对象成员必须是公开成员，使用public进行声明；

被声明为static的成员，属于类；在static方法或区块中不能用非static数据或非法成员；

使用import static语法时，注意名称冲突问题；

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

问题一：为什么1.0-0.8不等于 0.2？

解决过程：Java遵守IEEE 754浮点数运算规范，使用分数与指数来表示浮点数，而恰好0.1使用分数表示为无限循环，无法精确表示，从而造成运算上的误差；

补充：为了得到更好的精确度，可以使用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);
    }
}

运行结果如图：

问题二：浅层复制和深层复制到底有何区别？

解决过程：浅层复制复制的是每个索引中的参考，即将c1每个索引处参考的对象也给c2每个索引来参考，并没有真正复制出对象，而深层复制复制的是c1每个索引参考的对象；

问题三：this关键字不能出现在被声明为static的地方？

解决过程：不能，this在对象建立后，为“这个对象”的参考名称，在构造函数参数与对象数据成员同名时，用this加以区别；

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

1、提升精确度，对比两种类型中数值比较的差异，类类型中用equals()比较对象内含值是否相同；

import java.math.BigDecimal;

/**
 * Created by lenovo on 2016/3/19.
 */
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");
        }
    }
}

运行结果如图：

2、区分运用于基本类型和类类型的不同；类类型中：=是用在指定参考名称参考某个对象，是用在比较两个参考名称是否参考同一对象；

import java.math.BigDecimal;

public class bijiao {
    public static void main(String[] args) {


        BigDecimal a = new BigDecimal("0.1");
        BigDecimal b = new BigDecimal("0.1");
        System.out.println(a == b);
        System.out.println(a.equals(b));
    }

}

运行结果如图：

3、体会基本类型打包，体会打包带来的好处；

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

运行结果如图：

4、数组复制与C语言中不同，直接复制出现问题，体会复制参考和复制对象的区别；

public class Copy {
    public static void main(String[] args) {
        int[] scores1 = {88,81,74,68,78,76,77,85,95,93};
        int[] scores2 = new int[scores1.length];
        for (int i=0;i<scores1.length;i++){
            scores2[i] = scores1[i];
        }
    }
}

public class Copy {
    public static void main(String[] args) {
        int[] scores1 = {88,81,74,68,78,76,77,85,95,93};
        int[] scores2 = new int[scores1.length];
       System.arraycopy(scores1,0,scores2,0,scores1.length);
    }
}

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

运行结果如图：

5、关于字符串的比较，不同形式进行比较，显示结果不一样，原因在于name1、name2参考的是同一个对象，而new一定是新建对象，不同对象在类类型中==的含义显示的结果就是false；

public class Name {
    public static void main(String[] args) {
        String name1 = "Justin";
        String name2 = "Justin";
        String name3 = new String("Justin");
        String name4 = new String("Justin");
        System.out.println(name1 == name2);
        System.out.println(name1 == name3);
        System.out.println(name3 == name4);
    }
}

public class Name {
    public static void main(String[] args) {
        String name1 = "Justin";
        String name2 = "Justin";
        String name3 = new String("Justin");
        String name4 = new String("Justin");
        System.out.println(name1.equals(name2));
        System.out.println(name1.equals(name3));
        System.out.println(name3.equals(name4));
    }
}

运行结果如图：

6、在类中定义方法进行封装：（不用返回值，方法名称前可以声明void）；

class CashCard {
        String number;
        int balance;
        int bonus;
        CashCard(String number,int balance,int bonus){
            this.number = number;
            this.balance = balance;
            this.bonus = bonus;
        }
        void store(int money){
        if(money > 0){
            this.balance += money;
            if(money > 1000){
                this.bonus++;
            }
        }
        else{
            System.out.println("储值为负");
        }
    }
    void charge(int money){
        if(money > 0){
            if(money <= this.balance){
                this.balance -= money;
            }
            else {
                System.out.println("钱不够了");
            }
        }
        else{
            System.out.println("扣负数？这不是叫我储值吗？");
        }
    }int exchange(int bonus){
        if(bonus>0){
            this.bonus -= bonus;
        }
        return this.bonus;
    }
    }

7、建立多个同一类中的对象，可用数组，无需个别声明参考名称：（问题：每次在新建对象时可以直接写出数据成员，而之前都不用声明也不用写出构造函数吗？即为什么代码二无需代码一也能出现正确结果？）

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

import java.util.concurrent.Callable;

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)
        };//全都是参考至cards的对象
        for(CashCard card : cards){
            System.out.printf("(%s,%d,%d)%n",card.number,card.balance,card.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),
        };
        Scanner scanner = new Scanner(System.in);
        for(CashCard card:cards){
            System.out.printf("为（%s,%d,%d）储值：",card.number,card.balance,card.bonus);
            card.store(scanner.nextInt());
            System.out.printf("明细(%s,%d,%d)%n",card.number,card.balance,card.bonus);
        }
    }

}

运行结果如图：

补充：托管代码截图

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

本周的学习任务较上周难度明显增大，学习量也增大。困难之处在于都是新知识新定义，而且内容比较抽象不易理解，在学习过程中产生了很多疑惑，也有自己查资料解决，但还是觉得理解的不够清晰透彻，在看书过程中产生的问题往往书后面会有一定的解释，这也说明我在一个正确的方向上思考吧。另外，敲代码、运行代码、调试代码的确有助于理解新概念，通过实践慢慢掌握慢慢体会，我相信我会掌握。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	200/200	2/2	20/20
第二周	250/450	2/4	21/41
第三周	450/900	3/7	20/61	对类及对象有了较深认识
第四周	000/0000	2/9	00/00

参考资料

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