OOP Day03\

关于类:
一个Java源文件只能有一个public class
文件名与公有类类名一致
源文件中可以有多个类, 但是不能都是公有的
如果没有公有类, 文件名与某个类类名一致

一般情况下: 一个源文件一个类, 类是公有的!
类体(class body)中的成员:
属性
方法
构造器
语句块(以后讲, 很少用)
成员不能重复!
属性名不能重复
方法签名不能重复
构造器签名不能重复

1 方法签名(方法的识别关键字)
方法签名 = 方法名+参数类型列表
Java 类中不能存在相同方法签名的方法

方法重载: 方法名一样, 方法签名不同的方法

char[] chs = {‘A’,‘B’,‘C’};
int[] ary = {‘A’,‘B’,‘C’};
System.out.println(chs);//ABC// println(char[])
System.out.println(ary);//[[@34ADCD//println(Object)
System.out.println(ary.toString());// [[@34ADCD
System.out.println(‘A’);//A // println(char) 打印字符
System.out.println(65);//65// println(int) 打印整数
打人
打牌
方法重载就是: 动词的多意现象, 打人, 打牌, 打酱油, 打车
就是行为的多态

洗衣服, 洗手, 洗照片

保存联系人, 保存通话记录, 保存访问过的地址
save(Contact) save(Log) save(Url) save(Message)

2 java方法参数的传递规则: 基于值的传递, 是变量值的复制,\

基本类型就是其中值的复制,\
引用类型是引用值(地址)的复制, 对象不复制!
案例: ParamaterDemo.java
* 变量的值: a 基本类型的值是其本身,
b 引用变量的值是一个地址值,是被引用对象的首地址.
为了避免引用参数传递的副作用, 建议一切结果使用
返回值带回.

继承, 类型的继承
继承涉及到语法:
属性, 方法
构造器, 方法覆盖

* A 继承体现了自然逻辑系统中的分类关系
* B 父类型声明所有子类的公共特征(公共属性)和行为(公共方法)
* C 子类可以继承父类型的可以继承的属性和方法.
* D 继承可以实现代码的复用(重用), 子类可以不用再定义了
* E 子类可以声明特有的属性和方法, 叫: 特化(具体化, 特殊化)
* F 子类可以覆盖(重写)父类型的功能, 实现多态行为
* 如: 具体鸟(企鹅)可能修改了父类型(鸟类)飞翔的行为(多态)

3 继承用来表达概念上具体化延续的具体概念.
1 * 子类继承父类的属性和方法 (子类可见的方法)
2 * 构造器不能继承！
3 实例化子类，会递归分配所有父类的空间
4 子类构造器一定调用父类构造器

* 类一定有构造器

4 关于继承中的构造器：
1 * 子类构造器中, 一定调用父类构造器。
2 子类构造器默认调用父类无参数构造器！
3 如果父类没有无参数构造器，就必须在子类中明确指定调用
父类的有参数构造器！
4 使用super()调用父类构造器，必须写在子类构造器第一行
this() 必须写在子类构造器第一行
5 编程建议：所有的类都提供无参数构造器！减少继承时候的
麻烦。

5 关于对象的实例化过程：
* 1 按需加载类(Koo.class) 以及所有的父类型, 只加载一次!
* 2 递归调用所有父类构造器(从最高的父类执行 A-B-C)
* 父类中
* A 分配父类属性空间, 自动初始化为默认值
* B 执行属性初始化赋值
* C 执行父类构造器过程
* 子类中
* D 分配子类属性空间, 自动初始化为默认值
* E 执行子类属性初始化赋值
* F 执行子类构造器过程
* 3 最后创建的对象(子类实例), 包含所有父类型声明的属性空间
*
* super 关键字:
* A super() 在构造器的第一行, 调用父类构造器, 默认自动添加
* B super在子类中代表父类型对象的引用, 用来访问父类型的属性/方法
* 如: super.a 访问父类型实例的a属性
* super.a() 访问父类型的方法
* this 关键字:
* A this() 在构造器的第一行, 调用本类的构造器, 有this() 就
* 不再默认自动添加super()
* B this 代表当前对象的引用, 用来访问当前对象的属性, 和方法
* 如: this.a this.a()
* 如果能够区别局部变量和属性(实例变量), 可以省略this.

所有类默认继承于Object=>所有类都是Object(东西)=>啥都是东西
继承表达"是" 的关系

7 继承中的语法现象
1 父类型变量可以引用子类型的实例，父类型的实现是多态的！
2 子类可以覆盖父类的方法，修改父类的行为。
* 方法覆盖：子类覆盖了父类“相同方法签名”的方法。
方法的覆盖是由方法动态绑定实现的，就是Java虚拟机运行
时候确定执行那个那个对象那个方法，java最终执行子类的方法。

作业:
1 练习课题案例
2 实现如下案例:
设计图形（Shape）类及其子类（Circle、Rectangle）
（Shape 有属性: Point(x,y) 是图形位置,
1）Shape提供计算面积方法area，子类覆盖
2) Shape提供检查是否包含指定坐标的方法，子类覆盖
3 试题(Question), 单选题(SingleChoice)和
多选题(MultiChoice)之间的继承关系
要求:\

