201771010112罗松《面向对象程序设计（java）》第十一周学习总结

其他 2018-11-11 12:27:59 阅读次数: 0

 1、实验目的与要求

(1) 掌握Vetor、Stack、Hashtable三个类的用途及常用API；

(2) 了解java集合框架体系组成；

(3) 掌握ArrayList、LinkList两个类的用途及常用API。

(4) 了解HashSet类、TreeSet类的用途及常用API。

(5)了解HashMap、TreeMap两个类的用途及常用API；

(6) 结对编程（Pair programming）练习，体验程序开发中的两人合作。

2、实验内容和步骤

实验1： 导入第9章示例程序，测试程序并进行代码注释。

测试程序1：

l 使用JDK命令运行编辑、运行以下三个示例程序，结合运行结果理解程序；

掌握Vetor、Stack、Hashtable三个类的用途及常用API。

import java.util.Vector;

//示例程序1

class Cat {
    private int catNumber;

    Cat(int i) {
        catNumber = i;
    }

    void print() {
        System.out.println("Cat #" + catNumber);
    }
}
class Dog {
    private int dogNumber;

    Dog(int i) {
        dogNumber = i;
    }

    void print() {
        System.out.println("Dog #" + dogNumber);
    }
}
public class CatsAndDogs {
    public static void main(String[] args) {
        Vector cats = new Vector();//创建一个新的类
        for (int i = 0; i < 7; i++)
            cats.addElement(new Cat(i));
        cats.addElement(new Dog(7));
        for (int i = 0; i < cats.size(); i++)
        if(cats.elementAt(i)instanceof Cat)// instanceof运算符是用来指出对象是否是特定类的一个实例
        {    
            ((Cat) cats.elementAt(i)).print();
        }else {
            ((Dog) cats.elementAt(i)).print();
        }
    }}

结果：

示例二：

//示例程序2
import java.util.*;

public class Stacks {
    static String[] months = { "1", "2", "3", "4" };

    public static void main(String[] args) {
        Stack stk = new Stack();
        for (int i = 0; i < months.length; i++)
            stk.push(months[i]);//放入一个i值
        System.out.println(stk);
        System.out.println("element 2=" + stk.elementAt(2));//element表示一个节点
        while (!stk.empty())
            System.out.println(stk.pop());//出栈操作
    }
}

Stacks

结果：

示例三：

import java.util.*;

class Counter {
    int i = 1;
    public String toString() {
        return Integer.toString(i);
    }
    }
public class Statistics {
    public static void main(String[] args) {
        Hashtable ht = new Hashtable();//生成集合类Hashtable
        for (int i = 0; i < 10000; i++) //生成循环体
        {
            Integer r = new Integer((int) (Math.random() * 20));//随机生成实数定义为整型
            if (ht.containsKey(r))
                ((Counter) ht.get(r)).i++;//用来判断r是否为一个间值
            else
                ht.put(r, new Counter());//创建新的Counter对象
        }
        System.out.println(ht);
    }
}

结果：

测试程序2：

l 使用JDK命令编辑运行ArrayListDemo和LinkedListDemo两个程序，结合程序运行结果理解程序；

import java.util.*;

public class ArrayListDemo {
    public static void main(String[] argv) {
        ArrayList al = new ArrayList();
        //用Add来添加对象且可以重载
        // Add lots of elements to the ArrayList...
        al.add(new Integer(11));
        al.add(new Integer(12));
        al.add(new Integer(13));
        al.add(new String("hello"));
        System.out.println(al.size());//输出al的长度
        // First print them out using a for loop.
        System.out.println("Retrieving by index:");
        for (int i = 0; i < al.size(); i++) {
            System.out.println("Element " + i + " = " + al.get(i));
        }
    }
}

ArrayListDemo

mport java.util.*;
public class LinkedListDemo {
    public static void main(String[] argv) {
        LinkedList l = new LinkedList();
        l.add(new Object());
        l.add("Hello");
        l.add("zhangsan");//add方法可以重载
       
        ListIterator li = l.listIterator(0);//迭代器生成li对象
        while (li.hasNext())//hasNext方法用来返回迭代器的对象
            System.out.println(li.next());
        if (l.indexOf("Hello") < 0) //生成循环语句判断最后结果 
            System.err.println("Lookup does not work");
        else
            System.err.println("Lookup works");
   }
}

LinkedListDemo

测试程序3：

