嘎嘎986
嘎嘎986

Effective Java 78条军规

Effective Java, 2nd Edition

by Joshua Bloch

I, Michael Parker, own this book and took these notes to further my own learning. If you enjoy these notes, please purchase the book!

Chapter 2: Creating and Destroying Objects创建和销毁对象

Item 1: Consider static factories instead of constructors考虑使用静态工厂方法代替构造器

  • An instance-controlled class is one that uses static factories to strictly control what instances exist at any time.
  • By convention, static factory methods for an interface named Type are put in a non-instantiable class named Types.
  • When naming static factory methods, getInstance may return the same instance, while newInstance should not.
  • 静态工厂方法与构造器的第一大优势在于:他们有名称
  • 第二大优势:不必在每次调用他们的时候都创建一个新的实例
  • 第3大优势：他们可以返回任何原返回类型的任何子类型对象
  • 静态工厂方法的主要缺点1：类如果不包含public或proctected的构造器，就不能被子类化
  • 静态工厂方法的缺点2：他们与其他的静态方法实质上没有任何区别
  • 静态工厂的惯用名称:valuOf,of,getInstance,newInstance,getType,newType

Item 2: Consider a builder when faced with many constructor parameters遇到多个构造器参数时要考虑用构建器

  • The builder pattern simulates optional named parameters in Ada and Python.
  • A builder whose parameters have been set makes a fine abstract factory, assuming some generic Builder interface.
  • 重叠构造器模式是可行的，但是当有很多参数的时候，客户端代码会很难编写
  • Builder模式代码易于阅读，模拟了具名的可选参数
  • Class.newInstance破坏了编译时的异常检查
  • JavaBean模式会导致在构造过程中JavaBean可能处于不一致状态

Item 3: Enforce the singleton property with a private constructor or an enum type用私有构造器或枚举类型强化Singleton属性

  • Adding implements Serializable to a singleton class is not enough, you must declare all fields transient and provide a readResolve method.
  • A single-element enum type provides the serialization for free and is the best way to implement a singleton.
  • 现代的jvm实现几乎都能讲静态工厂方法的调用内联化
  • 为了维护并保证Singleton,必须声明所有实例域都是transient的，并提供一个readResolve方法。否则每次反序列化一个实例时都会创建一个新的实例。
  • 单元素的枚举类型已经成为实现Singleton的最佳方法

Item 4: Enforce non-instantiability with a private constructor使用私有构造器强化不可实例化的能力

  • A private constructor not only supresses instantiation, but subclassing.
  • 例如工具类不希望被实例化，实例对它没有任何意义
  • 企图通过将类做成抽象类来强制该类不可被实例化，这是行不通的。该类可以被子类化，并且该子类可以被实例化。

Item 5: Avoid creating unnecessary objects避免创建不必要的对象

  • Often lazy initialization only complicates the implementation and yields no noticeable performance increase.
  • Prefer primitives to boxed primitives, as unintentional autoboxing can lead to creating many new instances.
  • Highly optimized garbage collectors can easily outperform object pools that do not contain heavyweight objects.
  • 一般来说，最好能重用对象而不是在每次需要的时候就创建一个相同功能的新对象。
  • 延迟初始化中常见的情况会使方法的实现变得复杂，从而无法将性能显著地提高到超出已达到的水平。
  • 在Java1.5发行版中，有一种创建多余对象的新方法，成为自动封箱。
  • 要优先使用基本类型而不是装箱基本类型，当心无意识的自动封箱。

Item 6: Eliminate obsolete object references消除过期对象的引用

  • Whenever a class manages its own memory, like a stack or object pool, the programmer should be alert for memory leaks.
  • Caches, listeners, and callbacks can all be sources of memory leaks, but weak references can help.
  • 所谓过期引用，是指永远也不会再被删除的引用
  • 如果一个对象引用被无意识地保留起来了，那么，垃圾回收机制不仅不会处理这个对象，而且不会处理被这个对象所引用的所有其他对象。
  • 清空对象引用应该是一种例外，而不是一种规范行为。消除过期引用的最好方法就是让包含该引用的变量结束其生命周期。
  • 一般而言，只要类是自己管理内存，程序员就应该警惕内存泄露问题。
  • 内存泄露的另一个常见来源是缓存。可以用WeakHashMap代表缓存，当缓存中的项过期后，他们就会被自动删除。
  • 缓存应该时不时地清除掉没用的项，这项清除工作可以由一个后台线程(可能是Timer或ScheduledThreadPoolExecutor)来完成。
  • 内存泄露的第3个常见来源是监听器和其他回调。确保回调被当做垃圾回收的最佳方法时只保存他们的弱引用(weak reference),例如，只将他们保存成WeakHashMap中的键。

