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

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

教材学习内容总结

本周学习内容比较多，主要是第四第五章的学习。

第四章

类与对象

类是对象的设计图，对象是类的实例。

类（Class）的含义可以理解为，具有相同属性和行为的一组对象的集合,用于组合各个对象所共有操作和属性的一种机制。

对象（Object）的含义：存在的具体实体，具有明确的状态和行为。

书上的例子是设计一件衣服，分别从color和size两方面考虑。而这个的设计图就是

{
String color;
char size;
}

Clothes c1 = new Clothes();中，将c1名称参考至新建对象。c1与c语言中的指针相似。

c1是引用，在栈上

new Clothes()在堆上生成对象

//定义两个值域成员
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("sun (%s,%c)%n", spring.color,spring.size);
//显示个别对象的数据或成员值

	}
}

如果想在建立对象时，一并进行某个初始流程，像是指定数据成员值，则可以定义构造函数。

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); //输出结果
	}
}

使用标准类

java SE提供了标准API，这些API由许多类组成。 java.util.Scanner与java.math.BigDecimal

使用java.util.Scanner：

import java.util.Scanner; //使用import偷懒

class  Guess
{
	public static void main(String[] args)
	{
		Scanner scanner = new Scanner(System.in); //建立Scanner实例
		int number = (int) (Math.random()*10); //readom随机数，10以内
		int guess;

		do{
			System.out.print("猜数字(0~9):");
			guess = scanner.nextInt(); //取得下一个int整数
		}
		while(guess != number);

		System.out.println("猜中了...XD");

	}
}

（这次比较惨，最后一次才猜中）

程序偷懒之后只要输入Scanner就可以了。

为了得到更好的精确度，可以使用java.math.BigDecimal类

import java.math.BigDecimal; //同样，让程序偷懒

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); //输出结果
	}
}

运行结果：

改成比较大小是否相等的代码

import java.math.BigDecimal;

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)) //add为加 equals为比较两个bigdecimal实质上是否相同
		{
			System.out.println("等于 0.3"); //相同的输出"等于 0.3"
		}
		else {
			System.out.println("不等于 0.3");
		}
	}
}

运行结果：

基本类型打包器

基本类型打包器：Long、Integer、Double、Float、Boolean等类是所谓的打包器，正如此名称所示，这些类主要目的就是提供对象实例作为“壳”，将基本类型打包在对象之中。

//Integer打包实例
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));
	}
}

运行结果：

从java SE 5.0之后提供了自动装箱、拆箱功能。

数组对象

Java中，数组是对象。

与C语言不同，Java检查数组边界，越界会触发ArrayIndexOutOfBoundsException异常

定义数组的方式：int[] scores ={88,81,74,69,79,76,77,85,95,93};

//定义数组并依次输出
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++);//自增i
			{
				System.out.printf("学生分数：%d %n", scores[i]); //依次输出
			}
	}
}

运行结果：

二维数组实例：

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

运行结果：

如果事先不知道元素值，只知道元素个数，可以使用new关键词指定长度来建立数组。

如果默认初始值不符合需求，可以使用java.util.Arrays的fill()方法设定新建数组的元素值。

import java.util.Arrays; //使用import进行偷懒

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

运行结果：

也可以建立不规则数组

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

	}
}

运行结果：

上面的程序片段建立了0个Integer对象。每个索引其实都是Integer类型。

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(66);
	for(Integer score : scores)
		{
		System.out.println(score);
		}
	}
}

运行结果

Arrays.copyOf()的方法可以方便的复制数组

import java.util.Arrays;

class CopyArray
{
	public static void main(String[] args)
	{
		int[] scores1 = {88,81,74,69,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);
		}
	}
}

运行结果：

对于类类型声明的数组则要注意参考的行为。

class Clothes
{
	String color;
	char size;
	Clothes(String color,char size)
	{
		this.color = color;
		this.size = size;
	}
}

public class ShallowCopy
{
	public static void main(String[] args)
	{
		Clothes[] c1 = {new Clothes("red",'L'),new Clothes("blue",'M')};
		Clothes[] c2 = new Clothes[c1.length];
		for(int i = 0;i < c1.length;i++) //复制元素
		{
			c2[i] =  c1 [i];
		}
		c1[0].color = "yellow"; //通过c1修改索引0对象
		System.out.println(c2[0].color); //通过c2取得索引0对象的颜色
	}
}

运行结果：

深层复制行为Deepcopy

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

运行结果：

字符串对象

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

以下程序是让用户输入整数，输入0后会计算所有整数总和并显示。

import java.util.Scanner;

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

运行结果：

计算出所有整数平均：

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

运行结果：

使用stringBuilder来实现显示1+到100

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

运行结果：

第五章

封装

封装(Encapsulation)实际上使用方法(Method)将类的数据隐藏起来，控制用户对类的修改和访问数据的程度,隐藏对象细节,将对象当作黑箱进行操作。

假设要写个可以管理储值卡的应用程序，首先要定义储值卡会记录那些数据，比如储值卡号码、余额、红利点数。这些可以用class定义。

java定义构造函数：

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

如果用户想建立5个CashCard对象，可以用数组。

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

运行结果：

储值不能是负的，储值大于1000的话，就给予红利一点。定义（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;
	}

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

}

相应的app可以这样写数组。

public class CardApp2

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

程序运行结果如下

换个数字再次运行一下

类语法细节

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

结果是显示int版本被调用，如图。

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

运行结果：

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

运行结果：

不定长度自变量：

class  MathTool
{
	public static int sum(int ... numbers)
	{
		int sum = 0;
		for(int number : numbers)
		{
			sum += number;
		}
		return sum;
	}
}

java中只有传值调用。传值（Pass By Value，Call by Value）

public class CallByValue
{
	public static void main(String[] args)
	{
		Customer c1 = new Customer("Justin");
		some(c1); //c1与参数c参考同一对象
		System.out.println(c1.name);

		Customer c2 = new Customer("Justin");
		other(c2); //c2与参数c参考同一对象
		System.out.println(c2.name);
	}

	static void some(Customer c)
	{
		c.name = "John";
	}

	static void other(Customer c)
	{
		c = new Customer("Bill");//c参考至新建的对象
	}

}

class Customer
{
	String name;
	Customer(String name)
	{
		this.name = name;
	}
}

程序运行结果：

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

这次的代码比较多，所出现的问题也比较多。

上图的原因找了好久，原来是最后一个括号不是英文环境下的括号。

显然大括号与普通括号没有分清。

这个是Score的S小写了。在java中是很严格的区分大小写的。

Import一行也是需要写分号的。

这是因为最后的大括号个数错误、

这也是大小写问题造成的。

同时我还在编写过程中遇到了汉字编码的问题，我打算写一篇博客讨论这个问题。

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

这周学习的内容比较多，并且比较难于理解。可能一周的时间还不够好好消化新学的知识，还需要多看看书，视频。但这周敲得代码数量确实很多。其实编程、敲代码并不是一个无聊的过程。细细的品读代码的意义，不断解决代码调试过程中的各种错误，也是一件很有意思的事情。并且，随着代码数量的越来越多，所犯的错误也越来越少了。

学习java没有捷径，只有通过编写越来越多的代码，做越来越多的练习才能学好。

图片：

托管代码图片：

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	100/100	2/2	10/10	初部认识java
第二周	150/250	1/3	12/22	掌握Java基础语法
第三周	537/787	2/4	20/42	认识对象，对象封装

参考资料

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