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

教材学习内容总结

本周学习了课本第四、五章内容，即认识对象和对象封装。

第四章认识对象

4.1类与对象

定义类

要产生对象必须先定义类，类是对象的设计图，对象是类的实例。

类定义时使用class关键词。
建立实例时使用new关键词。
代码示例：

class Clothes
{
String color;
char size;
}
public class Field
{
    public static void main(String[] args)
    {
Clothes sun = new Clothes();
Clothes spring = new 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);
}}

运行结果
构造函数

构造函数是与类名称同名的方法。构造函数中，由于参数与数据类型重名，要使用this将参数值指定给对象的成员。
代码示例：

class Clothes2
{
String color;
char size;
Clothes2(String color, char size)
{
this.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);
}
}

运行结果：

2.标准类

两个基本标准类：java.util.Scanner与java.math.BigDecimal。

java.util.Scanner

使用java.util.Scanner的nextInt()方法会看标准输入中，有没有输入下一个字符串，有的话会尝试将之剖析为int类型。Scanner对每个基本类型都有对应的方法。

代码示例：

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.printf("GUESS A NUMBER:");
    guess = scanner.nextInt();
}
while(guess != number);
System.out.println("YOU ARE RIGHT!");
}
}

运行结果：

java.math.BigDecimal

使用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比较相等时，可以直接利用返回的BigDecimal再调用add()方法，最后再调用equals()比较两个BigDecimal实质上是否相同。

代码如下：

import java.math.BigDecimal;
public class DecimalDemo2
{
public static void main(String[] args)
{
BigDecimal o1 = new BigDecimal ("0.1");
BigDecimal o2 = new BigDecimal ("0.1");
BigDecimal o3 = new BigDecimal ("0.1");
BigDecimal result = new BigDecimal("0.3");
if(o1.add(o2).add(o3).equals(result))
{
    System.out.println("等于0.3");
}
else
{
    System.out.println("不等于0.3");
}
}}

运行结果：

4.2 基本类型打包器

1.基本类型long、int、double、float、boolean等。将基本类型打包在对象之中，就可以将基本类型当作对象操作。

代码如下：

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

运行结果：

2.自动装箱、拆箱

代码如下：

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

运行结果：

4.3 数组对象

数组基本上是用来收集数据，是具有索引的数据结构，在Java中要声明数组并初始值，代码如下

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

结果如图：

数组的length属性可以取得数组长度。也可用更方便的增强式for循环。

代码如下：

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

运行结果：

2.操作数组对象

在Java中只要看到new，一定是建立对象，这个语法代表了数组就是对象。使用new建立数组后，每个索引元素会有默认值，如果默认值不符合需求，则可以使用java.util.Arrays的fill()方法来设定新建数组的元素值。

eg.将每个学生的成绩默认为60分起：

import java.util.Arrays;
public class Score
{
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);
    }
}}

运行结果：

3.数组复制

数组复制的基本做法是另行建立新数组。

System.arraycopy()方法，它会使用原生方式复制每个索引元素，比自行使用循环来得快。System.arraycopy()的五个参数分别是来源数组、来源起始索引、目的数组、目的起始索引、复制长度。

Arrays.copyOf()方法建立新数组

代码如下：

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;
        for(int score : scores1)
            {
                System.out.printf("%3d",score);
            }
}}

运行结果：

System.arraycopy()和Arrays.copyOf()，用在类类型声明的数组时，都是执行浅层复制。
深层复制是每个索引的参考对象也会被复制。

代码如下：

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

运行结果：

4.4字符串对象

在Java中，字符串本质是打包字符数组的对象，是java.lang.String类的实例。

1.字符串基础

可以使用length()取得字符串长度，使用charAt()指定取得字符串中某个字符，使用toUppercase()将原本小写的字符串内容转为大写。
如果有一个char[]数组，也可以使用new来创建String。使用String的toCharArray（）方法，以将字符串以char[]数组返回。

eg. 让用户输入整数，输入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.print("输入数字:");
    number = Long.parseLong(scanner.nextLine());
    sum += number;
}while(number != 0);
System.out.println("总和为:"+sum);
}
}

运行结果：

2.字符串特性：

字符串常量与字符串池：用“”写下的字符串称为字符串常量，在JVM中只会建立一个String实例。
不可变动字符串：在java中，字符串对象一旦建立，就无法更改对象中任何内容，对象上没有任何方法可以更改字符串内容。可以使用 + 连接字符串，并用StringBuilder来改善。

代码如下：

public class OneTo100
{
public static void main(String[] args)
{
StringBuilder builder = new StringBuilder();
for(int i = 1; i < 100; i++)
{
    builder.append(i).append('+');
}
System.out.println(builder.append(100).toString());
}}

运行结果：

4.5查询API文档

学习Java要学会使用Java API,具有检索功能，使用方便。

第五章对象封装

5.1何谓封装

封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。封装目的主要是隐藏对象细节。

eg.定义构造函数，并用数组显示。

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

eg.建立三个CashCard对象使用数组

import java.util.Scanner;
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);
}
}}

5.2类语法细节

public权限修饰

public是个公开类，可以在其他包的类中使用。可以在构造函数上声明public，这表示其他包中的类可以直接调用这个构造函数。可以在方法上声明public，这表示其他包中的方法可以直接调用这个方法。
构造函数

在定义类时，可以使用构造函数定义对象建立的初始流程。构造函数是与类名称同名，无须声明返回类型的方法。
方法重载

代码如下：

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

运行结果：

若想调用参数为Integer版本的方法，修改代码如下(要明确指定)：

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

运行结果：

使用this

this关键字可以出现在类中任何地方，在构造函数参数与对象数据成员同名时，可用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);
   }
}

运行结果：

static类成员

1.被声明为static的成员，不会让个别对象拥有，而是属于类，是将类名称作为名称空间。

2.由于static成员是属于类，而非个别对象。在static方法或区块中不能出现this关键字。

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

Git代码托管截图

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

在看书的过程中，作者提到这样的一个例子：

String text1 = "Ja"+"va";

String text2 = "Java";

System.out.println(text == text2);

当时没有继续往下看时，以为会输出false。但答案是true。后来作者通过反编译解释了这个问题。

“+”是链接字符，并不是新产生的字符串。

所以在学习过程中，各程序语言会有细微、重要且不容忽视的特性。在学习程序语言是，不得不慎。

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

为什么有的代码中“输出文字”中带有中文时就会生成乱码，改成英文后就顺利输出。

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

java已经学习了三周，这周编写的代码较多，知识相比前几周也更难了，光靠看书感觉不能完全弄懂，看了视频感觉好一些。看视频后，再继续研究书上的代码，不会的地方记下来，直到理解。这周学习比较吃力，还希望继续努力。对于后面的学习，我希望自己可以更加合理的分配时间。java这门课，只有不断练习实践，才可以提高。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）
目标	4500行	30篇	400小时
第一周	200/200	2/2	15/15
第二周	300/500	1/3	25/40
第三周	400/900	1/4	30/70

参考资料