面向对象(中级)练习题

//案例一：定义一个Person类{name, age, job},初始化Person对象数组，有3个person对象，并
//按照age从大到小进行排序，提示，使用冒泡排序
package oop_work;
public class work01 {
    public static void main(String[] args) {
        person arr[] = new person[3];
        arr[0]=new person("小红",18,"唱歌");
        arr[1]=new person("小花",19,"唱歌");
        arr[2]=new person("小白",20,"唱歌");
        System.out.println("排序前：");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("排序后：");
    }
    public static person[] arr_paixu(person arr[]){
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j <arr.length-1-i ; j++) {
                if (arr[j].getAge()<arr[j+1].getAge()){
                    person person1=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=person1;
                }
            }
        }
        return arr;
    }
}
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 + '\'' +
                '}';
    }
}
//案例二 ：编写老师类
//要求有属性“姓名name",“年龄age" ,"职称post" ,“基本工资salary"
//1.编写业务方法，introduce () ,实现输出一个教师的信息。
//2.编写教师类的三个子类:教授类、副教授类、讲师类。工资级别分别为:教授为1.3、副授为1.2、 讲师类1.1。
//3.在三个子类里面都重写父类的introduce () 方法。
//定义并初始化一 个老师对象，调用业务方法，实现对象基本信息的后台打印.
package oop_work;
public class work03 {
    public static void main(String[] args) {
        professor p1=new professor("张老师",40,"教授",1.3);
        assprofessor p2=new assprofessor("王老师",41,"副教授",1.2);
        lecturer p3=new lecturer("肖老师",42,"讲师",1.1);
        p1.introduce();
        p2.introduce();
        p3.introduce();
    }
}
class teacher{
    private String name;
    private int age;
    private String post;//职称
    private double salary=3000;
    private double grade;
    public teacher(){
    }
    public teacher(String name, int age, String post,double grade) {
        this.name = name;
        this.age = age;
        this.post = post;
        this.grade=grade;
    }
    public double getGrade() { return grade; }
    public void setGrade(double grade) { this.grade = grade; }
    public void setName(String name) { this.name = name; }
    public void setAge(int age) { this.age = age; }
    public void setPost(String post) { this.post = post; }
    public void setSalary(double salary) { this.salary = salary; }
    public String getName() { return name; }
    public int getAge() { return age; }
    public String getPost() {return post; }
    public double getSalary() { return salary; }
    public void introduce(){
        System.out.println("name:"+name+" age:"+age+" post:"+post+" salary:"+salary
        +" grade="+grade);
    }
}
class professor extends teacher{
    public professor() { }
    public professor(String name, int age, String post, double grade) {
        super(name, age, post, grade);
    }
    @Override
    public void introduce() {
        System.out.print("教授： ");
        super.introduce();
    }
}
class assprofessor extends teacher{
    public assprofessor() { }
    public assprofessor(String name, int age, String post, double grade) { super(name, age, post, grade); }
    @Override
    public void introduce() {
        System.out.print("副教授： ");
        super.introduce();
    }
}
class lecturer extends teacher{
    public lecturer() { }
    public lecturer(String name, int age, String post, double grade) { super(name, age, post, grade); }
    @Override
    public void introduce() {
        System.out.print("讲师： ");
        super.introduce();
    }
}
//案例三：通过继承实现员工工资核算打印功能
//        父类:员工类
//        子类:部门经理类、普通员工类
//        (1)部门经理工资= 1000+单日工资*天数*等级(1.2) 。
//        (2)普通员工工资=单日工资*天数*等级(1.0) ;
//        (3)员工属性:姓名，单日工资，工作天数
//        (4)员工方法(打印工资)
//        (5)普遍员工及部门经理都是员工子类，需要重写打印工资方法。
//        (5)定义并初始化普通员工对象，调用打印工资方法输入工资，定义并初始化部门经理对象，
//        调用打印工资方法输入工资
package oop_work;

