1.做一个饲养员给动物喂食物的样例体现JAVA中的面向对象思想,接口（抽象类）的用处

package com.softeem.demo;
/**
*@authorleno
*动物的接口
*/
interface Animal
{
public void eat(Food food);
}
/**
*@authorleno
*一种动物类:猫
*/
class Cat implements Animal
{
public void eat(Food food)
{
System.out.println("小猫吃"+food.getName());
}
}
/**
*@authorleno
*一种动物类:狗
*/
class Dog implements Animal
{
public void eat(Food food)
{
System.out.println("小狗啃"+food.getName());
}
}

/**
*@authorleno
*食物抽象类
*/
abstractclass Food
{
protected String name;
public String getName() {
returnname;
}

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

/**
*@authorleno
*一种食物类:鱼
*/
class Fish extends Food
{
public Fish(String name) {
this.name = name;
}
}
/**
*@authorleno
*一种食物类:骨头
*/
class Bone extends Food
{
public Bone(String name) {
this.name = name;
}
}

/**
*@authorleno
*饲养员类
*
*/
class Feeder
{
/**
*饲养员给某种动物喂某种食物
*@paramanimal
*@paramfood
*/
public void feed(Animal animal,Food food)
{
animal.eat(food);
}
}

/**
*@authorleno
*測试饲养员给动物喂食物
*/
public class TestFeeder {
public static void main(String[] args) {
Feeder feeder=new Feeder();
Animal animal=new Dog();
Food food=new Bone("肉骨头");
feeder.feed(animal,food); //给狗喂肉骨头
animal=new Cat();
food=new Fish("鱼");
feeder.feed(animal,food); //给猫喂鱼
}
}

2.写一个方法，用二分查找法推断随意整数在随意整数数组里面是否存在，若存在就返回它在数组中的索引位置，不存在返回-1

/**
*二分查找特定整数在整型数组中的位置(递归)
*@paramdataset
*@paramdata
*@parambeginIndex
*@paramendIndex
*@returnindex
*/
publicint binarySearch(int[] dataset,int data,int beginIndex,int endIndex)
{
int midIndex = (beginIndex+endIndex)/2;
if(data <dataset[midIndex])
{
return binarySearch(dataset,data,beginIndex,midIndex-1);
}elseif(data>dataset[midIndex])
{
return binarySearch(dataset,data,midIndex+1,endIndex);
}else
{
return midIndex;
}
}

/**
*二分查找特定整数在整型数组中的位置(非递归)
*@paramdataset
*@paramdata
*@returnindex
*/
publicint binarySearch(int[] dataset ,int data)
{
int beginIndex = 0;
int endIndex = dataset.length - 1;
int midIndex = -1;
while(beginIndex <= endIndex) {
midIndex = (beginIndex+endIndex)/2;
if(data <dataset[midIndex]) {
endIndex = midIndex-1;
} elseif(data>dataset[midIndex]) {
beginIndex = midIndex+1;
}else
{
return midIndex;
}
}
return -1;
}

3.写一个彩票号码的生成器。35选7(1~35)。而且生成的7个号码不能反复

(第n个数字要与前n-1个数字进行比較)

  int[] number = new int[7];
  for(int i=0;i<7;i++){
     double d = Math.random();
     number[i]=(int)(d*35+1);
     for(int j=0;j<i;j++){
         if(number[i]==number[j]){
             i--;
             break;
         }
     }
  }
  for(int i=0;i<7;i++){
      System.out.println(number[i]);
  }

或者用HashSet(集合)存储数字。会自己主动过滤反复：

  HashSet hs = new HashSet();
  while(true){
     double d = Math.random();
     int number = (int)(d*35+1);
     hs.add(number);
     if(hs.size()==7)break;
  }
  System.out.println(hs);

或者还有一种考虑就是将下标作为讨论的对象：数组temp存储1~35个整数，第一次，从此数组下标0~34个中随机筛选出一下标5，将此下标相应的数赋给result[0] = temp[5],然后将temp数组位置上的数用此数组的最后一个数代替temp[34],第二次，从剩余33个中随机选取下标，. . .

  int[] result = new int[7];
  int[] temp = new int[35];
  for(int i=0;i<temp.length;i++){
     temp[i] = i+1;
  }
  for(int i=0;i<result.length;i++){
     int index = (int)(Math.random()*(35-i));
     result[i] = temp[index];
     temp[index] = temp[34-i];
  }
  for(int i=0;i<result.length;i++){
     System.out.println(result[i]);
  }