第八章作业

案列01；

1.定义一个Person类{name,age,job},初始化Person对象数组,有3个person对象;
* 并按照age从大到小进行排序，提示，使用冒泡排序Homework01.java

package com.homeWork;

/**
 * 1.定义一个Person类{name,age,job},初始化Person对象数组,有3个person对象;
 * 并按照age从大到小进行排序，提示，使用冒泡排序Homework01.java
 */
public class homework01 {
    public static void main(String[] args) {
        //定义一个对象数组，里面有三个person对象
        Person[] people = new Person[3];
        people[0] = new Person("smith", 36, "java开发工程师");
        people[1] = new Person("tom", 20, "PHP开发工程师");
        people[2] = new Person("june", 56, "算法工程师");
        //输出当前的对象数组

        for (int i = 0; i < people.length; i++) {
            System.out.println(people[i]);
        }

        Person temp = null;
        for (int i = 0; i < people.length - 1; i++) {
            for (int j = 0; j < people.length - 1 - i; j++) {

                //使用冒泡排序，名字长度从大到小进行排序，也就是前面的名字长度<后面的名字长度，就交换
                //if (people[j].getName().length() < people[j + 1].getName().length())
                //使用冒泡排序，age从大到小进行排序，也就是前面的年龄<后面的年龄，就交换
               if (people[j].getAge() < people[j + 1].getAge()) {
                    temp = people[j];
                    people[j] = people[j + 1];
                    people[j + 1] = temp;
                }
            }
        }
        System.out.println("排序后的效果如下：");
        for (int i = 0; i < people.length; i++) {
            System.out.println(people[i]);
        }


    }
}


class Person {
    private String name;
    private int age;
    private String job;

    public Person(String name, int age, String job) {
        this.name = name;
        this.age = age;
        this.job = job;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", job='" + job + '\'' +
                '}';
    }
}

 

 案列5.设计父类一员工类。子类：工人类（Worker),农民类(Peasant),教师类（Teacher),科学家类(Scientist),服务生类（Waiter)。
（1）其中工人，农民，服务生只有基本工资sal
（2）教师除基本工资外，还有课酬（元/天）classDay,classSal
（3）科学家除基本工资外，还有年终奖bonus
（4）编写一个测试类，将各种类型的员工的全年工资打印出来

测试：

package com.homeWork.homeWork05;

public class homework05 {
    public static void main(String[] args) {
        //工人
        worker worker = new worker("tom", 6900, 15);
        System.out.println("工人年工资如下：");
        worker.printSalary();
        System.out.println("===================================");
        //老师
        Teacher smith = new Teacher("smith", 7600, 14);
        //对日工资和工作天数进行动态设置
        smith.setDays(26);
        smith.setClassSalary(360);
        System.out.println("老师年工资如下");
        smith.printSalary();
        System.out.println("==================================");
        //科学家
        Scientist jack = new Scientist("jack", 45000, 16, 330000);
        System.out.println("科学家年工资如下：");
        jack.printSalary();

    }
}

父类：

package com.homeWork.homeWork05;

/**
 * 案列5.设计父类一员工类。子类：工人类（Worker),农民类(Peasant),教师类（Teacher),科学家类(Scientist),服务生类（Waiter)。
 * （1）其中工人，农民，服务生只有基本工资sal
 * （2）教师除基本工资外，还有课酬（元/天）classDay,classSal
 * （3）科学家除基本工资外，还有年终奖bonus
 * （4）编写一个测试类，将各种类型的员工的全年工资打印出来
 */
public class Employ {

    //定义属性类型
    private String name;
    private double sal;
    private int month;

    //方法（构造器、getter、setter）
    //构造器

    public Employ(String name, double sal, int month) {
        this.name = name;
        this.sal = sal;
        this.month = month;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }
    //方法
    public void printSalary(){
        System.out.println("年工资="+sal*month);
    }
}

子类：

package com.homeWork.homeWork05;

public class Teacher extends Employ {
    //特有属性
    private double classSalary;//课时费
    private int days;//上课天数
    //方法

    public Teacher(String name, double sal, int month) {
        //这里的日工资、工作天数不做统一设置，可以通过set进行动态设置
        super(name, sal, month);
    }

    public double getClassSalary() {
        return classSalary;
    }

    public void setClassSalary(double classSalary) {
        this.classSalary = classSalary;
    }

    public int getDays() {
        return days;
    }

    public void setDays(int days) {
        this.days = days;
    }

