久久久久久久久久久妇女,黄色国产在线,国产二区视频在线观看

JAVA STATIC 關(guān)鍵字

Static :
對于類的屬性來說
有類變量和實例變量
class StaticTest
{ static int i=47;
}
對于不同的對象 StaticTest st1=new StaticTest(),StaticTest st2=new StaticTest()都只有一個共享的存儲空間!
引用Static變量有兩種方法.可以用一個對象去定位他。.也可以用其類名直接調(diào)用!
如果一個成員被聲明為static，他就能夠在他的類的對象被創(chuàng)建之前被訪問，不必引用任何對象。最常見的例子是main()方法，
static定義的變量會優(yōu)先于任何其它非static變量，不論其出現(xiàn)的順序如何;
Java變量在類這個級別分兩種，類變量（static）和實例變量，而在靜態(tài)的方法中不能夠直接訪問實例變量，實例變量需要初始化一個類的實例才可以用。

靜態(tài)的東西之所以有這種區(qū)分是為了區(qū)別對待類和對象的成員。如果某個變量或者方法被聲明為static，意味著在類初始化時就必須分配內(nèi)存空間。而方法調(diào)用內(nèi)部需要的變量既然是臨時的，會隨著方法調(diào)用結(jié)束而失效的，那么沒有道理讓它成為static的對吧

1.靜態(tài)變量屬于類,為該類所有對象所分享,在程序開始執(zhí)行前就分配內(nèi)存空間,其作用可以類似VB中的全局變量,如果前面加上final,功能類似全局常量,不可以修改其值.比如圓周率

2.類的靜態(tài)方法不能訪問類的實例變量,可以訪問類的靜態(tài)變量、實例化的類的實例變量

3.靜態(tài)方法中不能定義靜態(tài)變量的

前幾天在csdn上看了一篇關(guān)于static的帖子，看了之后感覺很多疑惑都澄清了，今天粘在這里。

public class ExplicitStatic{
public static void main(String[] args){
    System.out.println("Inside main()");
      Cups.c1.f(99);
}
static Cups x=new Cups();
static Cups y=new Cups();
}
class Cup{
      Cup(int marker){
         System.out.println("Cup("+marker+")");
      }
      void f(int marker){
         System.out.println("f("+marker+")");
      }
}
class Cups{
static Cup c1=new Cup(11);
static Cup c2;
Cup c3=new Cup(33);
Cup c4;
{ c3=new Cup(3);
   c4=new Cup(4);
}
static{
   c1=new Cup(1);
   c2=new Cup(2);
}
Cups(){
System.out.println("Cups()");
}
}
/*輸出結(jié)果：
cup(11)
cup(1)
cup(2)
cup(33)
cup(3)
cup(4)
cups()
cup(33)
cup(3)
cup(4)
cup()
inside main()
f(99)
*/
/*
首先初始化的是static，順序是代碼順序up-to-down！然后在是自己調(diào)用的方法！
上面的執(zhí)行順序是
1： static Cups x=new Cups(); 轉(zhuǎn)入 Cups對象
2： static Cup c1=new Cup(11); 轉(zhuǎn)入 Cup對象
3：執(zhí)行Cup的輸出 Cup(11);
4: cups對象里的 static Cup c2；
5： static{
   c1=new Cup(1);轉(zhuǎn)入Cup對象輸出 Cup(1)
   c2=new Cup(2);轉(zhuǎn)入Cup對象輸出 Cup(2)
}
6: cups對象里的 Cup c3=new Cup(33); 輸出 Cup(33)
7：c3=new Cup(3); 輸出 Cup(3)
   c4=new Cup(4); 輸出 Cup(4)
8：Cups(){
System.out.println("Cups()"); 輸出 Cups()
}
9:static Cups y=new Cups();
注意Cups里的static成員已經(jīng)初始化所以 static Cup c1=new Cup(11);
static Cup c2;static{
   c1=new Cup(1);
   c2=new Cup(2);
}
不在執(zhí)行！
下面的就和上面一樣了！
*/

首次使用的地方也是static初始化發(fā)生的地方。裝載的時候，所有static對象和static代碼塊都會按照本來的順序初始化（亦即它們在類定義代碼里寫入的順序）。當然，static數(shù)據(jù)只會初始化一次。

程序一開始訪問MAIN方法,然后開始一加載對應的CLASS文件,如果他具有基類,加載基類,最后完成STATIC的初始化,

posted @ 2005-11-12 14:42 活在JAVA島的日子閱讀(3972) | 評論 (1) | 編輯收藏

Thinking IN java 訪問權(quán)限

對于繼承,static :hide;non static :override.

關(guān)鍵字:包訪問權(quán)
當屬性或方法前不聲明訪問權(quán)是默認為包訪問權(quán).
具有包訪問權(quán)的方法或者屬性只能被同一個包內(nèi)的其他類訪問.
處于相同目錄的類之間具有默認的包訪問權(quán)限.即可以訪問其他文件的包訪問權(quán)限方法.
//處于不同包類不能訪問具有包訪問權(quán)限的方法或?qū)傩?
package animal;
public class animal
{
void bite()
{
System.out.println("bite");
}
}
package test;
import animal.*;
public class test
{
   public static void main(String args[])
   {

       animal animal=new animal();
       animal.bite();//因為bite()只具有包訪問權(quán)
}
}
// 處于相同目錄的類之間具有默認的包訪問權(quán)限.即可以訪問其他文件的包訪問權(quán)限方法.
public class test
{
   public static void main(String args[])
   {
   animal animal=new animal();
   animal.bite();
}
}
public class test
{
   public static void main(String args[])
   {
   animal animal=new animal();
   animal.bite();
}
}

package test;
import animal.*;
public class dog extends animal    繼承但是不屬于同一個包
{
   public static void main(String args[])
   {
      dog dog=new dog();
      dog.bite();//bite只是具有包訪問權(quán)

   }
}
PROTECTED 關(guān)鍵字:繼承訪問權(quán)限!
導出類可以使用在基類定義為PROTECTED的方法,對于同一個包的非繼承關(guān)系類具有包訪問權(quán)!
在同一個包中，可以通過在子類中超類的實例來訪問超類的protected變量，而不在同一個包中，就不能這樣做
protected 指定該變量可以被同一個包中的類或其子類訪問，但是不能通過超類的實例來實現(xiàn)，在子類中可以覆蓋此變量
public class animal
{
protected void bite()
{
System.out.println("bite");
}
}
public class test
{
   public static void main(String args[])
   {
   animal animal=new animal();
   animal.bite();
}
}
導出類可以使用基類的PROTECTED方法
package animal;
public class animal
{
protected void bite()
{
System.out.println("bite");
}
}

