六、其它

• char是2个字节，utf-8是1~3个字节。
• 字符集（字符集不是编码）：ASCII码与Unicode码。
• 字符 -> 0xd83dde00(码点）。

• byteString = "中"
• unicodeString = u"中"

emoij = u"表情"
print(len(emoji)

• Java char不存UTF-8的字节，而是UTF-16。
• Unicode通用字符集占两个字节，例如“中”。
• Unicode扩展字符集需要用一对char来表示，例如“表情”。
• Unicode是字符集，不是编码，作用类似于ASCII码。
• Java String的length不是字符数。

• 分配到栈：

  String longString = "aaa...aaa";
  

• 分配到堆：

  byte[] bytes = loadFromFile(new File("superLongText.txt");
  String superLongString = new String(bytes);
  

• 源文件：*.java

  String longString = "aaa...aaa";
  字节数 <= 65535
  

• 字节码：*.class

  CONSTANT_Utf8_info { 
      u1 tag; 
      u2 length;
      (0~65535) u1 bytes[length]; 
      最多65535个字节 
  }
  

• 受字节码限制，字符串最终的MUTF-8字节数不超过65535。
• Latin字符，受Javac代码限制，最多65534个。
• 非Latin字符最终对应字节个数差异较大，最多字节个数是65535。
• 如果运行时方法区设置较小，也会受到方法区大小的限制。

• 受虚拟机指令限制，字符数理论上限为Integer.MAX_VALUE。
• 受虚拟机实现限制，实际上限可能会小于Integer.MAX_VALUE。
• 如果堆内存较小，也会受到堆内存的限制。

• 字节码中CONSTANT_Utf8_info的限制
• Javac源码逻辑的限制
• 方法区大小的限制

• Java虚拟机指令newarray的限制
• Java虚拟机堆内存大小的限制

• 匿名内部类的名字：没有人类认知意义上的名字
• 只能继承一个父类或实现一个接口
• 包名.OuterClass\(1，表示定位的第一个匿名内部类。外部类加\)N，N是匿名内部类的顺序。

• 匿名内部类的继承结构：Java中的匿名内部类不可以继承，只有内部类才可以有实现继承、实现接口的特性。而Kotlin是的匿名内部类是支持继承的，如

  val runnableFoo = object: Foo(),Runnable { 
          override fun run() { 
          } 
  }
  

• 匿名内部类会默认持有外部类的引用，可能会导致内存泄漏。
• 由编译器生成的。

• 外部对象（定义在非静态域内）
• 父类的外部对象（父类非静态）
• 父类的构造方法参数（父类有构造方法且参数列表不为空）
• 外部捕获的变量（方法体内有引用外部final变量）

CallBack callBack = () -> { 
        ... 
};

• 没有人类认知意义上的名字。
• 只能继承一个父类或实现一个接口。
• 父类是非静态的类型，则需父类外部实例来初始化。
• 如果定义在非静态作用域内，会引用外部类实例。
• 只能捕获外部作用域内的final变量。
• 创建时只有单一方法的接口可以用Lambda转换。

• 体现对技术的热情
• 体现好学的品质
• 显得专业

1. 尽量不要捕获类似 Exception 这样的通用异常，而是应该捕获特定异常。
2. 不要生吞异常。

• 匿名内部类用法：

  public class TryUsingAnonymousClass {
      public void useMyInterface() {
          final Integer number = 123;
          System.out.println(number);
          MyInterface myInterface = new MyInterface() {
              @Override
              public void doSomething() {
                  System.out.println(number);
              }
          };
          myInterface.doSomething();
          System.out.println(number);
      }
  }
  

• 编译后的结果

  class TryUsingAnonymousClass$1
          implements MyInterface {
      private final TryUsingAnonymousClass this$0;
      private final Integer paramInteger;
      TryUsingAnonymousClass$1(TryUsingAnonymousClass this$0, Integer paramInteger) {
          this.this$0 = this$0;
          this.paramInteger = paramInteger;
      }
      public void doSomething() {
          System.out.println(this.paramInteger);
      }
  }
  

1. ASCII：总共有 128 个，用一个字节的低 7 位表示，031 是控制字符如换行回车删除等；32126 是打印字符，可以通过键盘输入并且能够显示出来。
2. GBK：码范围是 8140~FEFE（去掉 XX7F）总共有 23940 个码位，它能表示 21003 个汉字，它的编码是和 GB2312 兼容的，也就是说用 GB2312 编码的汉字可以用 GBK 来解码，并且不会有乱码。
3. UTF-16：UTF-16 具体定义了 Unicode 字符在计算机中存取方法。UTF-16 用两个字节来表示 Unicode 转化格式，这个是定长的表示方法，不论什么字符都可以用两个字节表示，两个字节是 16 个 bit，所以叫 UTF-16。UTF-16 表示字符非常方便，每两个字节表示一个字符，这个在字符串操作时就大大简化了操作，这也是 Java 以 UTF-16 作为内存的字符存储格式的一个很重要的原因。
4. UTF-8：统一采用两个字节表示一个字符，虽然在表示上非常简单方便，但是也有其缺点，有很大一部分字符用一个字节就可以表示的现在要两个字节表示，存储空间放大了一倍，在现在的网络带宽还非常有限的今天，这样会增大网络传输的流量，而且也没必要。而 UTF-8 采用了一种变长技术，每个编码区域有不同的字码长度。不同类型的字符可以是由 1~6 个字节组成。

• String每次变化一个值就会开辟一个新的内存空间
• StringBuilder：线程非安全的
• StringBuffer：线程安全的

1. 如果要操作少量的数据用 String。
2. 单线程操作字符串缓冲区下操作大量数据用 StringBuilder。
3. 多线程操作字符串缓冲区下操作大量数据用 StringBuffer。

• 内部类可以有多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。
• 在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类。
• 创建内部类对象并不依赖于外围类对象的创建。
• 内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。
• 内部类提供了更好的封装，除了该外围类，其他类都不能访问。。

• 共同点
  • 是上层的抽象层。
  • 都不能被实例化。
  • 都能包含抽象的方法，这些抽象的方法用于描述类具备的功能，但是不提供具体的实现。
• 区别：
  • 在抽象类中可以写非抽象的方法，从而避免在子类中重复书写他们，这样可以提高代码的复用性，这是抽象类的优势，接口中只能有抽象的方法。
  • 多继承：一个类只能继承一个直接父类，这个父类可以是具体的类也可是抽象类，但是一个类可以实现多个接口。
  • 抽象类可以有默认的方法实现，接口根本不存在方法的实现。
  • 子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明方法的实现。子类使用关键字implements来实现接口。它需要提供接口中所有声明方法的实现。
  • 构造器：抽象类可以有构造器，接口不能有构造器。
  • 和普通Java类的区别：除了你不能实例化抽象类之外，抽象类和普通Java类没有任何区别，接口是完全不同的类型。
  • 访问修饰符:抽象方法可以有public、protected和default修饰符，接口方法默认修饰符是public。你不可以使用其它修饰符。
  • main方法:抽象方法可以有main方法并且我们可以运行它接口没有main方法，因此我们不能运行它。
  • 速度:抽象类比接口速度要快，接口是稍微有点慢的，因为它需要时间去寻找在类中实现的方法。
  • 添加新方法:如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。如果你往接口中添加方法，那么你必须改变实现该接口的类。

• 如果两个对象相等，那么他们一定有相同的哈希值（hashcode）。
• 如果两个对象的哈希值相等，那么这两个对象有可能相等也有可能不相等。（需要再通过equals来判断）

1. 创建阶段(Created)： JVM 加载类的class文件 此时所有的static变量和static代码块将被执行 加载完成后，对局部变量进行赋值（先父后子的顺序） 再执行new方法 调用构造函数 一旦对象被创建，并被分派给某些变量赋值，这个对象的状态就切换到了应用阶段。
2. 应用阶段(In Use)： 对象至少被一个强引用持有着。
3. 不可见阶段(Invisible)： 当一个对象处于不可见阶段时，说明程序本身不再持有该对象的任何强引用，虽然该这些引用仍然是存在着的。 简单说就是程序的执行已经超出了该对象的作用域了。
4. 不可达阶段(Unreachable)： 对象处于不可达阶段是指该对象不再被任何强引用所持有。 与“不可见阶段”相比，“不可见阶段”是指程序不再持有该对象的任何强引用，这种情况下，该对象仍可能被JVM等系统下的某些已装载的静态变量或线程或JNI等强引用持有着，这些特殊的强引用被称为”GC root”。存在着这些GC root会导致对象的内存泄露情况，无法被回收。
5. 收集阶段(Collected)： 当垃圾回收器发现该对象已经处于“不可达阶段”并且垃圾回收器已经对该对象的内存空间重新分配做好准备时，则对象进入了“收集阶段”。如果该对象已经重写了finalize()方法，则会去执行该方法的终端操作。
6. 终结阶段(Finalized)： 当对象执行完finalize()方法后仍然处于不可达状态时，则该对象进入终结阶段。在该阶段是等待垃圾回收器对该对象空间进行回收。
7. 对象空间重分配阶段(De-allocated)： 垃圾回收器对该对象的所占用的内存空间进行回收或者再分配了，则该对象彻底消失了，称之为“对象空间重新分配阶段。

• 结论：
  • Java中静态属性和静态方法可以被继承，但是不可以被重写而是被隐藏。
• 原因：
  • 静态方法和属性是属于类的，调用的时候直接通过类名.方法名完成，不需要继承机制即可以调用。如果子类里面定义了静态方法和属性，那么这时候父类的静态方法或属性称之为"隐藏"。如果你想要调用父类的静态方法和属性，直接通过父类名.方法或变量名完成，至于是否继承一说，子类是有继承静态方法和属性，但是跟实例方法和属性不太一样，存在"隐藏"的这种情况。
  • 多态之所以能够实现依赖于继承、接口和重写、重载（继承和重写最为关键）。有了继承和重写就可以实现父类的引用指向不同子类的对象。重写的功能是："重写"后子类的优先级要高于父类的优先级，但是“隐藏”是没有这个优先级之分的。
  • 静态属性、静态方法和非静态的属性都可以被继承和隐藏而不能被重写，因此不能实现多态，不能实现父类的引用可以指向不同子类的对象。非静态方法可以被继承和重写，因此可以实现多态。

1. 在Java应用程序执行期间，如果在equals方法比较中所用的信息没有被修改，那么在同一个对象上多次调用hashCode方法时必须一致地返回相同的整数。如果多次执行同一个应用时，不要求该整数必须相同。
2. 如果两个对象通过调用equals方法是相等的，那么这两个对象调用hashCode方法必须返回相同的整数。
3. 如果两个对象通过调用equals方法是不相等的，不要求这两个对象调用hashCode方法必须返回不同的整数。但是程序员应该意识到对不同的对象产生不同的hash值可以提供哈希表的性能。

1. 判断两个对象的hashCode是否相等。
2. 判断两个对象用equals运算是否相等。

• 强引用（FinalReference）：在内存不足时不会被回收。平常用的最多的对象，如新创建的对象。
• 软引用（SoftReference）：在内存不足时会被回收。用于实现内存敏感的高速缓存。
• 弱引用（WeakReferenc）：只要GC回收器发现了它，就会将之回收。用于Map数据结构中，引用占用内存空间较大的对象。
• 虚引用（PhantomReference）：在回收之前，会被放入ReferenceQueue，JVM不会自动将该referent字段值设置成null。其它引用被JVM回收之后才会被放入ReferenceQueue中。用于实现一个对象被回收之前做一些清理工作。

1. 因为new用到了Person.class，所以会先找到Person.class文件，并加载到内存中;
2. 执行该类中的static代码块，如果有的话，给Person.class类进行初始化;
3. 在堆内存中开辟空间分配内存地址;
4. 在堆内存中建立对象的特有属性，并进行默认初始化;
5. 对属性进行显示初始化;
6. 对对象进行构造代码块初始化;
7. 对对象进行与之对应的构造函数进行初始化;
8. 将内存地址付给栈内存中的p变量。

1. 当数值范围为-128~127时：如果两个new出来的Integer对象，即使值相同，通过 == 比较结果为false，但两个对直接赋值，则通过 == 比较结果为 true，这一点与String非常相似。
2. 当数值不在-128~127时，无论通过哪种方式，即使两对象的值相等，通过 == 比较，其结果为false；
3. 当一个Integer对象直接与一个int基本数据类型通过 == 比较，其结果与第一点相同；
4. Integer对象的hash值为数值本身；

1. 自反性： 对于任何非null的引用值x,x.equals(x)必须返回true。---这一点基本上不会有啥问题
2. 对称性： 对于任何非null的引用值x和y，当且仅当x.equals(y)为true时，y.equals(x)也为true。
3. 传递性： 对于任何非null的引用值x、y、z。如果 x.equals(y)==true,y.equals(z)==true ,那么 x.equals(z)==true 。
4. 一致性： 对于任何非null的引用值x和y，只要equals的比较操作在对象所用的信息没有被修改，那么多次调用x.equals(y)就会一致性地返回true,或者一致性的返回false。
5. 非空性： 所有比较的对象都不能为空。