北京金同方计算机培训,考试认证
当前位置:中招首页 -> IT培训 -> 国外认证 -> SUN认证 -> 复习指导 -> 
SCJP1.4高效率复习提纲

2006-02-28 11:35:02 来源:未知
  SECTION 1: DECLARATIONS AND ACCESS CONTROL
  1. An identifier in java must begin with a letter, a dollar sign($), or an underscore (_); subsequent characters may be letters, dollar signs, underscores, or digits.
  2. All the keywords in java are comprised of lower case characters only.
  3. There are three top-level elements that may appear in a file. None of these elements is required. If they are present, then they must appear in the following order:
    -package declaration
    -import statements
    -class definitions
  4. A Java source file (Java file) cannot have more than one public class, interface or combination of both.
  5. The variables in an interface are implicitly public, final and static. If the interface, itself, is declared as public the methods and variables are implicitly public.
  6. Variables cannot be synchronized.
  7. The variables in Java can have the same name as method or class.
  8. A transient variable may not be serialized.
  9. The transient keyword is applicable to variables only.
  10. The native keyword is applicable to methods only.
  11. The final keyword is applicable to methods, variables and classes.
  12. The abstract keyword is applicable to methods and classes.
  13. The static keyword is applicable to variables, methods or a block of code called static initializers.
  14. A native method cannot be abstract but it can throw exception(s).
  15. A final class cannot have abstract methods.
  16. An abstract class might not have any final methods.
  17. All methods of a final class are automatically final.
  18. Interfaces cannot be final and should not be declared abstract.
  19. The visibility of the class is not limited by the visibility of its members. I.e. A class with the entire members declared private can still be declared public.
  20. Interface methods cannot be native, static, synchronized, final, private, protected or abstract. They are implicitly public, abstract and non-static.
  21. The statement float f = 5.0; will give compilation error as default type for floating values is double and double cannot be directly assigned to float without casting. But f=5.0f is ok.
  22. A constructor cannot be native, abstract, static, synchronized or final.
  23. Be careful for static and abstract keyword in the program.
  24. Also be careful for private keyword in front of a class as top level classes or interfaces cannot be private.
  25. friendly is not a java keyword. This is often used as an alternate word in java literature to indicate the default access level by placing no modifier like public, private or protected in front of members of classes and interfaces.
  26. A local variable, already declared in an enclosing block and therefore visible in a nested block, cannot be redeclared in the nested block.
  27. Array in Java can be declared and defined like ---
     int[] count = null; int []count = null; int count[] = null;
     int count[] = new int[50]; int count[] = {5,10,15,20,25}
  SECTION 2: FLOW CONTROL, ASSERTIONS, AND EXCEPTION HANDLING
  28.Three types of statements regarding flow controls are used in Java:
     * Selection statements ' if…else, switch…case, try…catch…finally
     * Iteration statement ' while, do…while, for
     * Transfer statement ' return, break, continue
  29.The argument to switch can be either byte, short, char or int. Be careful about long, float, double or boolean as argument to switch.
  30.The expression for an if and while statement in Java must be a boolean.
  31.Breaking to a label (using break ;) means that the loop at the label will be terminated and any outer loop will keep iterating. While a continue to a label (using continue ;) continues execution with the next iteration of the labeled loop.
  32.The if() statement in Java takes only boolean as an argument. Note that if (a = true){}, provided a is of type boolean is a valid statement then code inside the if block will be executed otherwise skipped.
  33.The (-0.0 == 0.0) will return true, while (5.0 == -5.0) will return false.
  34. An assertion is a conditional expression that should evaluate to true if and only if your code is working correctly. If the expression evaluates to false, an error is signaled. Assertions are like error checks, except that they can be turned completely off, and they have a simpler syntax.
  34.AssertionError is the immediate subclass of java.lang.Error.
  35.assert is a java keyword from JDK1.4. So it cannot be used as an identifier from JDK1.4 or later. But as other JDK versions (JDK1.3 or earlier) had no keyword named assert, an interesting backward compatibility problem arises for those programs that used assert as a java identifier.
  36.Assertion checks can be turned on and off at runtime. By default, assertion mechanism is turned off. When assertions are off, they don't use system resources.
  37.The command for compiling a source using Java's new assertion feature is javac -source 1.4 filename.java. But if -source argument is not mentioned like javac filename.java, it will be assumed like javac -source 1.3 filename.java so that existing code compiles correctly even if it uses assert as a regular identifier.
  38.Remember that Assertions can be enabled and disabled for specific packages as well as specific classes. For example, assertions can be enabled in general but disabled for a particular package.
  39.One of the most common uses of assertions is to ensure that the program remains in a consistent state. Assertions are not alternative to exception handling rather complementary mechanism to improve discipline during development phase.
  40.Assertions may be used in the situations like:
    * to enforce internal assumptions about aspects of data structures.
    * to enforce constraints on arguments to private methods.
    * to check conditions at the end of any kind of method.
    * to check for conditional cases that should never happen.
    * to check related conditions at the start of any method.
    * to check things in the middle of a long-lived loop.
  41.Assertions may not be used in the situations like:
    * to enforce command- line usage.
    * to enforce constraints on arguments to public methods.
    * to enforce public usage patterns or protocols.
    * to enforce a property of a piece of user supplied information.
    * as a shorthand for if ( something) error();
    * as an externally controllable conditional.
    * as a check on the correctness of your compiler, operating system, or hardware, unless you have a specific
  42.reason to believe there is something wrong with it and is in the process of debugging it.
  43.An overriding method may not throw a checked exception unless the overridden method also throws that exception or a superclass of that exception.
  44.The java.lang.Throwable class has two subclasses: Exception and Error.
  45.An Error indicates serious problems that a reasonable application should not try to catch. Most such errors are abnormal conditions.
  46.The two kinds of exceptions in Java are: Compile time (Checked) and Run time (Unchecked) exceptions. All subclasses of Exception except the RunTimeException and its subclasses are checked exceptions.
    Examples of Checked exception: IOException, ClassNotFoundException.
    Examples of Runtime exception: ArrayIndexOutOfBoundsException, NullPointerException, ClassCastException, ArithmeticException, NumberFormatException.
  47.The unchecked exceptions do not have to be caught.
  48.A try block may not be followed by a catch but in that case, finally block must follow try.
  49.While using multiple catch blocks, the type of exception caught must progress from the most specific exception to catch to the superclass(es) of these exceptions.
  50.More than one exception can be listed in the throws clause of a method using commas. e.g. public void myMethod() throws IOException, ArithmeticException.
  51.Dividing an integer by 0 in Java will throw ArithmeticException.
  
  SECTION 3: GARBAGE COLLECTION
  52. Setting the object reference to null makes the object a candidate (or eligible) for garbage collection.
  53. Garbage collection mechanism in java is implemented through a low priority thread, the behavior of which may differ from one implementation to another. Nothing can be guaranteed about garbage collection except the execution of finalize().
  54. Garbage collection in Java cannot be forced. The methods used to call garbage collection thread are System.gc() and Runtime.gc().
  55. To perform some task when an object is about to be garbage collected, you can override the finalize() method of the Object class. The JVM only invokes finalize() method once per object. The signature of finalize() method of Object class is : protected void finalize() throws Throwable.
  
  SECTION 4: LANGUAGE FUNDAMENTALS
  56.const and goto are two keywords in Java that are not currently in use.
  57.null, true, false are reserved literals in Java.
  58.null statement may be used after any statement in any number, in Java if the statement is not unreachable (like after return statement) without any effect in the program. Like --- if (i<50) i += 5;;;;;;;
  59.NULL is not a reserved-word, but null is a reserved-word in Java. Java is a case-sensitive language.
  60.The initialization values for different data types in Java is as follows
  byte = 0, int = 0, short = 0, char = '\u0000', long = 0L, float = 0.0f, double = 0.0d, boolean = false, object deference (of any object) = null.
  61.A static method cannot refer to "this" or "super".
  62.A final variable is a constant and a static variable is like a global variable.
  63.A static method can only call static variables or other static methods, without using the instance of the class. e.g. main() method cannot directly access any non static method or variable, but using the instance of the class it can.
  64.instanceof is a Java keyword not instanceOf.
  65.The following definition of main method is valid:
  static public void main(String[] args)
  66.The main() method can be declared final.
  67.this() and super() must be the first statement in any constructor and so both cannot be used together in the same constructor.
  68.The example of array declaration along with initialization - int k[] = new int[]{1,2,3,4,9};
  69.The size of an array is given by arrayname.length.
  70.The local variables (variables declared inside method) are not initialized by default. But the array elements are always initialized wherever they are defined be it class level or method level.
  71.In an array, the first element is at index 0 and the last at length-1. Please note that length is a special array variable and not a method.
  72.The octal number in Java is preceded by 0 while the hexadecimal by 0x (x may be in small case or upper case)
  e.g. octal :022 and hexadecimal :0x12
  
  SECTION 5: OPERATORS AND ASSIGNMENTS
  73.Bit-wise operators - &, ^ and | operate on numeric and boolean operands.
  74.The short circuit logical operators && and || provide logical AND and OR operations on boolean types and unlike & and |, these are not applicable to integral types. The valuable additional feature provided by these operators is the right operand is not evaluated if the result of the operation can be determined after evaluating only the left operand.
  75.Understand the difference between x = ++y; and x = y++; In the first case y will be incremented first and then assigned to x. In the second case first y will be assigned to x then it will be incremented.
  76.Please make sure you know the difference between << , >> and >>>(unsigned rightshift) operators.
  
  SECTION 6: OVERLOADING, OVERRIDING, RUNTIME TYPE AND OBJECT ORIENTATION
  77.A static method cannot be overridden to non-static and vice versa.
  78.A final class cannot be subclassed.
  79.A final method cannot be overridden but a non final method can be overridden to final method.
  80.All the static variables are initialized when the class is loaded.
  81.An interface can extend more than one interface, while a class can extend only one class.
  82.Instance variables of a class are automatically initialized, but local variables of a function need to be initialized explicitly.
  83.An abstract method cannot be static because the static methods cannot be overridden.
  84.An abstract class may not have even a single abstract method but if a class has an abstract method it has to be declared as abstract.
  85.A method cannot be overridden to be more private. E.g. a public method can only be overridden to be public.
  86.While casting one class to another subclass to superclass is allowed without any type casting. e.g. A extends B, B b = new A(); is valid but not the reverse.
  87.Abstract classes cannot be instantiated and should be subclassed.
  88.Abstract classes can have constructors, and it can be called by super() when it's subclassed.
  89.Both primitives and object references can be cast.
  90.Polymorphism is the ability of a superclass reference to denote objects of its own class and its subclasses at runtime. This is also known as Dynamic Method Lookup.
  91.According to Method Overloading Resolution, most specific or matching method is chosen among the available alternative methods that do not directly match the argument lists but matches after automatic casting. Ambiguity is shown when compiler cannot determine which one to choose between two overloaded methods.
  92.Constructors are not inherited so it is not possible to override them.
  93.A constructor body can include a return statement provided no value is returned.
  94.A constructor never returns a value. If you specify a return value, the JVM (Java virtual machine) will interpret it as a method.
  95.If a class contains no constructor declarations, then a default constructor that takes no arguments is supplied. This default constructor invokes the no-argument constructor of the super class via super() call (if there is any super class, except java.lang.Object).
  96.If inner class is declared in a method then it can access only final variables of the particular method but can access all variables of the enclosing class.
  97.To refer to a field or method in the outer class instance from within the inner class, use Outer.this.fieldname.
  98.Inner classes may not declare static initializers or static members unless they are compile time constants i.e. static final var = value;
  99.A nested class cannot have the same name as any of its enclosing classes.
  100.Inner class may be private, protected, final, abstract or static.
  101.An example of creation of instance of an inner class from some other class:
  class Outer
  {
      public class Inner{}
  }
  
  class Another
  {
      public void amethod()
     {
         Outer.Inner i = new Outer().new Inner();
      }
  }
  102.Classes defined in methods can be anonymous, in which case they must be instantiated at the same point they are defined. These classes cannot have explicit constructor and may implement interface or extend other classes.
  103.One class in Java cannot reside under two packages. If no package declaration is made, a class is assumed to be the member of default or unnamed package.
  
  SECTION 7: THREADS
  104.The Thread class resides in java.lang package and so need not be imported.
  105.A Java thread scheduler can be preemptive or time-sliced, depending on the design of the JVM.
  106.The sleep and yield methods of Thread class are static methods.
  107.The range of Thread priority in Java is 1-10. The minimum priority is 1 and the maximum is 10. The default priority of any thread in Java is 5.
  108.There are two ways to provide the behavior of a thread in Java: extending the Thread class or implementing the Runnable interface.
  109.The only method of Runnable interface is "public void run();".
  110.New thread takes on the priority of the thread that spawned it.
  111.Using the synchronized keyword in the method declaration, requires a thread obtain the lock for this object before it can execute the method.
  112.A synchronized method can be overridden to be not synchronized and vice versa.
  113.In Java terminology, a monitor (or semaphore) is any object that has some synchronized code.
  114.Both wait() and notify() methods must be called in synchronized code.
  115.The notify() method moves one thread, that is waiting on this object's monitor, into the Ready state. This could be any of the waiting threads.
  116.The notifyAll() method moves all threads, waiting on this object's monitor into the Ready state.
  117.Every object has a lock and at any moment, that lock is controlled by at most one single thread.
  118.There are two ways to mark code as synchronized:
  a.) Synchronize an entire method by putting the synchronized modifier in the method's declaration.
  b.) Synchronize a subset of a method by surrounding the desired lines of code with curly brackets ({}).
  119.Deadlock a special situation that might prevent a thread from executing. In general terms, if a thread blocks because it is waiting for a condition to arise and something else in the program makes it impossible for that condition to arise, then the thread is said to be deadlocked.
  
  SECTION 8: FUNDAMENTAL CLASSES IN THE JAVA.LANG PACKAGE
  120.java.lang package is automatically imported in every java source file regardless of explicit import statement.
  121.The String class is a final class, it cannot be sub classed.
  122.The Math class has a private constructor, it cannot be instantiated.
  123.The random() method of Math class in Java returns a random number, a double, greater than or equal to 0.0 and less  than 1.0.
  124.The String class in Java is immutable. Once an instance is created, the string it contains cannot be changed. e.g. String  s1 = new String("test"); s1.concat("test1"); Even after calling concat() method on s1, the value of s1 will remain to be "test". What actually happens is a new instance is created. But the StringBuffer class is mutable.
  125.The + and += operators are the only cases of operator overloading in Java and is applicable to Strings.
  126.The various methods of java.lang.Object are
   clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString and wait.
  127.The Java.lang.System is a final class and cannot be sub classed.
  128.A String in Java is initialized to null, not empty string and an empty string is not same as a null string.
  129.The equals() method in String class compares the values of two Strings while == compares the memory address of the objects being compared.
   e.g. String s = new String("test"); String s1 = new String("test");
   s.equals(s1) will return true while s==s1 will return false.
  130.The valueOf() method converts data from its internal format into a human-readable form. It is a static method that is overloaded within String class for all of Java's built-in types, so that each type can be converted properly into a string.
  131.All the wrapper class objects are immutable. Wrapper classes are final also.
  132.java.lang.Character has only a single constructor that takes a char (character) as an argument.
  133.hashCode() produces a hash code of type int for an object that is typically used as an offset from the start of the memory that has been allocated to that object
  
  SECTION 9: THE COLLECTIONS FRAMEWORK
  134.Collections in Java (sometimes known as bag or multiset) can only hold object references not primitive values. But arrays in Java can hold both primitive values and object references.
  135.Collection is an Interface whereas Collections is a helper class.
  136.Collection imposes no order nor restrictions on content duplication.
  137.The main difference between Vector and ArrayList is that Vector is synchronized while the ArrayList is not.
  138.A Set is a collection, which cannot contain any duplicate elements and has no explicit order to its elements.
  139.A List is a collection, which can contain duplicate elements, and the elements are ordered.
  140.Maps use unique keys to facilitate lookup of their contents through key/value pairs.
  141.Set and List extend java.util.Collection interface, but Map has no super interface. So Map does not implement the Collection interface though it is a part of the Java's collection framework.
  142.A Hashtable object is thread-safe (like Vector and unlike HashMap) and do not accept null as a key.
  143.TreeSet class implements SortedSet interface (sub interface of Set) that holds its elements sorted in an order. In the same way, TreeMap class implements SortedMap interface (sub interface of Map) that keeps its elements sorted in an order.
  
  
   关键词  >>SCJP1.4高效率复习提纲
 
