20145308刘昊阳 《Java程序设计》第3周学习总结

20145308刘昊阳 《Java程序设计》第3周学习总结

教材学习内容总结

第四章 认识对象

• 要产生对象必须先定义类，类是对象的设计图，对象是类的实例
• 类是从少数实例推广到大量相似实例的抽象化过程
• 类可以视为相同属性和行为的一组对象的集合的模版，用于产生对象

4.1 类与对象

• 定义类
  • 1.先在程序中定义类class Clothes{String color;Char size;}(定义color和size两个对象数据成员) 2.新建一个对象new Clothes() 3.声明参考名称（参考变量或参考）Clothes c1; 4.将c1名称参考至新建对象 CLothes c1 = new Clothes();
  • 类：公开类和非公开类，一个原始码中只能有一个公开类，但可以有多个类定义，且文档中的主文档名必须与公开类名称相同(计量不要在一个类中写多个class)
  • this：this.color = color将参数的值指给这个对象的某个参数成员（this）
  • new:新建一个对象
  • 两个基本标准类
    • java.util.Scanner:Scanner对每个基本类型都有相应的nextxxx()方法，将字符串剖析至相应类型，直接取得上一个字符串使用next()，取得整行文字nextLine()

     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.print("猜数（0 ~ 9）：");
            guess = scanner.nextInt();
        }while(guess != number);

        System.out.println("猜中了！");
    }
}

• java.math.BigDecimal提供plus()、subtract()、multiply()、divide()

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

• 对象制定与相等性
  • =：用于基本类型，将值复制给变量；用于操作对象，指定参考名称参考某个对象==：用于基本类型，比较两个变量储存的值是否相同；用在操作对象，比较两个参考名称是否参考同一对象equals():用于操作对象，比较两对象的值是否相同

4.2 基本类型包装

• 将基本类型打包在对象之中，将基本类型当作对象来操作
• 打包器（Wrapper）：Long、Integer、Double、Float、Boolean、Byte

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

• 自动装箱(Autoboxing)Integer wrapper = 10;编译程序自动判断是否能进行自动装箱int data1 = 10;Integer wrapper1 = new Integer(data1);可利用自动装箱改写成Integer data1 = 10;
• 自动拆箱(Auto Unboxing)自动取出打包器中的基本形态信息Integer i = 10;//自动装箱 int foo = wrapper;//自动拆箱
• 自动拆装箱是编译程序蜜糖，不能让变量参考至空对象又对之进行操作，也不能超过打包器的值域范围
• 无论两个变量打包的值位于哪个范围，只要变量打包的值相同，equals()比较的结果就会是true

4.3 数组对象

• Java中，数组就是对象
• 数组是具有索引的数据结构，如果存取超出索引范围，就会抛出错误
• 依次取出数组中每个值的方法
  • for循环（数组的length属性可以取得数组的元素个数）

public 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++){
            System.out.printf("学生分数：%d %n",scores[i]);
        }
    }
}

• 增强式for循环

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

• 声明二维数组，在类型关键词旁加上[][]，cords.length得知有几行，cords[x].length得知每行有几个元素

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

• 利用增强for循环

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

    }
}

• 利用java.util.Arrays的fill()方法来设定新建数组的元素值

import java.util.Arrays;

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

• 如果要做数组复制，基本方法是另行建立新数组
• System.arraycopy()方法会使用原生方式复制每个索引元素，五个参数：来源数组、来源起始索引、目的数组、目的起始索引、复制长度，浅层复制
• Array.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;//不影响score2参考的数组对象
        for(int score : scores1){
            System.out.printf("%3d",score);
        }
    }
}

• 浅层复制：仅将c1每个索引处所参考的对象，也给c2每个索引来参考，用在类类型声明的数组时，都是执行浅层复制
• 深层复制：实际上c1每个索引参考的对象会被复制，分别指定给c2每个牵引

4.4 字符串对象

• 字符串是打包字符数组的对象，是java.lang.String类的实例
• length()取得字符串的长度，charAt()指定取得字符串中某个字符，toCharArray()将字符串以char[]数组返回

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.printf("总和："+ sum);
    }
}

• 以""包括的字符串，只要内容相同，无论在程序代码中出现几次，JVM只会建立一个String实例，并在字符串池中维护
• 字符串对象一旦建立，就无法更改对象中任何内容，对象中没有任何方法可以更改字符串内容

4.5 查询Java API文件

• 查询java各种类的各种方法

第五章 对象封装

5.1 何谓封装

• 封装实际上使用方法将类的数据隐藏起来，隐藏对象细节，将对象当作黑箱操作，用户不用再需要重复撰写对象初始化流程

