20145236 冯佳 《Java程序设计》第3周学习总结

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

参考资料

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