    @Override
    public void printSalary() {
        System.out.println("年工资="+(getSal()*getMonth()+classSalary*days));
    }
}

 

 

案列4.通过继承实现员工工资核算打印功能
父类：员工类
子类：部门经理类、普通员工类
（1）部门经理工资=1000+单日工资*天数*等级（1.2）。
（2）普通员工工资=单日工资*天数*等级（1.0）；
（3）员工属性：姓名，单日工资，工作天数
（4）员工方法（打印工资）
（5）普遍员工及部门经理都是员工子类，需要重写打印工资方法。
（5）定义并初始化普通员工对象，调用打印工资方法输入工资，定义并初始化部门经理对象，调用打印工资方法输入工资

案列3.编写老师类 Homework03.java
(1)要求有属性“姓名name"，“年龄age”，“职称post”，"基本工资salary”
（2）编写业务方法，introduce（），实现输出一个教师的信息。
（3）编写教师类的三个子类：教授类（Professor）、副教授类、讲师类。工资级别分别为：教授为1.3、副教授为1.2、讲师类1.1。
在三个子类里面都重写父类的introduce（）方法。
（4）定义并初始化一个老师对象，调用业务方法，实现对象基本信息的后台打印.

package com.homeWork;

public class homework03 {
    public static void main(String[] args) {
        Teacher teacher = new Teacher("tom",36,"教师",6500);
        System.out.println(teacher.introduce());
    }
}
/*
3.编写老师类 Homework03.java
(1)要求有属性“姓名name"，“年龄age”，“职称post”，"基本工资salary”
（2）编写业务方法，introduce（），实现输出一个教师的信息。
（3）编写教师类的三个子类：教授类（Professor）、副教授类、讲师类。工资级别分别为：教授为1.3、副教授为1.2、讲师类1.1。
在三个子类里面都重写父类的introduce（）方法。
（4）定义并初始化一个老师对象，调用业务方法，实现对象基本信息的后台打印.

 */
//创建教师类
class Teacher{
    private  String name;
    private int age;
    private String post;
    private double salary;
    //创建构造器
    public Teacher(String name, int age, String post, double salary) {
        this.name = name;
        this.age = age;
        this.post = post;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    public String getPost() {
        return post;
    }
    public void setPost(String post) {
        this.post = post;
    }

    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
   // 2）编写业务方法，introduce（），实现输出一个教师的信息。
    public String introduce(){
        return "姓名="+name+"\n"+"年龄="+age+"\n"+"职称="+post+"\n"+"月工资="+salary;
    }
}

//（3）编写教师类的三个子类：教授类（Professor）、副教授类、讲师类。
// 工资级别分别为：教授为1.3、副教授为1.2、讲师类1.1。
//在三个子类里面都重写父类的introduce（）方法。

class Professor extends Teacher{
    private String salaryLevel;

    public Professor(String name, int age, String post, double salary, String salaryLevel) {
        super(name, age, post, salary);
        this.salaryLevel = salaryLevel;
    }

    public String getSalaryLevel() {
        return salaryLevel;
    }
    public void setSalaryLevel(String salaryLevel) {
        this.salaryLevel = salaryLevel;
    }

//    public double Level(){
////        if ("教授".equals(getPost())){
////        return 1.3*getSalary();
////        }else if ("副教授".equals(getPost())){
////            return 1.2*getSalary();
////        }else if ("讲师".equals(getPost())){
////            return 1.1*getSalary();
////        }else{}
//    }
    @Override
    public String introduce() {
        return super.introduce();
    }
}

 案列06；

package com.homeWork.homeWork05;

/**
 * 6.假定Grand、Father和Son在同一
 * 个包，问：父类和子类中通过this和
 * super都可以调用哪些属性和方法
 */

public class homework06 {
    public static void main(String[] args) {

    }
}
class Grand{//超类
    String name="AA";
    private int age=100;
    public void g10(){

    }
}

class Father extends Grand {//父类
    String id = "001";
    private double score;
    public void f1(){};

}
//super可以访问哪些成员（属性和方法）？
//super 是用来访问父类的，但是不可以访问父类私有属性
// 公共的都可以访问（super.name、super.g10()、）
//this可以访问哪些成员？
//this是查找本类的属性，所有都可以访问


