]]>
Reader reader = new InputStreamReader( in ); //in is an instance of class InputStream or derived classesBut the issue is sometimes we need convert a reader to inputstream, think about following scenaros:
1.聽 the original inputstream has been filtered by certian reader, now we need save back filtered content into database by inputstream: we can not use original inputstream but filtered stream which can only get from your reader.
2.聽 Given a class who contains a reader to access a streaming content after complex parsering or downloading, we want to utilize the streaming content in this class while not repeating complex operations for content analysis, so we need employ some wrapper methods to get inputstream from reader.
-- Solution:
1. write own InputStream implementation, such as following:
class MyInputStream extends InputStreamNote: Applications that need to define a subclass of
{
private Reader rd;
public MyInputStream(Reader rd)
{
super();
this.rd = rd;
}
聽
聽
// implement the read() method to make this all work
publicint read()
{
int t = rd.read();
// you can do your processing on the inputReader here
// fiddle with the values and return
return t;
聽
}
}
InputStream
must always provide a method that returns the next byte of input. (refer to http://java.sun.com/j2se/1.4.2/docs/api/java/io/InputStream.html)
-- anything else? BTW, for parsering xml-based input stream by SAX, I am glad to see that the inputSource constructor can take either InputStream or Reader (refer to http://java.sun.com/j2se/1.4.2/docs/api/org/xml/sax/InputSource.html)
]]>
http://java.sun.com/j2se/1.4.2/docs/guide/util/logging/overview.html
]]>
1. what is the idea of generic?
To simply say, generic is an idea of parameterizing type, including class type and other data types.
2. examples?
-- We are familar with some container types, such as Collection. Here is an example for our former (Java 1.4 or before) typical usage:
Vector myList = new Vector();
myList.add(new Integer(100));
Integer value = (Integer)myList.get(0);
now it is better to write like this for type safety: (Eclipse IDE will display type safety warnings for above code if under java 1.5 compiler option)
聽聽Vector<Integer> myList = new Vector<Integer>();
聽聽myList.add(new Integer(100));
聽聽Integer value = myList.get(0);
-- the reason why write code like this is Class Vector has been defined as a generic:
public Class Vector<E>
{
聽聽聽聽聽聽void add(E x);
聽聽聽聽聽 ......
}
-- when we see some angle brackets(invocations) shown in聽declaration, that is a generic. The invocation is a parameterized type. to use this generic, we need specify an actual type argument. (such as Integer as above)
3. trick in generic
-- we know that the idea of generic makes some data type such as container more flexible or acceptable for inputting entries. But that will be also very tricky. To take container as an example of generic, one of tricks is聽can we copy values from one container to another container? if you want to copy like following style, the answer is no.
List<String> ls = new ArrayList<String>();
List<Object> lo = ls; //compile time error!
-- though we know String is a subtype of Object, and we can assign a value of String to an Object. But we can not assign a List of String to a List of Object as a whole part(like reference to a variable). The reason is we can access inner part of List(I mean element here, if List is as a simple data type such as Object, maybe we can do that), that will make List type unsafe. So, Java 1.5 complier will not let you do that.
-- Look inside two styles of code in above examples(of 2), we might say that the older style looks more flexible, because myList can accept more data types besides Integer, but the new style in 1.5 can only take Integer values. Well, if we need more flexible, we apply wildcards for generic.
4. Wildcards and bounded wildcards
-- if we see something like Collection<?> c, there is a question mark in angle brackets. That is Wildcard, which means type is temporarily unknown but it will be replaced by any type.
-- if we see something like Collection<? extends Number> c, that is bounded wildcard, which means the elements in Collection has a supertype bound. You can not put any other type whose supertype is not Number into this Collection.
-- But, no matter wildcard or bounded wildcard, we can not put a specified type value in it, that is because wildcard means type is unknown, you can not give a value to unknown data type.
-- So, what hell can wildcard be used for ? return back the flexible idea we mentioned before. We need apply wildcard to describe a flexible idea in definition or declaration, not to do real things.
for example, we can define an method like this:
void printCollection(Collection<?> c)
{
聽聽聽聽聽聽for(Object e : c){System.out.println(e);}
}
see? that is flexible. You can call this function for any Collection. You can use elements in Collection<?>, just don't try to put something in it.
-- So the question is, if we wanna that flexibility for our method, and we also need put something in it during the subroutine. How can we do? and then, we need use generic method
5. Generic method
-- that means method declaration can also be parameterized.
-- example:
聽聽聽聽public <T> void addCollection(List<T> objs, T obj)
聽 聽{
聽聽聽聽聽聽聽 objs.add(obj);
聽聽 聽}
6. when to use generic method and when to use wildcard ?
-- if the type parameter is used only once, or it has no relationship to other arguments of method including the return type, then wildcard聽is聽better to use to decribe clearer and more concise meanings.
-- otherwise, generic method should be used.
example:
class Collection
{
聽聽聽聽聽聽public static <T, S extends T> void copy(List<T> dest, List<S> src){...}
}
can be better rewritten as :
class Collection
{
聽聽聽聽聽聽public static <T> void copy(List<T> dest, List<? extends T> src){...}
}
reference: http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf
]]>
reference:
http://www.allapplabs.com/interview_questions/java_interview_questions.htm
http://www.allapplabs.com/interview_questions/java_interview_questions_2.htm
http://www.allapplabs.com/interview_questions/java_interview_questions_3.htm
http://www.allapplabs.com/interview_questions/java_interview_questions_4.htm
http://www.allapplabs.com/interview_questions/java_interview_questions_5.htm
http://www.allapplabs.com/interview_questions/java_interview_questions_6.htm
]]>
The volatile keyword is used on variables that may be modified simultaneously by other threads. This warns the compiler to fetch them fresh each time, rather than caching them in registers. This also inhibits certain optimisations that assume no other thread will change the values unexpectedly. Since other threads cannot see local variables, there is never any need to mark local variables volatile.
quote from:
http://mindprod.com/jgloss/volatile.html
]]>
A class within another class
Example:
class EnclosingClassPurpose:
{
...
class ANestedClass
{
...
}
}
Reflect and enforce the relationship between two classes. (esp. in the scenarios that the nested class makes sense only in the context of its enclosing class or when it relies on the enclosing class for its functionthe nested class makes sense only in the context of its enclosing class or when it relies on the enclosing class for its function)
Interesting features:
1. An instance of
InnerClass
can exist only within an instance of EnclosingClass
2. InnerClass instance has direct access to the instance variables and
methods of its enclosing instance.3. two special kinds of inner classes: local classes and anonymous classes
reference:
http://java.sun.com/docs/books/tutorial/java/javaOO/nested.html
]]>
1. Use Interface if something will change frequently in design
2. If the methods can be determined and implemented, use abstract classes to encapsulate them as methods of base classes and therefore can be inherited by subclasses.
3. If you just want to declare some methods in your design which allows to be devoloped from scratch later into different classes, the interface is best choice.
4. if need provide more common data structure, use abstract classes as base class.
5. if want to add your code to other existing third party class for later potential requirement, interface is good to choose.
6. Interfaces are often used to describe certain functionality of classes, thus one class can get multi-funcationlity from multiple interfaces (multiple inheritance), while an abstract class, try to describe a class's general attributes and functionalities which can be reused or re-implemented by its subclasses.
7. in other word, Abstract class want to say is-a proposition, while Interface want to say -able or can-do proposition.
reference:
http://mindprod.com/jgloss/interfacevsabstract.html
http://www.javaworld.com/javaworld/javaqa/2001-04/03-qa-0420-abstract.html
]]>