public class work04 {
    public static void main(String[] args) {
        personnel p1=new personnel("老王",120,30,1.0);
        manger p2 = new manger("小张",240,30,1.2,1000);
        p1.printwage();
        p2.printwage();
    }
}
class staff{
    private String name;
    private double onewage;
    private int days;
    private double grade;
    public staff(String name, double onewage, int days,double grade) {
        this.name = name;
        this.onewage = onewage;
        this.days = days;
        this.grade=grade;
    }
    public double getGrade() { return grade; }
    public void setGrade(double grade) { this.grade = grade; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public double getOnewage() { return onewage; }
    public void setOnewage(int onewage) { this.onewage = onewage; }
    public int getDays() { return days; }
    public void setDays(int days) { this.days = days; }
    public void printwage(){
        System.out.println(name+"工资是"+getOnewage()*getDays()*getGrade());
    }
}
class personnel extends staff{
    public personnel(String name, double onewage, int days, double grade) {
        super(name, onewage, days, grade);
    }
    @Override
    public void printwage() {
        System.out.println("员工"+getName()+"的工资是"+(getOnewage()*getDays()*getGrade()));
    }
}
class manger extends staff{
    private double bonus;
    public manger(String name, double onewage, int days, double grade, double bonus) {
        super(name, onewage, days, grade);
        this.bonus = bonus;
    }
    public double getBonus() { return bonus; }
    public void setBonus(double bonus) { this.bonus = bonus; }
    @Override
    public void printwage() {
        System.out.println("经理"+getName()+"的工资是"+(getOnewage()*getDays()*getGrade()+this.bonus));
    }
}
//案例四：设计父类一员工类。
// 子类:工人类,农民类,教师类,科学家类，服务生类。
//        (1)其中工人,农民服务生只有基本工资
//        (2)教师除基本工资外,还有课酬(元/天)
//        (3)科学家除基本工资外,还有年终奖
//        (4)编写一个测试类,将各种类型的员工的全年工资打印出来
package oop_work;

public class work05 {
    public static void main(String[] args) {
        worker p1=new worker("小王",5000,12);
        teachers p2=new teachers("张老师",3000,30,100,10);
        buttons p3=new buttons("小李",4500,12);
        scientist p4=new scientist("宋博士",7000,20000,40000,16);
        p1.printwage05();
        p2.printwage05();
        p3.printwage05();
        p4.printwage05();
    }
}
class staff05{
    private String name;
    private double salary;
    private int salarymon;
    public int getSalarymon() { return salarymon; }
    public void setSalarymon(int salarymon) { this.salarymon = salarymon; }
    public String getName() { return name; }
    public void setName(String name) {this.name = name; }
    public staff05(String name, double salary,int salarymon) {
        this.name = name;
        this.salary = salary;
        this.salarymon=salarymon;
    }
    public double getSalary() { return salary; }
    public void setSalary(double salary) { this.salary = salary; }
    public void  printwage05(){
        System.out.println(getName()+"年工资是"+getSalary()*getSalarymon());
    }
}
class buttons extends staff05{
    public buttons(String name, double salary,int salarymon) {
        super(name, salary,salarymon);
    }
    @Override
    public void printwage05() { super.printwage05(); }
}
class teachers extends staff05{
    private int days;
    private double wage;
    public teachers(String name, double salary, int salarymon, int days, double wage) {
        super(name, salary, salarymon);
        this.days = days;
        this.wage = wage;
    }
    public int getDays() { return days; }
    public void setDays(int days) { this.days = days; }
    public double getWage() { return wage; }
    public void setWage(double wage) { this.wage = wage; }
    @Override
    public void printwage05() {
        System.out.println("教师： "+"name:"+this.getName()+" salary:"+(getSalary()*getSalarymon()+getWage()*getDays()));
    }
}
class worker extends staff05{
    public worker(String name, double salary,int salarymon) {
        super(name, salary,salarymon);
    }
    @Override
    public void printwage05() { super.printwage05(); }
}
class scientist extends staff05{
    private int annualwage;
    private int month;
    public scientist(String name, double salary, int salarymon, int annualwage,int month) {
        super(name, salary, salarymon);
        this.annualwage = annualwage;
        this.month=month;
    }
    public int getMonth() { return month; }
    public void setMonth(int month) { this.month = month; }
    public int getAnnualwage() { return annualwage; }
    public void setAnnualwage(int annualwage) { this.annualwage = annualwage; }
    @Override
    public void printwage05() {
        System.out.println("科学家： "+"name:"+this.getName()+" salary:"+(this.getSalary()*month+this.annualwage));
    }
}
// 案例五：在父类和子类中通过this和super都可
//    以调用哪些属性和方法，假定Grand、
//    Father和Son在同一个包
public class work06 {
}
    class Grand {
        String name = "AA";
        private int age = 100;
        public void g1() { }
    }
class Father extends Grand{
    String id="001";
    private double score;
    public void f1(){}
}
//super可以访问哪些成员(属性和方法) ?g1,name
//this可以访问哪些成员?id,score,f1,name,g1
class Son extends Father{
    String name="BB";
    public void g1(){}
    private void show(){
//super可以访问哪些成员(属性和方法)?f1,id,name,g1
//this可以访问哪些成员?f1,id,name,g1,show
    }
}
// 案例六：写出程序结果:Test
                // Demo
                // Rose
                // Jack
                // john
                // Jack
public class work07 {

