Please enable JavaScript.

Coggle requires JavaScript to display documents.

Java Syntax (:pineapple:class (:banana:Wrapper Class (:fire:features (:one…

- - - - valueOf
      - switch
        
        switch (this){ case RED: return xx; case YELLOW: return yy; }
    - - public enum xx{ RED(1), YELLOW(2);.... xx(int i){ // ...; } }
    - - in a class? outside of a class?
- - - - constructor is not inherited,but default constructor of the superclass will be executed automatically, so there is no need to explicitly use the super keyword
      - :pineapple:Accessibility
        
        :link:accessibility summary
        
        :star:a subclass cannot weaken the accessibility.
        
        :explode: if a method is public in the super class, then the subclass must define it as public
    - - define a method with the same name as that in the superclass
      - :warning:we always need to override some method in "object" class
        
        :one:equals
        
        :two:toString
        
        :explode:default to "a class name + object id"
    - - :explode:the name of method is same, while the argument list is different
      - :bread:dynamic binding(superclass or subclass) vs method matching(method name + argument list)
  - - - :one:StringBuilder
        
        :fire:features
        
        :one: not thread safe,没有锁,可能会不一致
        
        :two:mutable
        
        单线程使用StringBuilder,多线程使用StringBuffer,平常使用String就好
        
        subString
      - :three:String
        
        String是常量,存放在常量池里,而String s = "h";s = s + 1本质上是重新创建1个常量"h1",然后指向他
        
        "A" + "B" > += "A";+= "B" > append("A");.append("B") (性能)
        
        :fire:features
        
        :two:immutable
        
        :arrow_right:effieciency:StringBuilder > StringBuffer > String
        
        :bread:String is immutable, while StringBuffer and StringBuilder are mutable. For s += "hello", String has to destroy the old object and construct a new object
        
        :bread:thread safety comes with a performance cost
        
        :one:线性安全
      - :two:StringBuffer
        
        :fire:features
        
        :one:thread safe
        
        :zap:methods are defined with synchronized keyword
        
        :two:constructor definitely call new
        
        :three:similar to python list, dynamically allocate char[]
        
        :four:mutable
    - - :one:immutable
      - :two:do not have no-arg constructor
      - :three:instances can be created from numeric type or String( using parseInt, parseDouble)
      - :four:have members, such as MAX_VALUE, MIN_VALUE
      - :five:Integer have an int member, while Double have a double member
    - - :pineapple:initialize an instance
        
        :one:use constant pool
        
        :two:String s = "hell" + "o";
        
        :one:String s = "hello"; and Integer i1 = 123; and Integer i4 = Integer.valueOf(123);
        
        :three:String s1 = s.intern();
        
        :four:Integer i3 = 122 + new Integer(1);
        
        :two:use heap
        
        :one:String s = new String("hello"); and Integer i2 = new Integer(123);
        
        :two:String s5 = "hell" + new String("o");
        
        :warning:warning
        
        :one:integer only have limited values, so 122 + new Integer(1); is different from "hell" + new String("o");
        
        :two:valueOf calls toString() which simple returns this (itself) => String s1 = String.valueOf(s2);, and s1 == s2 is always true even if String s2 = new String("hello");
        
        :star:== compares the reference itself, while equals compare values
      - :moneybag:contains class, method, variable, String constant, etc
      - :watermelon:intern
        
        :bread:try to add "hello" to the constant pool, and return a reference pointing to that space( If there is already "hello" existing in the constant pool, then it will be returned directly)
        
        :explode: create / use the "hello" in the constant pool
      - :heavy_dollar_sign:majority of the Wrapper class, except floating type
  - - - :explode:compare 2 primitive data type values or references for 2 objects
  - - - :explode:if both the outer class and inner class have the method with the same name, the inner class will call the inner method. OuterClassName.this.methodName() otherwise
    - - :one:方法内的类只能访问方法的final变量
        
        :bread:方法内的局部变量保存在栈中,生命周期一直到方法结束为止,但方法内的引用/对象会使用堆,因此即使方法结束也可能引用不被销毁(因为可能被其他人使用),所以方法内的方法不能使用方法内的局部变量
      - :two:方法内的类只能在方法内实例化
      - :three:方法内部类只能final和abstract修饰
    - - :pencil2:NumberCarrier anotherObject = new NumberCarrier(){ privete int number; //...}
    - - :fire:features
        
        :one:cannot create an object of abstract classes
        
        :two:ok to define variables
        
        :three:not implement method
        
        :four:a class is abstract as long as at least one of the methods is abstract
        
        :five:the subclass of an abstract class does not necessarily implement all methods in the super class
        
        :six:we can define an abstract class with all methods implemented. In this case, we say that the user should use it by extending rather than creating an object of it.(for example Object)
      - :heavy_dollar_sign:extend & implement all the methods
    - - :fire:features
        
        :one:a classlike construct that contains only constants and abstract methods
        
        :bread:specify the common behavior
        
        多继承
      - :pencil2:public interface InterfaceName (constant declartions; abstract metho xxx)
      - :warning:interface is compiled into a seperate bytecode
  - - - == => false; equals => true
      - deep copy & shallow copy