Shulou(Shulou.com)06/03 Report--

This article mainly introduces "what are the indispensable tips in Java". In daily operation, I believe many people have doubts about the indispensable tips in Java. The editor consulted all kinds of materials and sorted out simple and easy-to-use methods of operation. I hope it will be helpful for you to answer the doubts about "what are the indispensable tips in Java?" Next, please follow the editor to study!

Examples: Integer.valueOf ("1"), Boolean.valueOf ("true"), etc. Advantages:

High readability (method name)

Performance (not necessarily creating objects)

High flexibility

Here are some interpretations of the three advantages.

High readability

New Point (xmeny) and Point.at (xmemy), Point.origin (). The constructor can only see two parameters, which are easier to understand.

Performance

In some cases, some objects can be instantiated in advance and can be called directly when called without any change. For example, Boolean.

Public final class Boolean implements Serializable, Comparable {/ / preset two objects public static final Boolean TRUE = new Boolean (true); public static final Boolean FALSE = new Boolean (false); public Boolean (boolean var1) {this.value = var1;} public Boolean (String var1) {this (parseBoolean (var1));} / / Factory method public static Boolean valueOf (boolean var0) {return var0?TRUE:FALSE / / returns the preset object instead of creating the object} / / Factory method public static Boolean valueOf (String var0) {return parseBoolean (var0)? TRUE:FALSE;} / /. Other code} High flexibility

Subclasses can be returned according to the specific situation. The equivalent of a more powerful factory. Get the subclass directly from the parent class. Especially suitable for tool classes (various API are available). Example: Collections.

