java学习--练习题

/*建立一个person类有属性名字电话工作，把他们名字用冒泡将他们从大到小排序*/
package com.project.tesst02;

public class Test {
    public static void main(String[] args) {
        Person person[]=new Person[3];
        person[0]=new Person("小米",20,"工程师");
        person[1]=new Person("小王",30,"老师");
        person[2]=new Person("小李",19,"学生");
        //冒泡排序
        Person person1=null;
        int i=0,j=0;

        for( i=0;i<person.length-1;i++)
        {
            for( j=0;j<person.length-1;j++)
            {
                if (person[i].getAge()<=person[i+1].getAge()&&i+1!=3)
                {
                    person1=person[i];
                    person[i]=person[i+1];
                    person[i+1]=person1;


                }

            }

        }
        int v=0;
        for( v=0;v<person.length;v++)
        {
            System.out.println(person[v]);//会默认调用toString方法，
//所以我们需要重写一下toString方法，不然打印出来的是包名和类名＋hashcode
        }


    }


}


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

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

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        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;
    }

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

package com.project.test03;
/*(1)要求有属性“姓名name",“年龄age",“职称post",“基本工资salary”
(2)编写业务方法,introduce(),实现输出一个教师的信息。
(3)编写教师类的三个子类:教授类(Professor)、副教授类、讲师类。工资级别分别为:教
授为1.3、副教授为1.2、讲师类1.1。在三个子类里面都重写父类的introduce()方法。
(4)定义并初始化一个老师对象,调用业务方法,实现对象基本信息的后台打印.*/
class Main{
    public static void main(String[] args) {
        Teacher teacher = new Teacher("xiai", 23, "sd", 234567);
        teacher.introduce();
        Professor professor = new Professor("xiai", 23, "sd", 234567);
        professor.introduce();
        Associate_Professor associateProfessor = new Associate_Professor("xiai", 23, "sd", 234567);
        associateProfessor.introduce();
        lecturer lecturer = new lecturer("xiai", 23, "sd", 234567);
        lecturer.introduce();

    }
}
public class Teacher {
    String name;
    int age;
    String post;
    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;
    }
    public void introduce()
    {
        System.out.println("姓名："+name+"\t年龄："+age+"\t职位："+post+"\t基本工资："+salary);
    }
}
class Professor extends Teacher{
    public Professor(String name, int age, String post, double salary) {
        super(name, age, post, salary);
    }
    public void introduce()
    {
        //System.out.println("姓名："+name+"\t年龄："+age+"\t职位："+post+"\t基本工资："+salary*1.3);
        super.introduce();
    }


}
class Associate_Professor extends Teacher{
    public Associate_Professor(String name, int age, String post, double salary) {
        super(name, age, post, salary);
    }

    public void introduce()
    {
       // System.out.println("姓名："+name+"\t年龄："+age+"\t职位："+post+"\t基本工资："+salary*1.2);
        super.introduce();
    }


}
class lecturer extends Teacher{
    public lecturer(String name, int age, String post, double salary) {
        super(name, age, post, salary);
    }

    public void introduce()
    {
       // System.out.println("姓名："+name+"\t年龄："+age+"\t职位："+post+"\t基本工资："+salary*1.1);
        super.introduce();
    }


}

package com.project.test04;
/*
*
父类:员工类
子类:部门经理类、普通员工类
(1)部门经理工资=1000+单日工资*天数*等级(1.2)。
(2)普通员工工资=单日工资*天数*等级(1.0);
(3)员工属性:姓名,单日工资,工作天数
(4)员工方法(打印工资)
(5)普遍员工及部门经理都是员工子类,需要重写打印工资方法。
(5)定义并初始化普通员工对象,调用打印工资方法输入工资,定义并初始化部门经理对象,
调用打印工资方法输入工资*/
class Main{
    public static void main(String[] args) {
        Employee xais = new Employee("xais", 2354, 1234);
        xais.print();
        department_manager xais1 = new department_manager("xais", 2354, 1234);
        xais1.print();
        common_employee xais2 = new common_employee("xais", 2354, 1234);
        xais2.print();
    }
}
public class Employee {
    String name;
    double day_salary;
    int work_day;

