CSCI213/ITCS907
Spring Session, 2003 Assignment 1: Beginning Java and learning to use the JDK You should complete "Laboratory Exercise 1" before starting this assignment.Aren't you lucky! The submission date has been fixed. The subject outline said start of week 4 but really meant end of week 4.Aims
Objectives
Overview of assignment
Resources
Tasks
Submission
Marking --------------------------------------------------------------------------------AimsThis assignment aims to establish a basic familiarity with the Java Development Kit (JDK) and its associated on-line class documentation. It also introduces the use of some simple Java library (package) classes including I/O reader/printer classes, strings, collections and their associated iterators.You will soon learn that the biggest difference from C++ is that you write very little of your Java programs and you almost never start from scratch. Instead, you construct your programs mainly through the use of library classes. Typically, you start by taking an existing Java program that is similar to what you want, you strip the bits that you don't need and then build up your new program. You gradually acquire a collection of reusable code fragments for things like simple standard graphical user interfaces.The assignment involves several versions of essentially the same program; these versions introduce increasingly object-based, Java-oriented styles of solution to a problem. All versions of the program count toward your assignment .
--------------------------------------------------------------------------------ObjectivesThe programs for this assignment involve processing a collection of simple records of student s. The files contain data with student identifier, name, and s for assignments and final examination. The programs generate reports on grades and a ranked listing of the students.Five versions of the program are implemented. The versions start with simple procedural code manipulating simple data records and move toward more object-based styles that make increasing use of features of the Java language and its libraries.On completion of these tasks you should be able to: code and run Java programs using the development environment (simple text-editor - Windows NotePad or something equivalent, "javac" compiler, and "java" run-time interpreter).
make effective use of the on-line documentation system that supports the development environment.
code programs using Java in a hybrid style (procedural code using instances of simple classes) and in a more object-based style.
use collection and associated iterator classes from the java.util package.
manipulate string data. --------------------------------------------------------------------------------Overview of assignmentThe assignment involves the following parts:Writing some simple procedural style code that reads the contents of a file; storing the data in simple arrays, and sorting data. This part introduces String, PrintWriter, BufferedReader and similar classes.
The program works entirely with instances of classes from the standard libraries. Your own code is procedural, rather like the code for you C/C++ programs; so the overall program is hybrid - a procedural main-line making some use of instances of simple classes.
You have to implement a sorting function. You can choose your favorite algorithm from CSCI121: bubble sort, selection sort, insertion sort (the data sets are small so there is no need for sophisticated algorithms like quicksort).
For the second stage, you define a simple application specific class. This StudentRecord class defines a type of object that can hold the data for a single student record. The program is modified to use an array of these StudentRecord objects rather than separate arrays with student name, etc.
In the next stage, you make better use of Java. The Java system already comes with sophisticated sorting algorithms implemented in its libraries. You must modify your program to utilize these features. The sorting criteria are also made more stringent.
The Arrays class supplies the sorting algorithm. Arrays is not class for which you can create objects; instead it is a module that supplies a group of related functions that are useful for manipulating arrays of Java objects from other classes. The sort functions provided in the Arrays class can be used to sort arrays of any type of object that know how to compare themselves!
Many of the classes in the Java libraries define compareTo functions that allow instances to be compared and therefore sorted. The String class is an example; it has a compare function that will arrange for the string "Hello World" to be sorted before the string "Hi Mum". The Date class is another that defines comparable objects; it allows the data March 13th 1987 to be sorted before Jan 11th 1992.
Classes that want their instances to be sorted must implement the Comparable interface. Implementing the Comparable interface really means that the class supplies a function int compareTo(Object other) that returns a negative value if this object is "smaller" than other, 0 if they are equal, and positive value if this object is "larger" than other.
In order to use Arrays sort functions, you must extend your StudentRecord class so that it implements Comparable. The required compareTo function can be made reasonably sophisticated. In the earlier versions of the program, student records are simply sorted by total . Now the sort criteria can be made more exact so that students with the same appear in alphabetic order by name and initials.
The first three versions of the program have to preallocate arrays of fixed size (arrays of Strings and ints for part-1, arrays of StudentRecords for parts 2 and 3). Working with fixed size arrays is inconvenient because you have to create the arrays before you know how much data you must process (number of student records in the file).
Usually, it is better to utilize collection classes. You create an empty collection, and add data to it as necessary.
Java provides a variety of collection classes. The one that you will use most often is Vector; this is a simple dynamic array class where the array resizes when you add more elements. Another class is a form of linked list.
Some of Java's collection classes are designed for comparable data such as your improved StudentRecord objects. These classes maintain sorted collections - the data are kept in correctly sorted order. For this part of the assignment, you will be using a TreeSet collection.
Collection classes have associated iterators that allow a program to process each element from the collection in turn. The for loops that were used in earlier versions of the program will now be replaced with code that uses an iterator associated with your TreeSet collection.
The final version adopts a more truly object based style with an Mark Reporter class whose task is to read data from a student records file and produce reports on those data.
Spring Session, 2003 Assignment 1: Beginning Java and learning to use the JDK You should complete "Laboratory Exercise 1" before starting this assignment.Aren't you lucky! The submission date has been fixed. The subject outline said start of week 4 but really meant end of week 4.Aims
Objectives
Overview of assignment
Resources
Tasks
Submission
Marking --------------------------------------------------------------------------------AimsThis assignment aims to establish a basic familiarity with the Java Development Kit (JDK) and its associated on-line class documentation. It also introduces the use of some simple Java library (package) classes including I/O reader/printer classes, strings, collections and their associated iterators.You will soon learn that the biggest difference from C++ is that you write very little of your Java programs and you almost never start from scratch. Instead, you construct your programs mainly through the use of library classes. Typically, you start by taking an existing Java program that is similar to what you want, you strip the bits that you don't need and then build up your new program. You gradually acquire a collection of reusable code fragments for things like simple standard graphical user interfaces.The assignment involves several versions of essentially the same program; these versions introduce increasingly object-based, Java-oriented styles of solution to a problem. All versions of the program count toward your assignment .
--------------------------------------------------------------------------------ObjectivesThe programs for this assignment involve processing a collection of simple records of student s. The files contain data with student identifier, name, and s for assignments and final examination. The programs generate reports on grades and a ranked listing of the students.Five versions of the program are implemented. The versions start with simple procedural code manipulating simple data records and move toward more object-based styles that make increasing use of features of the Java language and its libraries.On completion of these tasks you should be able to: code and run Java programs using the development environment (simple text-editor - Windows NotePad or something equivalent, "javac" compiler, and "java" run-time interpreter).
make effective use of the on-line documentation system that supports the development environment.
code programs using Java in a hybrid style (procedural code using instances of simple classes) and in a more object-based style.
use collection and associated iterator classes from the java.util package.
manipulate string data. --------------------------------------------------------------------------------Overview of assignmentThe assignment involves the following parts:Writing some simple procedural style code that reads the contents of a file; storing the data in simple arrays, and sorting data. This part introduces String, PrintWriter, BufferedReader and similar classes.
The program works entirely with instances of classes from the standard libraries. Your own code is procedural, rather like the code for you C/C++ programs; so the overall program is hybrid - a procedural main-line making some use of instances of simple classes.
You have to implement a sorting function. You can choose your favorite algorithm from CSCI121: bubble sort, selection sort, insertion sort (the data sets are small so there is no need for sophisticated algorithms like quicksort).
For the second stage, you define a simple application specific class. This StudentRecord class defines a type of object that can hold the data for a single student record. The program is modified to use an array of these StudentRecord objects rather than separate arrays with student name, etc.
In the next stage, you make better use of Java. The Java system already comes with sophisticated sorting algorithms implemented in its libraries. You must modify your program to utilize these features. The sorting criteria are also made more stringent.
The Arrays class supplies the sorting algorithm. Arrays is not class for which you can create objects; instead it is a module that supplies a group of related functions that are useful for manipulating arrays of Java objects from other classes. The sort functions provided in the Arrays class can be used to sort arrays of any type of object that know how to compare themselves!
Many of the classes in the Java libraries define compareTo functions that allow instances to be compared and therefore sorted. The String class is an example; it has a compare function that will arrange for the string "Hello World" to be sorted before the string "Hi Mum". The Date class is another that defines comparable objects; it allows the data March 13th 1987 to be sorted before Jan 11th 1992.
Classes that want their instances to be sorted must implement the Comparable interface. Implementing the Comparable interface really means that the class supplies a function int compareTo(Object other) that returns a negative value if this object is "smaller" than other, 0 if they are equal, and positive value if this object is "larger" than other.
In order to use Arrays sort functions, you must extend your StudentRecord class so that it implements Comparable. The required compareTo function can be made reasonably sophisticated. In the earlier versions of the program, student records are simply sorted by total . Now the sort criteria can be made more exact so that students with the same appear in alphabetic order by name and initials.
The first three versions of the program have to preallocate arrays of fixed size (arrays of Strings and ints for part-1, arrays of StudentRecords for parts 2 and 3). Working with fixed size arrays is inconvenient because you have to create the arrays before you know how much data you must process (number of student records in the file).
Usually, it is better to utilize collection classes. You create an empty collection, and add data to it as necessary.
Java provides a variety of collection classes. The one that you will use most often is Vector; this is a simple dynamic array class where the array resizes when you add more elements. Another class is a form of linked list.
Some of Java's collection classes are designed for comparable data such as your improved StudentRecord objects. These classes maintain sorted collections - the data are kept in correctly sorted order. For this part of the assignment, you will be using a TreeSet collection.
Collection classes have associated iterators that allow a program to process each element from the collection in turn. The for loops that were used in earlier versions of the program will now be replaced with code that uses an iterator associated with your TreeSet collection.
The final version adopts a more truly object based style with an Mark Reporter class whose task is to read data from a student records file and produce reports on those data.
解决方案 »
- 大家都说初学java 应该多练习，多写代码，我想知道具体应该练习些什么
- java数组的小问题
- 非常菜鸟的问题！
- 长见但是一直不清楚具体的啊
- ★★★★★如果对Java代码进行可订制裁减★★★★★
- 请大家帮忙看下这个Date的问题，解决马上给分~
- java test 的时候就出现下面的错误
- 我想請問一下：從來沒有學過java, 我想從java的數據結構開始學習java, 直接學習java的算法， 不直到好不好? :)
- 求助!一个很简单的JDBC问题,立刻给分
- BufferedReader 无法定义是怎么回事，哪位大神帮忙看一下
- Java2图形设计 卷2:SWING 这本书如何，请大家给个评价吧
- 用JAVA怎么取得网卡的MAC地址
student's family name
student's initials
five real numbers representing the s that the student obtained in each of the five ten assignments
a final real number representing the in a final examination.
Example data are:u98443516 Ash TP 5 6.5 7 3 8 31
u87343021 Bennet VN 0 0 0 0 0 2
u79124691 Brenner JH 10 10 10 10 10 21There are several hundred records in the file.The following code fragment illustrates how such data may be read and processed. It produces an output listing showing student identifier, total , and total scaled according to the formula used by SITACS (the one that reduces assignment s when students fail examinations). (This code fragment is the starting point from which you develop your solutions to the assignment - as noted earlier, you very rarely start a Java program from scratch, you almost always modify existing code.)import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;public class A1 {
public static void main(String[] args) {
if(args.length!=1){
System.out.println("An input filename must be specified as a command line argument");
System.exit(1);
}
String filename = args[0];
FileReader fileInput = null;
try {
fileInput = new FileReader(filename);
}
catch(Exception e){
System.out.println("Failed to get file because" + e);
System.exit(1);
}
process(fileInput);
} private static void process(FileReader fileinput)
{
BufferedReader input = new BufferedReader(fileinput);
for(;;) {
String line = null;
try{
line = input.readLine();
}
catch(IOException ioe) { break; }
if(line == null) break; // Hit physical end of file
if(line.equals("")) break; // There may be blank lines at end of file
// This is a simple but rather dumb way of splitting up a line of input
// It is using the tab (\t) characters that separate the fields
// You will implement better mechanisms later in the assignment.
// The indexOf method of String is being used to find the next tab character
// after the specified starting point.
// A substring is then pulled from the String "line". int pos1 = 0;
int pos2 = 0;
pos2 = line.indexOf('\t', pos1);
String identifier = line.substring(0, pos2);
pos1 = pos2+1;
pos2 = line.indexOf('\t',pos1);
String familyName = line.substring(pos1, pos2);
pos1 = pos2+1;
pos2 = line.indexOf('\t',pos1);
String initials = line.substring(pos1, pos2);
// Obtain the s as String data elements
pos1 = pos2+1;
pos2 = line.indexOf('\t',pos1);
String A1 = line.substring(pos1,pos2);
pos1 = pos2+1;
pos2 = line.indexOf('\t',pos1);
String A2 = line.substring(pos1,pos2);
pos1 = pos2+1;
pos2 = line.indexOf('\t',pos1);
String A3 = line.substring(pos1,pos2);
pos1 = pos2+1;
pos2 = line.indexOf('\t',pos1);
String A4 = line.substring(pos1,pos2);
pos1 = pos2+1;
pos2 = line.indexOf('\t',pos1);
String A5 = line.substring(pos1,pos2);
// Remainder of line should contain exam
pos1 = pos2+1;
String Exam = line.substring(pos1);
// Convert strings to numeric values and calculate total
// and scaled
double totalMark = 0.0;
int scaledMark = 0;
try {
double = 0.0;
= Double.parseDouble(A1);
totalMark += ;
= Double.parseDouble(A2);
totalMark += ;
= Double.parseDouble(A3);
totalMark += ;
= Double.parseDouble(A4);
totalMark += ;
= Double.parseDouble(A5);
totalMark += ;
= Double.parseDouble(Exam);
totalMark += ;
scaledMark = scaleMark(, totalMark);
}
catch(NumberFormatException nfe){
System.out.println("Invalid data for record " + identifier);
System.exit(1);
}
System.out.println(identifier +"\t"+totalMark + "\t" + scaledMark);
}
try {
input.close();
}
catch(IOException ioe) {}
}
private static int scaleMark(double examMark, double totalMark)
{
// SITACS authorized fudging of s to downgrade assignments
// when exam result suggests student probably didn't do the assignment work
double finalMark = 0.0;
if(examMark >= 25.0) { finalMark = totalMark; }
else {
double assignmentMark = totalMark - examMark;
finalMark = examMark + (examMark*assignmentMark)/25.0;
}
// Further fudging of s to avoid tiresome appeals from pestilential students
if((finalMark >=43.0)&&(finalMark<45.0))finalMark=45.0;
else
if((finalMark >=48.0) &&(finalMark<50.0))finalMark=50.0;
else
if((finalMark>=63.5 )&& (finalMark<65.0))finalMark=65.0;
else
if((finalMark>=73.5) && (finalMark<75.0))finalMark=75.0;
else
if((finalMark>=83.5) && (finalMark<85.0))finalMark=85.0;
return ((int)(finalMark+0.5)); // round to nearest integer
}
}
The example code can be compiled:javac A1.javaand run, with input redirected from a data file:
java A1 data.txtThe main program creates a FileReader object ("input") that can be used to extract character data from a file. This FileReader object is passed to the process function. The process function first "wraps" the FileReader object inside a BufferedReader object. A BufferedReader is more useful in that it allows the program to read input data line by line. The program then has a loop to read all the lines in the file; the readLine operation of a BufferedReader returns the next line. If the physical end of file is encountered, readLine returns null. (The program checks for an empty line,""; there may be some blank lines at the end of the data before the physical end of file.) The loop terminates when all input data have been processed. The data in a line of the file is obtained as a java.lang.String object. String objects cannot be changed after creation. The String class defines methods for obtaining substrings, finding characters, etc. These methods are used to extract the data elements in the tab separated fields of the input line. (It is possible for some file download systems to substitute sequences of spaces for the tab characters in the data file. If this hapens, you will have to edit the modified data file to change spaces back to tabs). The example code finds the positions of these tab characters and uses this information to create substrings with identifier, time, and s data. The String (text) data for the s are then converted to numeric values. Java I/O is a little laborious. Static methods defined in the Integer, Float, and Double classes have to be used to "parse" character data and convert the data to numeric values. These conversions are done in a big try-catch block; a NumberFormatException will get thrown if any of the strings contain characters other than digits, decimal point, etc.The required data are printed using the out object belonging to the System class. This "PrintWriter" object is just cout and should be familiar from your C++ days. Java doesn't have C++ style output operators, instead one uses member functions of the PrintWriter class.
--------------------------------------------------------------------------------
Part2 Defining your own class.
Part3 Defining a Comparable class and using Java sorting.
Part4 Using a collection class and an iterator.
Part15 Defining "Mark Reporter" class. --------------------------------------------------------------------------------Procedural code using basic Java classesWrite a program (stored in file Part1.java with public class Part1) that reads the data from the file, storing each student's identifier, name and initials (three arrays of String objects) and scaled final (an array of int values). The arrays are sorted by final and the results are printed.Your Part1.java program will: Define a constant that specifies the size of arrays that are to be created.
Define static data members representing the arrays, and a count of records in the file.
Has a main function that obtains a filename as a command line argument, opens this file, and passes the opened FileReader object to a "process" function. (All functions are static, make sure you understand why static members and functions are being defined in this example.)
Has a process function that:
creates the actual arrays (make sure you understand the difference between the array declarations and the array creation);
invokes a function that will read the data file, maintain a count of items read, and store the required data in the arrays; this function uses the scaleMark function shown above to calculate the final from the s for the assessment tasks;
invokes a function that sorts the arrays so that the records are correctly ordered in descending order by (details with the student with the highest are placed first);
invokes a function that prints the sorted data.
The data file provided should result in output similar to the following:u24578531 Restah IP 93
u45678762 Craven PH 92
u24572420 Monet AS 90
u98717621 Coles AR 87
...
u87343021 Bennet VN 2
u75491100 Fifley OP 0
u25792266 Bleamish BN 0Your Part1.java program has a single public class Part1 that contains the declarations of all static data members and static functions.
--------------------------------------------------------------------------------Defining your own classImplement a new version of the program (public class Part2 in file Part2.java). The Part2.java file contains the definition both your main Part2 class that organizes the processing and a simple "Student record" class that you define to hold data for an individual student.Your "Student record" class will:own:
String data members for student identifier, name, and initials
an array of six double values for the five assignment s and the exam
an integer final
provide:
a constructor that takes the string and numeric values for the s as are needed to initialize the data members when a "Student record" object is created. The constructor is to use the static scaleMark function in your Part2 class to calculate the final for the student. (Note that you will have to adjust access permissions for this function.)
a String toString() function that returns a string with tab separated identifier, name, initals, and final data values.
All data and function members are to be public. At this stage, a "Student record" object is really being used as a simple "struct" just to hold data needed by other parts of the program. Normally, data members are private.Your Part2 class is similar to that implemented as Part1. The main difference is that it owns a single array of "Student record" objects instead of arrays for separate String and int variables. This should result in some tidying up of the functions for sorting and listing of the data.When run on the same input file, the revised program should produce identical output to that obtained earlier.
--------------------------------------------------------------------------------Defining a Comparable class and using Java sortingA new version of the program should be created as public class Part3 in file Part3.java. This file will also contain the declaration of a revised version of your "Student record" class.
--------------------------------------------------------------------------------Comparable classes
A "comparable" class is one that implements the Comparable interface, which really means that it defines a compareTo function.The following example code illustrates this approach. The main program (main() in public class OrderDemo) creates a number of "Boxes" and performs comparisons on them.A Box is something with width, breadth, height, and color. Boxes are sorted first by volume, if their volumes are equal they are sorted by color name, and if these are equal they are sorted by an automatically assigned integer identifier. This box class was designed for use with a sorted collection so it implements the Comparable interface and defines its compareTo method.Here are the class definitions:class Box implements Comparable {
private static int idCount = 0;
private int id;
private int width;
private int length;
private int height;
private String color; public Box(int w, int l, int h, String c) {
width = w;
length = l;
height = h;
color = c;
id = ++idCount;
} public long getVolume() { return width*length*height; } public int compareTo(Object o) {
// Can only compare boxes
// Cast other reference to Box (runtime exception
// occurs if other thing wasn't a Box)
Box other = (Box) o;
long val = getVolume() - other.getVolume();
if(val != 0) return (int)val;
// If boxes have same volume, then sort by color
val = color.compareTo(other.color);
if(val != 0) return (int)val;
return (int) (id - other.id);
} public String toString() {
StringBuffer sb = new StringBuffer();
sb.append("Box ");
sb.append(id);
sb.append(", Volume ");
sb.append(getVolume());
sb.append(", Color ");
sb.append(color);
return sb.toString();
}}public class OrderDemo { public static void main(String[] args) {
Box b1 = new Box(7, 8, 9, "red");
System.out.println(b1);
Box b2 = new Box(3, 13, 12, "yellow");
System.out.println(b2);
// b1 should be bigger than b2
if(b1.compareTo(b2)<0) System.out.println("b1 is 'smaller' than b2");
else
if(b1.compareTo(b2)==0) System.out.println("b1 and b2 are 'equal'");
else System.out.println("b1 is 'bigger' than b2"); Box b3 = new Box(2, 4, 63, "blue");
System.out.println(b3);
// b1 should be bigger than b3
// (equal volume but 'red' bigger than 'blue')
if(b1.compareTo(b3)<0) System.out.println("b1 is 'smaller' than b3");
else
if(b1.compareTo(b3)==0) System.out.println("b1 and b3 are 'equal'");
else System.out.println("b1 is 'bigger' than b3");
Box b4 = new Box(4, 2, 63, "red");
System.out.println(b4);
// b1 should be smaller than b4 (by identifier)
if(b1.compareTo(b4)<0) System.out.println("b1 is 'smaller' than b4");
else
if(b1.compareTo(b4)==0) System.out.println("b1 and b4 are 'equal'");
else System.out.println("b1 is 'bigger' than b4");
}
}
A compareTo() function must have the signature:public int compareTo(Object o)Boxes can only be really compared with other boxes (if you try to compare a box with a String, you have made a programming error and your program will die). So, the only valid argument to the Box.compareTo(Object) method must be a reference to another Box. Hence the type cast: Box other = (Box) o;The rest of the compareTo code compares by volume (and if the volumes are equal, compares by color, etc).
--------------------------------------------------------------------------------
Where students have the same , they are to be ordered alphabetically by name;
Students with the same s and names are to be ordered alphabetically by their initials;
If the records are still equal, they are to be ordered by (unique) student identifiers.
You should further modify the class so that the function that reads the input lines now employs a StringTokenizer to separate out the individual elements. Use of a StringTokenizer should result in much cleaner looking code than the earlier version based on the example code.Consult the Java package documentation to find out about class Arrays and its (static) sort functions. Rewrite your code so that the appropriate sort method from Arrays is used to sort your array of "student record" objects.Note that the data members in your "Student record" class can now be made private because they no longer need to be made directly available to a sorting function defined in a different class.
--------------------------------------------------------------------------------Using a collection class and an iteratorThe next version of the program should be created as public class Part4 in file Part4.java.You need to rewrite your previous Part3 class, removing the declarations of the constant (for array size) and the array data elements etc, replacing them with a declaration for a TreeSet (this will also require an import statement at the start of your file).Instead of creating arrays, your program will create an instance of a TreeSet. Your function that reads data and creates "student record" objects will simply add them to the TreeSet. You no longer require a sort step; the TreeSet sorts the data as they are added.Change the function that lists the sorted data so that it uses an Iterator rather than a coded for loop.
--------------------------------------------------------------------------------Defining "Mark Reporter" classThe final version of the program should be created as public class Part5 in file Part5.java. This file will also contain the definition of a new "Mark Reporter" class in addition to your "Student record" class..
The Part5 class becomes a simple stub that:checks for command line input arguments;
creates a FileReader for the input file;
creates a "Mark Reporter" object
asks its "Mark Reporter" to read data from the opened file;
asks its "Mark Reporter" to list the students and their final s as in previous versions of the program;
asks its "Mark reporter" to produces summary data on percentages of students obtaining different grades.
Your "Mark Reporter" class:owns private instance of a TreeSet;
has a public no argument constructor that performs initialization tasks (such as creation of the actual TreeSet object);
has a public method that takes a FileReader as an input argument; this method reads the data in the file, creating comparable student record objects that are added to the TreeSet;
has the public static scaleMark function that was originally part of your main Partx class;
has a public function that can be invoked to list student details on System.out;
has a public function that can be used to produce details of the percentages of students with different grades.
(The class could define additional methods that provide statictics on s in the different assignments etc. These methods are not required in this assignement.)The program should produce data like the following:u24578531 Restah IP 93
u45678762 Craven PH 92
...
u25792266 Bleamish BN 0
u75491100 Fifley OP 0
HDs 10 (4%)
Ds 28 (11%)
CRs 65 (26%)
Ps 94 (38%)
PCs 12 (4%)
Fs 36 (14%)
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------MarkingThis information is primarily for the tutors who will be ing the assignment; but some of you might be interested.Mark to 0.5 divisions, no 0.1 fractional s!Five parts to each part worth 2 s. One is for correct operation of the program, the other is for coding style issues.Common problems include: poor choice of identifiers, bad indentation, failure to break code into small well defined functions, failure to use class (static) and instance members correctly, failure to define constants properly, errors involving redundant creation of objects (eg String str = new String(); str = input.readLine(); ); failure to use the specified classes from Java libraries; failure to check for input errors; failure to comply with functional specifications of programs; dead code (later versions of the program derive from earlier versions, but code is dropped as well as added - make sure it is dropped). Give the student 1 if you feel the code is fine, 0.5 if there are one or two problems, 0 s if there are more than a couple of problems.Only penalize the student once for a mistake that is systematically repeated in all subsequent parts.
这都成专业英语考试了，不是java作业题
TasksPart1 Procedural code using basic Java classes.
Part2 Defining your own class.
Part3 Defining a Comparable class and using Java sorting.
Part4 Using a collection class and an iterator.
Part15 Defining "Mark Reporter" class.
[email protected]
谢谢（我好好帮你做:-))
问题不难,看懂了就容易了
其实难在都是英文，呵呵！
不过给分没用的
这边带做作业视难度收取100~1500加拿大元的报酬
就100美元好了
paypal支付
以上全部是事实
本人不过开个玩笑拜托转告您那位留学垃圾同学
不要再丢中国人的脸了
要有一些SOURCE的...资料太多了,看了一些很晕的感觉!
其实.它的要求好象对JAVA的技术性不是很强.
告诉你的朋友上网找找就得了!
In past years, roughly 10% - 15% of CSC*** students have been convicted of academic offenses. We are (unfortunately for us and our workload) very good at detecting cheating. Please don't do it. If you are desperate enough that you are considering cheating please do everyone a favour: come get help from a professor or a TA, visit the Help Center, or just don't submit the assignment. You are responsible for your own assignment, the first commitment to cheating will lead the second ........