l 运行SetDemo程序，结合运行结果理解程序；

import java.util.*;
public class SetDemo {
    public static void main(String[] argv) {
        HashSet h = new HashSet(); //也可以 Set h=new HashSet()
        h.add("One");
        h.add("Two");
        h.add("One"); // DUPLICATE
        h.add("Three");
        Iterator it = h.iterator();
        while (it.hasNext()) //hasNext方法
        {
             System.out.println(it.next());
        }
    }
}

 SetDemo

  •  在Elipse环境下调试教材365页程序9-2，结合运行结果理解程序；了解HashSet类的用途及常用API。
package set;


import java.util.*;

/**
 * This program uses a set to print all unique words in System.in.
 * @version 1.12 2015-06-21
 * @author Cay Horstmann
 */
public class SetTest
{
   public static void main(String[] args)
   {
       
      Set<String> words = new HashSet<>(); // HashSet implements Set
      long totalTime = 0;
      
      try (Scanner in = new Scanner(System.in))
      {
         while (in.hasNext())//迭代器的用法，判断当前元素是否存在
         {
            String word = in.next();//指向下一个元素
            long callTime = System.currentTimeMillis();
            words.add(word);//
            callTime = System.currentTimeMillis() - callTime;
            totalTime += callTime;
         }
      }

      Iterator<String> iter = words.iterator();//迭代器的简单实现
      for (int i = 1; i <= 20 && iter.hasNext(); i++)
         System.out.println(iter.next());
      System.out.println(". . .");
      System.out.println(words.size() + " distinct words. " + totalTime + " milliseconds.");
   }
}

小结：HashSet类中存放的对象不能重复，不能保证元素的排列顺序，顺序有可能发生变化。

在Elipse环境下调试教材367页-368程序9-3、9-4，结合程序运行结果理解程序；了解TreeSet类的用途及常用API。

package treeSet;

import java.util.*;

/**
 * This program sorts a set of item by comparing their descriptions.
 * @version 1.12 2015-06-21
 * @author Cay Horstmann
 */
public class TreeSetTest
{
   public static void main(String[] args)
   {
      SortedSet<Item> parts = new TreeSet<>();
      parts.add(new Item("Toaster", 1234));//add方法
      parts.add(new Item("Widget", 4562));
      parts.add(new Item("Modem", 9912));
      System.out.println(parts);

      NavigableSet<Item> sortByDescription = new TreeSet<>(
            Comparator.comparing(Item::getDescription));

      sortByDescription.addAll(parts);
      System.out.println(sortByDescription);
   }
}

TreeSetTest
package treeSet;

import java.util.*;

/**
 * An item with a description and a part number.
 */
public class Item implements Comparable<Item>//Item类实现Comparable接口
{
   private String description;
   private int partNumber;

   /**
    * Constructs an item.
    * 
    * @param aDescription
    *           the item's description
    * @param aPartNumber
    *           the item's part number
    */
   public Item(String aDescription, int aPartNumber)
   {
      description = aDescription;//字符串
      partNumber = aPartNumber;
   }

   /**
    * Gets the description of this item.
    * 
    * @return the description
    */
   public String getDescription()
   {
      return description;
   }

   public String toString()
   {
      return "[description=" + description + ", partNumber=" + partNumber + "]";
   }//返回该对象的字符串表示

   public boolean equals(Object otherObject)
   {
      if (this == otherObject) return true;
      if (otherObject == null) return false;
      if (getClass() != otherObject.getClass()) return false;
      Item other = (Item) otherObject;
      return Objects.equals(description, other.description) && partNumber == other.partNumber;
   }

   public int hashCode()
   {
      return Objects.hash(description, partNumber);
   }

   public int compareTo(Item other)
   {
      int diff = Integer.compare(partNumber, other.partNumber);
      return diff != 0 ? diff : description.compareTo(other.description);
   }
}

Item

小结：TreeSet是一种自带排序的set，TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式，自然排序 和定制排序。

测试程序4：

使用JDK命令运行HashMapDemo程序，结合程序运行结果理解程序；

import java.util.*;
public class HashMapDemo {
   public static void main(String[] argv) {
      HashMap h = new HashMap();
      // The hash maps from company name to address.
      h.put("Adobe", "Mountain View, CA");//定义对象
      h.put("IBM", "White Plains, NY");
      h.put("Sun", "Mountain View, CA");
      String queryString = "Adobe";
      String resultString = (String)h.get(queryString);
      System.out.println("They are located in: " +  resultString);
  }
}