    public Employee(String name, double day_salary, int work_day) {
        this.name = name;
        this.day_salary = day_salary;
        this.work_day = work_day;
    }

    public String getName() {
        return name;
    }

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

    public double getDay_salary() {
        return day_salary;
    }

    public void setDay_salary(double day_salary) {
        this.day_salary = day_salary;
    }

    public int getWork_day() {
        return work_day;
    }

    public void setWork_day(int work_day) {
        this.work_day = work_day;
    }
    public void print()
    {
        System.out.println(getDay_salary()*getWork_day());
    }

}
class department_manager extends Employee{
    public department_manager(String name, double day_salary, int work_day) {
        super(name, day_salary, work_day);
    }
    public void print()
    {
        System.out.println(1000+getDay_salary()*getWork_day()*1.2);
    }





}
class common_employee extends Employee{
    public common_employee(String name, double day_salary, int work_day) {
        super(name, day_salary, work_day);
    }
    public void print()
    {
       super.print();
    }





}

package com.project.test05;
/*
设计父类-员工类。子类:工人类(Wonker),农民类(Peasant),教师类(Teacher),科学家类
(Scientist),服务生类(Waiter)。
(1)其中工人,农民,服务生只有基本工资
(2)教师除基本工资外,还有课酬(元/天)
(3)科学家除基本工资外,还有年终奖
(4)编写一个测试类,将各种类型的员工的全年工资打印出来
*/
class Main{
    public static void main(String[] args) {
        Peasant jiayou = new Peasant("jiayou", 100, 50000);
        Scientist jiayou1 = new Scientist("jiayou", 100, 234567);
        jiayou1.setYear(12);
        jiayou.setYear(12);
        
        jiayou1.setBonues(123423);
        jiayou1.print();
        jiayou.print();
    }
}
public class Employee {
    String name;
    int age;
    double base_salary;
    int year;

    public Employee(String name, int age, double base_salary) {
        this.name = name;
        this.age = age;
        this.base_salary = base_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 double getBase_salary() {
        return base_salary;
    }

    public void setBase_salary(double base_salary) {
        this.base_salary = base_salary;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }
    public void print()
    {
        System.out.println(getBase_salary()*year);
    }
}
class Worker extends Employee{
    public Worker(String name, int age, double base_salary) {
        super(name, age, base_salary);
    }
    public void print()
    {
        super.print();
    }

}
class Peasant extends Employee{
    public Peasant(String name, int age, double base_salary) {
        super(name, age, base_salary);
    }
    public void print()
    {
        super.print();
    }
}
class Waiter extends Employee{
    public Waiter(String name, int age, double base_salary) {
        super(name, age, base_salary);
    }
    public void print()
    {
        super.print();
    }

}
class Teacher extends Employee{
    double day_salary;
    int day;


    public Teacher(String name, int age, double base_salary,  double day_salary) {
        super(name, age, base_salary);
        this.day_salary = day_salary;
    }

    public double getDay_salary() {
        return day_salary;
    }

    public void setDay_salary(double day_salary) {
        this.day_salary = day_salary;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    public void print()
    {
        System.out.println(getBase_salary()*year+getDay_salary()*day);
    }

}
class Scientist extends Employee{
    double bonues;

    public Scientist(String name, int age, double base_salary) {
        super(name, age, base_salary);

    }

    public double getBonues() {
        return bonues;
    }

