Java 第14章 ：综合案例：继承分析

课时67：案例分析一（学生类）

补习一下this调用构造函数的例子：

public CrawlDatum(){} 
public CrawlDatum(int status, int fetchInterval) { 
    this(); /*this调用的作用是调用上面的无参构造函数*/ 
    this.status = (byte)status; 
    this.fetchInterval = fetchInterval; 
    } 
public CrawlDatum(int status, int fetchInterval, float score) { 
    this(status, fetchInterval); /*this的作用是调用上面有两个参数的构造函数*/
    this.score = score; 
    } 

1， 实现代码复用。例如上面第三个构造函数如果不使用this就会是这样

public CrawlDatum(int status, int fetchInterval, float score) { 
    this.status = (byte)status; 
    this.fetchInterval = fetchInterval; 
    this.score = score; 
  } 

这样的话，前两行代码就完全是第二个构造函数中的语句，违背面向对象代码复用的原则。

2， 封装 如果说第二个构造函数的实现发生了变化，则我们除了修改第二个构造函数，还得修改第三个构造函数。 如果使用this就不需要修改第三个构造函数了。

 

package test;
 class Person {
    private String name;
    private String addr;
    private char sex;
    private int age;
    public Person(){}
    public Person(String name,String addr){
        this(name,addr,'男',0);
    }
    public Person (String name,String addr,char sex,int age){
        this.name = name;
        this.addr = addr;
        this.sex = sex;
        this.age = age;
    }
    public String getInfo(){
        return "姓名："+ this.name + "、性别：" + this.sex+ "、年龄："+ this.age +"、地址："+ this.addr;
    }
}
class Student extends Person{
    private double match;
    private double english;
    public Student(){}  //无参
    public Student(String name , String addr){   //两参
        super(name,addr);
    }
    public Student(String name,String addr,char sex,int age,double match,double english){   //六参
        super(name,addr,sex,age);//重点!!! super应在首行调用
        this.match = match;
        this.english = english;
    }
    public String getInfo(){
        return super.getInfo() + "、数学成绩："+ this.match + "、英语成绩" + this.english ;
    }
}
public class example {
    public static void main(String[] args) {
        Student stu = new Student("暖光","天府广场",'男',3,99.8,99.9) ;
        System.out.println(stu.getInfo() );
        }
      }
/*
不能被继承的：
        　 1.私有的属性(可以通过set get或super方法使用父类的私有属性)
        　　2.不同包的friendly
        　　3.构造方法不能继承
 */

课时68：案例分析二（管理人员与职员）