Item 7: Avoid finalizers避免使用finalize

  • Do not think of finalizers as Java's analogue of C++ destructors -- there's no guarantee finalizers will be called at all!
  • If an uncaught exception is thrown in a finalizer, it is ignored, and the finalization abruptly terminates.
  • There is a severe performance penalty for using finalizers -- object creation and deletion increases from nanoseconds to microseconds.
  • Java语言规范并不保证哪个线程将会执行finalize方法，所以除了不使用finalize方法之外，并没有很轻便的方法能避免这样的问题。
  • Java语言规范不仅不能保证finalize方法被及时地执行，而且根本就不保证它们会被执行。结论：不应该依赖finalize方法来更新重要的持久状态。
  • 不要被System.gc和System.runFinalization这两个方法所诱惑，它们确实增加了终结方法被执行的机会，但是它们并不保证终结方法就一定会被执行。
  • 使用终结方法有一个非常严重的性能损失。用终结方法后创建和销毁对象慢了约430倍。
  • 怎样做才能不用编写finalize方法呢？只需要提供一个显示的终止方法，并要求该类的客户端在每个实例不再可用的时候调用这个方法。显示的终止方法通常与try-finally结构结合起来使用，以确保及时终止。
  • 如果子类实现者覆盖了超类的finalize方法(或者有意选择不调用超类的finalize方法)，那么超类的finalize方法将永远也不会被调用到。要防范这样粗心大意或者恶意的子类是有可能的，代价就是为每个将被finalize的对象创建一个附加的对象。不是把finalize方法放在要求终结处理的类中，而是把finalize方法放在一个匿名类中，该匿名类的唯一用途就是终结它的外围实例(enclosing instance)。

Chapter 3: Methods Common to All Objects对于所有对象都通用的方法

Item 8: Obey the general contract when overriding equals覆盖equals时请遵循通用约定

  • Override equals when a class has a notion of logical equality that differs from mere object identity, and the superclass has not provided a suitable implementation.
  • For classes that represent a value, such as Integer or Date, the equals method should always be overridden.
  • There is no way to extend an instantiable class and add a value component (field) while preserving the equals contract.
  • By using composition with views to internal components, you can add value components to instantiable classes without violating the equals contract.
  • To compare float and double values, use the Float.compare and Double.compare methods to deal with NaN and -0.0 values.
  • For best performance, first compare fields that are more likely to differ, or less expensive to compare.
  • 覆盖equals时要遵循的通用约定：
  • 1-类的每个实例本质上都是唯一的。
  • 2-不关心是否提供了‘逻辑相等logical equality’的测试功能
  • 3-超类已经覆盖了equals,从超类继承过来的行为对于子类也是合适的。
  • 4-类是private的或是包级私有的，可以确定它的equals永远不会被调用。
  • equals等价关系约定
  • 自反性reflexive.x.equals(x)必须返回true
  • 对称性symmetric,当且仅当y.equals(x)返回true时,x.equals(y)必须返回true
  • 传递性transive,如果x.equals(y)返回true,并且y.equals(z)返回true，那么x.quals(z)也必须返回true.
  • 一致性consistent,多次调用x.equals(y)都会一致地返回true或一致地返回false.
  • 里氏交换原则认为，一个类型的任何重要属性也将适用于它的子类型，因此为该类型编写的任何方法，在它的子类型上也应该运行得很好。
  • Timestamp类有一个免责声明，告诫程序员不要混用Date和Timestamp对象。
  • 实现高质量equals方法的诀窍：
  • 1-使用==操作符检查‘参数是否为这个对象的引用’
  • 2-使用instanceof检查'参数是否为正确的类型'
  • 3-把参数转换为正确的类型。因为转换之前已经做过instanceof测试，所以确保成功
  • 4-对于该类中的每个'关键significant'域，检查参数中的域是否与该对象中相应的域相匹配。
  • 5-当你编写完equals方法后，应该问下自己：它是否是对称的，传递的，一致的？
  • 覆盖equals方法时总要覆盖hashCode方法

Item 9: Always override hashCode when you override equals重写hashCode方法时记得重写equals方法

  • To take the hash code of float and double values, use Float.floatToIntBits and Double.doubleToLongBits, respectively.
  • Immutability offers the chance to cache hash codes if computing them is expensive.
  • Try not to specify the behavior of your hash code method in Javadoc, as that limits your options for improving it later.
  • 在每个覆盖了equals方法的类中，也必须覆盖hashCode方法
  • 如果两个对象根据equals方法比较是相等的，那么两个对象的hashCode方法必须产生相等的整数结果。相等的对象必须具有相等的散列码。
  • 一个好的散列函数通常倾向于'为不相等的对象产生不相等的散列码'。
  • 在散列码的计算过程中，可以把冗余域redundant field排除在外。
  • 习惯上都使用素数来计算散列结果。31有个很好的特性，即用移位和减法来代替乘法，可以得到更好的性能：31*i==(i << 5)-i。
  • 不要试图从散列码计算中排除掉一个对象的关键部分来提高性能。

Item 10: Always override toString始终要覆盖toString

  • If you specify the format in Javadoc, provide a static factory method accepting a String parameter so a client can convert between the two forms.
  • Provide programmatic information to all the information provided by toString, or clients may try to parse the string to retrieve it.
  • 在实际应用中，toString方法应该返回对象中包含的所有值得关注的信息
  • 实现toString时，在文档中指定返回值的格式。
  • 无论你是否指定格式，都应该在文档中明确地表明你的意图。
  • 无论是否指定格式，都为toString返回值中包含的所有信息，提供一种编程式的访问途径。