    public void setBonues(double bonues) {
        this.bonues = bonues;
    }
    public void print()
    {
        System.out.println(getBase_salary()*year+getBonues());
    }

}

牢记this和super的查找规则，this从本来开始找，有就访问本类，没有就访问父类

super从父类开始。。。。。。

注意属性和方法访问修饰符，private只支持本类访问

牢记创建一个对象时，都会默认调用该类的无参构造器，所以new Demo（）--->来到了

Demo（）{

super（）;//-->运行到这来到了其父类的无参构造器Test（）{

System.out.println("Test");}此时打印出Test。

System.out.println("Demo");//然后来到了这句打印出Demo

}

然后因为new Demo（）.test()调用了本类的test（）方法则进入了该方法，来到了System.out.println(super.name);//指父类的name，此时打印出Rose，再往下来到了System.out.println(this.name);//指本类的name，此时打印出Jack。

接着运行new Demo（"john"）.test,

new Demo（"john"）代表调运了Demo中参数为String类型的构造器，该方法内的

super（s）；//代表调用父类的带参数为String类型的构造器，并带着值为“john”的s过去了，父类的带参数为String类型的构造器中的this.name=name,改变了他name的值，成为了John，再接着后面调用了Demo中test（）方法，输出了父类的name和本类的name，父类的name已为john，本类的还是jack

package com.project.test07;
/*9.设计一个Point类,其x和y坐标可以通过构造器提供。提供一个子类LabeledPoint,其
构造器接受一个标签值和x,y坐标,比如:new LabeledPoint("Black",1929,230.07),
写出对应的构造器即可 Homework09.java*/
class Main{
    public static void main(String[] args) {
        LabeledPoint sjd = new LabeledPoint("sjd", 13, 156);
        System.out.println(sjd);//直接输出对象，toString方法会被调用


    }
}

public class Point {
    double x;
    double y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

}
class LabeledPoint extends Point{
    String name;

    public LabeledPoint( String name,double x, double y) {
        super(x, y);
        this.name = name;
    }
    @Override
    public String toString() {
        return "LabeledPoint{" +
                "name='" + name + '\'' +
                ", x=" + x +
                ", y=" + y +
                '}';
    }
}

package com.project.test08;
/*10. 编写Doctor类{name,age, job, gender,sal}
相应的getter()和setter()方法,5个参数的构造器,重写父类的equals()方法:public
boolean equals(Object obj),并判断测试类中创建的两个对象是否相等。相等就是判断
属性是否相同
*/
class Main{
    public static void main(String[] args) {
        Doctor doctor = new Doctor("sd", 13, "as", "as", 1234);
        Doctor doctor1 = new Doctor("sd", 12, "as", "as", 1234);
        System.out.println(doctor.equals(doctor1));
    }
}
public class Doctor {
    String name;
    int age;
    String job;
    String  gender;
    double salary;

