Java 学习笔记 #4
by kenvix @ 2018-11-13 pm
内部类
内部类提供了更好的封装
例如，ConsoleOutput单独存在是没有意义的，将Output封装到Console则更具意义，即我们System.out
内部类可以访问外部类的私有成员，但外部类不可以。
枚举
java中，enum是类，但并不继承Object，因此具有类的特性。
当switch表达式传入enum时，case可以省略枚举名称。
个人原则：类是类 枚举是枚举 就算java枚举是类也不当类用
垃圾回收回调
Object类提供finalize()方法，重写此方法可以在被GC时让GC调用此方法
Java 学习笔记 #3
by kenvix @ 2018-11-10 pm
概念这种东西就是应付考试，实际生产中懂概念的不如有经验的。
多态
概念： 相同类型的变量、调用同一个方法时呈现出多种不同的行为特征，称为多态。
Java 中的多态与 TypeScript, C# 中的多态
这三种语言的处理策略不同，涉猎语言较多的用户可能会因此写出 Bug。
Upcasting in C
考虑代码：
class Father
{
public void Test()
{
Console.WriteLine("father");
}
}
class Child : Father
{
public void Test() //equals: public new void Test()
{
Console.WriteLine("child");
}
}
class Program
{
static void Main(string[] args)
{
Father father = new Child();
father.Test();
}
}
输出：father
Upcasting in java
考虑代码：
class Sunzi extends Test {
public void child() {
System.out.println("child!");
}
@Override
public void nmbd() {
System.out.println("extend!sunzi");
}
}
public class Test {
public void nmbd() {
System.out.println("super!");
}
public void father() {
System.out.println("father!");
}
}
Test test = (Test)new Sunzi();
test.nmbd();
输出：extend!sunzi
Java 中，test 的 运行时类型是 Sunzi 而不是 Test，这就导致其方法特征始终呈现为子类的特征，即实际调用了子类的方法。
而在编译其则呈现父类特征，即你不能调用 test.child();
Note: 实例变量与 C# 相同，均为父类的实例变量。
Upcasting in TypeScript
考虑以下 TypeScript 代码:
class father {
public test() {
console.log("father");
}
}
class child extends father{
public test() {
console.log("child");
}
}
const f: father = new child();
f.test();
输出：child
TypeScript 最终是要类型擦除输出JavaScript的，这种类型注解没有任何意义。
拆装箱
即对 基本数据类型 和 包装类型 的直接赋值操作，等效过时的new, getValue。
++ Object 是它们的子类，因此有这种智障操作：
Object obj = 666; //自动 upcasting
int i = (Integer)obj; //用作编译期
许多智障面试官也许会出这种问题
Integer a = 1;
Integer b = 1;
a == b // true
b = 199;
a == b //false (unlinked)
Integer c = 666;
Integer d = 666;
c == d //false
Java 对 -128~127 的 Integer 进行了缓存，故 a b 指向同一个数据。
立刻转 C# 保平安。
字符串常量池
String str1 = new String("fuck");
String str2 = new String("fuck");
String str3 = "fuck";
String str4 = "fuck";
System.out.println(str1==str2); //false
System.out.println(str1==str3); //false
System.out.println(str4==str3); //true
直接使用 String x = “” 表达式赋值的字符串由 JVM 常量池直接接管，相同的字符串引用将指向池中相同的值。
而 String str1 = new String(“fuck”); 则创建了字符串对象到 heap。
IDEA 明确告诉你这种方法很垃圾，但是sb面试官还是要问。
Java 学习笔记 #2
by kenvix @ 2018-11-07 am
java学得越深，越发觉得kotlin香
数据类型
参数传递
java 仅有值传递。传递一个对象时，传递该引用该对象的变量的拷贝（stack中产生引用变量的副本），但引用相同的对象，heap没有改变。
Python和java相反，只有引用传递。不过，Python的引用传递很有意思，改变实参基本类型的值不会影响形参，这是因为指了个新的。
数据类型和内存分配
基础数据类型(Value type)直接在栈(stack)空间分配，方法的形式参数，直接在栈空间分配，当方法调用完成后从栈空间回收。
引用数据类型，需要用new来创建，既在栈空间分配一个地址空间(reference)，又在堆空间分配对象的类变量（object）。方法的引用参数，在栈空间分配一个地址空间，并指向堆空间的对象区，当方法调用完成后从栈空间回收。
静态变量在heap的方法区储存。
类成员实例变量储存在heap，证明了之前成员变量性能低的猜想。
JVM细节
每一个Java应用都唯一对应一个JVM实例，每一个实例唯一对应一个堆，而每个线程包含一个栈区
类 包 对象
java的getter setter就是狗屎
import
实现import as的技巧 实现导入同名类
import com.text.Formatter;
private Formatter textFormatter;
private com.json.Formatter jsonFormatter;
import static导入可以导入类的静态成员，但垃圾java缺少as的支持使得污染问题十分严重
构造方法
如果签名一致，若子类构造器没有显式调用父类构造器，将隐式调用。
初始化顺序： 静态初始化块-普通初始化块-构造器
Java 学习笔记 #1
by kenvix @ 2018/11/06
Lambda （#1） ->
变量作用域: lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。
声明和使用
@FunctionalInterface
interface excited {
void gg(String message);
}
public static void main(String[] args) {
excited fff = message -> System.out.println("lambda block called");
fff.gg("fuck!!!");
}
此接口要求必须是函数式接口，如果其中有两个方法则lambda表达式会编译错误。但java8的新特性如许实现如下写法：
interface MathOperation {
int operation(int a, int b);
default int addition(int a, int b){
return a+b;
}
}
泛型
基本类型不能作为类型参数
泛形要求能包容的是对象类型，而基本类型在java里不属于对象
但是基本类型都有其包装类型，也就是对象类型
大括号
1. 作用域
创建一个新的作用于防止变量污染
2. 声明匿名类
new Object() {
//content of anymous class
};
3. 类的初始化块
import java.util.HashMap;
public class Test {
private static HashMap<String, String> map = new HashMap<String, String>() {
{
put("Name", "June");
put("QQ", "2572073701");
}
}; //可以在初始化时为HASHMAP赋值
public int nonStatic;
static { //静态块
System.out.println("Static block called");
}
{ //类的初始化块1
System.out.println("Init block called");
}
Test() {
System.out.println("Constrator block called");
}
{ //类的初始化块2
nonStatic = 555;
System.out.println("Init2 block called");
}
public void nmbd() {}
static {
System.out.println("Static2 block called");
}
}
OUTPUT:
Static block called
Static2 block called
Init block called
Init2 block called
Constrator block called
结合匿名类使用：
new Object() {
{
System.out.println("called!");
}
};