Item 12: Consider implementing Comparable考虑实现Comparable接口

  • Like the equals method, there is no way to extend and instantiable class with a new value component while preserving the compareTo contract.
  • If compareTo is consistent with equals, note that sorted collections (e.g. TreeSet, TreeMap) use the equality test imposed by compareTo instead of equals and may break the interface (e.g. Set, Map) contract.
  • Use methods Double.compare and Float.compare instead of relational operators, which don't obey the compareTo contract for floating point values.

Chapter 4: Classes and Interfaces类和接口

Item 13: Minimize the accessibility of classes and members使类和成员的可访问性最小化

  • Private and package-private members can "leak" into the exported API if the class implements Serializable.
  • Even a protected member is part of the class's exported API and must be supported forever.
  • With the exception of public static final fields to immutable objects, public classes should have no public fields.

Item 14: In public classes, use accessor methods, not public fields在public类中使用public方法而非public属性

  • If a class is package-private or a private nested class, there's nothing wrong with exposing its data.
  • A public class with immutable public fields is okay because it can enforce their invariants upon construction.

Item 15: Minimize mutability使可变性最小化

  • For immutable classes, the Java memory model requires that all fields be final to ensure correct behavior when passing an instance between threads without synchronization.
  • Defend against "leaking" references by making defensive copies in constructors, accessors, and readResolve methods when needed.
  • Instances of an immutable class can share internal objects with one another for efficiency.
  • If a client requires performing expensive multi-stage operations on your class, expose them as primitive methods, or provide a mutable companion class (like StringBuilder for String).

Item 16: Favor composition over inheritance复合优先于继承

  • Inheritance violates encapsulation because the subclass depends on the implementation details of the superclass for its proper function.
  • Inheritance means you inherit the scope and flaws of an API, whereas composition allows you to design a better suited one.
  • If an appropriate interface exists, using composition and forwarding allows you to instrument any implementation of the interface, instead of a single implementation through inheritance.

Item 17: Design and document for inheritance, or else prohibit it要么为继承设计和提供文档，要么禁止继承

  • The class that allows subclassing must document its self-use of overridable methods.
  • The only way to test if a class is suitably designed for inheritance (e.g. provides all the necessary implementation hooks through protected methods) is to actually write subclasses.
  • Eliminating a class's self use of methods, typically through introducing private helper methods, can make a class safe to subclass.

Item 18: Prefer interfaces to abstract classes接口优先于抽象类

  • Use interfaces to allow construction of non-hierarchical type frameworks.
  • Simulated multiple inheritance is where a class implementing an interface can forward invocations to an instance of a private inner class that extends the skeletal implementation of that interface and hence does the bulk of the work.
  • A variant of a skeletal implementation is the simple implementation, which is a concrete class that defines the simplest possible implementation, such as AbstractMap.SimpleEntry.
  • Java只允许单继承，所以，抽象类作为类型定义受到了极大的限制。
  • 接口是定义mixin混合类型的理想选择。
  • 接口允许我们构造非层次结构的类型框架。
  • 通过包装器wrapper class模式，接口使得安全地增强类的功能成为可能。通过对你导出的每个重要接口都提供一个抽象的骨架实现skelect implementation类，把接口和抽象类的优点结合起来。接口的作用仍然是定义类型，但是骨架实现类接管了所有与接口实现相关的工作。
  • 通过接口来定义允许多个实现的类型，与使用接口相比有一个明显的优势：抽象类的演变要比接口演变要容易得多。
  • 设计公有的接口要十分谨慎。接口一旦被公开发行，并且已被广泛实现，再想改变这个接口几乎是不可能的。

Item 19: Use interfaces only to define types接口只用于定义类型

  • Don't use constant interfaces, or interfaces that define no methods but only constants, which classes implement to access the constants without fully qualifying their names.
  • If the constants are static members of a class, and you really don't want to qualify their names, use the static import facility for brevity.

Item 21: Use function objects to represent strategies用函数对象表示策略

  • Classes that implement concrete strategies, or simulate function pointers, should be stateless and made into singletons.
  • When defining a strategy as an anonymous class that is inline in a method invocation, consider extracting the object as a private static final field so a new instance is not created upon every call.

Item 22: Favor static member classes over nonstatic优先考虑静态成员类

  • Nonstatic member classes are ideal for providing adapters, or views of an outer class as an instance of some unrelated class.
  • An anonymous class have enclosing instances if and only if they occur in a non-static context.

Chapter 5: Generics

