JAVASE學習筆記

生產者與消費者：

 1 public class ProducerConsumer {
 2     public static void main(String[] args) {
 3         Basket bs=new Basket();
 4         Producer p=new Producer(bs);
 5         Consumer stu1=new Consumer("張東",bs);
 6         Consumer stu2=new Consumer("王強",bs);
 7         Consumer stu3=new Consumer("趙璐",bs);
 8         new Thread(p).start();
 9         new Thread(stu1).start();
10         new Thread(stu2).start();
11         new Thread(stu3).start();
12     }
13 }
14 
15 class ManTou {
16     int id;
17     ManTou(int id){
18         this.id=id;
19     }
20     public String toString(){
21         return  "第"+id+"個饅頭" ;
22     }
23 }
24 
25 class Basket {
26     int index = 0;
27     ManTou[] mt = new ManTou[10];
28 
29     public synchronized void push(ManTou ton) {
30         while (index == mt.length) {
31             try {
32                 this.wait();
33             } catch (InterruptedException e) {
34                 e.printStackTrace();
35             }
36         }
37         this.notifyAll();
38         mt[index] = ton;
39         index++;
40     }
41     public synchronized ManTou pop() {
42         while (index == 0) {
43             try {
44                 this.wait();
45             } catch (InterruptedException e) {
46                 e.printStackTrace();
47             }
48         }
49         this.notifyAll();
50         index--;
51         return mt[index];
52     }
53     
54 }
55 
56 class Producer implements Runnable{
57     Basket bs= null;
58     Producer(Basket bs){
59         this.bs=bs;
60     }
61     public void run(){
62         for(int i=1;i<=15;i++){
63             ManTou mt=new ManTou(i);
64             bs.push(mt);
65             System.out.println("李師傅生產了"+mt.toString());
66             try{
67                 Thread.sleep((int)(Math.random()*100));
68             }catch(InterruptedException e){
69                 e.printStackTrace();
70             }
71         }
72     }
73     
74 }
75 
76 
77 class Consumer implements Runnable{
78     Basket bs= null;
79     String name;
80     Consumer(String stu,Basket bs){
81         this.bs=bs;
82         name=stu;
83     }
84     public void run(){
85         for(int i=1;i<=5;i++){
86             ManTou mt=bs.pop();
87             System.out.println(name+"消費了"+mt.toString());
88             try{
89                 Thread.sleep((int)(Math.random()*1000));
90             }catch(InterruptedException e){
91                 e.printStackTrace();
92             }
93         }
94     }
95     
96 }

View Code

 

 

java類的初始化順序

父類--靜態變量
父類--靜態初始化塊
子類--靜態變量
子類--靜態初始化塊
子類main方法
父類--變量
父類--初始化塊
父類--構造器
子類--變量
子類--初始化塊
子類--構造器

上面所說有一點是錯的，即靜態無論是變量仍是初始化塊都會按順序加載，別人的垃圾博客誤人子弟啊！

 

 

 1 public class Interview_02 extends X{
 2     Interview_02(){
 3         System.out.println("Z");
 4     }
 5     Y y = new Y();
 6     
 7     public static void main(String[] args) {
 8 
 9         new Interview_02();
10     
11     }
12 
13     
14 
15 }
16 
17 class X{
18     Y b = new Y();
19     X(){
20         System.out.println("X");
21     }
22 }
23 
24 class Y{
25     Y(){
26         System.out.println("Y");
27     }
28 }

View Code

執行結果爲：YXYZ

 

類型通配符上限經過形如Box<? extends Number>形式定義，相對應的類型通配符下限爲

Box<? super Number>形式，其含義與類型通配符上限正好相反

 

assertEquals
　　函數原型1：assertEquals([String message],expected,actual)
參數說明：
message是個可選的消息，假如提供，將會在發生錯誤時報告這個消息。
　　expected是指望值，一般都是用戶指定的內容。
actual是被測試的代碼返回的實際值。
　　函數原型2：assertEquals([String message],expected,actual,tolerance)
參數說明：
message是個可選的消息，假如提供，將會在發生錯誤時報告這個消息。
　　expected是指望值，一般都是用戶指定的內容。
　　actual是被測試的代碼返回的實際值。
　　tolerance是偏差參數，參加比較的兩個浮點數在這個偏差以內則會被認爲是
　　相等的。

 

 

 

 

抽象類：

　（1）凡是用abstract 修飾符修飾的類被稱爲抽象類。凡是用abstract修飾符修飾的成員方法被稱爲抽象方法。
　（2）抽象類中能夠有零個或多個抽象方法，也能夠包含非抽象的方法。
　（3）抽象類中能夠沒有抽象方法，可是，有抽象方法的類必須是抽象類。
　（4）對於抽象方法來講，在抽象類中只指定其方法名及其類型，而不書寫其實現代碼。
　（5）抽象類能夠派生子類，在抽象類派生的子類中必須實現抽象類中定義的全部抽象方法。
　（6）抽象類不能建立對象，建立對象的工做由抽象類派生的子類來實現。
　（7）若是父類中已有同名的abstract方法，則子類中就不能再有同名的抽象方法。
　（8）abstract不能與final並列修飾同一個類。
　（9）abstract 不能與private、static、final或native並列修飾同一個方法。 