l 在Elipse环境下调试教材373页程序9-6，结合程序运行结果理解程序；

package map;

import java.util.*;

/**
 * This program demonstrates the use of a map with key type String and value type Employee.
 * @version 1.12 2015-06-21
 * @author Cay Horstmann
 */
public class MapTest
{
   public static void main(String[] args)
   {
      Map<String, Employee> staff = new HashMap<>();//HashMap implements Map
      staff.put("144-25-5464", new Employee("Amy Lee"));
      staff.put("567-24-2546", new Employee("Harry Hacker"));
      staff.put("157-62-7935", new Employee("Gary Cooper"));
      staff.put("456-62-5527", new Employee("Francesca Cruz"));

      // print all entries

      System.out.println(staff);

      // remove an entry

      staff.remove("567-24-2546");

      // replace an entry

      staff.put("456-62-5527", new Employee("Francesca Miller"));

      // look up a value

      System.out.println(staff.get("157-62-7935"));

      // iterate through all entries

      staff.forEach((k, v) -> 
         System.out.println("key=" + k + ", value=" + v));
   }
}

l 实验2：结对编程练习：

关于结对编程：以下图片是一个结对编程场景：两位学习伙伴坐在一起，面对着同一台显示器，使用着同一键盘，同一个鼠标，他们一起思考问题，一起分析问题，一起编写程序。

l 关于结对编程的阐述可参见以下链接：

 http://www.cnblogs.com/xinz/archive/2011/08/07/2130332.html

http://en.wikipedia.org/wiki/Pair_programming

l 对于结对编程中代码设计规范的要求参考：

http://www.cnblogs.com/xinz/archive/2011/11/20/2255971.html

以下实验，就让我们来体验一下结对编程的魅力

l 确定本次实验结对编程合作伙伴；

l 各自运行合作伙伴实验九编程练习1，结合使用体验对所运行程序提出完善建议；

l 各自运行合作伙伴实验十编程练习2，结合使用体验对所运行程序提出完善建议；

1、合作伙伴：张云飞

  • 采用结对编程方式，与学习伙伴合作完成实验九编程练习1； 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.util.Collections;//对集合进行排序、查找、修改等；

public class Test {
    private static ArrayList<Citizen> citizenlist;

    public static void main(String[] args) {
        citizenlist = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);
        File file = new File("E:/java/身份证号.txt");
        //异常捕获
        try {
            FileInputStream fis = new FileInputStream(file);
            BufferedReader in = new BufferedReader(new InputStreamReader(fis));
            String temp = null;
            while ((temp = in.readLine()) != null) {

                Scanner linescanner = new Scanner(temp);

                linescanner.useDelimiter(" ");
                String name = linescanner.next();
                String id = linescanner.next();
                String sex = linescanner.next();
                String age = linescanner.next();
                String birthplace = linescanner.nextLine();
                Citizen citizen = new Citizen();
                citizen.setName(name);
                citizen.setId(id);
                citizen.setSex(sex);
                // 将字符串转换成10进制数
                int ag = Integer.parseInt(age);
                citizen.setage(ag);
                citizen.setBirthplace(birthplace);
                citizenlist.add(citizen);

            }
        } catch (FileNotFoundException e) {
            System.out.println("信息文件找不到");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("信息文件读取错误");
            e.printStackTrace();
        }
        boolean isTrue = true;
        while (isTrue) {

            System.out.println("1.按姓名字典序输出人员信息");
            System.out.println("2.查询最大年龄的人员信息、查询最小年龄人员信息");
            System.out.println("3.查询人员中是否查询人员中是否有你的同乡");
            System.out.println("4.输入你的年龄，查询文件中年龄与你最近人的姓名、身份证号、年龄、性别和出生地");
            System.out.println("5.退出");
            int nextInt = scanner.nextInt();
            switch (nextInt) {
            case 1:
                Collections.sort(citizenlist);
                System.out.println(citizenlist.toString());
                break;
            case 2:
                int max = 0, min = 100;
                int m, k1 = 0, k2 = 0;
                for (int i = 1; i < citizenlist.size(); i++) {
                    m = citizenlist.get(i).getage();
                    if (m > max) {
                        max = m;
                        k1 = i;
                    }
                    if (m < min) {
                        min = m;
                        k2 = i;
                    }
                }
                System.out.println("年龄最大：" + citizenlist.get(k1));
                System.out.println("年龄最小：" + citizenlist.get(k2));
                break;
            case 3:
                System.out.println("出生地：");
                String find = scanner.next();
                String place = find.substring(0, 3);
                for (int i = 0; i < citizenlist.size(); i++) {
                    if (citizenlist.get(i).getBirthplace().substring(1, 4).equals(place))
                        System.out.println("出生地" + citizenlist.get(i));
                }
                break;
            case 4:
                System.out.println("年龄：");
                int yourage = scanner.nextInt();
                int near = peer(yourage);
                int j = yourage - citizenlist.get(near).getage();
                System.out.println("" + citizenlist.get(near));
                break;
            case 5:
                isTrue = false;
                System.out.println("程序已退出!");
                break;
            default:
                System.out.println("输入有误");
            }
        }
    }

    public static int peer(int age) {
        int flag = 0;
        int min = 53, j = 0;
        for (int i = 0; i < citizenlist.size(); i++) {
            j = citizenlist.get(i).getage() - age;
            if (j < 0)
                j = -j;
            if (j < min) {
                min = j;
                flag = i;
            }
        }
        return flag;
    }
}