class CashApp {
    String number;
    int balance;
    int bonus;
    CashApp(String number,int balance,int bonus){
        this.number = number;
        this.balance = balance;
        this.bonus = bonus;
    }
}
public class CashCard{
   public static void main(String[] args){
       CashApp[] cards =  {
               new CashApp("A001",500,0),
               new CashApp("A002",300,0),
               new CashApp("A003",1000,1),
               new CashApp("A004",2000,2),
               new CashApp("A005",3000,3),
       };

       for(CashApp card : cards){
           System.out.printf("(%s,%d,%d)%n",card.number,card.balance,card.bonus);
       }
   }
}

• 在类中定义方法，如果不用返回值，方法名称前可声明void，方法若会返回值，必须在方法前声明返回值的类型
• *存取类私有数据，使用private定义，也可以用在方法或构造函数声明，也可以用在内部类声明

5.2 类语法细节

• 三个权限修饰：public、private、 protected
• public权限修饰
  • 如果想在其他包的类程序中存取某包的类或对象成员，则该类或对象成员必须是公开成员，用public加以声明
  • 声明类为public，表示它是个公共类，可以在其他包的类中使用
  • 声明构造函数为public，表示其他包中的类可以直接调用这个构造函数
  • 声明方法为public，表示其他包的方法中可以直接调用这个方法
  • 声明数据成员为public
• 定义类时，可以使用构造函数定义对象建立的初始流程
• 构造函数是与类名称同名，无须声明返回类型的方法
• 编译程序会在你没有撰写任何构造函数时，自动加入默认构造函数
• 在没有编写任何构造函数时，也可以Some some = new some();这样以无自变量方式调用函数
• 重载构造函数：定义多个构造函数，只要参数类型或个数不同
• 调用方法valueOf()根据传递的自变量类型不同，会调用对应的方法

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

• 除被声明static的地方外，this关键字可以出现在类中的任何地方，在对象建立后为“这个对象”的参考名称
• this()代表调用另一个构造函数，根据调用时给的自变量类型与个数定调用哪个函数，只能出现在构造函数的第一行
• 在创建对象后、调用函数前，若有想执行的流程，可以用{}定义
• 如果撰写了对象初始化区块，对象建立之后会先执行对象初始区块，接着再调用指定的构造函数
• 对象数据成员被声明为final，但没有明确用=指定值，表示延迟对象成员值的定义，但在构造函数执行流程中，一定要有对该数据成员指定值的动作
• static不用每个对象各自拥有，表示它属于类
• 通过类名称.static成员取得static成员
• static方法或区块中，不能调用非static方法或区块，可以使用static数据成员或方法成员
• import static解析顺序：1.局部变量覆盖2.成员覆盖3.重载方法比较
• 使用不定长度自变量，声明参数列时要在类型关键字后加...,方法上声明的不定长度参数必须是参数列最后一个
• 使用两个不定长度参数列是不合法的
• 内部类：在类中再定义类
• 内部类可以用public、protected、private声明
• 内部类本身可以存取外部类成员
• 非静态内部类会声明为private
• 被声明为static的内部类，将外部类当作名称空间，Some.Other o = new Some.Other()
• 被声明为static的内部类，虽然将外部类当作名称空间，但是算是独立类，只可以存取外部类static成员
• 方法中也可以声明类，辅助方法中演算，方法外无法使用
• java中只有传值调用

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

• 问题：对于参考名称、对象之间的关系不明白
• 解决过程：看了老师给的学习指导，仔细的看了书上的参考图，理解了参考名称和参考对象的关系

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

• 问题
  • 代码

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

• 运行结果
  
  

• 解决过程
  
  发现是声明为public的类和另一个类的名称写反了，声明为public的类名需要和文件名称相同，调用其他类时包括新建对象一定要注意名称书写准确

class CashApp {
    String number;
    int balance;
    int bonus;
    CashApp(String number,int balance,int bonus){
        this.number = number;
        this.balance = balance;
        this.bonus = bonus;
    }
}
public class CashCard{
   public static void main(String[] args){
       CashApp[] cards =  {
               new CashApp("A001",500,0),
               new CashApp("A002",300,0),
               new CashApp("A003",1000,1),
               new CashApp("A004",2000,2),
               new CashApp("A005",3000,3),
       };

       for(CashApp card : cards){
           System.out.printf("(%s,%d,%d)%n",card.number,card.balance,card.bonus);
       }
   }
}

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

• 学习任务越来越重，学习时间也越来越紧，没有别的办法，只能抓紧学习
• 这周尝试了代码托管，问了很多同学自己也尝试了很长时间，终于成功了，以下是截图
  
  

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	30/30	1/2	16/16	基础知识
第二周	100/130	1/3	20/36	基本语法
第三周	100/230	1/4	30/66	对象封装