package test;
import animal.*;
public class dog extends animal
{
   public static void main(String args[])
   {
      dog dog=new dog();
      dog.bite();//bite只是具有包訪問權(quán)
}
}
Private關(guān)鍵字
具有Private關(guān)鍵字的方法只能被定義該方法的內(nèi)部
public class animal
{
private String s="fasf";
private void test()
{}
protected void bite()
{ System.out.println("bite");}
}
public class test
{
   public static void main(String args[])
   {
   animal animal=new animal();
   //animal.s="fafaf";  can not access private
  // animal.test();    can not access private
   animal.bite();
}
}
//私有構(gòu)造函數(shù)
class privatetest
{
    private privatetest()
    {}
    public static privatetest make()
    {
    return new privatetest();
    }
    public void f()
    {
  System.out.println("success");
}
}
public class test
{
   public static void main(String srgs[])
   {
       privatetest pt=privatetest.make();
       pt.f();
}
}
類的訪問權(quán)限類的訪問權(quán)限只能是缺省或者是"public"
//包訪問權(quán)限:
package animal;
class animal
{
protected void bite()
{ System.out.println("bite");}
}
package test;
import animal.*;
public class test
{
   public static void main(String args[])
   { animal animal=new animal(); // can not access from outside package;
       animal.bite();//因為bite()只具有包訪問權(quán)
     }
}

posted @ 2005-11-12 11:57 活在JAVA島的日子閱讀(978) | 評論 (0) | 編輯收藏

java的事件(轉(zhuǎn))

JAVA事件的總結(jié)（轉(zhuǎn)）- -

在阿泠的自省上看到的文章，雖然我現(xiàn)在還沒有看到事件，不過先收錄過來^_^。

JAVA事件無非就是鍵盤事件，鼠標事件，按鈕等事件。專業(yè)點可以分為語義事件（按鈕等到事件）和低層事件（鍵盤事件，鼠標事件）；

下面我簡要的總結(jié)一下：

1、鼠標事件：點鼠標按鈕事它會調(diào)用三個監(jiān)聽器方法：mousePressed,mouseReleased,mouseClicked.

鼠標事件提供了mousePressed,mouseClicked,mouseDragged,mouseEntered,mouseExited， mouseUp，mouseDown，mouseDrag等事件。下面介紹一個鼠標一例子：
import java.awt.*;
import java.applet.Applet;
public class CountClick extends Applet
{int CurrentMarks=0;
int a,b;
public boolean mouseDown(Event evt,int x,int y)//鼠標按下時做的事
{ CurrentMarks++;//計錄按下次數(shù)
   repaint();//刷新面版
   a=x;//得到鼠標的橫坐標
   b=y;//得到鼠標的豎坐標
   return true;
}
public void paint(Graphics g)
{ g.drawString(" "+CurrentMarks,10,10);//打印按下次數(shù)
   g.drawString(" "+a,10,30);//打印鼠標的橫坐標
   g.drawString(" "+b,10,20);//打印鼠標的堅坐標
}
}
//<applet code="CountClick.class" width="200" height="100"></applet>

   2、鍵盤事件：如果我們希望使用鍵盤獲得輸入信息，就必須處理鍵盤事件。我們可以用在Conponent的keyDown來實現(xiàn)。如下例子：
import java.applet.Applet;import java.awt.*;
{   char Presskey;
     public boolean keyDown(Event evt, int key)
     {   Presskey=(char)key;//記錄你按下的鍵
     repaint(); return true;
}
      public void paint(Graphics g)
     {    g.drawString(Presskey,10,10); }//打印你按下的鍵值
}
   3、銨鈕等事件：這方面的內(nèi)容比較多，通過一個例子做一個簡單的介紹。

//*******注意Repaint()方法的使用******//
//**通過本程序?qū)AVA的數(shù)據(jù)隱藏有了一近一步的了解***///

import java.awt.*;
import java.applet.Applet;
import java.awt.event.*;
public class Awtactiontest2 extends Applet implements ItemListener ,ActionListener
//實現(xiàn)ItemListener ,ActionListener接口
{
int num = 5;
  Choice ch=new Choice ();
Button one=new Button("one");
Button two=new Button("two");
Button three=new Button("three");
Image  aa[];
Image  a;
public void init()
{
        aa = new Image[num];
        for(int i = 0; i < num; i++)//把圖片的路徑加到數(shù)組中存儲
        {
            aa[i] = getImage(getdocument．a(chǎn)se(),"A"+(i+1)+".JPG");
        }
        num=4;//給一個初值
this.setBackground(Color.white);
ch. addItem("A1.JPG" );
ch. addItem ("A2.JPG" );
ch. addItem ("A3.JPG" );
ch. addItem ("A4.JPG" );
add (ch);
a = getImage(getdocument．a(chǎn)se(),"A1.JPG");//對a一個初值；
add (one);
add (two);
add (three);
ch.addItemListener(this);//注意把ItemListener接口implements進來
one.addActionListener(this);//注意把ActionListener接口implements進來
two.addActionListener(this);
three.addActionListener(this);
}
public void itemStateChanged (ItemEvent e)
  {

    a = getImage(getdocument．a(chǎn)se(),ch.getSelectedItem ());
    repaint();
  }
public void actionPerformed(ActionEvent e)
{
if(e.getSource()==one)
{
        num=1;
        repaint();//對程序刷新
}
if(e.getSource()==two)
{
        num=2;
        repaint();
}
if(e.getSource()==three)
{
        num=3;
        repaint();
}
}
public void paint(Graphics g)
{
        //g.drawImage(aa[i],0,0,this);

  int w=a.getWidth(this);
  int h=a.getHeight(this);
// g.drawLine(100,1,200,500);
try{
g.drawImage(a,20,300,10+w,20+h,this);//要抓異常，如果圖片找不到呢
g.drawImage(aa[num],50,50,200,200,this);
}
catch(Exception e)
{
  System.out.println(e);
}
  }
public boolean handleEvent(Event ewt)//關(guān)窗體,我原以為這個可以把死循環(huán)給關(guān)了，其它不然.一樣的關(guān)不了程序
{
         if(ewt.id==Event.WINDOW_DESTROY)
          System.exit(0);
          else
          return super.handleEvent(ewt);
          return true;
}
}
//<Applet code="Awtactiontest2.class" width=400 height=500></applet>