test
public class Citizen implements Comparable<Citizen> {

    private String name;
    private String id;
    private String sex;
    private int age;
    private String birthplace;

    public String getName() {
        return name;
    }

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

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getage() {
        return age;
    }

    public void setage(int age) {
        this.age = age;
    }

    public String getBirthplace() {
        return birthplace;
    }

    public void setBirthplace(String birthplace) {
        this.birthplace = birthplace;
    }

    public int compareTo(Citizen other) {
        return this.name.compareTo(other.getName());
    }

    public String toString() {
        return name + "\t" + sex + "\t" + age + "\t" + id + "\t" + birthplace + "\n";
    }
}

citizen

l 各自运行合作伙伴实验十编程练习2，结合使用体验对所运行程序提出完善建议；

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;

public class calculator {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Count count=new Count();
        PrintWriter out = null;
        try {
            out = new PrintWriter("test.txt");
            int sum = 0;
            for (int i = 1; i <=10; i++) {
                int a = (int) Math.round(Math.random() * 100);
                int b = (int) Math.round(Math.random() * 100);
                int menu = (int) Math.round(Math.random() * 3);
                switch (menu) {
                case 0:
                    System.out.println(i+":"+a + "+" + b + "=");
                    int c1 = in.nextInt();
                    out.println(a + "+" + b + "=" + c1);
                    if (c1 == (a + b)) {
                        sum += 10;
                        System.out.println("恭喜答案正确");
                    } else {
                        System.out.println("抱歉，答案错误");
                    }
                    break;
                case 1:
                    while (a < b) {
                        b = (int) Math.round(Math.random() * 100);
                    }
                    System.out.println(i+":"+a + "-" + b + "=");
                    int c2 = in.nextInt();
                    out.println(a + "-" + b + "=" + c2);
                    if (c2 == (a - b)) {
                        sum += 10;
                        System.out.println("恭喜答案正确");
                    } else {
                        System.out.println("抱歉，答案错误");
                    }

                    break;
                case 2:
                    System.out.println(i+":"+a + "*" + b + "=");
                    int c3 = in.nextInt();
                    out.println(a + "*" + b + "=" + c3);
                    if (c3 == a * b) {
                        sum += 10;
                        System.out.println("恭喜答案正确");
                    } else {
                        System.out.println("抱歉，答案错误");
                    }

                    break;
                case 3:
                     while(b == 0){
                            b = (int) Math.round(Math.random() * 100);
                        }
                        while(a % b != 0){
                            a = (int) Math.round(Math.random() * 100);
                            
                        }
                    System.out.println(i+":"+a + "/" + b + "=");
                    int c4 = in.nextInt();
                    if (c4 == a / b) {
                        sum += 10;
                        System.out.println("恭喜答案正确");
                    } else {
                        System.out.println("抱歉，答案错误");
                    }

                    break;
                }
            }
            System.out.println("你的得分为" + sum);
            out.println("你的得分为" + sum);
            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

}

calculate
public class Count<T> {
    private T a;
    private T b;
    public Count() {
        a=null;
        b=null;
    }
    public Count(T a,T b) {
        this.a=a;
        this.b=b;
    }
    public int count1(int a,int b) {
        return a+b;
    }
    public int count2(int a,int b) {
        return a-b;
    }
    public int count3(int a,int b) {
        return a*b;
    }
    public int count4(int a,int b) {
        return a/b;
    }
}

count

l 采用结对编程方式，与学习伙伴合作完成实验九编程练习1；

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class Xinxi {
    private static ArrayList<Student> studentlist;

    
    public static  void main(String[] args) {
        studentlist = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);
        File file = new File("D:\\身份证号\\身份证号.txt");
        try {
            FileInputStream fis = new FileInputStream(file);
            BufferedReader in = new BufferedReader(new InputStreamReader(fis));
            String temp = null;
            while ((temp = in.readLine()) != null) {

                Scanner linescanner = new Scanner(temp);

                linescanner.useDelimiter(" ");
                String name = linescanner.next();
                String number = linescanner.next();
                String sex = linescanner.next();
                String age = linescanner.next();
                String province = linescanner.nextLine();
                Student student = new Student();
                student.setName(name);
                student.setnumber(number);
                student.setsex(sex);
                int a = Integer.parseInt(age);
                student.setage(a);
                student.setprovince(province);
                studentlist.add(student);

            }
        } catch (FileNotFoundException e) {//添加的异常处理语句try{   }catch{   }语句
            System.out.println("所找信息文件找不到");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("所找信息文件读取错误");//采取积极方法捕获异常，并将异常返回自己所设定的打印文字
            e.printStackTrace();
        }
        boolean isTrue = true;
        while (isTrue) {
            System.out.println("选择你的操作，输入正确格式的选项");
            System.out.println("1按姓名字典序输出人员信息");
            System.out.println("2.查询最大和最小年龄的人员信息");

            System.out.println("3.寻找年龄相近的人的信息");
            System.out.println("4.寻找老乡");

            System.out.println("5.退出");
            String n = scanner.next();
            switch (n) {
            case "1":
                Collections.sort(studentlist);
                System.out.println(studentlist.toString());
                break;
            case "2":
                int max = 0, min = 100;
                int j, k1 = 0, k2 = 0;
                for (int i = 1; i < studentlist.size(); i++) {
                    j = studentlist.get(i).getage();
                    if (j > max) {
                        max = j;
                        k1 = i;
                    }
                    if (j < min) {
                        min = j;
                        k2 = i;
                    }

                }
                System.out.println("年龄最大：" + studentlist.get(k1));

                System.out.println("年龄最小：" + studentlist.get(k2));
                break;
            case "3":
                System.out.println("家乡在哪里？");
                String find = scanner.next();
                String place = find.substring(0, 3);
                for (int i = 0; i < studentlist.size(); i++) {
                    if (studentlist.get(i).getprovince().substring(1, 4).equals(place))
                        System.out.println("同乡" + studentlist.get(i));
                }
                break;

            case "4":
                System.out.println("年龄：");
                int yourage = scanner.nextInt();
                int near = agenear(yourage);
                int value = yourage - studentlist.get(near).getage();
                System.out.println("" + studentlist.get(near));
                break;
            case "5":
                isTrue = false;
                System.out.println("退出程序!");
                break;
            default:
                System.out.println("输入有误");

            }
        }
    }

