20145236 《Java程序设计》第3周学习总结
教材学习内容总结
第四章 认识对象
一、面向对象和面向过程
•面向对象是相对面向过程而言
•面向对象和面向过程都是一种思想
•面向过程强调的是功能行为
•面向对象将功能封装进对象，强调具备了功能的对象。
•面向对象是基于面向过程的。
•面向对象的特征:封装 继承 多态
创建对象，使用对象
class Car//对Car这类事物进行描述
{
String color = "red";
int num = 4;
void show()
{
System.out.println("color="+color+"..num="+num);
}
}
class CarDemo
{
public static void main(String[] args)
{
Car c = new Car();//建立对象
c.color = "black";//对对象的属性进行修改
c.show();//使用对象的功能。
}
}
二、对象指定与相等性（“=” 和 “==”）
“=”用于基本类型时，是将值复制给变量，“==”用于基本类型时，是比较两个变量储存的值是否相同，如下面的程序：
int a = 10;
int b = 10;
int c = a;
System.out.println(a == b); //显示true
System.out.println(a == c); //显示true
• ==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。
equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。
==比较的是两个对象的地址，而equals比较的是两个对象的内容。
三、基本类型打包器
Java中有两个类型系统，即基本类型与类类型，使用基本类型目的在于效率，然而更多时候，会使用类建立实例，因为对象本身可以携带更多信息，如果要让基本类型像对象一样操作，可以使用Long、Integer、Double、Float、Boolean、Byte等类来打包（Wrap）基本类型。
public class IntegerDemo {
public static void main(String[] args) {
int data1 = 10;
int data2 = 10;
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));
}
}
output:
3
3.3333333333333335
0
基本类型打包器都是归类于java.lang包中，如果要使用Integer打包int类型数据，方法之一是用new创建Integer实例时，传入int类型数据。除了使用new创建基本类型打包器之外，从J2SE 5.0之后提供了自动装箱功能和自动拆箱功能。自动装箱与拆箱的功能事实上是编译程序蜜糖。
四、数组
数组在Java中就是对象。
1.数组的创建：
元素类型[] 数组名= new 元素类型[]{元素，元素，……};
int[] arr = new int[]{3,5,1,7};
int[] arr = {3,5,1,7};
2.使用for循环，通过使用length属性获取数组长度：
int[] scores = { 88, 81, 74, 68, 78, 76, 77, 85, 95, 93};
for (int i = 0; i < scores.length; i++) {
System.out.printf("学生分数：%d %n",scores[i]);
}
3.使用增强式for循环：
for(int score:scores){
System.out.printf("学生分数：%d %n",score);
}
五、字符串
字符串本质是打包字符数组的对象，是java.lang.String类的实例。字符串对象一旦建立，就无法更改对象中的任何内容，对象上没有任何方法可以更改字符串内容。
输入整数，再输入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);
}
}
运行结果：
•课后操作题3
下面是一个数组，请使用程序使其中元素排序为由小到大：
int[] number = {70, 80, 31, 37, 10, 1, 48, 60, 33, 80}
package cc.openhome;
class Number
{
public static void main(String[] args)
{
int[]arr=new int[]{70,80,31,37,10,1,48,60,33,80};
for (int c=0;c<arr.length ;c++ )
{
for (int b=c+1;b<arr.length;b++ )
{
if(arr[c]>arr[b])
{
int tep=arr[c];//实现两个变量的值互换，由此可以排列出数组从小到大
arr[c]=arr[b];
arr[b]=tep;
}
}
System.out.print(arr[c]+" ");//第一次跳出内循环：arr{9,12,56,45,10}第二次跳出：arr{9,10,56,45,12}
}
}
}
运行结果：
第五章 对象封装
一、Java封装概念
在面向对象程式设计方法中，封装（英语：Encapsulation）是指，一种将抽象性函式接口的实作细节部份包装、隐藏起来的方法。
封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。
要访问该类的代码和数据，必须通过严格的接口控制。
封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。
适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。
二、构造函数与方法重载
如果定义类时，没有撰写任何构造函数，编译程序会自动加入一个无参数、内容为空的构造函数，称为默认构造函数。可以定义多个构造函数，只要参数类型或个数不同，这称为重载构造函数。
方法重载让程序设计人员不用苦恼方法名称的设计，可用一致的名称来调用类似功能的方法，方法重载可根据传递自变量的类型不同，也可根据参数列个数的不同来设计方法重载。
eg:
public class SomeClass {
public void someMethod(){
}
public void someMethod(int i){
}
public void someMethod(float f){
}
public void someMethod(int i,float f){
}
}
编译程序在处理重载函数时，会依以下顺序来处理：
（1）还没有装箱动作前可符合自变量个数与类型的方法
（2）装箱动作后可符合自变量个数与类型的方法
（3）尝试有不定长度自变量并可符合自变量类型的方法
（4）找不到合适的方法，编译错误
三、static和final
•final定义的变量可以看做一个常量，不能被改变；
•final定义的方法不能被覆盖；
•final定义的类不能被继承。
•final static 就是再加上static的特性就可以了
•static和final是没有直接关系的
•static 是在内存中分配一块区域，供整个类通用，所有的类的对象都享有它的共同的值
教材学习中的问题和解决过程
在学习Java这么久了，我一直都不知道类到底是什么，只知道用class就能产生一个类，但是学了第四章，我才差不多明白，要产生对象必须先定义类，类是对象的设计图，对象是类的实例。类定义时使用class关键词，建立实例要使用new关键词。在对Java了解不多的时候只觉得这个东西很抽象，但是随着不断地敲书上的代码练习，现在已经能理解类的大概含义了。然而接下来就是数组了，虽然以前学C语言的时候接触过数组，但是对于数组还并不能熟练地掌握和运用，比如数组的复制，操作数组对象，必须要跟着书上的内容来编写数组代码验证结果。至于第五章的内容则是更加的抽象，因为我不明白为什么要封装，要怎样才叫封装？封装的意义是什么？还有什么是构造函数和方法重载？带着这些疑问，我将教材上的内容仔细的看了好几遍，努力的去理解，认真的去实践书上的程序，所以最终可能开窍了一点儿了。封装的目的主要就是隐藏对象细节，将对象当做黑箱进行操作。而对于static和final的区别：final可修饰类、域（变量和常量）、方法 ，而static不修饰类，static和final是没有直接关系的。
Java封装类实例：
public class EncapTest{
private String name;
private String idNum;
private int age;
public int getAge(){
return age;
}
public String getName(){
return name;
}
public String getIdNum(){
return idNum;
}
public void setAge( int newAge){
age = newAge;
}
public void setName(String newName){
name = newName;
}
public void setIdNum( String newId){
idNum = newId;
}
}
代码调试中的问题和解决过程
•定义类。只要有一个类定义，编译程序机会产生一个.class文档。在Clothes类中，定义了color和size两个变量。
•ClassObject Field.java
package cc.openhome;
class Clothes //定义Clothes类
{
String color;
char size;
}
public class Field
{
public static void main(String[] args)
{
Clothes sun = new Clothes();//建立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);//显示个别对象的数据成员值
}
}
运行结果：
•构造函数
•ClassObject Field2.java
package cc.openhome;
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.util.Scanner
•ClassObject Guess.java
package cc.openhome;
import java.util.Scanner;//告诉编译程序接下来想偷懒
public class Guess
{
public static void main(String[] args)
{
Scanner scanner = new Scanner (System.in);//建立Scanner实例
int number = (int) (Math.random() * 10);
int guess;
do
{
System.out.printf("猜数字（0—9）：");
guess = scanner.nextInt();//取得下一个整数
}
while(guess != number);
System.out.println("猜中了...XD");
}
}
运行结果：
•使用java.math.BigDecimal
•ClassObject DecimalDemo.java
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比较相等
•ClassObject DecimalDemo2.java
package cc.openhome;
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");
}
}
}
运行结果：
•基本类型打包器
•Wrapper IntegerDemo.java
package cc.openhome;
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));
}
}
运行结果：
•声明数组来储存XY坐标位置要放的值
•Array XY.java
package cc.openhome;
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();
}
}
}
运行结果：
•操作数组对象
•将每个学生成绩默认为60分起
•Array Score2.java
package cc.openhome;
import java.util.Arrays;
public 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);
}
}
}
运行结果：
•数组复制
•Array CopyArray.java
package cc.openhome;
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;//不影响scorel参考的数组对象
for(int score : scores1)
{
System.out.printf("%3d",score);
}
}
}
运行结果：
•字符串特性
•String Oneto100.java
package cc.openhome;
public class One
{
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());
}
}
运行结果：
•通过成员方法（函数）封装操作
•Encapsulation2 CashAPP.java
package cc.openhome;
import java.util.Scanner;
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)
};
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);
}
}
}
运行结果：
这个程序不知道是哪里出了问题，应该是CashCard的问题，但是目前还没有解决。
•构造函数与方法重载
•Class OverloadBoxing.java
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);
}
}
运行结果：
•使用this
•Class ObjectlnitialBlock.java
package cc.openhome;
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类成员
•Class ImportStatic.java
package cc.openhome;
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.java
package cc.openhome;
public class Main{
public static int sum(int... numbers){
int sum = 0;
for(int number:numbers){
sum+=number;
}
return sum;
}
}
•传值调用
•Class CallByValue
public class CallByValue {
public static void main(String[] args) {
Customer c1 = new Customer("Justin");
some(c1);
System.out.println(c1.name);
Customer c2 = new Customer("Justin");
other(c2);
System.out.println(c2.name);
}
static void some(Customer c) {
c.name = "John";
}
static void other(Customer c) {
c = new Customer("Bill");
}
}
class Customer {
String name;
Customer(String name) {
this.name = name;
}
}
运行结果：
•代码托管
其他（感悟、思考等，可选）
我觉得通过这两章内容的自学，自己又掌握了很多知识，对于自己的Java程序设计又达到了一个新的突破，虽然书上的概念性的知识好多还是没有；理解，但是我按照老师布置的学习任务去做，把书上的代码挨着敲了一遍，当然，虽然是原搬的，但是发现还是遇到了错误的地方，很多还是自己粗心输错了，或者少输了，就导致代码编译不通过。所编代码一定要认真认真再认真，因为有可能少输一个分号就可能使代码运行不成功。但是通过敲这些代码，从中我也掌握了很多技巧性的东西，所以 这周的学习让我收获颇丰。但是有一个最大的问题！代码托管不会弄，研究了一下午都没托管上去，简直爆炸！！！但是后来通过咨询同学，看了好多相关的博客，终于成功的将代码都推送上去了。
学习进度条
| 代码行数（新增/累积） | 博客量（新增/累积） | 学习时间（新增/累积） | 重要成长 | |
|---|---|---|---|---|
| 目标 | 5000行 | 30篇 | 400小时 | |
| 第一周 | 200/200 | 2/2 | 20/20 | |
| 第二周 | 300/500 | 2/4 | 18/38 | |
| 第三周 | 500/1000 | 1/5 | 40/78 |