新世纪电脑培训学校
北京新华电脑学校
百事特教育学院
金同方计算机学校
北大燕工教育研究院
中科院计算所培训中心

  ■ 最新推荐课程

 ·长城平面设计师就业专修课程  ·育人电脑组装维修培训课程  ·新科海三维设计师就业班课程
 ·中科院JAVA软件工程师培训课程  ·中科院计计算机网络系统集成  ·千禧艺海高级三维室内装潢设计
 ·金同方高级文秘助理实战课程  ·科华时代 3ds max设计师课程  ·北京交通大学日语软件工程师
相关文章
没有相关文章!
论坛热贴
 【发表评论】
 昵称:
 内容:
 
 【最新评论】 更多...
中招在线版权与免责声明:
① 凡本站注明“稿件来源:中招在线”的所有文字、图片和音视频稿件,版权均属本网所有,任何媒体、网站或个人未经本网协议授权不得转载、链接、转贴或以其他方式复制发表。已经本站协议授权的媒体、网站,在下载使用时必须注明"稿件来源:中招在线",违者本站将依法追究责任。
② 本站注明稿件来源为其他媒体的文/图等稿件均为转载稿,本站转载出于非商业性的教育和科研之目的,并不意味着赞同其观点或证实其内容的真实性。如转载稿涉及版权等问题,请作者在两周内速来电或来函联系。
热 点 聚 焦
Google
   
精 彩 推 荐
免费下载Firefox,改进网页浏览
免费下载相片软件整理你的照片
·新科海平面设计师就业课程
·新科海软件测试工程师课程
·理工百事特软件编程课程
·百事特装饰装潢设计师课程
·J2EE Struts及XML编程技术
·千禧艺海影视后期特效课程
·JAVA软件开发专业课程
·清华万博1+6网络技术总监
·中科院企业VI平面广告课程
·中科院VC++ 6.0/VC++.Net
 
本周院校排行榜
最新资源排行榜
 
 
关于中招 - 广告服务 - 网站建设 - 版权声明 - 联系我们 - 英才加盟 - 网站地图 - 友情链接 - 免责声明 - 设为首页
Copyright @ 2005-2008 zhongzhao.com All Rights Reserved.
中招在线 版权所有