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 |