    class Son extends Father{//子类
            String name="BB";
            public void g1(){}
            private void show(){
            }
        }
//super可以访问哪些成员（属性和方法）？
                //super.id;super.f1(0;super.name;super.g1
//this可以访问哪些成员？
            //this可以访问本类中所有元素

案列07；请写出程序的最终结果

package com.homeWork.homework07;
//7.写出程序结果
public class homework07 {
}

class Test {//父类
    String name = "Rose";

    Test() {
        System.out.println("Test");
    }

    Test(String name) {
        this.name = name;
    }
}

class Demo extends Test{//子类
    String name="Jack";
    Demo() {
        super();
        System.out.println("Demo");
    }
        Demo(String s){
                super(s);
    }
        public void test() {
            System.out.println(super.name);
            System.out.println(this.name);
        }
            public static void main(String[] args) {
                
                    new Demo().test();//匿名对象
                    new Demo("john").test();//匿名
                }
        //请输出最终的结果

}

 

案列9.设计一个Point类，其x和y坐标可以通过构造器提供。提供一个子类LabeledPoint,其
构造器接受一个标签值和x,y坐标,比如：new LabeledPoint(“Black
Thursday",1929,230.07),写出对应的构造器即可Homework09.java

 

 

 

 

案列10.编写Doctor类{name,age,job,gender,sal}
相应的getter()和setter()方法，5个参数的构造器，重写父类的equals()方法：public
boolean equals(Object obj)，并判断测试类中创建的两个对象是否相等。相等就是判断
属性是否相同

package com.unit01;

/**
 * 10.编写Doctor类{name,age,job,gender,sal}
 *   相应的getter()和setter()方法，5个参数的构造器，
 *   重写父类的equals()方法：public
 *   boolean equals(Object obj)，并判断测试类中创建的两个对象是否相等。
 *   相等就是判断属性是否相同
 */
public class doctor {
    //属性
    private  String name;
    private int age;
    private  char gender;
    private  double sal;
    //构造器
    public doctor(String name, int age, char gender, double sal) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.sal = sal;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public double getSal() {
        return sal;
    }
    public void setSal(double sal) {
        this.sal = sal;
    }
    //重写父类equals的方法
    public boolean equals(Object obj){
        //判断两个对象是否相同
        if (this==obj){
        return  true;
        }
        //判断obj是否是doctor类型或者子类型
        //过关斩六将
        if (!(obj instanceof doctor)){//不是的情况
            return false;
        }
        //obj是doctor类型或者子类型:向下转型
        doctor doctor= (doctor) obj;
        return this.name.equals(doctor.name)&& this.age==doctor.age && this.gender==doctor.gender&& this.sal==doctor.sal;
    }
}

package com.unit01;

public class homework10 {
    public static void main(String[] args) {
        doctor doctor1 = new doctor("simth", 26, '男',26500);
        doctor doctor2 = new doctor("simth", 26, '男',26500);
        System.out.println(doctor1.equals(doctor2));//true;由于已经重写了父类，所以判断的是后的属性是否相同
    }
}

 

案列11；

11.现有Person类，里面有方法run、eat，Student类继承了Person类，并重写了run方
法，自定义了study方法，试写出对象向上转型和向下转型的代码，并写出各自都可以调用
哪些方法，并写出方法输出什么？
class Person{/∥父类
public void run() {System.out.println("person run"); }
public void eat() {System.out.println("person eat"); }

class Student extends Person {//子类
public void run() {System.out.println("student run");}
public void study() {System.out.printIn("student study."); }
}

//向上转型：父类的引用指向子类的对象

Person p= new stustent();

p能调用的是它的编译类型Preson类中的run方法和eat方法

p.run()//最终的运行效果要看它 的运行类型：p的运行类型是stustent（）方法：所以输出student run

p.eat()//先去子类student类中查找，没有再去父类中查找：所以输出"person eat"

//向下转型：向下转型：把指向子类对象的父类引用，转成指向子类对象的子类引用

Student s =（Student）p

s能调用的是它的编译类型Student类中的run方法和study方法和父类中的eat（）

s.run() 运行结果是student run

s.study()运行结果是student study

s.eat()运行结果是person eat

 

案例13题目描述：

(1)做一个Student类,Student类有名称(name)，性别(sex),年龄　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
（age），学号（stu id），做合理封装，通过构造器在创建对象时将4个
属性赋值。
(2）写一个Teacher类Teacher类有名称（name)，性别（sex），年龄
（age），工龄（work_age)，做合理封装，通过构造器在创建对象时将4个
属性赋值。
（3）抽取一个父类Person类，将共同属性和方法放到Person类
（4）学生需要有学习的方法（study），在方法里写生“我承诺，我会好好
学习。”。
（5）教师需要有教学的方法（teach），在方法里写上“我承诺，我会认真
教学。”。
（6）学生和教师都有玩的方法（play），学生玩的是足球，老师玩的是象棋，
此方法是返回字符串的，分别返回“xx爱玩足球”和“xx爱玩象棋”（其
中xx分别代表学生和老师的姓名）。因为玩的方法名称都一样，所以要求
此方法定义在父类中，子类实现重写。
（7）定义多态数组，里面保存2个学生和2个教师，要求按年龄从高到低排序，
（8）定义方法，形参为Person类型，功能：调用学生的study或教师的teach方法

案列13.打印效果如下
老师的信息：
姓名：张飞
年龄：30
性别：男
工龄：5
我承诺，我会认真教课。
张飞爰玩象棋
学生的信息：
姓名：小明
年龄：15
性别：男
学号：00023102
我承诺，我会好好学习。
小明爱玩足球。
Homework13.java

package com.homework13;
/**
 * (1)做一个Student类,Student类有名称(name)，性别(sex),年龄
 * （age），学号（stu id），做合理封装，通过构造器在创建对象时将4个
 * 属性赋值。
 * (2）写一个Teacher类Teacher类有名称（name)，性别（sex），年龄
 * （age），工龄（work_age)，做合理封装，通过构造器在创建对象时将4个
 * 属性赋值。
 * （3）抽取一个父类Person类，将共同属性和方法放到Person类
 * （4）学生需要有学习的方法（study），在方法里写生“我承诺，我会好好
 * 学习。”。
 * （5）教师需要有教学的方法（teach），在方法里写上“我承诺，我会认真
 * 教学。”。
 * （6）学生和教师都有玩的方法（play），学生玩的是足球，老师玩的是象棋，
 * 此方法是返回字符串的，分别返回“xx爱玩足球”和“xx爱玩象棋”（其
 * 中xx分别代表学生和老师的姓名）。因为玩的方法名称都一样，所以要求
 * 此方法定义在父类中，子类实现重写。
 * （7）定义多态数组，里面保存2个学生和2个教师，要求按年龄从高到低排序，
 * （8）定义方法，形参为Person类型，功能：调用学生的study或教师的
 */
//整体测试
public class homework13 {
    public static void main(String[] args) {
        //测试学生类
        Student student = new Student("李明", '男', 25, 2016);
        student.printInfo();//调用学生里面的打印输出方法

        System.out.println("=========================================");
        Teacher teacher = new Teacher("张飞", '男', 24, 2);
        teacher.printInfo();


        //（7）定义多态数组，里面保存2个学生和2个教师
        Person[ ] persons = new Person[4];
        persons[0] = new Student("jack",'男',25,2015);
        persons[1] = new Student("marry",'女',22,2016);
        persons[2] = new Teacher("smith",'女',32,5);
        persons[3] = new Teacher("linda",'男',28,5);

            //创建对象
        homework13 homework13 = new homework13();
        homework13.bubbleSort(persons);
        System.out.println("=======================================");
        //创建排序后的数组
        System.out.println("排序后的数组情况");
        for (int i = 0; i <persons.length ; i++) {
            System.out.println(persons[i]);
        }
        //遍历数组，调用test方法（）
        System.out.println("=================================");
        for (int i = 0; i < persons.length ; i++) {
            homework13.test(persons[i]);
        }
    }

    //（8）定义方法，形参为Person类型，功能：调用学生的study或教师的teach
    //分析：这里需要使用到向下转型和类型判断
    public void test(Person p){
        if (p instanceof Student){//如果p的运行类型属于学生类型
            ((Student) p).study();//向下转型
        }else if (p instanceof  Teacher){  //如果p的运行类型属于老师类型
            ((Teacher) p).teach();
        }else {
            System.out.println("do nothing");
        }
    }

    //要求按年龄从高到低排序
    public void  bubbleSort(Person[ ] persons){
        Person temp = null;
        for (int i = 0; i <persons.length-1 ; i++) {
            for (int j = 0; j <persons.length-1-i ; j++) {
                //判断年龄从高到低排序
                if (persons[j].getAge()<persons[j+1].getAge()){
                    temp = persons[j];
                    persons[j]=persons[j+1];
                    persons[j+1]= temp;
                }
            }
        }
    }

}

教师类：

package com.homework13;

/*
(2）写一个Teacher类Teacher类有名称（name)，性别（sex），年龄
（age），工龄（work_age)，做合理封装，通过构造器在创建对象时将4个
属性赋值。
3）抽取一个父类Person类，将共同属性和方法放到Person类
（5）教师需要有教学的方法（teach），在方法里写上“我承诺，我会认真教学。
 */
public class Teacher extends Person {//教师类
    //属性
    private int work_age;

    //构造器
    public Teacher(String name, char sex, int age, int work_age) {
        super(name, sex, age);
        this.work_age = work_age;
    }

        //getter和setter方法
        public int getWork_age() {
            return work_age;
        }

        public void setWork_age(int work_age) {
            this.work_age = work_age;
        }

        //特有方法
        public void teach() {
            System.out.println(getName()+"承诺，会搞好教学");
        }
        //重写父类的play方法

        @Override
        public String play() {
            return super.play()+"踢足球";
        }
        //输出打印信息，体现封装
            public void printInfo(){
                System.out.println("信息如下：");
                System.out.println(super.basicInfo());
                System.out.println("工龄："+work_age);
                teach();
                System.out.println(play());
            }

    @Override
    public String toString() {
        return "Teacher{" +
                "work_age=" + work_age +
                '}'+super.toString();
    }
}

学生类：

package com.homework13;

/*
案例题目描述：
(1)做一个Student类,Student类有名称(name)，性别(sex),年龄
（age），学号（stu id），做合理封装，通过构造器在创建对象时将4个
属性赋值。
3）抽取一个父类Person类，将共同属性和方法放到Person类
（4）学生需要有学习的方法（study），在方法里写生“我承诺，我会好好
 * 学习。”。
 */
public class Student extends Person {  //学生类
    //属性
    private int stu_id;
    //构造器
    public Student(String name, char sex, int age, int stu_id) {
        super(name,sex,age);
        this.stu_id = stu_id;
    }
        //方法
            public int getStu_id() {
                return stu_id;
            }
            public void setStu_id(int stu_id) {
                this.stu_id = stu_id;
            }
            //学生特有的学习方法
        public void study(){
            System.out.println(getName()+"承诺，会好好学习");
        }
        //重写父类的play（）方法
        @Override
        public String play() {
            return super.play()+"打篮球";
        }
        //输出一个打印信息，体现封装
        public void printInfo(){
            System.out.println("学生信息如下：");
            System.out.println(super.basicInfo());//去调用父类的基本信息
            System.out.println("学号:"+stu_id);
            study();
            System.out.println(play());
        }

    @Override
    public String toString() {
        return "Student{" +
                "stu_id=" + stu_id +
                '}'+super.toString();
    }
}

父类：

package com.homework13;
public class Person {//父类
    private String name;
    private char sex;
    private int age;

    public Person(String name, char sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

            public String getName() {
                return name;
            }
            public void setName(String name) {
                this.name = name;
            }

            public char getSex() {
                return sex;
            }
            public void setSex(char sex) {
                this.sex = sex;
            }

            public int getAge() {
                return age;
            }
            public void setAge(int age) {
                this.age = age;
            }
            //方法玩play()，把相同的内容输出
            public  String play(){
                return name+"兴趣爱好是";
            }
            //定义一个基本信息
            public String basicInfo(){
                return "姓名:"+name+"\n年龄:"+age+"\n性别:"+sex;
            }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", age=" + age +
                '}';
    }
}

 案列14：

案列分析情况：

1.C c = new C()    首先进入的是C类的无参方法。this.("hello"),而this指的是本类中的带参数的方法；所以指向super.("hahah")

2.而super.("hahah")指向的是父类的带参方法B(string name),这里面有个默认的super(),这时候的super(),指的是父类的无参方法A（）

输出结果：
我是A类，
hahah我是B类的有参构造
我是c类的有参参构造
我是c类的无参构造

 

 

案列15.什么是多态，多态具体体现有哪些？（可举例说明）Homework15.java
多态：方法或对象具有多种形态，是OOP的第三大特征，是建立在封装和继承基础之上
多态具体体现
1.方法多态
（1）重载体现多态（2）重写体现多态
2.对象多态
（1）对象的编译类型和运行类型可以不一致，编译类型在定义时，就确定，不能变化
（2）对象的运行类型是可以变化的，可以通过getClasss(）来查看运行类型
（3）编译类型看定时时=号的左边，运行类型看=号右边
3.举例说明