package test;
class Employee{
    private String name;
    private int age;
    private String sex;
    public Employee(){}
    public Employee (String name,int age, String sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public String getInfo(){
        return "姓名："+this.name+"、年龄："+this.age+"、性别："+this.sex;
    }
}
class Manager extends Employee{
    private String job;
    private double yearSalary;
    public Manager (){}
    public Manager (String name,int age,String sex,String job,double yearSalary){   //继承父类此处也应该添加成员属性才可继承
        super(name,age,sex);
        this.job = job;
        this.yearSalary = yearSalary;
    }
    public String getInfo(){
        return "【管理层】："+super.getInfo() + "、职务："+this.job + "、年薪："+this.yearSalary ;
    }
}
class Worker extends Employee{
    private String department;
    private double monthSalary;
    public Worker(){}
    public Worker(String name,int age, String sex,String department,double monthSalary ){
        super(name,age,sex);
        this.department = department ;
        this.monthSalary = monthSalary ;
    }
    public String getInfo(){
        return "【职员】："+super.getInfo() +"、部门："+this.department +"、月薪："+this.monthSalary ;
    }
}
public class example {
    public static void main(String[] args) {
         Manager man = new Manager("张三",30,"男","主管",15000.00);
         Worker str = new Worker("李斯",25,"女","出纳",3000.00);
         System.out.println(man.getInfo());
         System.out.println(str.getInfo());
    }
      }

课时69：案例分析三（字符串统计）

统计“want you to know one thing”字母“n”、“o”出现次数。

方案1：先做一个单独的处理类

补充：分析Java中的关键字static：https://baijiahao.baidu.com/s?id=1636927461989417537&wfr=spider&for=pc

package test;
class StringUtil{
    /*
    static方便在没有创建对象的情况下来进行调用。被static关键字修饰的不需要创建对象去调用，直接根据类名就可以去访问。
    如果没有用static修饰count，则只能new 一个外部类实例。再通过外部实例创建内部类。
    static是一个修饰符，用于修饰成员。（成员变量，成员函数）static修饰的成员变量 称之为静态变量或类变量。
    static修饰的成员被所有的对象共享。
    static优先于对象存在，因为static的成员随着类的加载就已经存在。
    static修饰的成员多了一种调用方式，可以直接被类名所调用，（类名.静态成员）。
    static修饰的数据是共享数据，对象中的存储的是特有的数据。
    */
    public static int[] count(String str){
        int countData [] = new int[2];    //相当于把两个用来统计的变量放一起了,其中就是countData[0]、countData[1]
        char [] data = str.toCharArray();  //将一个字符串转换成一个Char型的字符数组
        for (int x = 0;x<data.length;x++){
            if(data[x] == 'n' || data[x] == 'N'){
                countData[0]++;
            }
            if(data[x] == 'o' || data[x] == 'O'){
                countData[1]++;
            }
        }
        return countData;
    }
}
public class example {
    public static void main(String[] args) {
        String str = "want you to know one thing";
        int result[] = StringUtil.count(str) ;
        System.out.println(result[0]);//n
        System.out.println(result[1]);//o
    }
      }

方案2：用继承的方式统计

package test;
class StringUtil{
    private String content;
    public StringUtil(String content){
        this.content=content;
    }
    public String getContent(){
        return this.content;
    }
    public String getInfo(){
        return this.getContent();
    }
}
class StringCount extends StringUtil{
    private int nCount;
    private int oCount;
    public StringCount(String content){
        super(content);
        this.countChar();
    }
    public void countChar(){
        char [] data = super.getContent() .toCharArray();  //将一个字符串转换成一个Char型的字符数组
        for (int x = 0;x<data.length;x++){
            if(data[x] == 'n' || data[x] == 'N'){
               this.nCount++;
            }
            if(data[x] == 'o' || data[x] == 'O'){
                this.oCount++;
            }
        }
    }
    public int getNCount(){
         return this.nCount ;
    }
    public int getOCount (){
        return this.oCount ;
    }
    public String getInfo(){
        return "字母N的个数"+ this.nCount +"、字母O的个数"+ this.oCount;
    }
}
public class example {
    public static void main(String[] args) {
        StringCount sc = new StringCount("want you to know one thing") ;
        System.out.println(sc.getInfo() );
    }
      }

课时70：案例分析四（数组操作）

1、实现基本的数组操作类定义

package test;
class Array{             //数组的操作类
    private int[] data;  //整形数组
    private int foot;    //进行数组的索引控制
    Array(int len){
        if(len > 0){
            this.data = new int[len]; //开辟len个空间
        } else {
            this.data = new int[1];  //开辟一个空间。长度：也就是内部存储元素的数量
        }
    }
    //实现数组容量的扩充，给出的是扩充大小；实际大小是：已有大小+扩充大小
    public void increment(int num){
       //数组特征（缺陷）：长度固定，要扩充只有new一个数组
        int newData [] = new int[this.data.length + num];
        System.arraycopy(this.data,0,newData,0,this.data.length) ;  //拷贝
        this.data = newData ;  //改变数组引用
    }
    public boolean add(int num){
        if(this.foot < this.data.length){     //有位置：数组还没用满，还有多余的空间
            this.data[this.foot++] = num;
            return true;
        }
        return false;
    }
    public int [] getData(){
        return this.data;
    }
}
public class example {
    public static void main(String[] args) {
      Array arr = new Array(5);
      System.out.println(arr.add(10));
      System.out.println(arr.add(5));
      System.out.println(arr.add(20));
      System.out.println(arr.add(3));
      System.out.println(arr.add(6));
      arr.increment(3) ;
      System.out.println(arr.add(1));
      System.out.println(arr.add(7));
      System.out.println(arr.add(0));
    }
      }

2、进行排序子类定义

package test;
class Array{             //数组的操作类
    private int[] data;  //整形数组
    private int foot;    //进行数组的索引控制
    Array(int len){
        if(len > 0){
            this.data = new int[len]; //开辟len个空间
        } else {
            this.data = new int[1];  //开辟一个空间。长度：也就是内部存储元素的数量
        }
    }
    //实现数组容量的扩充，给出的是扩充大小；实际大小是：已有大小+扩充大小
    public void increment(int num){
       //数组特征（缺陷）：长度固定，要扩充只有new一个数组
        int newData [] = new int[this.data.length + num];
        System.arraycopy(this.data,0,newData,0,this.data.length) ;  //拷贝
        this.data = newData ;  //改变数组引用
    }
    public boolean add(int num){
        if(this.foot < this.data.length){     //有位置：数组还没用满，还有多余的空间
            this.data[this.foot++] = num;
            return true;
        }
        return false;
    }
    public int [] getData(){
        return this.data;
    }
}
class SortArray extends Array{
    public SortArray(int len){
        super(len);
    }
    public int[] getData(){
        java.util.Arrays.sort(super.getData() );
        return super.getData() ;
    }
}
public class example {
    public static void main(String[] args) {
      SortArray arr = new SortArray(5);
      System.out.println(arr.add(10));
      System.out.println(arr.add(5));
      System.out.println(arr.add(20));
      System.out.println(arr.add(3));
      System.out.println(arr.add(6));
      arr.increment(3) ;
      System.out.println(arr.add(1));
      System.out.println(arr.add(7));
      System.out.println(arr.add(0));
      int result[] = arr.getData() ;
      for(int temp : result ){
          System.out.print(temp + "、");
      }
    }
      }

3、定义反转子类

建立一个可以实现整形数组操作类（Array），而后在里面可以操作的数组的大小由外部来决定，而后在Array类里面需要提供有数组的如下处理：进行数据的增加（如果数据满了则无法增加）、可以实现数组的容量扩充、取得数组的全部内容。完成之后在此基础上再派生出两个子类：

