由 Sun Microsystems 所研究及開發的 Java 語言，應用範圍十分廣泛，從一般的網頁程式，到大型的系統設計，都可以大派用場。而 Java 屬於跨平台語言 (Cross Platforms Language)，意思是程式設計員只要以 Java 編寫程式一次，之後無論在任何操作系統，如 Windows、UNIX、Linux 或 Mac OS 上都可以執行。Java 這種與生俱來的特質，對資訊科技界而言可說是一大突破，亦為電腦程式設計者帶來無限方便。Java 技術已成為 I.T. 界的標準，無論在基礎層面，或是專業領域上都有 Java 的存在，這亦是 Java 在 I.T. 界認受性廣泛的主要原因。

Sun Certified Java Programmer for Java 2 Platform 6.0 必考科目

(310-065) Sun Certified Java Programmer for Java 2 Platform 6.0

適合人仕 : 系統開發人員，程式編寫人員 系統工程師，資訊科技部門主管 / 經理 修讀條件 : - 對 Windows 系統有基本操作經驗 - 對互聯網及 TCP/IP 有基本認識 - 參加者無需擁有程式語言撰寫經驗，惟需具備電腦   基本操作能力 課程包括 : - Sun SCJP for Java 2 筆記及 PDF 電子書   (授課時以英文版課本為主) - 模擬考試試題連參考答案 - 課程實習 CD-ROM 一隻 - 由擁有多年編寫 Java 程式經驗之導師任教

Sun Certified Java Programmer Certificate Sample

Java 2 中文版課本筆記 (第 1 至 4 章節)   310-065 - Sun SCJP Java 2 模擬試題
授課語言 :     以廣東話授課為主，亦會以英語輔助。 課程全長 :     6 堂  / 24 小時 (每堂 4 小時)

開課日期 :      SCJP1026          10 月  26 日 (逢星期日，1 - 5 p.m)   最後 1 位
                          SCJP1130          11 月  30 日 (逢星期日，1 - 5 p.m)  

課程費用 :     原價 $2,380   特價 $ 1,880(只限9月)

                 匯豐信用卡分期 $ 188 x 12 個月

(教學質素保證，如考試不合格的同學，可免費重讀)


現在報讀更可獲得 Sun Certified Java Programmer 多媒體網上教學光碟

    

參加考試 :
考試方面，SCJP 只需要通過一個考試 (Exam 310-065 -- Sun Certified Programmer for Java Platform v6.0)。考試形式以多項選擇題為主，考生需要在 210 分鐘內完成 72 條多項選擇題，合格分數為 65%，考試結果會在考試完結後即時在螢光幕上顯示出來。

報考前的注意事項 :
在報考 SCJP 考試之前，首先要向 Sun Microsystems 香港分公司購買考試卷 (Exam Voucher)，然後再利用考試卷上的編號，登記有關考試。凡修讀本課程之同學，我們將可為你代購考試卷，以及辨理一切考試有關之報名手續 。

Sun Microsystems 香港區辨事處
地址: 香港灣仔港灣道 18 號中環廣場 66 樓
電話: (852) 2202 6688


課程內容 :


Section 1: Declarations, Initialization and Scoping

• Develop code that declares classes (including abstract and all forms of nested classes), interfaces, and enums, and includes the appropriate use of package and import statements (including static imports).
• Develop code that declares an interface. Develop code that implements or extends one or more interfaces. Develop code that declares an abstract class. Develop code that extends an abstract class.
• Develop code that declares, initializes, and uses primitives, arrays, enums, and objects as static, instance, and local variables. Also, use legal identifiers for variable names.
• Develop code that declares both static and non-static methods, and - if appropriate - use method names that adhere to the JavaBeans naming standards. Also develop code that declares and uses a variable-length argument list.
• Given a code example, determine if a method is correctly overriding or overloading another method, and identify legal return values (including covariant returns), for the method.
• Given a set of classes and superclasses, develop constructors for one or more of the classes. Given a class declaration, determine if a default constructor will be created, and if so, determine the behavior of that constructor. Given a nested or non-nested class listing, write code to instantiate the class.

• Develop code that implements an if or switch statement; and identify legal argument types for these statements.
• Develop code that implements all forms of loops and iterators, including the use of for, the enhanced for loop (for-each), do, while, labels, break, and continue; and explain the values taken by loop counter variables during and after loop execution.
• Develop code that makes use of assertions, and distinguish appropriate from inappropriate uses of assertions.
• Develop code that makes use of exceptions and exception handling clauses (try, catch, finally), and declares methods and overriding methods that throw exceptions.
• Recognize the effect of an exception arising at a specified point in a code fragment. Note that the exception may be a runtime exception, a checked exception, or an error.
• Recognize situations that will result in any of the following being thrown: ArrayIndexOutOfBoundsException,ClassCastException, IllegalArgumentException, IllegalStateException, NullPointerException, NumberFormatException, AssertionError, ExceptionInInitializerError, StackOverflowError or NoClassDefFoundError. Understand which of these are thrown by the virtual machine and recognize situations in which others should be thrown programatically.

