JAVA笔记一
一：在多态下，引用与对象可以是不同的类型，运行多态时，引用类型可以是实际对象类型的父类。参数和返回类型也可以多态。
二：抽象类不能被初始化，就是不能被new。抽象类除了被继承过之外，是没有用途，没有值，没有目的的。抽象类代表此类必须要被extend，抽象方法代表此方法一定要被覆盖。抽象的方法没有实体。如果你声明一个抽象的方法，就必须将类也标记为抽象的。你不能在非抽象类中拥有抽象的方法。
二：JAVA内存分配和管理
1、 JAVA（JVM）内存模型（可见性和有序性）
可见性：多个线程之间是不能相互传递数据通信的，他们之间的沟通只能通过数据共享来进行。JAVA内存模型（JMM）规定了JVM有主内存，主内存是多个线程共享的。当new一个对象的时候，也是被分配在主内存中，每个线程都有自己的工作内存，工作内存存储了主内存的某些对象的副本，当然线程的工作内存大小是有限制的。当线程操作某个对象时，执行顺序如下：
（1） 从主存复制变量到当前工作内存（read and load）；
（2） 执行代码，改变共享变量值（use and assign）
（3） 用工作内存数据刷新主存相关内存（store and write）。
JVM规范定义了线程对主内存的操作指令：read、load、use、assign、store、write。当一个共享变量在多个线程的工作内存中都有副本时，如果一个线程修改了这个共享变量，那么其他线程应该能够看到这个被修改后的值，这就是多线程的可见性问题。
有序性：线程在引用变量时不能直接从主存中引用，如果线程工作内存中没有该变量，则会从主要中拷贝一个副本到工作内存中，这个过程为read-load，完成后线程会引用该副本。当同一线程再度引用该字段时，有可能重新从主从中获取该变量副本（read-load-use），也有可能直接引用原来的副本（use），也就是说read，load，use顺序可以由JVM实现系统决定。
线程不能直接为主存中的字段赋值，他会将值指定给工作内存中的变量副本（assign），完成后这个变量副本会同步到主存储区（store-write），至于何时同步过去，根据JVM实现系统决定，则会从主内存中将该字段赋值到工作内存中，这个过程为（read-load），完成后线程将会引用该变量副本，当同一线程多次重复对字段复制时，比如：
For（int i=0；i<10;i++）
{
a++;
}
线程有可能只对工作内存中的副本赋值，只到最后一次赋值才同步到主存储区，所以assign，store，write顺序可以有JVM实现系统决定。假设有一个共享变量x，线程a执行x=x+1；从上面的描述中可以只到x=x+1；并不是一个原子操作，他的执行过程如下：
（1） 从主存中读取变量x副本到工作内存
（2） 给x加1
（3） 将x加1后的值写回主存。
如果另外一个线程b执行x=x-1；执行过程如下：
（1） 重主存中读取变量x副本到工作内存
（2） 给x减1
（3） 将x减1后的值写回主存
那么显然，最终x的值是不可靠的。假设现在为10；最终可能会得到多种结果。
Synchronized作为一种同步手段，解决java多线程的执行有序性和内存可见性。而volatile关键字解决多线程的内存可见性为题。
public class Account {
private int balance;
public Account(int balance) {
this.balance = balance;
}
public int getBalance() {
return balance;
}
public void add(int num) {
balance = balance + num;
}
public void withdraw(int num) {
balance = balance - num;
}
public static void main(String[] args) throws InterruptedException {
Account account = new Account(1000);
Thread a = new Thread(new AddThread(account, 20), "add");
Thread b = new Thread(new WithdrawThread(account, 20), "withdraw");
a.start();
b.start();
a.join();
b.join();
System.out.println(account.getBalance());
}
static class AddThread implements Runnable {
Account account;
int amount;
public AddThread(Account account, int amount) {
this.account = account;
this.amount = amount;
}
public void run() {
for (int i = 0; i < 200000; i++) {
account.add(amount);
}
}
}
static class WithdrawThread implements Runnable {
Account account;
int amount;
public WithdrawThread(Account account, int amount) {
this.account = account;
this.amount = amount;
}
public void run() {
for (int i = 0; i < 100000; i++) {
account.withdraw(amount);
}
}
}
}
这段代码的执行结果会不一致。
2、 synchronized关键字
当一段代码会修改共享变量，这一段代码成为互斥区或者临界区，为了保证共享变量的正确性，synchronized标示了临界区。典型用例“
Synchronized（锁）{
临界区代码
}
为了保证上面代码的安全，可以操作账号的方法如下：
public synchronized void add(int num) {
balance = balance + num;
}
public synchronized void withdraw(int num) {
balance = balance - num;
}
那么对于public synchronized void add(int num)这种情况，意味着什么呢？其实这种情况，锁就是这个方法所在的对象。同理，如果方法是public static synchronized void add(int num)，那么锁就是这个方法所在的class。
理论上，每个对象都可以做为锁，但一个对象做为锁时，应该被多个线程共享，这样才显得有意义，在并发环境下，一个没有共享的对象作为锁是没有意义的。假如有这样的代码：
public class ThreadTest{
public void test(){
Object lock=new Object();
synchronized (lock){
//do something
}
}
}
lock变量作为一个锁存在根本没有意义，因为它根本不是共享对象，每个线程进来都会执行Object lock=new Object();每个线程都有自己的lock，根本不存在锁竞争。
每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列，就绪队列存储了将要获得锁的线程，阻塞队列存储了被阻塞的线程，当一个被线程被唤醒 (notify)后，才会进入到就绪队列，等待cpu的调度。当一开始线程a第一次执行account.add方法时，jvm会检查锁对象account 的就绪队列是否已经有线程在等待，如果有则表明account的锁已经被占用了，由于是第一次运行，account的就绪队列为空，所以线程a获得了锁，执行account.add方法。如果恰好在这个时候，线程b要执行account.withdraw方法，因为线程a已经获得了锁还没有释放，所以线程 b要进入account的就绪队列，等到得到锁后才可以执行。
一个线程执行临界区代码过程如下：
1 获得同步锁
2 清空工作内存
3 从主存拷贝变量副本到工作内存
4 对这些变量计算
5 将变量从工作内存写回到主存
6 释放锁
可见，synchronized既保证了多线程的并发有序性，又保证了多线程的内存可见性。
三、Object对象
当你把对象装进Object中，他就变成Object对象，如果想转回原有对象，可以用以下方式：
Object o = a.get(index);
Dog d = (Dog)o;
如果不能确定他是Dog对象，可以用
If(o instanceof Dog){
Dog d = (Dog)o;
}
四、如何判断应该是设计类、子类、抽象类或接口
1、如果新的类无法对其他类通过IS-A测试时，就设计部继承其他类的类；
2、只有在需要某类的特殊化版本时，以覆盖或者增加新的方法来继承现有的类；
3、当你需要定义一群子类的模板，又不想让程序员初始化此模板是时，设计出抽象的类给他们使用；
4、如果想要定义出类可以扮演的角色，使用接口。
五、堆和栈
对象的生存空间是堆（heap），方法调用及变量的生存空间是栈（stack）。（实例对象是指声明在类中，而不是在方法中的变量，实例变量存在于对象所属的堆上）不管是实例变量还是局部变量，对象本身会放在堆中，对象引用变量与primitive主数据类型变量都会放在栈上。
对象的实例变量的值是存放于该对象中。
Life和scope的区别：
1、 只要变量的堆栈块还存在于堆栈上，局部变量就算活着。
2、 局部变量的范围只局限于声明他的方法之内，当此方法调用别的方法时，该变量还活着，但不在目前范围内，执行其他方法完毕返回时，范围也跟着回来。
六、静态方法不能调用非静态变量（实例变量），静态方法不能调用非静态方法；静态变量的值对所有实例来说都是相同的。