    public static int agenear(int age) {
        int j = 0, min = 53, value = 0, flag = 0;
        for (int i = 0; i < studentlist.size(); i++) {
            value = studentlist.get(i).getage() - age;
            if (value < 0)
                value = -value;
            if (value < min) {
                min = value;
                flag = i;
            }
        }
        return flag;
    }

}

xinxi

xinxi
public  class Student implements Comparable<Student> {

    private String name;
    private String number;
    private String sex;
    private String province;
    private int age;

    public void setName(String name) {
        // TODO 自动生成的方法存根
        this.name = name;

    }

    public String getName() {
        // TODO 自动生成的方法存根
        return name;
    }

    public void setnumber(String number) {
        // TODO 自动生成的方法存根
        this.number = number;
    }

    public String getNumber() {
        // TODO 自动生成的方法存根
        return number;
    }

    public void setsex(String sex) {
        // TODO 自动生成的方法存根
        this.sex = sex;
    }

    public String getsex() {
        // TODO 自动生成的方法存根
        return sex;
    }

    public void setprovince(String province) {
        // TODO 自动生成的方法存根
        this.province = province;
    }

    public String getprovince() {
        // TODO 自动生成的方法存根
        return province;
    }

    public void setage(int a) {
        // TODO 自动生成的方法存根
        this.age = age;
    }