• Develop code that uses the primitive wrapper classes (such as Boolean, Character, Double, Integer, etc.), and/or autoboxing & unboxing. Discuss the differences between the String, StringBuilder, and StringBuffer classes.
• Given a scenario involving navigating file systems, reading from files, or writing to files, develop the correct solution using the following classes (sometimes in combination), from java.io: BufferedReader,BufferedWriter, File, FileReader, FileWriter and PrintWriter.
• Develop code that serializes and/or de-serializes objects using the following APIs from java.io: DataInputStream, DataOutputStream, FileInputStream, FileOutputStream, ObjectInputStream, ObjectOutputStream and Serializable.
• Use standard J2SE APIs in the java.text package to correctly format or parse dates, numbers, and currency values for a specific locale; and, given a scenario, determine the appropriate methods to use if you want to use the default locale or a specific locale. Describe the purpose and use of the java.util.Locale class.
• Write code that uses standard J2SE APIs in the java.util and java.util.regex packages to format or parse strings or streams. For strings, write code that uses the Pattern and Matcher classes and the String.split method. Recognize and use regular expression patterns for matching (limited to: . (dot), * (star), + (plus), ?, \d, \s, \w, [], ()). The use of *, +, and ? will be limited to greedy quantifiers, and the parenthesis operator will only be used as a grouping mechanism, not for capturing content during matching. For streams, write code using the Formatter and Scanner classes and the PrintWriter.format/printf methods. Recognize and use formatting parameters (limited to: %b, %c, %d, %f, %s) in format strings.

• Write code to define, instantiate, and start new threads using both java.lang.Thread and java.lang.Runnable.
• Recognize the states in which a thread can exist, and identify ways in which a thread can transition from one state to another.
• Given a scenario, write code that makes appropriate use of object locking to protect static or instance variables from concurrent access problems.
• Given a scenario, write code that makes appropriate use of wait, notify, or notifyAll.

• Develop code that implements tight encapsulation, loose coupling, and high cohesion in classes, and describe the benefits.
• Given a scenario, develop code that demonstrates the use of polymorphism. Further, determine when casting will be necessary and recognize compiler vs. runtime errors related to object reference casting.
• Explain the effect of modifiers on inheritance with respect to constructors, instance or static variables, and instance or static methods.
• Given a scenario, develop code that declares and/or invokes overridden or overloaded methods and code that declares and/or invokes superclass, overridden, or overloaded constructors.
• Develop code that implements "is-a" and/or "has-a" relationships.

• Given a design scenario, determine which collection classes and/or interfaces should be used to properly implement that design, including the use of the Comparable interface.
• Distinguish between correct and incorrect overrides of corresponding hashCode and equals methods, and explain the difference between == and the equals method.
• Write code that uses the generic versions of the Collections API, in particular, the Set, List, and Map interfaces and implementation classes. Recognize the limitations of the non-generic Collections API and how to refactor code to use the generic versions.
• Develop code that makes proper use of type parameters in class/interface declarations, instance variables, method arguments, and return types; and write generic methods or methods that make use of wildcard types and understand the similarities and differences between these two approaches.
• Use capabilities in the java.util package to write code to manipulate a list by sorting, performing a binary search, or converting the list to an array. Use capabilities in the java.util package to write code to manipulate an array by sorting, performing a binary search, or converting the array to a list. Use the java.util.Comparator and java.lang.Comparable interfaces to affect the sorting of lists and arrays. Furthermore, recognize the effect of the "natural ordering" of primitive wrapper classes and java.lang.String on sorting.

• Given a code example and a scenario, write code that uses the appropriate access modifiers, package declarations, and import statements to interact with (through access or inheritance) the code in the example.
• Given an example of a class and a command-line, determine the expected runtime behavior.
• Determine the effect upon object references and primitive values when they are passed into methods that perform assignments or other modifying operations on the parameters.
• Given a code example, recognize the point at which an object becomes eligible for garbage collection, and determine what is and is not guaranteed by the garbage collection system. Recognize the behaviors of System.gc and finalization.
• Given the fully-qualified name of a class that is deployed inside and/or outside a JAR file, construct the appropriate directory structure for that class. Given a code example and a classpath, determine whether the classpath will allow the code to compile successfully.
• Write code that correctly applies the appropriate operators including assignment operators (limited to: =, +=, -=), arithmetic operators (limited to: +, -, *, /, %, ++, --), relational operators (limited to: <, <=, >, >=, ==, !=), the instanceof operator, logical operators (limited to: &, |, ^, !, &&, ||), and the conditional operator ( ? : ), to produce a desired result. Write code that determines the equality of two objects or two primitives.