posted @ 2005-11-12 02:36 活在JAVA島的日子閱讀(257) | 評論 (0) | 編輯收藏

2-4

第2章萬事萬物皆對象

一．所有對象都必須由你建立
1．存儲在哪里
1. 寄存器：我們在程序中無法控制
2. stack：存放基本類型的數(shù)據(jù)和對象的reference，但對象本身不存放在stack中，而是存放在Heap中
3. Heap：存放用new產(chǎn)生的數(shù)據(jù)
4. Static storage：存放在對象中用static定義的靜態(tài)成員
5. Constant storage：存放常量
6. NON-RAM：硬盤等永久存儲空間
2．特例：基本型別
基本類型數(shù)據(jù)存放在Stack中，存放的是數(shù)據(jù)。而產(chǎn)生對象時，只把對象的reference存放在stack中，用于指向某個對象，對象本身存放在Heap中。
3． Java中的數(shù)組
當你產(chǎn)生某個存儲對象的數(shù)組時，真正產(chǎn)生的其實是存儲reference的數(shù)組。引數(shù)組建立后，其中的每一個reference都會被自動設為null，表示"不指向任何對象"。
二．建立新的數(shù)據(jù)型別：class
1．數(shù)據(jù)成員和函數(shù)
1.1 基本成員的缺省值
1）當class的某個成員屬于基本型別時，即使你沒有為它提供初值，Java仍保證它有一個缺省值。
2）只有當變量身份是"class內(nèi)的成員時，Java才保證為該變量提供初值。
三．函數(shù)（Mehtods），引數(shù)（arguments），返回值（return values）
1．引數(shù)列
當引數(shù)傳遞的是對象時，傳遞的是對象的reference。
四．注解用內(nèi)嵌式文檔
Java提供兩種注解風格：/*XXXX*/、//XXXX

第3章控制程序流程

一．使用Java運算符
1.關(guān)系運算符
1.）當對兩個對象運用關(guān)系運算符進行比較時，比較的是object reference，如：

Integer n1 = new Integer(3);
Integer n2 = new Integer(3);
System.out.println(n1==n2);

結(jié)果為false，因為兩個object reference（n1和n2）值是不同的
2） equals()的缺省行為也是拿referenct來比較。不過Java中的class覆寫了equals方法(覆寫時一般先做instanceof的比較，然后在做期望的值的比較，如Integer期望的比較值就是其數(shù)值)，如：

Integer n1 = new Integer(3);
Integer n2 = new Integer(3);
System.out.println(n1.quals(n2));//值為true

2．邏輯運算符
1）只能將and、or、not施用于boolean值身上。如果邏輯運算符兩邊的值存在non-boolean值，將會出錯，如：

