Java第五次作业

---

一、学习总结

1.在上周完成的思维导图基础上，补充本周的学习内容，对Java面向对象编程的知识点做一个全面的总结。

• 思维导图:点击图片拖动查看大图
  

2.汽车租赁公司，出租汽车种类有客车、货车和皮卡三种，每辆汽车除了具有编号、名称、租金三个基本属性之外，客车有载客量，货车有载货量，皮卡则同时具有载客量和载货量。用面向对象编程思想分析上述问题，将其表示成合适的类、抽象类或接口，说明设计思路并画出类图。

• 程序设计思路：
  • 创建出租汽车抽象类，有编号、名称、租金的相应get抽象方法。
  • 创建两个接口分别有载客量、载货量的get抽象方法。
  • 创建客车类、货车类、皮卡类声明相应私有成员，继承汽车抽象类，覆写抽象类里继承的抽象方法。客车类、货车类分别实现两个接口，并覆写两个抽象方法。
  • 再创建一个租赁公司类做相关操作。

• 类图：
  

3.阅读下面程序，分析代码是否能编译通过，如果不能，说明原因，并进行改正。如果能，列出运行结果

    interface Animal{    
        void breathe();
        void run();
        void eat();
    }
    class Dog implements Animal{
        public void breathe(){
            System.out.println("I'm breathing");
        }
        void eat(){
            System.out.println("I'm eating");
        }
    }
    public class Test{
        public static void main(String[] args){
            Dog dog = new Dog();
            dog.breathe();
            dog.eat();
        }
    }

• 不能通过编译
• 原因：
  • 第一、因为Dog类实现Animal接口必须实现接口内的所有方法。而Dog类没有run()方法。
  • 第二、在实现接口的方法时可视性不能比接口的低。接口中的方法默认为public abstract型；在类实现接口的方法时，若类中不写public，则只能被同一个包内的其他类引用。因此降低了继承方法的可视性，不能编译通过。

• 修改后：

interface Animal{    
    void breathe();
    void run();
    void eat();
}
class Dog implements Animal{
    public void breathe(){
        System.out.println("I'm breathing");
    }
    public void eat(){
        System.out.println("I'm eating");
    }
    public void run() {
        System.out.println("I'm runing");
    }
}
public class Test{
    public static void main(String[] args){
        Dog dog = new Dog();
        dog.breathe();
        dog.eat();
    }
}

• 运行结果：
  I'm breathing
  I'm eating

4.运行下面的程序

    import java.util.Arrays;
    public class Test{
        public static void main(String[] args){
            String[] fruits = {"peach","banana","orange","apple"};
            Arrays.sort(fruits);
            for(int i = 0;i < fruits.length;i++)
            {
                System.out.println(fruits[i]);
            }
        }
    }

程序输出的结果是升序排序的。查看String 类的源码，说明是如何实现的？如果现在希望对输出的结果进行降序排序，该如何处理？修改上述代码，实现按照字母顺序逆序排序。

• 运行结果：
  apple
  banana
  orange
  peach

