JavaSE编码试题强化练习7

1.编写应用程序，创建类的对象，分别设置圆的半径、圆柱体的高，计算并分别显示圆半径、圆面积、圆周长，圆柱体的体积。

/**
 * 圆类
 */
public class Circle {
  /**
   * 类属性--圆半径
   */
  private double radius;
  /**
   * 构造方法
   */
  public Circle() {
  }

  public Circle(double radius) {
    this.radius = radius;
  }
  /**
   * 成员方法--计算圆的周长
   */
  double getPerimeter(){
    return 2*Math.PI*radius;
  }
  /**
   * 成员方法--计算圆的面积
   */
  protected double getArea(){
    return Math.PI*radius*radius;
  }
  /**
   * 成员方法--显示圆的半径，周长，面积
   */
  String show(){
    return "圆的半径 = "+radius+"\n"+"圆的周长 = "+getPerimeter()+"\n"+
      "圆的面积 " +
      "= "+getArea();
  }
}

/**
 * 圆柱体类--圆类的子类
 */
public class Cylinder extends Circle {
  /**
   * 类属性--圆柱体的高
   */
  private double hight;

  /**
   * 构造方法
   */
  public Cylinder() {
  }

  public Cylinder(double hight) {
    this.hight = hight;
  }

  Cylinder(double r, double h) {
    super(r);
    this.hight = h;
  }
  /**
   * 成员方法--计算圆柱体的体积
   */
  private double getVolume(){
    return getArea()*hight;
  }
  /**
   * 成员方法--展示圆柱体高和体积
   */
  public String show(){
    return "圆柱体的高 = "+hight+"\n"+"圆柱体体积 = "+getVolume();
  }
}

/**
 * 测试类
 */
public class Test {
  public static void main(String[] args) {
    /**
     * 创建圆、圆柱体对象，通过构造方法完成赋值
     */
    Circle c = new Circle(0.5);
    Cylinder cy = new Cylinder(0.8,5);
    /**
     * 调用方法
     */
    System.out.println(c.show());
    System.out.println(cy.show());
  }
}

运行结果：

 此处小结一下：

Java中的四个权限访问修饰符及其访问范围

1) 类的访问权限只有两种
　　a) public(公共的) 可被同一项目中的所有的类访问。（必须与文件名同名）
　　b) 默认 可被同一个包中的类访问。
2) 成员（成员变量或成员方法）访问权限共有四种：
　　a) public(公共的) 可以被项目中所有的类访问。
　　b) protected(受保护的) 可以被这个类本身访问；同一包中的所有其他的类访问；被它的子类（同一包以及不同包中的子类）访问。
　　c) 默认 被这个类本身访问；被同一个包中的类访问。
　　d) private(私有的) 只能被这个类本身访问。
用一张图表总结如下：

权限修饰符	同一类中	同一包中不同类	不同包中子类	不同包中非子类
public	YES	YES	YES	YES
protected	YES	YES	YES	NO
默认	YES	YES	NO	NO
private	YES	NO	NO	NO

2.编写一个Worker类，为Worker类添加相应的代码，使得Worker对象能正确放入TreeSet中。并编写相应的测试代码。
思路:
1) Worker类含有name,age,salary三个属性
2) 取值，赋值的方法、构造方法
3) 先按工人的年龄大小比较，年龄小的排在前面；若年龄相同，则按字典顺序比较工人姓名
4) 编写测试类，向集合中添加三条数据
5) 遍历集合，输出集合中的元素信息(Worker类编写toString方法)

/**
 * 工人类
 */
public class Worker implements Comparable<Worker>{
  /**
   * 属性：姓名，年龄，薪水
   */
  private String name;
  private int age;
  private double salary;
  /**
   * 构造方法
   */
  public Worker() {
  }

  public Worker(String name, int age, double salary) {
    this.name = name;
    this.age = age;
    this.salary = salary;
  }
  /**
   * getter setter方法
   */
  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 getSalary() {
    return salary;
  }

  public void setSalary(double salary) {
    this.salary = salary;
  }
  /**
   * toString方法
   */
  public String toString(){
    return "工人信息：{ "+"姓名： "+name+"  "+"年龄： "+age+"  "+"薪水： "+salary+" }";
  }
  /**
   * 重写compareTo方法
   */
  @Override
  public int compareTo(Worker other) {
    if (this.age != other.age){
      return this.age - other.age;
    }else {
      return this.name.compareTo(other.name);
    }
  }
}

