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