多线程Thread的习题2

1.编写两个线程类，它们同时运行。
一个线程输出10000以内的奇数，一个线程输出10000以内的偶数。

/*
1. 编写两个线程类，它们同时运行。
一个线程输出10000以内的奇数，一个线程输出10000以内的偶数。
 */
public class Test {

  public static void main(String[] args) {
    T t=new T();
    T1 t1=new T1();
    t.start();
    t1.start();

  }
}
class T extends Thread{

  @Override
  public void run() {
    System.out.println(0);
    for (int i = 1; i < 10001; i++) {
      if(i%2==0){
        System.out.println("偶数："+i);
      }
    }
  }
}
class T1 extends Thread{

  @Override
  public void run() {
    for (int i = 1; i < 10001; i++) {
      if(i%2!=0){
        System.out.println("奇数："+ i);
      }
    }
  }
}

2.用多线程程序模拟龟兔赛跑。
总路程为100米，兔子1秒跑5米需要休息6秒，乌龟每3秒跑2米需要休息1秒。
分析：首先该俩个线程的路程是各走各的，是独立的，俩者共用的是时间，也就是线程，同时开始线程就意味着同时出发。
然后看题干，兔子1s跑5米就要休息6秒，而乌龟可以跑3秒才需要休息1秒，这3s乌龟可以跑2米，所以应该有一个时间变量，兔子1s后就线程休眠6s，乌龟3s后线程休息1s。那么思路就来了。

	package TT;
/*
用多线程程序模拟龟兔赛跑。
总路程为100米，兔子1秒跑5米需要休息6秒，乌龟每3秒跑2米需要休息1秒。
 */
public class Test {

  public static void main(String[] args) {

    Rabbit r=new Rabbit();
    Tortoise t=new Tortoise();
    r.start();
    t.start();
  }
}
class Game{

  public void victory(){

  }
}
class  Rabbit extends Thread{
  public int route = 100;
  public int time=1;
  @Override
  public void run() {
    while (true){
      route=100-5*time;

      time++;
      System.out.println("兔子还剩"+route+"米");
      if(route<=0){
        System.out.println("兔子获取了胜利!");
        System.exit(0);
      }
      try {
        Thread.sleep(6000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
}
class Tortoise extends Thread{
  public int route;
  public int time=1;
  @Override
  public void run() {

    while (true){
      time++;
      if(time%3==0){
      route=100-time*2;

      System.out.println("乌龟还剩"+route+"米");
      if(route<=0){
        System.out.println("乌龟获取了胜利!");
        System.exit(0);
      }

        try {
          Thread.sleep(1000);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }

    }

  }
}

一、某小型公司主要有三类工作人员(Worker)：经理(Manager)、兼职技术人员(Technician)和兼职推销员(Salesman)。

1. 这三类人员共同拥有的相关属性：姓名、编号；
2. 相关方法：获取月薪的public double getPay()方法、显示个人信息的public String toString()方法。
3. 兼职技术人员还应该有每月工作小时数属性。兼职推销人员还应该有每月销售额属性。
4. 人员编号基数为1000，每创建一个人员实例对象，其编号属性的值顺序加1。
5. 月薪计算方法：
   1. 经理拿固定月薪8000元；
   2. 兼职技术人员按每小时100元领取月薪；
   3. 兼职推销人员的月薪按当月的销售额的4%提成。
6. 分别创建一个经理，一个兼职技术人员，一个兼职推销员，分别显示他们的信息及月薪。
   Test.java

public class Test {

  public static void main(String[] args) {
    Worker manager= new Manager("经理");
    Worker technician=new Technician("技术人员");
    Worker salesman=new Salesman("销售员");
    System.out.println(manager.toString()+" 销售额"+manager.getPay());
    System.out.println(technician.toString()+" 销售额"+technician.getPay());
    System.out.println(salesman.toString()+" 销售额"+salesman.getPay());
  }
}

Worker.java

public class Worker{
  private static int n=1000;
  private String name;
  private int num;

  public Worker() {
  }

  public Worker(String name) {
    this.name = name;
    this.num=++n;
  }

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

  public void setNum() {
    this.num=num++;
  }

  public String getName() {
    return name;
  }

  public int getNum() {
    return num;
  }

  public double getPay(){
    return 0.0;
  }
  public String toString(){
    String s="名字："+name+" 编号"+num;
    return s;
  }
}

Manager.java

pulic class Manager extends Worker{

  public Manager() {
  }

  public Manager(String name) {
    super(name);
    setNum();
  }
  public String toString(){
    String s = super.toString();
    return s;

  }
  public double getPay(){
    double d=8000;
    return d;
  }
}

Technician.java

public class Technician extends Worker{
  private int workHours;

  public void setWorkHours(int workHours) {
    this.workHours = workHours;
  }

  public int getWorkHours() {
    return workHours;
  }

  public Technician() {
  }

  public Technician(String name) {
    super(name);
    setNum();
  }
  public String toString(){
    String s = super.toString()+" 工作时长："+workHours;
    return s;
  }
  public double getPay(){
    double d=100*workHours;
    return d;
  }
}

Salesman.java

public class Salesman extends Worker{
  private int salesNum;

  public void setSalesNum(int salesNum) {
    this.salesNum = salesNum;
  }

  public int getSalesNum() {
    return salesNum;
  }

  public Salesman() {
  }

  public Salesman(String name) {
    super(name);
    setNum();
  }
  public String toString(){
    String s = super.toString()+" 销售额："+salesNum;
    return s;
  }
  public double getPay(){
    double d=0.04*salesNum;
    return d;
  }
}

编程模拟一个军队作战。

1. 军队里有各种兵(soldier): 骑兵(cavalryman)和步兵(rifleman)等。每个兵都有自己的名字，但每种兵的攻击(attack)敌人方式不一样。
2. 军队有一个军官(officer)：军官有一种行为就是发号，军官发号(sendingSignal)了，所有的兵都得去战场攻击敌人。
   提示：通过军官(officer)的构造方法把他带的所有兵(数组)传递进去。
3. 创建3个骑兵和3个步兵，由一个军官发信号让所有的兵去作战。
   Test.java

package TT;

public class Test {

  public static void main(String[] args) {
    Officer o=new Officer();
    Soldier s1=new Cavalryman(new String[]{"小明", "小绿", "小红"});
    Soldier s2=new Rifleman(new String[]{"张三", "李四", "王武"});
    o.sendingSignal(s1.s);
    o.sendingSignal(s2.s);
  }
}

Soldier.java

package TT;

public class Soldier {
public String[] s;

  public Soldier() {
  }

  public Soldier(String[] s) {
    this.s = s;
  }
}

Cavalryman.java

package TT;

public class Cavalryman extends Soldier {

  public Cavalryman(String[] s) {
    super(s);//调用父类构造器
  }
}

Rifleman.java

package TT;

public class Rifleman extends Soldier {

  public Rifleman(String[] s) {
    super(s);
  }
}

Officer.java

package TT;

public class Officer {
public void sendingSignal(String[] s){
  for (String aa:s) {
    System.out.print(aa);
    System.out.println("发起了进攻！");
  }
}
}