public class TestWorker {
  public static void main(String[] args) {
    /**
     * 创建集合对象完成信息添加
     */
    Set<Worker> set = new TreeSet<Worker>();
    set.add(new Worker("A",26,9959));
    set.add(new Worker("J",25,8848));
    set.add(new Worker("V",26,7868));
    set.add(new Worker("A",27,9527));
    /**
     * 遍历集合输出结果
     */
    Iterator<Worker> it = set.iterator();
    while (it.hasNext()){
      Worker w  = it.next();
      System.out.println(w.toString());
    }
  }
}
/**
 * 小结：Set集合类型
 * 1、特点：
 *    1）无序
 *    2）唯一（不允许重复元素）
 * 2、包括HashSet、LinkedHashSet、TreeSet
 *    1）HashSet
 *      ◆采用Hashtable（哈希表）存储结构（神奇的结构）
 *      ◆优点：添加、查找、删除速度快
 *      ◆缺点：无序
 *    2）LinkedHashSet
 *      ◆采用了哈希表存储结构，同时使用链表维护次序
 *      ◆特点：有序（添加顺序）
 *    3)TreeSet
 *      ◆采用二叉树（红黑树）的存储结构
 *      ◆优点：有序，查询速度比List快（按内容查找）
 *      ◆缺点：查询速度没有HashSet快
 * 3、总结：
 *    ◆HashSet 哈希表 唯一 无序
 *    ◆LinkedHashSet 哈希表+链表 唯一 有序（添加顺序）
 *    ◆TreeSet 红黑树 一种二叉平衡树 唯一 有序（自然顺序）
 *    ◆List针对Collection增加了一些关于索引位置操作的方法，get(i);add(i,elem);remove(i);set(i,elem)
 *    ◆Set是无序的，不可能提供关于索引位置操作的方法，set针对Collection没有增加任何方法
 *    ◆List遍历有三种方式：for循环；for-each循环；Iterator迭代器
 *    ◆Set的遍历方式有两种：for-each循环；Iterator迭代器
 * 注意：
 * 对于自定义类：
 *    ◆在HashSet和LinkedHashSet中要实现hasCode()和equals()方法；
 *    ◆在TreeSet中要实现Comparable接口并指定比较的规则。
 */

运行结果：

3.采用递归和非递归的方式对int数组进行折半查找。（与前面有重复，重复加深记忆，锻炼熟练度）
肝！！！

public class TestBinarySearch {
  public static void main(String[] args) {
    int[] arr = {22,23,33,34,55,56,66,67,78};
    int key1 = 22;
    int key2 = 55;
    int key3 = 78;
    int key4 = 88;
    int n1 = binarySearch(arr,key1);
    int n2 = binarySearch(arr,key2);
    int n3 = binarySearch(arr,key3);
    int n4 = binarySearch(arr,key4);
    System.out.println("非递归查找key1的索引号为："+n1);
    System.out.println("非递归查找key2的索引号为："+n2);
    System.out.println("非递归查找key3的索引号为："+n3);
    System.out.println("非递归查找key4的索引号为："+n4);
    System.out.println("==========================");
    int n5 = binarySearch(arr,key1);
    int n6 = binarySearch(arr,key2);
    int n7 = binarySearch(arr,key3);
    int n8 = binarySearch(arr,key4);
    System.out.println("递归查找key1的索引号为："+n5);
    System.out.println("递归查找key2的索引号为："+n6);
    System.out.println("递归查找key3的索引号为："+n7);
    System.out.println("递归查找key4的索引号为："+n8);
  }
  public static int binarySearch(int[] arr,int key){
    int start = 0;
    int end = arr.length - 1;
    while (start <= end){
      int mid = (start + end) / 2;
      int value = arr[mid];
      if (key == value){
        return mid;
      }else if (key > value){
        start = mid + 1;
      }else {
        end = mid - 1;
      }
    }
    return -1;
  }
  public static int recursionBinarySearch(int[] arr,int key){
    int start = 0;
    int end = arr.length - 1;
    return recursionBinarySearch(arr,start,end,key);
  }

  private static int recursionBinarySearch(int[] arr, int start, int end, int key) {
    int mid = (start + end) / 2;
    int value = arr[mid];
    while (start <= end){
      if (key > value){
        return recursionBinarySearch(arr,mid + 1,end,key);
      }else if (key < value){
        return recursionBinarySearch(arr,start,mid - 1,key);
      }else {
        return mid;
      }
    }
    return -1;
  }
}

运行结果：