    数组排序类：返回的数据必须是排序后的结果；

    数组反转类：可以实现内容的首尾交换。

 

for(int i:b)  在java 编程中的使用

这种有冒号的for循环叫做foreach循环，foreach语句是java5的新特征之一，在遍历数组、集合方面，foreach为开发人员提供了极大的方便。

foreach语句是for语句的特殊简化版本，但是foreach语句并不能完全取代for语句，然而，任何的foreach语句都可以改写为for语句版本。

foreach并不是一个关键字，习惯上将这种特殊的for语句格式称之为“foreach”语句。从英文字面意思理解foreach也就是“for 每一个”的意思。实际上也就是这个意思。

foreach的语句格式：

int a[] {1,2,3,4,5,6,7} 
for（数组类型int  变量i :数组名a）{
System.out.print(i);
}

int b[]={1,2,3,4,5,6};
   public void showall(){
   for(int i:b){
   System.out.println(i); 
   }
}

package test;
class Array{             //数组的操作类
    private int[] data;  //整形数组
    private int foot;    //进行数组的索引控制
    Array(int len){
        if(len > 0){
            this.data = new int[len]; //开辟len个空间
        } else {
            this.data = new int[1];  //开辟一个空间。长度：也就是内部存储元素的数量
        }
    }
    //实现数组容量的扩充，给出的是扩充大小；实际大小是：已有大小+扩充大小
    public void increment(int num){
       //数组特征（缺陷）：长度固定，要扩充只有new一个数组
        int newData [] = new int[this.data.length + num];
        System.arraycopy(this.data,0,newData,0,this.data.length) ;  //拷贝
        this.data = newData ;  //改变数组引用
    }
    public boolean add(int num){
        if(this.foot < this.data.length){     //有位置：数组还没用满，还有多余的空间
            this.data[this.foot++] = num;
            return true;
        }
        return false;
    }
    public int [] getData(){
        return this.data;
    }
}
class ReverseArray extends Array{
    public ReverseArray(int len){
        super(len);
    }
    public int[] getData(){
        int center = super.getData().length / 2;
        int head = 0;
        int tail = super.getData().length - 1;
        for(int x = 0; x<center; x++){
            int temp = super.getData()[head];
            super.getData()[head] = super.getData()[tail];
            super.getData()[tail] = temp;
            head++;
            tail--;
        }
        return super.getData();
    }
}
public class example {
    public static void main(String[] args) {
        ReverseArray arr = new ReverseArray(5);
      System.out.println(arr.add(10));
      System.out.println(arr.add(5));
      System.out.println(arr.add(20));
      System.out.println(arr.add(3));
      System.out.println(arr.add(6));
      arr.increment(3) ;
      System.out.println(arr.add(1));
      System.out.println(arr.add(7));
      System.out.println(arr.add(0));
      int result[] = arr.getData() ;
      for(int temp : result ){
          System.out.print(temp + "、");
      }
    }
      }