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、  局部变量的范围只局限于声明他的方法之内，当此方法调用别的方法时，该变量还活着，但不在目前范围内，执行其他方法完毕返回时，范围也跟着回来。

六、静态方法不能调用非静态变量（实例变量），静态方法不能调用非静态方法；静态变量的值对所有实例来说都是相同的。