    public Doctor(String name, int age, String job, String gender, double salary) {
        this.name = name;
        this.age = age;
        this.job = job;
        this.gender = gender;
        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 getJob() {
        return job;
    }

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

    public String getGender() {
        return gender;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public boolean equals(Object obj) {
        if (this==obj)//先看两个是不是同一个对象
        return true;
        else if (obj instanceof Doctor)//如果不是同对象再来判断是否为同类或者是否是其子类
        {
            Doctor doctor=(Doctor) obj;//是同类或者子类就将obj向下转型，这样才能访问子类的数据。

            return this.name.equals(doctor.name)&&this.age==doctor.age&&this.job.equals(doctor.job)&&
                    this.gender.equals(doctor.gender)&&this.salary==doctor.salary ;//逐个判断
        }
        else
            return false;



    }
}

牢记，向上转型是看编译类型（等号左边的）来找，而向上转型的等号左边往往是父类，父类是无法直接访问子类的属性和方法的，所以，题中向上转型只能访问方法run和eat。但当要看访问的方法的运行结果时，这时就要从运行类型（等号右边的）中的方法来看，往往是子类，看有没有调用的方法，如果有则运行 运行类型的方法，如果没有则去父类找，如还没有再找直至最高父类。

向下转型，此时可以直接调用其子类属性和方法，运行时也是先从子类看是否有，若有运行子类的，没有就去父类找

package com.project.test09;
/*

13.打印效果如下

老师的信息:
姓名:张飞
年龄:30
性别:男
工龄:5
我承诺,我会认真教课。
张飞爱玩象棋

学生的信息:
姓名:小明
年龄:15
性别:男
学号:00023102
我承诺,我会 好好学习。
小明爱玩足球。
本章作业
案例题目描述:
(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方法

。*/
class Main{
    public static void main(String[] args) {
        Person person[]=new Person[4];
        person[0]=new Student("小明",15,"男","00023102");
        person[1]=new Student("小明",15,"男","00023102");
        person[2]=new Teacher("张飞",30,"男",5);
        person[3]=new Teacher("张飞",30,"男",5);
//冒泡排序
        for(int i=0;i<person.length-1;i++)
        {
            for(int j=0;j<person.length-1-i;j++)
            {
                Person p=null;
                if (person[j].age<person[j+1].age&&j+1<person.length)
                {
                    p=person[j];
                    person[j]=person[j+1];
                    person[j+1]=p;


                }
            }

        }
        for(int i=0;i<person.length;i++)
        {
            System.out.println(person[i]);//打印信息
            person[i].pt(person[i]);//打印对应的方法
            person[i].play();//打印兴趣爱好
        }




    }
}

public class Person {
    String name;
    int age;
    String gender;

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

    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  getGender() {
        return gender;
    }

    public void setGender(String  gender) {
        this.gender = gender;
    }
    public void play()
    {
        System.out.println(name+"喜欢踢足球");
    }

    @Override
    public String toString() {
        return
                "姓名：" + name + '\n' +
                "年龄：" + age +
                "\n性别：" + gender + '\n'
                ;
    }
    public void pt(Person person)
    {
        if (person instanceof Teacher)//判断是否为其子类和同类
        {
            ((Teacher) person).teach_();是就向下转型调用其相应的方法
        }
        else if (person instanceof Student)
            ((Student) person).student_();
        else
            System.out.println("查询失败");

    }
}
class Student extends Person{
    String student_id;

    public Student(String name, int age, String  gender, String  student_id) {
        super(name, age, gender);
        this.student_id = student_id;
    }

    public String  getStudent_id() {
        return student_id;
    }

    public void setStudent_id(String  student_id) {
        this.student_id = student_id;
    }
    public void student_()
    {
        System.out.println("我承诺我一定会好好学习！");
    }
    public void play()
    {
        System.out.println(name+"喜欢踢足球");
    }

    @Override
    public String toString() {
        return "学生的信息:\n" +
               super.toString() +
                "学号：" + student_id;
    }
}
class Teacher extends Person{
    int work_age;

    public Teacher(String name, int age, String  gender, int work_age) {
        super(name, age, gender);
        this.work_age = work_age;
    }

    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("我承诺我一定会好好学习！");
    }
    public void play()
    {
        System.out.println(name+"喜欢下象棋");
    }

    @Override
    public String toString() {
        return "老师的信息:\n" +
                super.toString()  +
                "工龄：" + work_age;
    }
}

牢记：子类的构造器中第一行默认会有一句super（）；默认调用父类的无参构造器，除非，父类自己定义了一个有参构造器，这时就不会默认去调用父类的无参构造器，只能自己手动选择调用哪个构造器

所以该题的流程为

再创建C c=new C（）时调用了C类的无参构造器，C类中的this("hello")；调用了该类中有参构造器，而该类的有参构造器中的super（“hahah”）；调用了其父类的有参构造器,此时注意，B的父类除无参构造器并未再创建其他构造器，则，B类有参构造器默认调用了其父类A类的无参构造器，所以第一句先输出的是A类无参构造器中的我是A类，然后接着输出hahah我是B类的有参构造器，再是我是C类有参构造器，最后为，我是C类无参构造器。