    public static void main(String[] args){
            new Demo().test();
            new Demo("john").test();
    }
}
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);
    }
}
//案例七：package oop_work;
//要求:
//        (1)在上面类的基础。上扩展新类CheckingAccount
//        对每次存款和取款都收取1美元的手续费
//        (2)扩展前一个练习的BankAccount类，
//        新类
//        SavingsAccount每个月都有利息产生
//        (earnMonthlyInterest方法被调用)，并且有每月三
//        次免手续费的存款或取款。在earnMonthlyInterest
//        方法中重置交易计数
public class work08 {
}
//8.扩展如下的BankAccount类
class BankAccount {
    private double balance;
    public double getBalance() { return balance; }
    public void setBalance(double balance) { this.balance = balance; }
    //存款
    public BankAccount(double initialBalance) { this.balance = initialBalance; }
//取款
    public void deposit(double amount) { balance += amount; }
    public void withdraw(double amount) { balance -= amount;}
}
class CheckingAccount extends BankAccount{
    public CheckingAccount(double initialBalance) {
        super(initialBalance);
    }
    @Override
    public void deposit(double amount) { super.deposit(amount-1); }
    @Override
    public void withdraw(double amount) { super.withdraw(amount+1); }
}
class SavingsAccount extends BankAccount{
    private int counts=3;
    private double rate=0.01;
    public SavingsAccount(double initialBalance) {
        super(initialBalance);
    }
    public int getCounts() { return counts; }
    public void setCounts(int counts) { this.counts = counts; }
    public void earnMonthlyInterest(){
        setCounts(3);
        deposit(getBalance()*rate);
    }
    @Override
    public void deposit(double amount) {
        if (getCounts()>0) {
            super.deposit(amount);
            setCounts(getCounts()-1);
        }else{
            super.deposit(amount-1);
        }
    }
    @Override
    public void withdraw(double amount) {
        if (getCounts()>0) {
            super.withdraw(amount);
            setCounts(getCounts()-1);
        }else{
            super.deposit(amount+1);
        }
    }
}
package oop_work;

public class work09 {
//    案例八：设计一个Point类，其x和y坐标可以通过构造器提供。提供一个子类LabeledPoint, 其
//    构造器接受一个标签值和x,y坐标比如:new LabeledPoint( "Black
//                                         Thursday" ,1929,230.07),写出对应的构造器即可
}
class LabelPoint{
    private String label;
    private double x;
    private double y;
    public LabelPoint(String label, double x, double y) {
        this.label = label;
        this.x = x;
        this.y = y;
    }
    public String getLabel() { return label; }
    public void setLabel(String label) { this.label = label; }
    public double getX() { return x; }
    public void setX(double x) { this.x = x; }
    public double getY() { return y; }
    public void setY(double y) { this.y = y; }
}
package oop_work;

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

    }
}
//案例九：编写Doctor类{name, age, job, gender, sal}
//        相应的getter()和setter(方法，5个参数的构造器，重写父类的equals()方法: public
//boolean equals(Object obj),并判断测试类中创建的两个对象是否相等。相等就是判断
//        属性是否相同
class Doctor{
    String name;
    String job;
    int age;
    char gender;
    int sal;
    public Doctor(String name, String job, int age, char gender, int sal) {
        this.name = name;
        this.job = job;
        this.age = age;
        this.gender = gender;
        this.sal = sal;
    }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getJob() { return job; }
    public void setJob(String job) { this.job = job; }
    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 int getSal() { return sal; }
    public void setSal(int sal) { this.sal = sal; }
    @Override
    public boolean equals(Object o) {
        //判断两个比较对象是否相同
        if (this == o) {
            return true;
        }
//判断obj 是否是Doctor类型或其 子类
//过关斩将校验方式
        if (!(o instanceof Doctor)) { //不是的话
            return false;
        }
//向下转型，因为obj的运行类型是Doctor或者其子类型
        Doctor doctor = (Doctor)o;
        return getAge() == doctor.getAge() && getGender() == doctor.getGender() && getSal() == doctor.getSal() && getName().equals(doctor.getName()) && getJob().equals(doctor.getJob());
    }
}
package oop_work;