Item 23: Don't use raw types in new code

  • List is read as "list of E", and List is read as "list of string", where String is the actual type parameter and E is the formal type parameter.
  • While an instance of the raw type List could be designated to hold only types of a single class but opts out of type-checking, List is typesafe because it explicitly states that it can contain objects of any type.
  • The unbound wildcard type, such as in List, represents a list of some unknown type and so forbids inserting any element other than null, unlike the raw type List which is not typesafe.

    • Item 24: Eliminate unchecked warnings

    • Always use the @SuppressWarnings annotation on the smallest scope possible, to not mask other, critical warnings.

    Item 25: Prefer lists to arrays

    • Arrays are covariant, so Sub[] is a subtype of Super[], and reified, so they retain their type-information at runtime and Super[] can throw an ArrayStoreException when given a different subclass; by contrast, List is covariant and erased.
    • Consequently, arrays provide runtime safety but not compile-time safety, while a generic type like List provides compile-time safety but not runtime safety.

    Item 27: Favor generic methods

    • You can exploit the type inference provided by generic methods and write generic static factory methods that make instances easier to create.
    • If you have an immutable, singleton instance of a generic class that could be shared across all types, make it private and of type Object, and then let a generic singleton factory method cast it to the caller's desired type.
    • The type bound > may be read as "for every type T that can be compared to itself" and is the definition of a mutually comparable type.

    Item 28: Use bounded wildcards to improve API flexibility

    • If a parameterized type represents a T producer, use ; if a parameterized type represents a T consumer, use .
    • Do not use wildcard types as return types, or clients will be forced to use wildcard types in their code.
    • Comparables and comparators are always consumers, so you should always use Comparator in preference to Comparator.
    • If a type parameter appears only once in a method declaration, replace it with a wildcard, using a private helper method to capture the type if necessary.

    Item 29: Consider typesafe heterogeneous containers优先考虑类型安全的异构容器

    • A type token is a class literal is passed among methods to communicate both compile-time and runtime type information.
    • The cast method of the Class type is the dynamic analog of Java's cast operator, throwing a ClassCastException if the operation fails.
    • The "checked" collection wrappers in java.util.Collections use this method with type tokens to enforce, at runtime, that invalid types are not added to a collection through its raw type.

    Chapter 6: Enums and Annotations枚举和注解

    Item 30: Use enum instead of int constants使用枚举代替int常量

    • You can add or reorder constants in an enum type without recompiling its clients because the constant values are not compiled into the clients as they are with the int enum pattern.
    • Enums are by their nature immutable, and so all their fields should be final.
    • If you override the toString method of an enum type, consider writing a fromString method, similar to how the static valueOf method would perform if you had not overridden toString.
    • To share a constant specific method implementations between enum values, move each implementation into a private nested enum, and pass an instance of this strategy enum to the constructor of the top-level enum.

    Item 32: Use EnumSet instead of bit fields使用EnumSet代替位域

    • An EnumSet is represented by one or more long values, and so many of its operations are effiiciently performed with bitwise arithmetic.

    Item 33: Use EnumMap instead of ordinal indexing用EnumMap代替序数索引

    • When you access an array that is indexed by the ordinal value of an enum, it is your responsibility to use the correct int value, as no type safety is afforded.
    • An EnumMap contains an array internally, offering the speed of an ordinal-indexed array with the type safety and richness of the Map interface.
    • Instead of using an array of arrays to define a mapping from two enum values, use EnumMap<..., EnumMap<...>>, which is internally represented as an array of arrays.

    Item 34: Emulate extensible enumerated types with interfaces用接口模拟可伸缩的枚举

    • If two enumerated types implement the same interface, both their classes adhere to the type  & InterfaceName>.
    • Since implementations cannot be inherited from one enum type to another, the functionality must be encapsulated in a helper class or a static helper method.

    Item 35: Prefer annotations to naming patterns注解优先于命名模式

    • Annotations like Retention and Target for annotation type declarations are called meta-annotations.
    • A marker annotation is one with no parameter and simply serves to mark some class, method, or field for interpretation by some other method or program.

    Item 36: Consistently use the Override annotation坚持使用override注解

    • There is no need to use the @Override annotation when a concrete class overrides an abstract method, i.e. implements it, because a differing signature will be caught by the compiler anyway.
    • In an abstract class or interface, annotate all methods you believe to override superclass or superinterface methods, whether concrete or abstract, to ensure that you don't accidentally introduce any new methods.

    Item 37: Use marker interfaces to define types使用标记接口定义类型

    • Use a marker interface instead of an annotation if you want to write one or more methods that accept only objects that have this marking, or implement the interface.
    • Use a marker interface instead of an annotation if you want to limit the use of the marker to elements of a particular interface, by having the marker interface extend that interface.
    • A marker annotation, however, allows marking elements other than classes and interfaces, and allows adding more information while retaining backwards compatibility through type elements with defaults.

    Chapter 7: Methods方法

    Item 38: Check parameters for validity检查参数有效性

    • Nonpublic methods should check their parameters using assertions, which are enabled with the -enableassertions command line flag, instead of explicitly throwing exceptions.
    • Skip checking a method's parameters before performing the computation if the validity check would be expensive or impractical and the validity check is performed implicitly during the computation.

    Item 39: Make defensive copies when needed必要时进行保护性拷贝

    • When making defensive copies of constructor parameters, check the validity of the copies instead of the originals to guard against malicious changes to the parameters by another thread.
    • Do not use the clone method to make a defensive copy of a constructor parameter whose type is subclassable by untrusted parties.
    • The defensive copy can be replaced by documented transfer of ownership if copying the object would be costly and the class trusts its clients not to modify the components inappropriately.

    Item 40: Design method signatures carefully谨慎设计方法签名

    • If you go over four parameters, try to break up the method into orthogonal methods with fewer parameters, introduce helper classes that bundle related parameters together, or use a builder pattern.
    • Prefer two-element enum types to boolean parameters.

    Item 41: Use overloading judiciously慎用重载

    • Beware that selection among overloaded methods is static, while selection among overridden methods is dynamic.
    • Avoid cases where the same set of parameters can be passed to different overloadings of a method by the addition of casts.
    • If a method with a primitive parameter overloads a method with a generic parameter, the two can become conflated from autoboxing.

    Item 42: Use varargs judiciously慎用可变参数

    • Don't blindly retrofit every method that has a final array parameter to use varargs; use varargs only when a call operates on a variable-length sequence of values.

    Item 43: Return empty arrays or collections, not nulls返回零长度的数组或集合而不是null

    • Returning null from an array or collection-valued method complicates the caller logic, and usually the callee's.
    • To eliminate the overhead from creating an empty collection or array, return the immutable empty collections in java.util.Collections, or create a static empty array which is necessarily immutable.

    Item 44: Write doc comments for all exposed API elements为所有导出的API元素编写文档注释

    • To include a multiline code example in a doc comment, use a Javadoc {@code} tag wrapped inside an HTML 
       tag.
    • The {@literal} tag is like the {@code} tag in that it eliminates the need to escape HTML metacharacters, but doesn't render the contents in monospaced font.
    • No two members or constructors should have the same summary description, which is the first (sometimes incomplete) sentence of a doc comment.

    Chapter 8: General Programming通用程序设计

    Item 45: Minimize the scope of local variables将局部变量的作用域最小化

    • Declare a variable at the latest point possible, typically right before it is first used, and strive to provide an initializer.
    • If the bound for a loop variable is expensive to compute on every iteration, store it in a loop variable that will fall out of scope with the counter variable.

    Item 46: Prefer for-each loops to traditional for loops for-each循环优先于传统for循环

    • If you are writing a type that represents a group of elements, have it implement the Iterable interface even if it does not implement Collection.
    • The enhanced for loop cannot be used if you need to remove elements through an iterator, reassign elements through a list iterator, or iterate over collections in parallel.

    Item 47: Know and use the libraries了解和使用类库

    • Every programmer should be familiar with the contents of java.lang and java.util (particularly the collections framework), and to a lesser extent java.io and java.util.concurrent.

    Item 48: Avoid float and double if exact answers are required需要精确的结果时避免使用float和double

    • The BigDecimal can contain decimal values of arbitrary size and provides eight rounding modes, which is ideal for business calculations with legally mandated rounding behavior.
    • If you choose to keep track of the decimal point yourself, int provides up to nine decimal digits, while long provides up to eighteen.

    Item 49: Prefer primitive types to boxed primitives基本类型优先于装箱类型

    • Never use == on two boxed primitives, because this always performs identity comparison, while the < and > operators compare the underlying primitive values.
    • When you mix primitives and boxed primitives in a single operation, the boxed primitive is auto-unboxed, which can result in NullPointerExceptions.
    • Beware of boxed primitives being implicitly unboxed and then re-boxed, which can cause performance problems.

    Item 50: Avoid strings where other types are appropriate如果其他类型更适合，避免使用String

    • Instead of using a key to represent an aggregate type, write a private static member class -- even if it only has two fields.

    Item 51: Beware the performance of string concatenation当心字符串连接的性能

    • A consequence of strings being immutable is that the time to concatenate n strings is quadratic in n.
    • An alternative to using a StringBuilder is to try processing the strings one at a time to avoid all concatenation.

    Item 52: Refer to objects by their interfaces通过接口引用对象

    • If you depend on any properties of an implementation not specified by its interface, such as its synchronization policy, use the class as a type and document the requirements.

    Item 53: Prefer interfaces to reflection接口优先于反射机制

    • If a class is unavailable at compile time but there exists an appropriate interface, create instances reflectively and access them normally through their interface.
    • If writing a package that runs against multiple versions of some other package, you can compile it against the minimal environment required to support it, and access any newer classes or methods reflectively.

    Item 55: Optimize judiciously谨慎地进行优化

    • Strive for encapsulation so that a part of the system can be rewritten for performance without changing its other parts.
    • You need to measure attempted optimization carefully on the Java platform, because the language does not have a strong performance model, or well-defined relative costs.

    Item 56: Adhere to generally accepted naming conventions遵守普遍接受的命名惯例

    • Components of a package name should be short, generally eight or fewer characters, where abbreviations are encouraged and acronyms are acceptable.
    • Names of static final fields whose values are immutable should be in uppercase with words separated by underscores.
    • Methods that convert a type have the format toType, while methods that return a view have the format asType, and methods that return a primitive representation have the format typeValue.

    Chapter 9: Exceptions异常

    Item 57: Use exceptions for exceptional conditions仅在异常情况下才使用Exception

    • Do not force clients to use exceptions for ordinary control flow, and instead offer methods to test whether an exception could be thrown, such as hasNext for class Iterator.
    • Use a distinguished return value, like null, if the object is accessed by multiple threads or if the state-testing method duplicates the work of the state-dependent method.

    Item 58: Use checked exceptions for recoverable conditions and runtime exceptions for programming errors对可恢复的情况使用受检异常，对编程性错误使用运行时异常

    • Use runtime exceptions to indicate programming errors, typically precondition violations.
    • Don't implement any new Error subclasses, and don't define a throwable that does not subclass Exception or RuntimeException.

    Item 59: Avoid unnecessary use of checked exceptions避免不必要地使用受检异常

    • When designing an API, only throw a checked exception if it can be prevented by a proper use of the API, and the programmer can take some useful action once thrown.

    Item 60: Favor the use of standard exceptions优先使用标准异常

    • Throw a NullPointerException instead of an IllegalArgumentException if a caller passes in a null parameter where prohibited.
    • Throw an IndexOutOfBoundsException instead of an IllegalArgumentException if the caller passes in an invalid index for a sequence.

    Item 61: Throw exceptions appropriate to the abstraction抛出与抽象对应的异常

    • Use exception translation, where low-level exceptions are caught and exceptions appropriate to the higher-level abstraction are thrown.
    • If an exception does not have a chaining-aware constructor, use the initCause method of Throwable.
    • Try to avoid low-level exceptions by checking the higher-level method's parameters upfront.

    Item 62: Document all exceptions thrown by each method每个抛出的异常都要有文档注释

    • Document the unchecked exceptions a method can throw, thereby documenting its preconditions.
    • Do not use the throws keyword to include unchecked exceptions in a method declaration.

    Item 63: Include failure-capture information in detail messages在消息细节中包含能捕获的失败信息

    • The toString method, or "detail message," should contain the values of all the parameters and fields contributing to the exception.
    • To capture this information easily, make them parameters to the constructor, and internally generate the detail message from them.

    Item 64: Strive for failure atomicity努力使失败保持原子性

    • A failed method invocation should leave the object in the state it was prior to the invocation.
    • Typically you can easily achieve failure atomicity by checking the parameters' validity before the operation.

    Chapter 10: Concurrency并发

    Item 66: Synchronize access to shared mutable data synchronize共享的可变数据

    • Synchronization is not just for mutual exclusion, but ensuring that a value written by one thread is seen by another.
    • Both read and write operations on mutable data must be synchronized or visibility is not guaranteed.
    • Beware that the increment and decrement operators are not atomic on volatile integers.

    Item 67: Avoid excessive synchronization避免过度同步

    • Inside a synchronized region, do not invoke a method that is provided by the client as a function object, or can be overriden.
    • Reentrant locks simplify the construction of multi-threaded object oriented programs, but can allow foreign methods to access an object in an inconsistent state.
    • Only make a mutable class thread-safe if intended for concurrent use and you can achieve better concurrency with internal locking; otherwise, punt locking to the client.

    你可能感兴趣的:(Java)

    • Long类型前后端数据不一致 igotyback 前端
      响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    • LocalDateTime 转 String igotyback java开发语言
      importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
      需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
      ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
      华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
      ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
      Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    • node.js学习 小猿L node.jsnode.js学习vim
      node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    • Java 重写(Override)与重载(Overload) 叨唧唧的
      Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    • 简单了解 JVM 记得开心一点啊 jvm
      目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
      1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    • Java企业面试题3 马龙强_ java
      1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
      Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
      一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
      欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    • python语法——三目运算符 HappyRocking pythonpython三目运算符
      在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
      ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
      一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    • Java：爬虫框架 dingcho Javajava爬虫
      一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    • python怎么将png转为tif_png转tif weixin_39977276
      发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
      在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
      文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
      文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    • 博客网站制作教程 2401_85194651 javamaven
      首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    • 00. 这里整理了最全的爬虫框架（Java + Python） 有一只柴犬 爬虫系列爬虫javapython
      目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    • JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式androidjava常用设计模式
      博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
      在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
    • 切换淘宝最新npm镜像源是 hai40587 npm前端node.js
      切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
    • 【Java】已解决：java.util.concurrent.CompletionException 屿小夏 java开发语言
      文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
    • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】） ok!ko 设计模式设计模式建造者模式java
      文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
    • ztree异步加载 3213213333332132 JavaScriptAjaxjsonWebztree
      相信新手用ztree的时候,对异步加载会有些困惑，我开始的时候也是看了API花了些时间才搞定了异步加载，在这里分享给大家。 我后台代码生成的是json格式的数据，数据大家按各自的需求生成，这里只给出前端的代码。 设置setting，这里只关注async属性的配置 var setting = { //异步加载配置
    • thirft rpc 具体调用流程 BlueSkator 中间件rpcthrift
      Thrift调用过程中，Thrift客户端和服务器之间主要用到传输层类、协议层类和处理类三个主要的核心类，这三个类的相互协作共同完成rpc的整个调用过程。在调用过程中将按照以下顺序进行协同工作：         （1）     将客户端程序调用的函数名和参数传递给协议层（TProtocol），协议
    • 异或运算推导, 交换数据 dcj3sjt126com PHP异或^
      /* * 5 0101 * 9 1010 * * 5 ^ 5 * 0101 * 0101 * ----- * 0000 * 得出第一个规律: 相同的数进行异或, 结果是0 * * 9 ^ 5 ^ 6 * 1010 * 0101 * ---- * 1111 * * 1111 * 0110 * ---- * 1001
    • 事件源对象 周华华 JavaScript
      <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
    • MySql配置及相关命令 g21121 mysql
              MySQL安装完毕后我们需要对它进行一些设置及性能优化，主要包括字符集设置，启动设置，连接优化，表优化，分区优化等等。           一 修改MySQL密码及用户      
    • [简单]poi删除excel 2007超链接 53873039oycg Excel
            采用解析sheet.xml方式删除超链接，缺点是要打开文件2次,代码如下:      public void removeExcel2007AllHyperLink(String filePath) throws Exception { OPCPackage ocPkg = OPCPac
    • Struts2添加 open flash chart 云端月影
      准备以下开源项目： 1. Struts 2.1.6 2. Open Flash Chart 2 Version 2 Lug Wyrm Charmer (28th, July 2009) 3. jofc2，这东西不知道是没做好还是什么意思，好像和ofc2不怎么匹配，最好下源码，有什么问题直接改。 4. log4j 用eclipse新建动态网站，取名OFC2Demo，将Struts2 l
    • spring包详解 aijuans spring
      下载的spring包中文件及各种包众多，在项目中往往只有部分是我们必须的，如果不清楚什么时候需要什么包的话，看看下面就知道了。 aspectj目录下是在Spring框架下使用aspectj的源代码和测试程序文件。Aspectj是java最早的提供AOP的应用框架。 dist 目录下是Spring 的发布包，关于发布包下面会详细进行说明。 docs&nb
    • 网站推广之seo概念 antonyup_2006 算法Web应用服务器搜索引擎Google
         持续开发一年多的b2c网站终于在08年10月23日上线了。作为开发人员的我在修改bug的同时，准备了解下网站的推广分析策略。     所谓网站推广，目的在于让尽可能多的潜在用户了解并访问网站，通过网站获得有关产品和服务等信息，为最终形成购买决策提供支持。     网站推广策略有很多，seo，email，adv
    • 单例模式,sql注入,序列 百合不是茶 单例模式序列sql注入预编译
        序列在前面写过有关的博客,也有过总结,但是今天在做一个JDBC操作数据库的相关内容时 需要使用序列创建一个自增长的字段  居然不会了,所以将序列写在本篇的前面    1,序列是一个保存数据连续的增长的一种方式; 序列的创建; CREATE SEQUENCE seq_pro 2 INCREMENT BY 1 -- 每次加几个 3
    • Mockito单元测试实例 bijian1013 单元测试mockito
      Mockito单元测试实例： public class SettingServiceTest { private List<PersonDTO> personList = new ArrayList<PersonDTO>(); @InjectMocks private SettingPojoService settin
    • 精通Oracle10编程SQL(9)使用游标 bijian1013 oracle数据库plsql
      /* *使用游标 */ --显示游标 --在显式游标中使用FETCH...INTO语句 DECLARE CURSOR emp_cursor is select ename,sal from emp where deptno=1; v_ename emp.ename%TYPE; v_sal emp.sal%TYPE; begin ope
    • 【Java语言】动态代理 bit1129 java语言
        JDK接口动态代理 JDK自带的动态代理通过动态的根据接口生成字节码(实现接口的一个具体类)的方式，为接口的实现类提供代理。被代理的对象和代理对象通过InvocationHandler建立关联   package com.tom; import com.tom.model.User; import com.tom.service.IUserService;
    • Java通信之URL通信基础 白糖_ javajdkwebservice网络协议ITeye
      java对网络通信以及提供了比较全面的jdk支持，java.net包能让程序员直接在程序中实现网络通信。 在技术日新月异的现在，我们能通过很多方式实现数据通信，比如webservice、url通信、socket通信等等，今天简单介绍下URL通信。 学习准备：建议首先学习java的IO基础知识   URL是统一资源定位器的简写，URL可以访问Internet和www，可以通过url
    • 博弈Java讲义 - Java线程同步 (1) boyitech java多线程同步锁
        在并发编程中经常会碰到多个执行线程共享资源的问题。例如多个线程同时读写文件，共用数据库连接，全局的计数器等。如果不处理好多线程之间的同步问题很容易引起状态不一致或者其他的错误。    同步不仅可以阻止一个线程看到对象处于不一致的状态，它还可以保证进入同步方法或者块的每个线程，都看到由同一锁保护的之前所有的修改结果。处理同步的关键就是要正确的识别临界条件（cri
    • java-给定字符串，删除开始和结尾处的空格，并将中间的多个连续的空格合并成一个。 bylijinnan java
      public class DeleteExtraSpace { /** * 题目：给定字符串，删除开始和结尾处的空格，并将中间的多个连续的空格合并成一个。 * 方法1.用已有的String类的trim和replaceAll方法 * 方法2.全部用正则表达式，这个我不熟 * 方法3.“重新发明轮子”，从头遍历一次 */ public static v
    • An error has occurred.See the log file错误解决！ Kai_Ge MyEclipse
      今天早上打开MyEclipse时，自动关闭！弹出An error has occurred.See the log file错误提示！ 很郁闷昨天启动和关闭还好着！！！打开几次依然报此错误，确定不是眼花了！ 打开日志文件！找到当日错误文件内容： --------------------------------------------------------------------------
    • [矿业与工业]修建一个空间矿床开采站要多少钱? comsci
             地球上的钛金属矿藏已经接近枯竭...........        我们在冥王星的一颗卫星上面发现一些具有开采价值的矿床.....        那么,现在要编制一个预算,提交给财政部门..
    • 解析Google Map Routes dai_lm google api
      为了获得从A点到B点的路劲，经常会使用Google提供的API，例如 [url] http://maps.googleapis.com/maps/api/directions/json?origin=40.7144,-74.0060&destination=47.6063,-122.3204&sensor=false [/url] 从返回的结果上，大致可以了解应该怎么走，但
    • SQL还有多少“理所应当”？ datamachine sql
      转贴存档，原帖地址：http://blog.chinaunix.net/uid-29242841-id-3968998.html、http://blog.chinaunix.net/uid-29242841-id-3971046.html！ ------------------------------------华丽的分割线--------------------------------
    • Yii使用Ajax验证时，如何设置某些字段不需要验证 dcj3sjt126com Ajaxyii
      经常像你注册页面,你可能非常希望只需要Ajax去验证用户名和Email,而不需要使用Ajax再去验证密码,默认如果你使用Yii 内置的ajax验证Form,例如: $form=$this->beginWidget('CActiveForm', array(        'id'=>'usuario-form',&
    • 使用git同步网站代码 dcj3sjt126com crontabgit
      转自:http://ued.ctrip.com/blog/?p=3646?tn=gongxinjun.com   管理一网站，最开始使用的虚拟空间，采用提供商支持的ftp上传网站文件，后换用vps，vps可以自己搭建ftp的，但是懒得搞，直接使用scp传输文件到服务器，现在需要更新文件到服务器，使用scp真的很烦。发现本人就职的公司，采用的git+rsync的方式来管理、同步代码，遂
    • sql基本操作 蕃薯耀 sqlsql基本操作sql常用操作
      sql基本操作 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月1日 17:30:33 星期一     &
    • Spring4+Hibernate4+Atomikos3.3多数据源事务管理 hanqunfeng Hibernate4
      Spring3+后不再对JTOM提供支持，所以可以改用Atomikos管理多数据源事务。Spring2.5+Hibernate3+JTOM参考：http://hanqunfeng.iteye.com/blog/1554251Atomikos官网网站：http://www.atomikos.com/   一.pom.xml <dependency> <
    • jquery中两个值得注意的方法one()和trigger()方法 jackyrong trigger
        在jquery中，有两个值得注意但容易忽视的方法，分别是one()方法和trigger()方法,这是从国内作者<<jquery权威指南》一书中看到不错的介绍 1） one方法     one方法的功能是让所选定的元素绑定一个仅触发一次的处理函数，格式为    one(type,${data},fn) &nb
    • 拿工资不仅仅是让你写代码的 lampcy 工作面试咨询
      这是我对团队每个新进员工说的第一件事情。这句话的意思是，我并不关心你是如何快速完成任务的，哪怕代码很差，只要它像救生艇通气门一样管用就行。这句话也是我最喜欢的座右铭之一。 这个说法其实很合理：我们的工作是思考客户提出的问题，然后制定解决方案。思考第一，代码第二，公司请我们的最终目的不是写代码，而是想出解决方案。 话粗理不粗。 付你薪水不是让你来思考的，也不是让你来写代码的，你的目的是交付产品
    • 架构师之对象操作----------对象的效率复制和判断是否全为空 nannan408 架构师
      1.前言。   如题。 2.代码。 (1)对象的复制，比spring的beanCopier在大并发下效率要高，利用net.sf.cglib.beans.BeanCopier Src src=new Src(); BeanCopier beanCopier = BeanCopier.create(Src.class, Des.class, false);
    • ajax 被缓存的解决方案 Rainbow702 JavaScriptjqueryAjaxcache缓存
      使用jquery的ajax来发送请求进行局部刷新画面，各位可能都做过。 今天碰到一个奇怪的现象，就是，同一个ajax请求，在chrome中，不论发送多少次，都可以发送至服务器端，而不会被缓存。但是，换成在IE下的时候，发现，同一个ajax请求，会发生被缓存的情况，只有第一次才会被发送至服务器端，之后的不会再被发送。郁闷。 解决方法如下： ① 直接使用 JQuery提供的 “cache”参数，
    • 修改date.toLocaleString()的警告 tntxia String
        我们在写程序的时候，经常要查看时间，所以我们经常会用到date.toLocaleString()，但是date.toLocaleString()是一个过时 的API，代替的方法如下：   package com.tntxia.htmlmaker.util; import java.text.SimpleDateFormat; import java.util.
    • 项目完成后的小总结 xiaomiya js总结项目
      项目完成了，突然想做个总结但是有点无从下手了。 做之前对于客户端给的接口很模式。然而定义好了格式要求就如此的愉快了。 先说说项目主要实现的功能吧 1，按键精灵 2，获取行情数据 3，各种input输入条件判断 4，发送数据（有json格式和string格式） 5，获取预警条件列表和预警结果列表， 6，排序， 7，预警结果分页获取 8，导出文件（excel，text等） 9，修