    public int getage() {
        // TODO 自动生成的方法存根
        return age;
    }

    public int compareTo(Student o) {
        return this.name.compareTo(o.getName());
    }

    public String toString() {
        return name + "\t" + sex + "\t" + age + "\t" + number + "\t" + province + "\n";
    }
}

student类

student

l 采用结对编程方式，与学习伙伴合作完成实验十编程练习2。

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;

public class calculator {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Count count=new Count();
        PrintWriter out = null;
        try {
            out = new PrintWriter("test.txt");
            int sum = 0;
            for (int i = 1; i <=10; i++) {
                int a = (int) Math.round(Math.random() * 100);
                int b = (int) Math.round(Math.random() * 100);
                int menu = (int) Math.round(Math.random() * 3);
                switch (menu) {
                case 0:
                    System.out.println(i+":"+a + "+" + b + "=");
                    int c1 = in.nextInt();
                    out.println(a + "+" + b + "=" + c1);
                    if (c1 == (a + b)) {
                        sum += 10;
                        System.out.println("恭喜答案正确");
                    } else {
                        System.out.println("抱歉，答案错误");
                    }
                    break;
                case 1:
                    while (a < b) {
                        b = (int) Math.round(Math.random() * 100);
                    }
                    System.out.println(i+":"+a + "-" + b + "=");
                    int c2 = in.nextInt();
                    out.println(a + "-" + b + "=" + c2);
                    if (c2 == (a - b)) {
                        sum += 10;
                        System.out.println("恭喜答案正确");
                    } else {
                        System.out.println("抱歉，答案错误");
                    }

                    break;
                case 2:
                    System.out.println(i+":"+a + "*" + b + "=");
                    int c3 = in.nextInt();
                    out.println(a + "*" + b + "=" + c3);
                    if (c3 == a * b) {
                        sum += 10;
                        System.out.println("恭喜答案正确");
                    } else {
                        System.out.println("抱歉，答案错误");
                    }

                    break;
                case 3:
                     while(b == 0){
                            b = (int) Math.round(Math.random() * 100);
                        }
                        while(a % b != 0){
                            a = (int) Math.round(Math.random() * 100);
                            
                        }
                    System.out.println(i+":"+a + "/" + b + "=");
                    int c4 = in.nextInt();
                    if (c4 == a / b) {
                        sum += 10;
                        System.out.println("恭喜答案正确");
                    } else {
                        System.out.println("抱歉，答案错误");
                    }

                    break;
                }
            }
            System.out.println("你的得分为" + sum);
            out.println("你的得分为" + sum);
            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

}

calculate
public class Count<T> {
    private T a;
    private T b;
    public Count() {
        a=null;
        b=null;
    }
    public Count(T a,T b) {
        this.a=a;
        this.b=b;
    }
    public int count1(int a,int b) {
        return a+b;
    }
    public int count2(int a,int b) {
        return a-b;
    }
    public int count3(int a,int b) {
        return a*b;
    }
    public int count4(int a,int b) {
        return a/b;
    }
}

count

实验总结：

 通过这周的学习，我对Vetor、Stack、Hashtable三个类的用途及常用API有了大致的了解，还大致了解了java集合框架体系组成；基本 掌握ArrayList、LinkList两个类的用途及常用API。了解了HashSet类、TreeSet类的用途及常用API和HashMap、TreeMap两个类的用途及常用API；

不过上述这些都只是有了一个初步的了解，要做到运用自如还要深入研究，苦下功夫。这周学习还有个最大的不同就是体验了程序开发中两人合作的感觉，从有意见不同到最后解决，那个过程很让人享受，有种竞争感和成就感，总之这周收获很大，今后的学习会更加努力！

猜你喜欢

转载自www.cnblogs.com/xuezhiqian/p/9941647.html
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
【转】spring中对控制反转和依赖注入的理解
tms webcore 安装和使用
java程序员进阶相关书籍
SpringMVC接受请求参数、
如何保存训练好的机器学习模型
MyEclipse、Eclipse设置项目JDK的三个地方
商超行业微信小程序开发定制一般多少钱 （行业技术人员解读）
Markdown编辑器语言——30分钟入门到到精通
Linux系统下MongoDB的简单安装与基本操作
Power Strings
每日归档
更多
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022