public class work11 {
    public static void main(String[] args) {
        Person p1=new Student();//向上转型,可以调用eat，run(student)方法
        p1.eat();
        Student p2=(Student)p1;//向下转型,可以调用run(study)和study方法
    }
}
//案例十.现有Person类，里面有方法run、eat, Student类继承了Person类，并重写了run方
//        法，自定义了study方法,试写出对象向上转型和向下转型的代码，并写出各自都可以调用
//        哪些方法，并写出方法输出什么?
//        I
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.println("student study."); }
}
//案例十一
package oop_work;

public class work13 {
    public static void main(String[] args) {
        // (7)定义多态数组，里面保存2个学生和2个教师，要求按年龄从高到低排序，
        person13 p[]=new person13[4];
        p[0]=new student13("小明",'男',18,"0023102");
        p[1]=new student13("小李",'男',18,"0023112");
        p[2]=new teacher13("王飞",'男',32,5);
        p[3]=new teacher13("张强",'男',28,1);
        person13 p2;
        for (int i = 0; i < p.length; i++) {
            for (int j = 0; j <p.length-i-1 ; j++) {
                if (p[j].age<p[j+1].age){
                    p2=p[j];
                    p[j]=p[j+1];
                    p[j+1]=p2;
                }
            }
        }
        // (8)定义方法，形参为Person类型，功能:调用学生的study或教师的teach方法
        for (int i = 0; i < p.length; i++) {
            if(p[i] instanceof teacher13){
                teacher13 p1=(teacher13)p[i];
                System.out.println("老师的信息：\n姓名:"+p1.name+"\n年龄:"+p1.age+"\n" +
                        "性别:"+p1.gender+"\n工龄:"+p1.work_age);
                p1.teach();
                System.out.println(p1.play());
            }else{
                student13 p3=(student13)p[i];
                System.out.println("老师的信息：\n姓名:"+p3.name+"\n年龄:"+p3.age+"\n" +
                        "性别:"+p3.gender+"\n学号:"+p3.stu_id);
                p3.study();
                System.out.println(p3.play());
            }
            System.out.println("---------------------");
        }

    }
}
//        (3)抽取一个父类Person类,将共同属性和方法放到Person类
class person13{
    String name;
    char gender;
    int age;
    public person13(String name, char gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }
    //        (6)学生和教师都有玩的方法(play) ,学会玩的是足球，老师玩的是象
//        棋，此方法是返回宇符串的，分别返回"xx爱玩足球”和"xx爱玩象棋"
//        (其中xx分别代表学生和老师的姓名)。因为玩的方法名称都一样，所以
//        要求此方法定义在父类中，子类实现重写。
    public String  play(){
        return "爱玩";
    }
}
//案例题目描述:
//        (1)做一个Student类, Student类有名称(name)，性别(sex),年龄
//        (age) , 学号(stu id)，做合理封装，通过构造器在创建对象时将4个属性赋值。
class student13 extends person13{
    String stu_id;
    public student13(String name, char gender, int age, String stu_id) {
        super(name, gender, age);
        this.stu_id = stu_id;
    }
    // (4)学生需要有学习的方法(study) ,在方法里写生“我承诺，我会好好学习。
    public void study(){
        System.out.println("我承诺，我会好好学习。");
    }

    @Override
    public String play() {
        return this.name+super.play()+"足球";
    }
}
//        (2)写一个Teacher类，Teacher类有名称 (name)，性别(sex) ,
//        年龄(age) ，工龄(work age),做合理封装，通过构造器在创建对象时将
//        4个属性赋值。
class teacher13 extends person13{
    double work_age;
    public teacher13(String name, char gender, int age, double work_age) {
        super(name, gender, age);
        this.work_age=work_age;
    }
    //        (5)教师需要有教学的方法(teach) ,在方法里写上“我承诺，我会认真教学。
    public void teach(){
        System.out.println("我承诺，我会认真教学。");
    }

    @Override
    public String play() {
        return this.name+super.play()+"象棋";
    }
}

12.写出四种访问修饰符和各自的访问权限`

13.说出==和equals的区别：

14.什么是多态，多态具体体现有哪些?

15.java的动态绑定机制是什么?