1. 继承时方法会被override但是成员变量不会被override

2. 子类可以同时获得自己和父类的non-private成员变量，但是父类不知道子类。

3. final方法不可以被继承

4. static方法不可以被继承，随着类的加载而加载，继承毛线。但是如果权限允许子类还是可以用。

5. 继承的好处是是可以提高效率，抽取封装，缺点是提高了代码耦合。

6. 牢记is-a法则

reciprocates ： 往复运动
rigid ： 严格的
https://zhuanlan.zhihu.com/p/44670566
详细介绍：https://www.cnblogs.com/roy-blog/p/7669143.html
延伸 ： 类加载过程 https://zhuanlan.zhihu.com/p/33509426
多态：https://www.jianshu.com/p/b7fd72de2d0e
static : https://zhuanlan.zhihu.com/p/70110497

1. 8种基本类型(primitive types) : boolean、char、byte、int、long、short、float、double.

2. Java is pass by value, which means pass by copy. Everything, copy of primitive or copy of a remote reference to an object.

3. 类成员变量有初始值，任何局部变量没有默认值，若不initialize就使用会error，数字一旦new 出来之后就有默认值。

4. == 比较bits in two variables, what those bits represent doesn’t matter.

1
2
3

int a = 3;
byte b = 3;
if(a == b){// true cast byte to int}

5. 比较primitives 或者 指向相同对象的引用可以用 ==, 比较对象是否是同一对象用.equals().

6. import ！= include，只是为了声明class的时候省事

7. java.lang 类不需要导入，包含System，String等类。

Java把内存分成两种，一种叫做栈内存，一种叫做堆内存

在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉为该变量分配的内存空间，该内存空间可以立刻被另作他用。

堆内存用于存放由new创建的对象和数组。在堆中分配的内存，由java虚拟机自动垃圾回收器来管理。在堆中产生了一个数组或者对象后，还可以在栈中定义一个特殊的变量，这个变量的取值等于数组或者对象在堆内存中的首地址，在栈中的这个特殊的变量就变成了数组或者对象的引用变量，以后就可以在程序中使用栈内存中的引用变量来访问堆中的数组或者对象，引用变量相当于为数组或者对象起的一个别名，或者代号。

引用变量是普通变量，定义时在栈中分配内存，引用变量在程序运行到作用域外释放。而数组＆对象本身在堆中分配，即使程序运行到使用new产生数组和对象的语句所在地代码块之外，数组和对象本身占用的堆内存也不会被释放，数组和对象在没有引用变量指向它的时候，才变成垃圾，不能再被使用，但是仍然占着内存，在随后的一个不确定的时间被垃圾回收器释放掉。这个也是java比较占内存的主要原因，实际上，栈中的变量指向堆内存中的变量，这就是 Java 中的指针!
https://iamjohnnyzhuang.github.io/java/2016/07/12/Java%E5%A0%86%E5%92%8C%E6%A0%88%E7%9C%8B%E8%BF%99%E7%AF%87%E5%B0%B1%E5%A4%9F.html

https://juejin.im/post/5b7d69e4e51d4538ca5730cb#heading-14

https://www.jianshu.com/p/eb30a388c5fc

Eager

1
2
3
4
5
6
7

public class SingleB {
    private static final SingleB INSTANCE = new SingleB();
    private SingleB() {}
    public static SingleB getInstance() {
        return INSTANCE;
    }
}

Lazy

如果一个对象使用频率不高，占用内存还特别大，明显就不合适用饿汉式了，这时就需要一种懒加载的思想，当程序需要这个实例的时候才去创建对象，就如同一个人懒的饿到不行了才去吃东西。
v1

1
2
3
4
5
6
7
8
9
10
11

// Version 1.1
public class Single1 {
    private static Single1 instance;
    private Single1() {}
    public static Single1 getInstance() {
        if (instance == null) {
            instance = new Single1();
        }
        return instance;
    }
}

v2加锁版

1
2
3
4
5
6
7
8
9
10
11
12

public class SingletonClass {
    private static SingletonClass SINGLE_INSTANCE = null;
    private SingletonClass() {}
    public static SingletonClass getInstance() {
        if (SINGLE_INSTANCE == null) {  
          synchronized(SingletonClass.class) {
          SINGLE_INSTANCE = new SingletonClass();
          }
        }
        return SINGLE_INSTANCE;
    }
}

v3 加锁版

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class SingletonClass {
    private static SingletonClass SINGLE_INSTANCE = null;
    private SingletonClass() {}
    public static SingletonClass getInstance() {
        if (SINGLE_INSTANCE == null) {
            synchronized (SingletonClass.class) {
                if (SINGLE_INSTANCE == null) {
                    SINGLE_INSTANCE = new SingletonClass();
                }
            }
        }
        return SINGLE_INSTANCE;
    }
}

https://juejin.im/post/5c94654e6fb9a071090d63ac
https://blog.csdn.net/gavin_dyson/article/details/69668946

每天学一点点，记录一点点。

考虑使用静态工厂方法代替构造器

能够增大类的提供者对自己所提供的类的控制力。

2.1 第一优势，静态工厂方法有名字
2.2 第二个优势，不用每次被调用时都创建新对象
2.3 第三个优势，可以返回原返回类型的子类
2.4 第四个优势，在创建带泛型的实例时，能使代码变得简洁
3.1 可以有多个参数相同但名称不同的工厂方法
3.2 可以减少对外暴露的属性
参考：https://www.jianshu.com/p/ceb5ec8f1174

ps：静态工厂方法和工厂方法模式，抽象工厂模式的区别
参考：https://blog.csdn.net/QuinnNorris/article/details/66977156

  上周五晚上在室友群里看到博仔收到了亚麻offer的消息，意味着一年前一起入学，住进同一个townhouse的“四兄弟”全部拿到了flag的实习offer，突然想写点东西来纪念一下过去整整一年的时间，那些大家相互激励相互扶持的日子。
  我相信，对于每一个转cs的同学来说，入学第一年开始找暑假实习的过程都会是出国留学计划中最重要的一环，这篇文章将从我自己的角度出发，结合身边同学的经验，希望能够给在题海中挣扎的同学一点帮助。