• 查看String类部分源码：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

    /**
     * A Comparator that orders {@code String} objects as by
     * {@code compareToIgnoreCase}. This comparator is serializable.
     * <p>
     * Note that this Comparator does <em>not</em> take locale into account,
     * and will result in an unsatisfactory ordering for certain locales.
     * The java.text package provides <em>Collators</em> to allow
     * locale-sensitive ordering.
     *
     * @see     java.text.Collator#compare(String, String)
     * @since   1.2
     */
    public static final Comparator<String> CASE_INSENSITIVE_ORDER
                                         = new CaseInsensitiveComparator();
    private static class CaseInsensitiveComparator
            implements Comparator<String>, java.io.Serializable {
        // use serialVersionUID from JDK 1.2.2 for interoperability
        private static final long serialVersionUID = 8575799808933029326L;

        public int compare(String s1, String s2) {
            int n1 = s1.length();
            int n2 = s2.length();
            int min = Math.min(n1, n2);
            for (int i = 0; i < min; i++) {
                char c1 = s1.charAt(i);
                char c2 = s2.charAt(i);
                if (c1 != c2) {
                    c1 = Character.toUpperCase(c1);
                    c2 = Character.toUpperCase(c2);
                    if (c1 != c2) {
                        c1 = Character.toLowerCase(c1);
                        c2 = Character.toLowerCase(c2);
                        if (c1 != c2) {
                            // No overflow because of numeric promotion
                            return c1 - c2;
                        }
                    }
                }
            }
            return n1 - n2;
        }

        /** Replaces the de-serialized object. */

• 明显的能看到String类实现了Comparable接口和Comparator接口。
• 重写String实现的Comparator接口中的Compare方法，逆序排序：

package test;
import java.util.Arrays;
import java.util.Comparator;
public class Test{
    public static void main(String[] args){
        String[] fruits = {"peach","banana","orange","apple"};
        Arrays.sort(fruits,new StringComparator());
        for(int i = 0;i < fruits.length;i++)
        {
            System.out.println(fruits[i]);
        }
    }
}
class StringComparator implements Comparator<String>{
     public int compare(String s1, String s2) {
         int n1 = s1.length();
         int n2 = s2.length();
         int min = Math.min(n1, n2);
         for (int i = 0; i < min; i++) {
             char c1 = s1.charAt(i);
             char c2 = s2.charAt(i);
             if (c1 != c2) {
                 c1 = Character.toUpperCase(c1);
                 c2 = Character.toUpperCase(c2);
                 if (c1 != c2) {
                     c1 = Character.toLowerCase(c1);
                     c2 = Character.toLowerCase(c2);
                     if (c1 != c2) {
                         // No overflow because of numeric promotion
                         return c2 - c1;
                     }
                 }
             }
         }
         return n1 - n2;
     }

}

• 修改后运行结果：
  peach
  orange
  banana
  apple

5.其他需要总结

• 接口中不能实例化，不能定义构造方法，只能定义抽象方法和全局常量。
• 接口中的属性默认是常量public static final

二、实验总结：

1.某工厂生产各种音乐盒，客户无需知道音乐盒的制作过程，只需知道如何播放音乐盒即可。用简单工厂设计模式实现该过程：接口MusicBox具有方法play()，两个音乐盒类PianoBox,ViolinBox，MusicBoxFactory 产生MusicBox的实例。

• 程序设计思路：
  • 创建音乐盒接口，接口里面有播放音乐盒抽象方法。
  • Piano类、Violin类分别实现接口抽象方法。
  • 创建一个音乐盒工厂，里面含有得到音乐盒名字的方法，此方法里判断调用相应音乐盒构造方法。
  • 在测试类里，让用户输入要播放的音乐盒名，调用播放方法。

2.修改第三次作业的第一题，使用java.util.Date类表示职工的生日和参加工作时间，并将职工信息按照生日大小排序后输出。（分别用comparable和comparator实现）

(1)Comparator方法排序

• 程序设计思路：
  • 在实验三的前提下，删除自己写的Date类，换成String类与Date类的互相转换来实现。
  • 创建EmployeeComparator类用员工类实现Comparator接口，里面写入相应比较方法。
  • 在测试类里面在主方法名后面写入抛出异常的列表，并且添入排序方法并输出。

• 问题1：在进行字符串转化为Date类时，发现提示了有错误。
• 原因：因为没有在提供的字符串格式有错误时，进行异常处理。
• 解决方案：点提示的内容，在方法名后面写入抛出异常的parse这个列表，throws ParseException语句。

(2)Comparable方法排序

• 程序设计思路：在以上的程序前提下修改。将EmployeeComparator类删去,将按出生年月排序的方法compareTo(Employee o)写入Employee类中（在写进之前先将Employee类用实现Comparable接口）。

3.在案例宠物商店的基础上，实现以下功能：

（1）展示所有宠物

（2）购买宠物

（3）显示购买清单

• 程序设计思路：
  • 创建宠物接口，里面有得到宠物相关信息的各种抽象方法。
  • 分别创建狗类、猫类实现宠物类接口，里面声明私有属性，并且有相应get、set方法，实现了宠物接口抽象方法的覆写。(注：猫类里面没有大小型这个成员，在getType()抽象方法覆写里，面直接返回”null”字符串以便之后判断是猫类还是狗类。)
  • 创建宠物商店，里面含有相关私有成员，并且有得到长度并定义宠物个数构造方法、得到宠物店所有宠物方法、放入所有类型宠物信息方法、展示一个猫类或狗类的信息的两个方法、展示一个宠物最终结果的方法。
  • 创建测试类，有展示所有宠物的方法、购买宠物的方法、主方法。主方法中，将宠物放入宠物商店，并调用显示宠物信息和购买方法。

• 问题1：多次出现空指针错误。
• 原因：双循环内将下标不小心写入错误。
• 解决方案：看是执行到哪出现的错误，然后逐字查看发现修改。

三、代码托管（务必链接到你的项目）

• 码云commit历史截图
  上传实验项目代码到码云，在码云项目中选择“统计-commits”，设置搜索时间段，搜索本周提交历史，并截图。

• 代码托管
• 截图
  

---

转载于:https://www.cnblogs.com/nuanxinwuyu/p/6754841.html