int test1 = 1;
System.out.println((test && 1<2);//編輯出錯，test是non-boolean值

3．位移運算符
如果所操作的位移對象是char、byte、short，位移動作發(fā)生之前，其值會先被晉升為int，運算結(jié)果會是int。
二．流程控制
1．迭代（iteration）
1.1 逗號運算符
逗號運算符只能用于for循環(huán)的控制表達式中的initialization和step兩部分中，如：for(int i=0, j=I+1; I<5; i++, j=I*2)
1.2 break和continue
break表示退出循環(huán)；continue表示退出本次循環(huán)，回來循環(huán)起始位置。
1.3 label
label只有放在迭代語句之前才起作用，在label和迭代語句之間插入任何語句都不會起作用。
2． Switch
switch中的選擇器必須是int或char型，而且每個case段都應該break，否則不管是否匹配，將按代碼順序執(zhí)行每個case段的代碼。如：

char c='c';
switch (c){

  case 'a':System.out.println("a");break;//如果不break將繼續(xù)執(zhí)行下面的case 'b',case 'c',default等段

  case 'b':System.out.println("b");break;

  default:System.out.println("default");break;

  case 'c':System.out.println("c");break;

3．計算細節(jié)
1）從float或double轉(zhuǎn)為整數(shù)值，總是以完全舍棄小數(shù)的方式進行。
2) 默認情況帶小數(shù)的為double型，如：1.23應該是double型，如果你想要float型的話得寫為 1.23f 或 1.23F。
4． Math.random()的輸出范圍是[0, 1)。

第4章初始化和清理

一．以構(gòu)造函數(shù)（constructor）確保初始化的進行
如果某個class具備構(gòu)造函數(shù)，Java便會在對象生成之際，使用者有能力加以操作之前，自動調(diào)用其構(gòu)造函數(shù)，于是便能名確保初始化動作一定被執(zhí)行。
二．函數(shù)重載（Method overloading）
1．區(qū)分重載函數(shù)
由于只能從函數(shù)名和函數(shù)的引數(shù)列來區(qū)分兩個函數(shù)，而重載函數(shù)具有相同的函數(shù)名稱，所以每個重載函數(shù)都必須具備獨一無二的引數(shù)列。
2． Default構(gòu)造函數(shù)
1） default構(gòu)造函數(shù)是一種不帶任何引數(shù)的構(gòu)造函數(shù)。如果你所開發(fā)的class不具任何構(gòu)造函數(shù)，編譯器會自動為你生成一個default構(gòu)造函數(shù)。
2）如果你自行定義了任何一個構(gòu)造函數(shù)（不論有無引數(shù)），編譯器就不會為你生成default構(gòu)造函數(shù)。
3）如果定義了一個class，如

class Bush{
  Bush(int I){}
}

當想用new Bush();來產(chǎn)生class的實例時，會產(chǎn)生錯誤。因為在定義class時已定義了構(gòu)造函數(shù)，所以編譯器就不會為class生成default構(gòu)造函數(shù)。當我們用new Bush()來產(chǎn)生實例時，會嘗試調(diào)用default構(gòu)造函數(shù)，但在class中沒有default構(gòu)造函數(shù)，所以會出錯。如：

class Sundae
{
    Sundae(int i) {}
}
public class IceCream
{
    public static void main(String[] args)
{
			//Sundae x = new Sundae();會編譯出錯，無構(gòu)造函數(shù)Sundae()
        Sundae y = new Sundae(1);
    }
}

＊：在定義一個class時，如果定義了自己的構(gòu)造函數(shù)，最好同時定義一個default構(gòu)造函數(shù)
3．關(guān)鍵字this
1） this僅用于函數(shù)之內(nèi)，能取得"喚起此一函數(shù)"的那個object reference。
2）在構(gòu)造函數(shù)中，通過this可以調(diào)用同一class中別的構(gòu)造函數(shù)，如

public class Flower{
		Flower (int petals){}
		Flower(String ss){}
		Flower(int petals, Sting ss){
		//petals++;調(diào)用另一個構(gòu)造函數(shù)的語句必須在最起始的位置
this(petals);
		//this(ss);會產(chǎn)生錯誤，因為在一個構(gòu)造函數(shù)中只能調(diào)用一個構(gòu)造函數(shù)
		}
}

＊＊：1）在構(gòu)造調(diào)用另一個構(gòu)造函數(shù)，調(diào)用動作必須置于最起始的位置
2）不能在構(gòu)造函數(shù)以外的任何函數(shù)內(nèi)調(diào)用構(gòu)造函數(shù)
3）在一個構(gòu)造函數(shù)內(nèi)只能調(diào)用一個構(gòu)造函數(shù)
4． Static的意義
無法在static函數(shù)中調(diào)用non-static函數(shù)（反向可行）。為什么不能呢，我們看下面的例子。
例4.2.4.1
假設能在static函數(shù)中調(diào)用non-static函數(shù)，那么（a）處就將出錯。因為在沒有產(chǎn)生Movie class實例之前，在就不存在Movie class內(nèi)的name實例，而在getName()中卻要使用name實例，顯然的錯誤的。

class Movie{
	String name = "";
	Movie(){}
	public Movie(String name) { this.name = name; }
	public static String getName() { return name; }
}
public class Test{
	public static void main(String[] args){
		//下面兩名先產(chǎn)生實例后再調(diào)用getName()沒有問題
		//Movie movie1 = new Movie("movie1");
		//String name1 = movie1.getName();
		//下面一名將出錯
		//String name2 = Movie.getname(); （a）
	}
}

三．清理（cleanup）：終結(jié)（finalization）與垃圾回收（garbage collection）
1）你的對象可能不會被回收
只有當程序不夠內(nèi)存時，垃圾回收器才會啟動去回收不再被使用的對象的內(nèi)存空間。某個對象所占用的空間可能永遠不會被釋放掉，因為你的程序可能永遠不會逼近內(nèi)存用完的那一刻，而垃圾回收器完全沒有被啟動以釋放你的對象所占據(jù)的內(nèi)存，那些空間便會在程序終止時才一次歸還給操作系統(tǒng)
3）只有在采用原生函數(shù)（native methods）時，才使用finalize()。

四．成員初始化（member initialization）
1）函數(shù)中的變量不會被自動初始化，如

void f(){
		int i;
		i++;
}

將發(fā)生編譯錯誤，因為i沒有被初始化。
2） class的數(shù)據(jù)成員會被自動初始化，具體情況如下（見P220例子）：
基本型別：boolean：false、char：null（\u0000）、byte：0、short：0、int：0、
long：0 、float：0、double：0
對象（reference）：null

五．初始化次序：
1）所有變量一定會在任何一個函數(shù)（甚至是構(gòu)造函數(shù)）被調(diào)用之前完成初始化（見P233例子）
2）在產(chǎn)生一個class的對象（包含static成員的class的代碼被裝載）時，首先自動按代碼排列順序初始化class中的static成員變量或static block，所有這些初始化操作只在第一次生成該對象時進行。
3）自動初始化class中的其它成員變量或non-static block。
4）調(diào)用構(gòu)造函數(shù)。
例：

class Cup{
	Cup(int marker){
		System.out.println("Cup(" + marker + ")");
	}
	void f(int marker){
		System.out.println("f(" + marker + ")");	
	}	
}

class Cups{
	static Cup c1 = new Cup(11);
	static Cup c2;
    Cup c3 = new Cup(33); 
    Cup c4;
    {
        c3 = new Cup(3);
        c4 = new Cup(4);
    }
	static{
		c1 = new Cup(1);
		c2 = new Cup(2);
	}
	Cups(){
		System.out.println("Cups()");
	}
}

public class ExplicitStatic{
	public static void main(String[] args){
		System.out.println("Inside main()");
		Cups.c1.f(99);
	}
	static Cups x = new Cups();
	static Cups y = new Cups();
}

結(jié)果為：
Cup(11)
Cup(1)
Cup(2)
Cup(33)
Cup(3)
Cup(4)
Cups()
Cup(33)
Cup(3)
Cup(4)
Cups()
Inside main()
f(99)
2． Array的初始化
1）定義數(shù)組時不能指定大小。如int[4] iArr = {0, 1, 2, 3};，由于指定了數(shù)組的大小，會編譯出錯。
2）數(shù)組只是存放reference的數(shù)組。Array與non-array的結(jié)構(gòu)圖如下：
a）對于基本型別數(shù)據(jù)，存放的是數(shù)據(jù)。如
int i = 5;

b）對于class變量，存放的是reference，這個reference指向一個存有class實例的內(nèi)存空間。如

String s = "hello";

變量s存放的是一個reference，這個reference指向一個存有String實例的內(nèi)存空間。
c）對于基本型別數(shù)組，存放的是reference數(shù)組，數(shù)組中的每一個reference都指向一個class實例的內(nèi)存空間。如

int[] ia = {10, 11, 12};

數(shù)組ia存放的是一個reference數(shù)組，數(shù)組中的每一個reference都指向一個的int實例的內(nèi)存空間。
d）對于class數(shù)組，存放的是reference數(shù)組，數(shù)組中的每一個reference都指向一個的class實例的內(nèi)存空間。如

String[] sa = {"hello1", "hello2", "hello3"};

數(shù)組sa存放的是一個reference數(shù)組，數(shù)組中的每一個reference都指向一個的String實例的內(nèi)存空間。
3）任何數(shù)組都要進行初始化，使用沒有進行初始化的數(shù)組會產(chǎn)生運行時錯誤，如：

int[] iArr;
System.out.pritnln(iArr[0]);//產(chǎn)生錯誤，因為iArr還未初始化

數(shù)組初始化可在任何地方，可用以下方法來對數(shù)組進行初始化：
a） int[] iArr = {1,1,1,1};//數(shù)組的長度為{}元素的個數(shù)
b） int i = 10;

int[] iArr = new int[i];//數(shù)組的長度可為變量（這在C/C++中不行）
System.out.println(iArr[0]);//iArr[0]是一個int，自動初始化值為0
Integer[] iArr2 = new Integer[i];
System.out.println(iArr2[0]);//iArr[0]是一個reference，自動初始為null

I）對于基本型別數(shù)組，new產(chǎn)生的是用于存放數(shù)據(jù)的數(shù)組；否則，產(chǎn)生的只是存放reference的數(shù)組。
II） new可用來初始化基本型別的數(shù)組，但不能產(chǎn)生non-array的　　基本型別數(shù)據(jù)。
c） int[] iArr = new int[]{1,1,1,1};

Integer[] iArr2 = new Integer[]{new Integer(1), new Integer(2)};

3．多維數(shù)組（Multidimensional）arrays
多維數(shù)組每一維的大小可以不一樣，如：

Integer[][][] a5;
a5 = new Integer[3];
for(int i=0; i<a5.length; i++)
   a5[i] = new Integer[i+1];
   for(int j=0; j<a5[i].length
       a5[i][j] = new Integer[i+j+1];

posted @ 2005-11-12 02:33 活在JAVA島的日子閱讀(135) | 評論 (0) | 編輯收藏

轉(zhuǎn)貼別人的讀書筆記 Think In Java讀書筆記5-7

Think In Java讀書筆記－1（第5——7章）- -

第5章隱藏實現(xiàn)細節(jié)

一．Java訪問權(quán)限飾詞（access specifiers）
Java有public、protect、friendly、private四種訪問權(quán)限，并且這四訪問權(quán)限的訪問范圍越來越小。
1． friendly
1）果一個class內(nèi)的數(shù)據(jù)成員或方法沒有任何權(quán)限飾詞，那么它的缺省訪問權(quán)限就是friendly。同一個package內(nèi)的其它所有classes都可以訪問friendly成員，但對package以外的classes則形同private。
2）　　對于同一個文件夾下的、沒有用package的classes，Java會自動將這些classes初見為隸屬于該目錄的default package，可以相互調(diào)用class中的friendly成員。如以下兩個class分別在同一個文件夾的兩個文件中，雖然沒有引入package，但隸屬于相同的default package。

class Sundae{
		//以下兩個方法缺省為friendly
    		Sundae(){}
		Void f() {System.out.println("Sundae.f()");
}
public class IceCream{
    		public static void main(String[] args){
			Sundae x = new Sundae();   
			x.f();
    		}
}

2． public：可以被任何class調(diào)用
3． private：private成員只能在成員所屬的class內(nèi)被調(diào)用，如：

class Sundae{
    private Sundae(){}//只能在Sundae class中被調(diào)用
    Sundae(int i) {}
    static Sundae makASundae()    {
        return new Sundae();
    }
}
public class IceCream{
    public static void main(String[] args){
        // Sundae class中構(gòu)造函數(shù)Sundae()是private，
        // 所以不能用它進行初始化
        //Sundae x = new Sundae();
        Sundae y = new Sundae(1);//Sundae(int)是friendly，可以在此調(diào)用
        Sundae z = Sundae.makASundae();
    }
}

4． protected：具有friendly訪問權(quán)限的同時，又能被subclass（當然包括子孫類，即子類的子類）所訪問。即，既能被同一package中的classes訪問，又能被protected成員所在class的subclass訪問。

二．Class的訪問權(quán)限
1．Class同樣具有public、protect、friendly、private四種訪問訪問權(quán)限：
1）public：在任何地方都可被使用
2）protect、private：除了它自己，沒有任何class可以使用，所以class不能是
protected或private（inner class除外）
3） friendly：同一個package中的classes能用
2．如何調(diào)用構(gòu)造函數(shù)被聲明為private的class
1）用static函數(shù)
2）用Singteton模式

class Soup{
	private Soup(){}
 	//（1）靜態(tài)函數(shù)方法
		public static Soup makeSout(){
			return new Soup();
		}
     //（2）The "Singleton" pattern:
     private static Soup ps1 = new Soup();
     public static Soup access(){
         return ps1;
     }
     public void f(String msg){
         System.out.println("f(" + msg + ")");
     }
 }
 public class Lunch{
     public static void main(String[] args){
         //Soup priv1 = new Soup();編譯錯誤
         Soup priv2 = Soup.makeSout();
         Soup priv3 = Soup.access();
         priv2.f("priv2");
         priv3.f("priv3");
     }

第6章重復運用classes

一．繼承（inheritance）
1．在derived class中overriding某個函數(shù)時，只能覆寫base class中的接口，即base class中的public或protected或friendly函數(shù)。如果試圖overriding一個private函數(shù)，雖然編譯通過，但實際上你只是在derived class中添加了一個函數(shù)。如

class Cleanser{    
     private void prt(){//（b）
        System.out.println("Cleanser.prt()");
    }
 }
public class ExplicitStatic extends Cleanser{
    public void prt(){
        System.out.println("ExplicitStatic.prt()");
    }
    public static void main(String[] args){
        Cleanser x = new ExplicitStatic();
        x.prt();//（a）
    }
}

因為Cleanser中的prt()是private，所以不能在其derived　class中被覆寫。ExplicitStatic中的prt()只是ExplicitStatic中的一個函數(shù)，所以當試圖在（a）處通過多態(tài)來調(diào)用prt()時，會發(fā)生錯誤。如果把（b）處的private去掉，則結(jié)果為
ExplicitStatic.prt()
2． Super的使用
1）通過關(guān)鍵字super可以調(diào)用當前class的superclass（父類）。
例6.1.1.1

class Base{
    Base(){System.out.println("Base()");}
    public void scrub() { System.out.println(" Base.scrub()"); }
}
class Cleanser extends Base{
    private String s = new String("Cleanser");
    public void append(String a) { s+=a; }
    public void dilute() { append(" dilute()"); }
    public void apply() { append(" apply()"); }
    public void scrub() { append(" scrub()"); }
    public void print() { System.out.println(s); }
    Cleanser(){
        System.out.println("Cleanser(): " + s);
    }
    public static void testStatic(){
        System.out.println("testStatic()");
    }
    public static void main(String[] args){
        Cleanser x = new Cleanser();
        x.dilute(); x.apply(); x.scrub(); x.print();
    }
 }
public class ExplicitStatic extends Cleanser{
    ExplicitStatic(){
        System.out.println("ExplicitStatic()");
    }
    public void scrub(){
        append(" Detergen.scrub()"); 
        super.testStatic();
        super.scrub();//調(diào)用的是Cleanser.scrub()
    }
    public void foam() { append(" foam()"); }
    public static void main(String[] args){
        ExplicitStatic x = new ExplicitStatic();
        x.dilute(); x.apply(); x.scrub(); x.foam();
        x.print(); System.out.println("Test base class:");
        Cleanser.main(args);   
        testStatic();
    }
}

運行結(jié)果：
Base()
Cleanser(): Cleanser
ExplicitStatic()
testStatic()
Cleanser dilute() apply() Detergen.scrub() scrub() foam()
Test base class:
Base()
Cleanser(): Cleanser
Cleanser dilute() apply() scrub()
testStatic()
2）通過super來調(diào)用superclass中的成員時，調(diào)用的是最近成員。
例6.1.1.2

class Base{
    protected String baseS = "Base";//（a）
    //private String baseS = "Base";
    Base(){System.out.println("Base()");}
}
class Cleanser extends Base{
    protected String baseS = "Cleanser";//（b）
    public String s = new String("Cleanser");
    Cleanser(){
        System.out.println("Cleanser(): " + s);
    }
    Cleanser(String a){
        System.out.println("Cleanser(" + a + "): s = " + s );
    }
 }
public class ExplicitStatic extends Cleanser{
    String s2 = s;
    String baseS = super.baseS; //（c）
    ExplicitStatic(){
        super("ExplicitStatic");
        System.out.println("ExplicitStatic():s2 = " + s2 + ", baseS = "+ baseS + "super.baseS = " + super.baseS); 
baseS = "ExplicitStatic";
System.out.println("baseS = " + baseS + " , super.baseS = " + super.baseS);
}
public static void main(String[] args){
ExplicitStatic x = new ExplicitStatic();
}
}

結(jié)果1：
Base()
Cleanser(ExplicitStatic): s = Cleanser
ExplicitStatic():s2 = Cleanser, baseS = Cleanser,super.baseS = Cleanser
baseS = ExplicitStatic , super.baseS = Cleanser
在上面例子中，在三個class中都存在String bases實例。在ExplicitStatic中如果直接調(diào)用baseS，則實際調(diào)用的是當前類ExplicitStatic中的baseS（即（c）處的成員）；如果通過super.bases來調(diào)用baseS，則調(diào)用的是離當前類ExplicitStatic最近的baseS成員，即Cleanser class中的baseS實例（即（b）處），產(chǎn)生的結(jié)果如結(jié)果1所示。如果把（b）處語句注釋掉，則將調(diào)用Base class中的baseS，結(jié)果如結(jié)果2所示。
結(jié)果2：
Base()
Cleanser(ExplicitStatic): s = Cleanser
ExplicitStatic():s2 = Cleanser, baseS = Base,super.baseS = Base
baseS = ExplicitStatic , super.baseS = Base
3． Base class的初始化
2.1 當你產(chǎn)生derived class對象時，其中會包含base class子對象（subobject）。這個子對象就和你另外產(chǎn)生的base class對象一模一樣。
2.2 通過super()可調(diào)用base class的構(gòu)造函數(shù)，但必須放在構(gòu)造函數(shù)的第一行，并且只能在構(gòu)造函數(shù)中運用。
2.3 初始化順序為：
1） 加載代碼（.class文件）
2） 初始化class的靜態(tài)成員，初始化順序了"從里到外"，即從base　class開始。
3） 在derived class的構(gòu)造函數(shù)中調(diào)用base class的構(gòu)造函數(shù)。
如果在derived class的構(gòu)造函數(shù)中沒有通過super()顯式調(diào)用調(diào)用base class的構(gòu)造函數(shù)，編譯器會調(diào)用bass class的default構(gòu)造函數(shù)并自動生成相應的調(diào)用語句，從而產(chǎn)生一個base class實例。如果在derived class的構(gòu)造函數(shù)中通過super()顯示調(diào)用了父類的構(gòu)造函數(shù)，則調(diào)用所指定的構(gòu)造函數(shù)。調(diào)用構(gòu)造函數(shù)的調(diào)用順序是"從里到外"。
4） 調(diào)用derived class的構(gòu)造函數(shù)。
＊＊：當base class沒有default構(gòu)造函數(shù)時，必須在derived class的構(gòu)造函數(shù)中通過super顯示調(diào)用base class的構(gòu)造函數(shù)。
例：下面代碼的初始化過程為：
1） 裝載ExplicitStatic的代碼（裝載ExplicitStatic.class文件）。
2） 發(fā)現(xiàn)ExplicitStatic有關(guān)鍵字extends，裝載ExplicitStatic的base　class的代碼（裝載Cleanser.class文件）。
3） 發(fā)現(xiàn)Cleanser有關(guān)鍵字extends，裝載Cleanser的base　class的代碼（裝載Base.class文件）。
4） 初始化Base class中的靜態(tài)成員。
5） 初始化Cleanser class中的靜態(tài)成員。
6） 初始化ExplicitStatic class中的靜態(tài)成員。
如果把（c）處的代碼注釋掉，那么初始化工作到此就結(jié)束了。
7） 為ExplicitStatic對象分配存儲空間，并把存儲空間初始化為0。
8） 在ExplicitStatic class的構(gòu)造中調(diào)用super("ExplicitStatic")（在ExplicitStatic class的構(gòu)造函數(shù)中顯式調(diào)用父類的構(gòu)造函數(shù)），試圖產(chǎn)生一個Cleanser class實例。
9） 為Cleanser對象分配存儲空間，并把存儲空間初始化為0。
10） 由于Cleanser class又是繼承自Base class，會在Cleanser class的構(gòu)造函數(shù)中通過super()（由于沒有顯式調(diào)用父類的構(gòu)造函數(shù)，所以自動調(diào)用父類的default構(gòu)造函數(shù)）調(diào)用父類的構(gòu)造函數(shù)，試圖產(chǎn)生一個Cleanser class實例。
11） 產(chǎn)生一個Base class實例。先初始化成員變量，再調(diào)用構(gòu)造函數(shù)。
12） 回到Cleanser class，產(chǎn)生一個實例。首先初始化Cleanser class中的成員數(shù)據(jù)，再執(zhí)行構(gòu)造函數(shù)Cleanser(String a)中的其余部分。
13） 回到ExplicitStatic class，產(chǎn)生一個實例。首先初始化ExplicitStatic class中的成員數(shù)據(jù)，再執(zhí)行構(gòu)造函數(shù)ExplicitStatic ()中的其余部分（System.out.println("ExplicitStatic()")）。
class Base{
    static int s1 = prt("s1 initialized.", 11);
    int i1 = prt("i1 initialized.", 12);
    Base(){
        System.out.println("Base()");
        System.out.println("s1 = " + s1 + " ,i1 = " + i1);
        draw();//（d）
    }
    void draw(){
        System.out.println("base.draw：s1 = " + s1 + " ,i1 = " + i1);
    }
    static int prt(String s, int num) {
        System.out.println(s);
        return num;
    }
}
class Cleanser extends Base{
    static int s2 = prt("s2 initialized.", 21);
    int i2 = prt("i2 initialized.", 22);
    Cleanser(){
        System.out.println("Cleanser()");
        System.out.println("s2 = " + s2 + " ,i2 = " + i2);
    }
    Cleanser(String a){
        //super();（b）
        System.out.println("Cleanser(" + a + ")");
        System.out.println("s2 = " + s2 + " ,i2 = " + i2);
    }
    
    void draw(){
        System.out.println("Cleanser.draw：s2 = " + s2 + " ,i2 = " + i2);
    }
 }
public class ExplicitStatic extends Cleanser{
    static int s3 = prt("s3 initialized.", 31);
    int i3 = prt("i3 initialized", 31);
    ExplicitStatic(){
        super("ExplicitStatic");//（a）
        System.out.println("ExplicitStatic()");
        System.out.println("s3 = " + s3 + " ,i3 = " + i3);
    }
    public static void main(String[] args){
        ExplicitStatic x = new ExplicitStatic();//（c）
    }
}

結(jié)果：
s1 initialized.
s2 initialized.
s3 initialized. 
//如果把（c）處的代碼注釋掉，輸出結(jié)果到此為止，不會輸出下面結(jié)果
i1 initialized. 
Base()
s1 = 11 ,i1 = 12
Cleanser.draw：s2 = 21 ,i2 = 0//（d）處結(jié)果
i2 initialized.
Cleanser(ExplicitStatic)//（a）處結(jié)果
s2 = 21 ,i2 = 22
i3 initialized
ExplicitStatic()
s3 = 31 ,i3 = 31
由于在Base()中調(diào)用draw()時，Cleanser中的i2還未進行初始化，而在為Cleanser對象分配存儲空間時，把存儲空間初始化為0，所以此時i2為0。
2.4 代碼及結(jié)果中的（a）說明了是先產(chǎn)生當前class的base class的實例，否則在derived class中無法調(diào)用base class的成員。在調(diào)用Cleanser class的構(gòu)造函數(shù)Cleanser(String a)時，在Cleanser(String a)中沒有用super顯式調(diào)用Base class的構(gòu)造函數(shù)，所以系統(tǒng)會自動生成調(diào)用Base class的default構(gòu)造函數(shù)的語句，如（b）。
4． 組合與繼承之間的快擇
. 1）繼承表示的是一種"is-a（是一個）"的關(guān)系，如貨車是汽車中的一種；組合表示的是一種"has-a（有一個）"的關(guān)系，如汽車有四個輪子。
2）是否需要將新的class向上轉(zhuǎn)型為base class。
5． 在繼承中的訪問權(quán)限
protect變量能被子孫類所調(diào)用。如Base class中的baseS能被Cleanser class和ExplicitStatic class調(diào)用。
class Base{
    protected String baseS = "Base";
    //private String baseS = "Base";
    Base(){System.out.println("Base()");}
}
class Cleanser extends Base{
    protected String baseS = "Cleanser";
    public String s = new String("Cleanser");
    Cleanser(){
        System.out.println("Cleanser(): " + s);
    }
    Cleanser(String a){
        System.out.println("Cleanser(" + a + "): s = " + s );
    }
 }
public class ExplicitStatic extends Cleanser{
    String s2 = s;
    String baseS = super.baseS;
    ExplicitStatic(){
        super("ExplicitStatic");
        System.out.println("ExplicitStatic():s2 = " + s2 + ", baseS = " 
          + baseS + "super.baseS = " + super.baseS);
        baseS = "ExplicitStatic";
        System.out.println("baseS = " + baseS + " , super.baseS = " + super.baseS);
    }
    public static void main(String[] args){
        ExplicitStatic x = new ExplicitStatic();
    }
}

結(jié)果：
Base()
Cleanser(ExplicitStatic): s = Cleanser
ExplicitStatic():s2 = Cleanser, baseS = Cleanser, super.baseS = Cleanser
baseS = ExplicitStatic , super.baseS = Cleanser
二．關(guān)鍵字final
1．Final data
1.1　final data
1）當基本型別被定義為final，表示它的數(shù)據(jù)值不能被改變。如
final int i = 9;
i++;//編譯錯誤，不能改變I的值
2) 當object　reference被定義為final時，不能改變的只是reference而不是對象本身。如
class Value{  int i = 1;
}
public class ExplicitStatic extends Cleanser{
public static void main(String[] args){
final Value v = new Value();//v.i = 1
v.i++;//v.i = 2
//v = new Value();
}
}

由于v為final，所以不能通過new Value()使v重新指向一個對象；但是v所指向的對象的值是可以改變的（v.i++）。
1.2　blank finals
我們可以將數(shù)據(jù)成員聲明為final但不給予初值，這就是blank　finals。但blank　finals必須且只能在構(gòu)造函數(shù)中進行初始化。
public class ExplicitStatic {
    final int ib;
    final int i = 1;
    ExplicitStatic()
    {
        ib = 2;//（a）
        //i = 3;　（b）
        System.out.println("i = " + i  + ", ib = " + ib);
    }
    public static void main(String[] args){
        ExplicitStatic ex = new ExplicitStatic();
    }
}

ib為blank　finals，所以可以在構(gòu)造函數(shù)中進行初始化。如果把（a）處的代碼注釋掉，則ib沒有初值，編譯出錯。而i在定義處已進行了初始化，則不能改變i的值，（b）處的代碼編譯錯誤。
＊＊：非blank　finals成員即使在構(gòu)造函數(shù)中也不能更改其值
2．Final　methods
1）被聲明為final的函數(shù)不能被覆寫
2）class中所有private函數(shù)自然而然會是final。
3． Final　classes
1）當一個class被聲明為final時，表示它不能被繼承，但class的數(shù)據(jù)成員不是final，可以被改變。如
class SmallBrain{}

final class Dinosaur{
    		int i = 7;
    		int j = i;
    		SmallBrain x = new SmallBrain();
    		void f(){};
}

//不能繼承final函數(shù)
//class Further extends Dinosaur{}

public class ExplicitStatic{
    		public static void main(String[] args){
        		Dinosaur n = new Dinosaur();
        		n.f();
        		n.i = 40;//final class中的non-final數(shù)據(jù)成員可以被改變
       	 	n.j++;
    		}
}

2）final　class中的所有函數(shù)也都自然是final，因為沒有人能夠加以覆寫。

第7章 多態(tài)

一．再探向上轉(zhuǎn)型（upcasting）
將某個object　reference視為一個"reference　to　base　type"的動作，稱為向上轉(zhuǎn)型。
1． Upcasting后調(diào)用某個函數(shù)時，如果derived　class中覆寫了該函數(shù)，則會調(diào)用derived　class中的函數(shù)；否則，會調(diào)用base　class中的函數(shù)。如
class First{
    public void prt(){
        System.out.println("First");
    }
}
class Second extends First{
	//（a）
     public void prt(){
        System.out.println("Second");
    }
}
public class ExplicitStatic{
    public static void main(String[] args){
        First n = new Second();
        n.prt();;
    }
}

結(jié)果為Second。如果當Second　class中的prt()函數(shù)注釋掉，將輸出First。
2． 向上轉(zhuǎn)型后只能調(diào)用base　class中被derived　class覆寫的函數(shù)。
/*
abstract class First{
    int i = 122;
    public void prt(){
        System.out.println("First.i = " + i);
    }
    public abstract void prt(First f);
}

class Second extends First{
     public void prt(){
        System.out.println("Second.i = " + i);
    }
    
    public void prt(First i)
    {
        
    }
    
    public void prt(int i)
    {
        
    }
}
public class ExplicitStatic{
    public static void main(String[] args){
        First n = new Second();
        n.prt(2);;
    }
}
*/
class First{
    public void prt(){
        System.out.println("First");
    }
}
class Second extends First{
	//（a）
     public void prt(){
        System.out.println("Second");
    }
    public void prt(int i){//（a）
        System.out.println("Second.i = " + i);
    }
}
public class ExplicitStatic{
    public static void main(String[] args){
        First n = new Second();
        n.prt(3);
    }
}

（a）處的函數(shù)只是Second　class中的函數(shù)，所以不能通過n.prt(3)進行調(diào)用。
二．Abstract　class和Abstract　methods
1． 如果一個class中存在abstract　class，則class也必須被聲明為abstract　class。
2． abstract　class不能被實例化。
3． 如果base　class是一個abstract　class，那么derived　class必須實現(xiàn)base　class中所有的abstract　methods；否則，derived　class也必須被聲明為abstract　class。
三．其它要點
1． 純粹繼承與擴充
純粹繼承：只有base　class所建議的函數(shù)，才被derived　class加以覆寫。
擴充：除了覆寫base　class的函數(shù)，還實現(xiàn)了自己的函數(shù)
abstract class First{
    public abstract void f();
    public abstract void g();
}
//純粹繼承
class Second extends First{
     public void f(){}
     public void g(){}
}
//擴充
class Third extends First{
     public void f(){}
     public void g(){}
     public void u(){}//base　class不存在的函數(shù)
}

2． 向下轉(zhuǎn)型
1） 向下轉(zhuǎn)型時只能調(diào)用base　class中被覆寫過的函數(shù)
2） 只有本來就為derived　class對象時才能正確向下轉(zhuǎn)弄。
class First{
     public void f(){}
     public void g(){}
}
class Second extends First{
     public void f(){}
     public void g(){}
     public void u(){}
     public void v(){}
}
public class ExplicitStatic{
    public static void main(String[] args){
        First[] x = {new First(), new Second()};
        x[0].f();
        x[1].g();
        //！x[1].u();class　First中不存在函數(shù)u()
        //((Second)x[0]).f();（a）
        ((Second)x[1]).u();
}
}

posted @ 2005-11-12 02:26 活在JAVA島的日子閱讀(502) | 評論 (0) | 編輯收藏

開始努力了

學習了JAVA一段時間了。有時也看看人家寫的BLOG,覺得自己也應該寫點東西!或許有助于提高自己吧!

posted @ 2005-11-11 17:57 活在JAVA島的日子閱讀(133) | 評論 (0) | 編輯收藏

第7章多態(tài)

常用鏈接

留言簿(4)

隨筆檔案

文章分類

文章檔案

Links

搜索

最新評論

閱讀排行榜

評論排行榜

JAVA事件的總結(jié)（轉(zhuǎn)）- -

第2章萬事萬物皆對象

第3章控制程序流程

第4章初始化和清理

Think In Java讀書筆記－1（第5——7章）- -

第5章隱藏實現(xiàn)細節(jié)

第6章重復運用classes

常用鏈接

留言簿(4)

隨筆檔案

文章分類

文章檔案

Links

搜索

最新評論

閱讀排行榜

評論排行榜

JAVA事件的總結(jié)（轉(zhuǎn)）- -

第2章 萬事萬物皆對象

第3章 控制程序流程

第4章 初始化和清理

Think In Java讀書筆記－1（第5——7章）- -

第5章 隱藏實現(xiàn)細節(jié)

第6章 重復運用classes

第7章 多態(tài)

第2章萬事萬物皆對象

第3章控制程序流程

第4章初始化和清理

第5章隱藏實現(xiàn)細節(jié)

第6章重復運用classes

第7章多態(tài)