　 (10)在面向對象的概念中，全部的對象都是經過類來描繪的，可是反過來，並非全部的類都是用來描繪對象的，若是一個類中沒有包含足夠的信息來描繪一個具體的對象，這樣的類就是抽象類。

　 (11)抽象類除了不能實例化對象以外，類的其它功能依然存在，成員變量、成員方法和構造方法的訪問方式和普通類同樣。抽象類必須被繼承，才能被使用。（它沒有足夠信息描繪一個對象，只有等子類來繼承完善後才能使用）

 

接口：（抽象方法的集合）

（1）類描述對象的屬性和方法。接口則包含類要實現的方法。
（2）除非實現接口的類是抽象類，不然該類要定義接口中的全部方法。　

（3）接口沒法被實例化，可是能夠被實現。一個實現接口的類，必須實現接口內所描述的全部方法（全部方法都是抽象的方法），不然就必須聲明爲抽象類。　

 (4)接口沒有構造方法，支持多重繼承，不能包含成員變量，除了static和final變量，若是不寫修飾符，默認就是static final;

 (5)接口是隱式抽象的，當聲明一個接口和接口中方法的時候，沒必要使用abstract關鍵字。接口中的方法都是公有的。

 (6)類在實現接口的方法時，不能拋出強制性異常，只能在接口中，或者繼承接口的抽象類　中拋出該強制性異常。

區別

　　接口不是類，抽象類是一個功能不齊全的類，都不能實例化對象。

　　一個類能夠實現（implements）多個接口。一個類只能繼承（extends）一個抽象類。

　　 接口沒有構造函數，全部方法都是 public abstract的，通常不定義成員變量。（全部的成員變量都是 static final ，並且必須顯示初始化）。
　　抽象類除了不能實例化對象以外，類的其它功能依然存在，成員變量、成員方法和構造方法的訪問方式和普通類同樣。

　　一個實現接口的類，必須實現接口內所描述的全部方法（全部方法都是抽象的方法），不然就必須聲明爲抽象類。　
　　若是一個類包含抽象方法，那麼該類必須是抽象類。任何子類必須重寫父類的抽象方法，或者聲明自身爲抽象類。

 

 內部類：

　雖然咱們在定義的內部類的構造器是無參構造器，編譯器仍是會默認添加一個參數，該參數的類型爲指向外部類對象的一個引用，

因此成員內部類中的Outter this&0 指針便指向了外部類對象，所以能夠在成員內部類中隨意訪問外部類的成員。
從這裏也間接說明了成員內部類是依賴於外部類的，若是沒有建立外部類的對象，
則沒法對Outter this&0引用進行初始化賦值，也就沒法建立成員內部類的對象了。

　　　　　　　　　　　　　　　　　　　　　　　　　　-----------------------詳情參照博客 http://www.javashuo.com/article/p-hdzvhjxq-ed.html

private static ExecutorService executor = new ThreadPoolExecutor(100, 1000, 0L,
                    TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10000),
                    Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardPolicy());

ForkJoin框架是從jdk7中新特性,它同ThreadPoolExecutor同樣，也實現了Executor和ExecutorService接口。
它使用了一個無限隊列來保存須要執行的任務，而線程的數量則是經過構造函數傳入，
若是沒有向構造函數中傳入但願的線程數量，那麼當前計算機可用的CPU數量會被設置爲線程數量做爲默認值。
幫其餘線程幹活，因而它就去其餘線程的隊列裏竊取一個任務來執行。而在這時它們會訪問同一個隊列，
因此爲了減小竊取任務線程和被竊取任務線程之間的競爭，一般會使用雙端隊列，
被竊取任務線程永遠從雙端隊列的頭部拿任務執行，而竊取任務的線程永遠從雙端隊列的尾部拿任務執行。

java提供隊列方法大全：

add        增長一個元索                  若是隊列已滿，則拋出一個IIIegaISlabEepeplian異常remove   移除並返回隊列頭部的元素    若是隊列爲空，則拋出一個NoSuchElementException異常element   返回隊列頭部的元素            若是隊列爲空，則拋出一個NoSuchElementException異常offer       添加一個元素並返回true        若是隊列已滿，則返回falsepoll        移除並返問隊列頭部的元素     若是隊列爲空，則返回nullpeek       返回隊列頭部的元素            若是隊列爲空，則返回nullput         添加一個元素                  若是隊列已滿，則阻塞take        移除並返回隊列頭部的元素     若是隊列爲空，則阻塞