Question 包含题干属性(text)\
Question 包含检测标准答案的方法
boolean check(int[] answers)
answers 是用户提供的答案, 是单选就应该只有一个答案
3）MultiChoice和SingleChoice是Question类的子类，
MultiChoice 包含属性
选项: String[] options
多选标准答案: int[] answers

SingleChoice 包含属性
选项: String[] options
单选标准答案: int answer

在MultiChoice实现参数为(String text,
String[] options, int[] answers)的构造方法，
其中:
text 是题干,
options 是选项,
answers 是多选标准答案, 是正确选项的序号\
在SingleChoice实现参数为(String text,
Stirng[] options, int answer)的构造方法。
其中:
text 是题干,
options 是选项,
answer 是标准答案, 是正确选项的序号
6）在MultiChoice和SingleChoice类中重写
Question类check方法提供具体的检查用户答案的逻辑

预习: final static Object

重要代码演示说明：
单选题与多选题问题

/*選擇題父類 Question.java*/
/** 選擇題, 考題 是繼承的父類型, 要派生出子類型: 單選題和多選題
 * A 繼承體現了自然邏輯系統中的分類關系
 * B 父類型聲明所有子類的公共特征(公共屬性)和行爲(公共方法)
 * C 子類可以繼承父類型的可以繼承的屬性和方法.
 * D 繼承可以實現代碼的複用(重用), 子類可以不用再定義了
 * E 子類可以聲明特有的屬性和方法, 叫: 特化(具體化, 特殊化)
 * F 子類可以覆蓋(重寫)父類型的功能, 實現多態行爲
 *   如: 具體鳥(企鵝)可能修改了父類型(鳥類)飛翔的行爲(多態)
 **/
public class Question {
  String title;//題幹
  String[] options;//選項
  public void print(/* Question this */){//打印題
    System.out.println(this.title);
    for(int i=0; i<this.options.length; i++){
      String option = this.options[i];
      System.out.print("t"+option);
    }
    System.out.println();
  }
  public boolean check(char[] answers){//檢查用戶答案
    return false;
  }
}

/*多選題  MultiQuestion.java*/
import java.util.Arrays;
/** 多選題也是選擇題, 也繼承于選擇題 */
public class MultiQuestion extends Question {
  char[] answers;
  public MultiQuestion(
      String title,
      String[] options,
      char[] answers) {
    this.title = title;
    this.options = options;
    this.answers = answers;
  }
  /** 覆蓋檢查方法 */
  public boolean check(char[] answers) {
    if(answers==null){
      return false;
    }
    return Arrays.equals(this.answers, answers);
  }
}

/*單選題  SingleQuestion.java*/
/** 單選題, 單選題擴展于選擇題: 單選題是選擇題
 */
public class SingleQuestion extends Question {
  char answer;//單項選擇的標准答案
  public SingleQuestion(
      String title,
      String[] options,
      char answer) {
    this.title = title;//this.title 繼承于父類型Question
    this.options = options;
    this.answer = answer;//子類聲明的特殊屬性
  }
  /** 覆蓋(重寫) 檢查題的方法, 修改(實現)具體的檢查邏輯
   * 覆蓋(重寫): 子類的方法簽名與父類中的方法簽名壹樣!
   *  */
  public boolean check(char[] answers){
    if(answers==null || answers.length!=1){
      return false;
    }
    return this.answer==answers[0];
  }
}

/*運行實例  Question.java*/
import java.util.Scanner;
/** 繼承關系的使用, 與測試 */
public class QuestionDemo {
  public static void main(String[] args){
    //paper 表示試卷, 表達: 試卷包含多個選擇題
    //對象數組, 元素自動初始化爲null, 元素是類型爲Question
    //元素是引用變量. 表示試卷上有兩個考題空(null)位子
    Question[] paper = {null, null};//new Question[2];
    paper[0] = new SingleQuestion("Java 特點是",
        new String[]{"A 面向過程", "B 多線程",
        "C 與C語言壹樣", "D 是咖啡品種"}, 'B');
    paper[1] = new MultiQuestion("java 基本類型包括",
        new String[]{"A String","B int",
        "C long", "D Boolean"}, new char[]{'B','C'});
    Scanner console = new Scanner(System.in);
    for(int i=0; i<paper.length; i++){
      Question question = paper[i];
      question.print();//print(question)
      System.out.print("請選擇:");
      //console.nextLine() 從控制台讀取下壹行字符串
      String ans = console.nextLine();//"A" "ABC"
      char[] answers = ans.toCharArray();//"ABC"->['A','B','C']
      //方法是動態綁定到對象的方法上! 編譯期間按照類型檢查!
      if(question.check(answers)){
        System.out.println("行呀!");
      }else{
        System.out.println("還需努力!");
      }
    }
  }
}

[媒体不可用]
课堂提纲教案

Hello OOP Day03

OOP Day03\

在这里找找