Public class Collections {/ / private, typical factory private Collections () {} public static final List EMPTY_LIST = new EmptyList (); / / factory method public static final List emptyList () {return (List) EMPTY_LIST } private static class EmptyList extends AbstractList implements RandomAccess, Serializable {/ / code} / / Factory method public static List checkedList (List list, Class type) {/ / get the corresponding subclass return (list instanceof RandomAccess? New CheckedRandomAccessList (list, type): new CheckedList (list, type)); subclass 1 static class CheckedRandomAccessList extends CheckedList implements RandomAccess {CheckedRandomAccessList (List list, Class type) {super (list, type);} public List subList (int fromIndex, int toIndex) {return new CheckedRandomAccessList (list.subList (fromIndex, toIndex), type) }} / / subclass 2 static class CheckedList extends CheckedCollection implements List {/ / code}} 2, consider using constructors when you have multiple constructors

Especially in Android development, you will encounter this situation. It is usually an object with multiple member variables that may need to be initialized, while conventional methods require a large number of constructors to be provided. For example:

/ / AlertDialog in non-Android to facilitate explanation. For example, public class AlertDialog {private int width; private int height; private String title; private String confirmText; private String denyText; private AlertDialog () {} public AlertDialog (int width, int height) {/ / blank warning box AlertDialog (width,height,null) } / / warning box with title public AlertDialog (int width, int height, String title) {/ / warning box with title AlertDialog (width, height, title, "OK");} / / warning box with title with public AlertDialog (int width, int height, String title, String confirm) {AlertDialog (width, height, title, confirm, null) } / / captioned warning box with OK button, cancel button public AlertDialog (int width, int height, String title, String confirm, String denyText) {/ / set every thing. }}

There are many types of warning boxes, and multiple constructors must be provided in order to make it easy to call. Otherwise, when calling, the user can only use the complete constructor, which is easy to make mistakes and cannot be read. Very inflexible. If you take a different approach, you can solve it, but it will take a lot of experience to deal with concurrency:

/ / AlertDialog in non-Android is easy to explain. For example, public class AlertDialog {private int width; private int height; private String title; private String confirmText; private String denyText; public AlertDialog () {} / / blank constructor public void setWidth (int width) {this.width = width;} / / other set methods}

When called, it is set by calling the set method of each parameter. Here's the problem:

Concurrence

Unable to perform parameter verification. For example, creating an object and setting a title with no size is equivalent to creating a warning box with no size.

In Android, a large number of controls use the constructor Builder.

/ / AlertDialog in non-Android is easy to explain. For example, protected AlertDialog (Builder b) {width = b.width; height = b.width; / / in public class AlertDialog {private int width; private int height; private String title; private String confirmText; private String denyText; / / private private AlertDialog () {} / / Builder. If (width==0 | | height==0) throws new Exception ("size must be set");} / / Constructor public static class Builder {private int width; private int height; private String title; private String confirmText; private String denyText; / / Note: the returned Builder. Public Builder setTitle (String title) {this.title = title; return this;} / / other set... Public AlertDialog build () {return AlertDialog (this);}

Therefore, according to the corresponding requirements, the corresponding settings can be made, and when the AlertDialog is really constructed, the parameters can be verified. It's like this:

New AlertDialog.Builder (). SetTitle (prompt). Build ()

In the above example, an exception will be thrown successfully.

3. Strengthen Singleton with privatized constructor or enumerated type.

Singleton refers to a class that can be instantiated at most once. Under normal circumstances, there is nothing wrong with the previous practice. However, in some advanced cases, Singleton is destroyed by accessing the constructor of private using the relevant knowledge of reflection.

Public class Elvis {/ / Note, the public final object public static final Elvis INSTANCE = new Elvis (); private Elvis () {}}

On the other hand, in the process of serialization, the object deserialized is no longer what it used to be (breaking the Singleton), in which case it can be handled by a single element enumeration.

Public enum Elvis {INSTANCE; / / some methods} 4, enhanced non-instantiation capabilities through privatized constructors

There are some utility classes that just provide some capabilities and do not have any attributes of their own, so it is not suitable to provide constructors. However, the missing constructor compiler automatically adds a constructor with no parameters. Therefore, you need to provide a privatized constructor. To prevent misuse within the class, add a protective measure and comment.

Public class Util {private Util () {/ / throws an exception to prevent internal miscalls to throw new AssertionError ();}}

The downside is that the class cannot be inherited (the subclass calls super ()).

5. Avoid creating unnecessary objects

Reuse of objects

Expensive objects, using object pool

For cheap objects, be careful with object pools. Modern JVM creates and destroys cheap objects very quickly, so object pooling is not suitable at this time.

6. Eliminate expired object references

The following three situations can cause memory leaks:

Self-managed memory (after the length of the array is reduced, the objects out of pop can easily cause memory leaks)

Caching

Monitoring and callback

Self-managed memory

Be careful with the memory you manage, such as:

Public class Stack {private Object [] elements; private int size= 0; private static final int DEFAULT_INITIAL_CAPACITY = 16; public Stack () {elements = new object [default _ INITIAL_CAPACITY];} public void push (Object e) {ensureCapacity (); elements [size++] = e; / / allocate new heap memory and stack memory} public Object pop () {if (size==0) throw new EmptyStackException () Return element [--size]; / / pop element [size], the object is no longer valid. The cause of the memory leak. } private void ensureCapacity () {if (elements.length==size) elements = Arrays.copyOf (elements, 2*size+1);}}

The pop-up object is no longer valid, but JVM doesn't know it, so it stays there all the time, causing a memory leak.

Resolve:

Public Object pop () {if (size==0) throw new EmptyStackException (); elements [size] = null; / / waiting for return element [--size];} cache

Cached objects are easily forgotten by programmers, and mechanisms need to be set up to maintain the cache, such as irregularly reclaiming caches that are no longer in use (using timers). In some cases, the effect of cache collection can be achieved by using WeakHashMap. Note that WeakHashMap is valid only if the cache depends on the external environment, not on the value.

Monitor or callback

Remember to unregister when using monitoring and callbacks. The best implementation to ensure recycling is to use weak references (weak reference), for example, to save them only as WeakHashMap keys.

7. Avoid displaying and calling GC

Java's GC has a powerful recycling mechanism, and you can simply remember: do not display calls to finalizer. It can be understood as follows:

Jvm is designed for specific hardware, but the program is not designed for specific hardware, so java code can not solve the gc problem very well (because of its platform differentiation). In addition, the performance overhead of finalizer is very high, and it should not be used from this point of view.

8. Please follow the general convention to override the equals method.

Reflexivity. X.equals (x) = = true

Symmetry. Currently, only when y.equals (x) = = true, x.equals (y) = = true

Transitivity. If (x.equals (y) & & y.equals (z)), y.equals (z) = = true

Consistency.

It's not empty. X.equals (null) = = false

9. Always override hashCode when overriding the equals method

In order to ensure that hash-based collections use this class (HashMap, HashSet, HashTable), which is also a general convention of Object.hashCode, hashCode must be overridden when overriding the equals method.

10. Always overwrite toString

The general convention for the toString method of Object is the description of the object. Note that when overwriting, if there is a format, please note or return in strict accordance with the format.

11. Carefully override clone12, consider implementing Comparable interface 13, and minimize the accessibility of classes and members

The aim is to decouple. To put it simply, the priority of using modifiers is from high to low, private > protected > default (default) > public. If at the beginning of the design, after the design is a private modifier, and if the subsequent coding process has to expand its role, you should first check to see if the design is true.

The subclass overrides the superclass and does not allow the access level to be lower than that of the superclass. (the protected of the superclass, which cannot be changed to default after the subclass is overridden).

Member variables are never allowed to be public. Once it is made public, it gives up the ability to deal with him. This category is not thread-safe. Even if it is final, it is not allowed. Unless you want to expose constants through public static final. Member variables always need to be maintained using setter and getter. There is one exception: an array of non-zero length. This is a source of security vulnerabilities.

/ / Security loophole! The array here is not an immutable public static final Thing [] VALUES = {.}

Improvements:

Private static final Thing [] PRIVATE_VALUES = {...} / / what is obtained at this time is the "constant" public static final List VALUS = Collections.unmodifiableList (Arrays.asList (PRIVATE_VALUES))

The other is:

Private static final Thing [] PRIVATE_VALUES = {...} / / what is obtained at this time is the "constant" public static final Thing [] values () {return PRIVATE_VALUES.clone ();} 14. Use access methods in public classes instead of public member variables (similar to 13) 15, minimize variability 16, and composition takes precedence over inheritance.

Inheritance is good for code reuse, but cross-package inheritance is avoided as much as possible. Inheritance in a package is an excellent way of design, and the files in a package are under the control of the same programmer. But inheritance has its limitations: subclasses depend on superclasses. Once the superclass changes, it is possible to break the subclass. Moreover, if the superclass is defective, the subclass will also get a "genetic disease".

Composition, that is, do not extend the existing class, but add an existing class to the class. It is equivalent to the existence of an existing class as a build in a new class. In this way, only what is needed will be used, without representing all the methods and member variables of the existing class. The new class can also be called a "wrapper class", which is the Decorate pattern in the design pattern.

17. Either design for inheritance and provide documentation, or prohibit inheritance 18, interface is superior to abstract class 19, interface is only used to define type 20, class hierarchy takes precedence over label class 21, and policy is represented by function object

Function arguments can be passed in listener-like objects in order to use methods in listener. If anonymous parameters are used, a new object is created with each call. You can declare listener as a member variable, reuse the same object each time, and you can use static fields (static variables). For example, the CASE_INSENSITIVE_ order domain of the String class.

Follow the official account [programmer Bai Nannan] to get a set of summary interview materials at the end of 2020!

22. Give priority to static class members

The purpose of a nested class should only be to provide services for its peripheral class, and should be designed as a top-level class if it may be used in other environments in the future. A static class is equivalent to an ordinary external class, but happens to be declared inside a class. The usual users are: Calculator.Operation.PLUS and so on. The only difference from the ordinary class is that before PLUS, there are two prefixes to indicate its meaning. A non-static class must exist in an external class object. Instead of manually creating an internal non-static class object outside, the process of creating it is: instance.New MemberClass (). This is very strange.

If the member class does not need to access the peripheral class, you need to add static, which becomes a static member class, otherwise each instance will contain an additional reference to the peripheral object. Will affect the garbage collection mechanism.

23. Specify specific types of generics instead of using native types directly.

For example, List should be specified and direct use of List is not recommended.

24. Eliminate non-first inspection warnings

When using IDE for coding, powerful IDE will prompt warning in your coding process, need to eliminate warning as much as possible, at the very least, you should be careful with these warning. Use SuppresWarning carefully, and if IDE prompts you to solve the warning by adding this annotation, please don't do that. If you really want to use it, please add a comment explaining why.

25. Lists take precedence over arrays

Compared with generics, arrays have some defects. List and List are irrelevant, and Sub [] is a subclass of Super [].

/ / Fails at runtimeObject [] objectArray = new Long [1]; objectArray [0] = "I don't fit in"; / / throw exception// won't compileList ol = new ArrayList (); / / Incompatible typesol.add ("I don't fit in")

As you can see from the code, using generics will find errors in advance.

26. Give priority to generics 27, give priority to generics methods 28, and use limited wildcards to improve the flexibility of API

PECS,producer-extends,consumer-super .

/ / public class Stack {/ / public Stack (); / / public void push (E); / / public E pop (); / / public boolean isEmpty (); / /} public void pushAll (Iterator)

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.