Java課

Java課第八章 類的高級特性~2 final

關鍵字: final
final與static一樣屬於修飾符,可放在變量,方法,和類的前面,與訪問修飾符不同

1.想聲明一個常量,不希望它的值有所改變,只可賦值一次
例:final i;     i=30;   此時,變量i不可再被賦值,第一次賦值可在任何地方;
2.聲明一個方法,可以不被任何其他方法所覆蓋,通常用在父類方法中
例:final void print(){}  此時print方法被定義爲最終方法,不可被其他方法覆蓋
3.聲明一個最終類,不可被任何類繼承(String 類也屬於final類,因此他的對象不可被改變)
例:final class Demo(){}

 

變量-作用
1.一個變量可以聲明爲final,這樣做的目的是阻止它的內容被修改.
2.聲明final變量後,只能被初始化一次,然後就不能對其值進行修改
3.一個final變量實質上是一個常量.

 

方法-作用
1.在方法聲明中使用final關鍵字向編譯器表明子類不能覆蓋此方法.

 

類-作用
1.在聲明中,一個final方法只能被實現一次,聲明final的類不能被繼承
2.如果一個類爲final類,那麼它的所有方法都爲隱式的final方法

Java課第八章 類的高級特性

靜態修飾符：

static ：

用static 可以用來修飾變量和方法，被修飾的變量和方法可以當作全局變量，既沒有創建對象，也可以直接使用該方法或變量。

被靜態修飾符修飾的變量，可以當作是類自己的屬性，是實際的，而不是抽象的，並且不屬於某個具體的實例對象。它們也叫做類變量和類方法 ，顧名思義 ~！！

使用它的意義，例 ：

用Student對象保存學生信息，希望每個對象有一個單獨的編號。第一個創建的對象編號爲1，第二個對象編號爲2，以此類推.

class Student

{

  static int id=0;

  String name;

  Student(String name)

  {

   this.name=name;

   id++;

  }

 

  public static void main(String args[])

 {

 Student s1=new Student("超人");

 System.out.println(s1.id,s1.name)

 Student s2=new Student("神仙");

 System.out.println(s2.id,s2.name)

 Student s3=new Student("汽車人");

 System.out.println(s3.id,s3.name)

 Student .........

 }
}

這樣他們的 ID號就一按順序這麼排列下去。要注意的是，如果對象創建到 N的時候 ，靜態的那個成員也自動加到n......

 

靜態成員可以在包中任何地方被訪問，被訪問的格式

className.staticVar       className.staticMethod

 

小結：

1.構造函數是不能夠靜態化的

2.類方法只能訪問本身的參數和類變量。訪問非類變量的嘗試會引起編譯錯誤。

3.靜態方法重載和覆蓋的4個情況

--可以使用非靜態的方法重載靜態方法  (應爲靜態方法被編譯器最先執行，所以非靜態方法可以覆蓋靜態方法 ，反之，靜態方法不能夠重載非靜態方法)

 

--可以靜態方法重載靜態方法

 

--靜態方法可以被靜態方法覆蓋

 

成員初始化順序:

1.首先按從上到下的順序初始化父類和相關子類中的 靜態屬性或方法

2.再則是初始化父類定義初始化,然後在父類構造函數

3.子類定義初始化，然後子類構造函數

4.最後纔是另外的一些成員方法 或 別的操作

 

 

Java課第七章 *面向對象*~5 (END)

關鍵字：instanceof,import,package   特殊方法:toString(),equals()

instanceof:
1.instanceof運算符可以用來檢查對象與類之間的關係
2.格式：if(obj instanceof classname).....,當obj爲classname類或其子類的對象時，運算符返回true.
例：Father爲一個父類，Son爲一個子類
Son s1=new Son();
if(s1 instanceof Father)  //返回的值爲true,因爲子類的對象也可以屬於是父類

Father s2=new Father();
if (s2 instanceof Son)   /返回的值爲false,因爲父類的對象不屬於子類

類型轉換：
1.執行自動類型轉換需要2個條件：
  -接受轉換的類型種類是兼容的
  -目的類型數的範圍比源類型大

2.強制類型轉換的格式：
(目標類型)value

Object類
1.所有創建的類都有一個默認的公共超級父類Object,它其中有一些已經定義好的方法
2.Object類包括在java.lang的包中，無論是哪個文件,系統默認調用java.lang這個包
3.此類定義了所有對象都具有的基本屬性和方法 既默認的構造函數
4.可以用類型爲Object的變量來引用任意類型的對象  //不解

equals()
格式:
(obj_name.equals(obj_name2));
對象1與對象2比較,

1.equals()這個方法在Object中，在其他類中可以任意調用
2.用於比較兩個對象在堆中指向的地點是否相同，如果相同就返回true
3.子類可以通過覆蓋Object的equals方法來實現由意義的測試，可以實現:若同一類型的兩個不同對象包含相同的信息既返回true。也可以理解爲同類中兩個對象的值是否相等.
子類覆蓋equals方法:
public boolean equals(Object Obj)
     {
        if(this==Obj) return true;//比較的是兩個對象的引用(references)是否相等
        if(Obj==null) return false;//檢查 Obj是否爲空
        if(getClass() != Obj.getClass()) return false;//檢查是否屬於同一個class
        return true;
     }
第一句：//比較的是兩個對象的引用(references)是否相等
第二句：//檢查 Obj是否爲空
第三句：//檢查是否屬於同一個class

toString()
1.toString也是Object類中的一個方法，也可以在任何類中被調用
2.toString 用於返回對象的字符串表示
3.建議所有子類都覆蓋此方法
4.使用"+"運算符將對象同一個字符串連接，java編譯器會自動調用toString方法，獲取對象的字符串表現形式
(以上好像在實際中都運用了)

源文件(編譯單元)
1.每個編譯單元必須是以.java結尾的文件名稱,在一個編譯單元裏(既一個文件內),可以有一個public的類,這個類的名字必須與保存的文件同名.在一個單元內,除了public類,其它的類如果沒被聲明訪問權限,就默認爲protected的.

2.可以,儘管很少見,一個編譯單元沒有一個public類,所有的類都是protected的,那麼文件名可以任意起,

3.編譯一個.java文件時,對應於文件中的每一個類,會得到一個.class文件,文件名與類的名字相同.一個程序是一堆.class文件.

包:庫單元 (最重要的部分之一)
1.用import來引入包或者包裏的成員.
  例:import java.util.*;  //這裏引入了java.util中的所有類
     import java.util.Vector //這裏引入了java.util中的Vector類(可以具體化)

2.java中，包德主要用途
  -包允許將類組合成較小的單元.
  -包允許在在更廣的範圍內保護類、數據和方法.
  -在一個包中可以調用其它包中任何類,起到"類"_"覆用"的作用.

3.包可以是類、接口和子包的集合

4.兩個不同包中含有同名類，如java.util包和java.sql包中都有一個Date類，下面程序會出現編譯    出錯，因爲編譯器不知道使用哪個Date類，這個時候要給......不知道同時調用他們的Date類

 

使用包:
創建包:
格式:  package package_name;

訪問java成員包
格式: package_name.class_name

導入包:
格式: import package_namme.*;

導入子包:
格式: import package_name.package2_name.*;

注意:
--只能用*來引入一個包中的所有類,並不能嵌套引入下層包
例: package_name下層還有一個包爲package_name2,這裏就不能用package_name.*來調用package_name2中間的類

--若兩個Date類都要使用,則只能在每個類前面加上完整的包名
例:根據前面的例來導入2個包中的所有類
import package_name.*;
import package_name.package_name2.*;

--只能引入類,不能引入對象.如: 不能用import System.out.

--Java缺省自動引入java.lang包中所有的類,相當於import java.lang.*

CLASSPATH  類的路徑
1.CLASSPATH是一個環境變量,包含一個或多個目錄
2.它的意思是說JVM需要找一個.class文件的時候到哪裏去找
3.CLASSPATH,它們作爲一種特殊的根使用,從這裏展開對.class文件的搜索
4.如果在沒有設置CLASSPATH的環境變量時,系統默認給了一個"."(當前目錄),編譯器會在當前目錄裏去尋找.class文件

 

Java課第七章 *面向對象*~4

關鍵字:super

Super關鍵字:

1.super關鍵字用來解決如何直接訪問從父類繼繼承過來的屬性或方法

例：

class Father

{

  int value;

  String name;

  public Father(int value,String name)

  {

   this.value=value;

   this.name=name;

  }

class Son extends Father

{

 String character;

 String like;

 Son(int value,String name,String character,String like)

 {

 super(value,name)//這裏將調用父類中的構造函數，這裏的參數要與父類的構造函數配對

 this.character=character;

 this.like=like;

 }

 

2.調用父類的構造函數，用來訪問被子類覆蓋了的父類成員

例

class Weapon
{
 int price;
 int value;
}

class Sword extends Weapon
{
 int price;
 int value;
 Sword(int p,int v)
 {
 super.price=10;    //雖然子類的成員變量與父類的相同，在這裏加了super.來識別變量爲父類的
 super.value=50;  //如果想子類中給父類的成員變量賦值，必須在子類的構造函數中
 price=p;           
 value=v;
 }
 
 void print()
 {
  System.out.println(super.price);  //在這裏，一樣可以打印父類的，怕子類的成員變量覆蓋父類的
  System.out.println(super.value);
 }

 public static void main(String args[])
 {
  Sword s1=new Sword(100,50);
  s1.print();
 }

} 

 

 

3.它用在對象的 構造函數中，將構造細節通過繼承鏈往上傳

 

4.與this一樣，必須在構造函數的第一行

 

Super的使用格式:

super.variable 用來訪問被子類成員變量覆蓋的父類的成員變量

super.Method([paramlist]) 調用父類中被重寫的方法

super([paramlist]) 調用父類的構造函數

 

this 與 super:

1.如果子類聲明瞭一個與父類的成員變量同名的成員變量，則稱父類的該成員變量被隱藏

 

2.如果子類聲明瞭一個與父類的成員方法同名的成員方法，則稱父類的該成員方法被覆蓋

 

3.關鍵字this 和super分別用來指明子類和父類中同名的成員變量或成員方法

  this 區分本類中相同名稱的成員變量與局部變量和參數

  super 區分子類與父類之間相同名稱的成員變量與方法

 

4.當父類的成員變量、子類的成員變量和類中方法使用的局部變量三者同名，或其中的兩者同名時，可以使用關鍵字this和super來指定所要使用的變量.

 

5. 如果一個構造函數既沒有調用super(…)也沒有調用this(…)，編譯器自動插入一個對父類構造函數的調用super() (不帶參數)

 

成員初始化順序：

  在java中，成員初始化(塊)順序是在構造函數之前被執行，構造函數之前我們就做了定義初始化。在一個類中，初始化順序是由變量在類內的定義順序決定的，即使初始化(塊)大量遍佈與類中最下面或中間位置，那些變量仍然會在調用任何方法之前得到初始化。

 

面向對象的多態性：方法覆蓋

1.方法覆蓋是java實現多態性機制的另一種方式。第一種是方法重載

2. 在類層次結構中，如果子類中的一個方法與父類中的方法有相同的方法名並具有相同數量和類型的參數列表，這種情況稱爲方法覆蓋.

例：父類中有

void print()

{

 System.out.println("父類");

}

子類中也有

void print()

{

System.out.println("子類");

}

這種情況下，子類的方法將覆蓋父類方法。他們擁有相同的名稱以及相同數量的參數和數據類型，所以這了構成方法覆蓋.

 

3.當一個覆蓋方法通過父類引用被調用，Java根據當前被引用對象的類型來決定執行哪個版本的方法。

比如用父類來創建一個對象，但new 的是子類，java根據子類與父類中的構造函數中的參數來決定執行哪一個版本的方法.

例:

class SuperClass {
 int a;
 SuperClass()
 {
  a = 10;
 }
 public void printA()
 {
  System.out.println("父類中a ="+a);
 }
 
 public void printB()
 {
  System.out.println("你好，兒子。我是你爸爸");
 }
}

class SubClass extends SuperClass {
 int a;
 SubClass(int a)
 {
  this.a = a; 
 }
 public void printA()
 {
  System.out.println("子類中a = "+a);
 }
}

public class OverrideDemo {
   public static void main(String args[]) {
     SuperClass s1 = new SubClass(10);   //關鍵就是這裏，new 的構造函數是子類的
     s1.printA();          //後面參數10等於給子類構造函數中的a賦值,
     s1.printB();          //最後輸出子類中的print這個方法覆蓋的版本
   }
}

 

4.可以通過super關鍵字調用直屬父類中被覆蓋的方法版本

 

覆蓋的3條規則：

1.必須有一個與它所覆蓋的方法相同的返回類型

2.不能比它所覆蓋的方法訪問性差。

3.不能比它所覆蓋的方法拋出更多的異常

 

Java課第七章 *面向對象*~3

關鍵字:extends,this

第9天

this 引用:

1.this 調用了那個方法的那個對象(這個還是不大明白)

2.在一個構造函數調用另外一個構造函數時，用this

例：

class Vehicle
{
  String brand;
  String color;
  int price;
  int number;
  Vehicle(String b,String c)
  {
   brand=b;  color=c;
  }
 
  Vehicle(String b,String c,int p,int n)
  {
   this(b,c);/*這裏的(b,c)對應上面的那個構造函數，
               this將自動調用式配與參數相同的構造函數*/
   price=p;
   number=n;
   System.out.print("車牌="+brand );
   System.out.print("- 顏色="+color);
   System.out.print("- 價格="+price );
   System.out.print("- 座位數="+number);
  }
  public static void main(String args[])
  {
     Vehicle c1=new Vehicle("法拉利","紅色",300,4);
  }
}

 

3.如果方法的參數與成員變量名稱相同，方法的局部變量與成員變量名稱相同。這裏可以用this來引用類的成員變量。比如上面的例子,稍微改一下

Vehicle(String brand,String color,int price,int number)

{

 this.brand=brand;     this.color=color;

 this.price=price;     this.number=number;

}

 //這裏就用this的引用來將要被賦值的brand當作爲成員變量，而不是局部變量和參數

 

 

繼承:extends

繼承允許創建“分等級層次”類。可創建一個通用類定義一系列一般特性。

例：

“僱員”這個父類下面分爲“工人類”和“管理員類”，在僱員類可以中可以定義他們都有的共同性質，比如，年紀，姓名，等等.....到了“工人類”中就可以定義更加具體的一些屬性，比如工人的“工作內容”等等屬性.......

 

1.被繼承的類爲“父類”

2.繼承“父類”的類“爲子類”

3.“子類”自動繼承“父類”擁有的屬性，並且擁有自身的特有的屬性。

 

格式：

class subclass-name extends superclass-name{//主體}

例：

class Empolyee

{

 String name;

 int age;

 ....

}

class Worker extends Empolyee

{

  //這裏將不需要再定義name和age兩個屬性，將自動繼承“父類”中有的所有屬性和行爲

 

}

 

 

Java課第七章 *面向對象*~2

關鍵字：new

第8天

構造函數：

定義規則：

1.構造函數與類名稱相同

2.構造函數沒有任何返回值 所以構造函數前沒有任何void和所返回的類型

3.他的任務是在創建對象時初始化其內部狀態

例：

class Car

{

   int speed;

   int weight;

    Car(int s,int w)

    {

       speed=s;

        weight=w;

    }

}

這樣，就可以在創建Car這個對象的時候給對象賦不同的屬性了.

 

類的多態性：

1.多態性是指對類的成員函數的調用導致完全不同的行爲

2.java中類的多態性主要表現爲方法的重載(overlord),和方法的覆蓋(override).

 

 

方法重載:

1.方法重載是java實現面向對象多態性機制的一種方式。

2.在一個類中多個方法名稱相同，但參數列表不同(個數和類型不同),這個情況構成方法重載

3.返回類型不同，不足以構成方法的重載

4.當重載方法被調用時，編譯器根據參數類型和數量來確定實際調用哪個重載方法的版本

5.java中不允許在一個類中聲明2個識別標記相同的方法

例:  test(int x,int y)

      test(int i,int k)  

這兩種方法的識別標記是相同的，雖然形參的變量名不同，但還是不足以構成方法重載

 

構成方法重載的例子：

    test (int x)

    test (int x,int y)

    test (float i)

    test (double i)

    test (float i ,double k)

 

重載構造函數：

1.java會爲每一個類自動缺省一個構造函數，缺省構造函數將成員變量的值初始化爲缺省值。

如，boolean x;  x的缺省值爲false.   int x;   x的缺省值爲0

2.一旦創建了自己的構造函數，缺省的構造函數將失效

3.重載構造函數提供了一組創建對象的方式，根據需要，是否帶初始參數。

例：

class Bread

{

 int water,flour,sugar; 

 Bread(int w,int f,int s)

 {

  water=w;

  flour=f;

  sugar=s;

  System.out.println("帶3個參數的構造函數");

 }

 Bread(int w,int f)

 {

 water=w;

 flour=f;

 System.out.println("帶2個參數的構造函數");

 }

 

如果在這了在創建對象的時候，給的參數不一樣，就構成了構造函數的重載

Bread b1=new Bread(10,5,10);

Bread b2=new Bread(10,50);

b1調用了第一個構造函數，因爲他對應第一個構造函數的參數

b2就對應第2個，相同的對應了第2個構造函數的參數

 

 

Java中內存分配的方法：

棧區(stack):這裏一般儲存"引用變量"，函數的參數值，和局部變量的值等...

堆區(heap):所有new出來的對象都是在堆中分配的，內存不夠時使用垃圾回收機制處理。

 

創建對象：

格式：

class name=new 構造函數();  //類名_對象名=new 構造函數();

必須使用new來創建對象,關鍵字new通常稱爲創建運算符，用於分配對象內存，並且該內存初始化爲缺省值。

一旦new完成分配和初始化內存，它就將調用構造函數來執行對象初始化。

 

缺省初始值：

變量在被初始化之前是不能使用的，在一個方法的局部變量必須先初始化才能使用

比如 void Demo

{

 int x;

}

這裏面的x是不能使用的，因爲沒有被初始化!

 

關鍵字 public,protected,private

第七天 初步瞭解了“類”與“對象”這兩個概念。

對象：一個對象首先應該有一個名字，並且有自身的狀態（屬性->變量），還有自身的功能，即行爲（方法->函數),例：

person(一個人)

屬性 ：人名：jack        公開(public)

          體重：100kg     受保護(protected)

          身高:180cm       受保護(protected)

          銀行密碼:*****  私有的(private)

          等等.......      可以給屬性4種封裝，public protected,private,....

 

行爲：行走  {用方法（函數） 來實現}

         思考 

         搏鬥

         等等..........

 

對象是某類事物的一個個體，也稱爲實例，具有自身的結構，即屬性與行爲。行爲在程序中可以當作是具體的某種操作。比如說移動。。。

 

類：物以“類”聚，人以羣分，類是對某一類事物的抽象，概念上的定義。我們可以基於類來創建對象。例：生物這個類是對動物+植物的抽象，動物又分爲許多類……等等....

 

抽象的理解：抽象是從特定的實例中抽取共同的性質而形成概念上的過程，比如男人和女人被“人類”抽象，將男人與女人共有的性質抽象而形成“人類”。類也稱爲模板，因爲它們提供了對象的基本框架

 

面向對象3大優點：1.按照人類的超自然思維的方式，面對客觀世界建立軟件模型

                          2.所構造的類可以重複使用

                          3.易擴展性與易修改性

 

*面向對象3大特性*：

1.封裝：將類與對象中的變量與方法可以封裝起來，可以阻止外部定義的代碼隨意訪問內部代碼和數據。封裝把對象的所有組成部份結合在一起，封裝定義程序如何引用對象的數據。

封裝允許有選擇性的隱藏類與對象中的屬性和方法。控制使用者對類的修改和訪問數據的程度。

 

2.繼承性：繼承在中文意思中有“接過來”和“照搬使用”的意思，繼承性就是自動地共享父類中的方法和數據的機制。例：比如前面說了，“人類”算父類，“男人”算子類，男人直接繼承父類中的“行走”這個行爲。例：

人類-->男人-->中年男人

從共性-->個性

從大-->小

從抽象-->具體

 

3.多態性：程序中，參數不一樣的相同的方法調用時，可導致不同的行爲。在子類中重新定義父類中已有的方法，隱藏了父類的方法，使子類擁有自己具體的實現，更進一步表明了與父類相比，子類所具有的特殊。例如，在“動物”這個類中，“鳥”繼承了動物“行走”這個行爲，但是在“鳥”這個類中的時候，行走時用的可能是翅膀了，與“父類”中“移動”這個行爲不同。（這個還得具體到程序中去做菜能明白）

 

創建類：

class name

{

 type variable1;//成員變量，對象的屬性或狀態

 type variableN;

 ....

 type methodName1(parameter-list)//成員方法，既對象的行爲或操作

 {

  //方法體

  }

 type methodNameN(parameter-list)

 {

 //方法體

 }

}

 

定義方法（函數):

[access]type methodName1([parameter-list])

{

  //方法體

 }

 

例：

public int setdate(int day,int month,int year)

{

 day=7;  month=5;  year=2005;

}

 

 

簡單訪問控制：

public 聲明的數據成員和函數成員可以從類外部的任何地方訪問

private 聲明的將被隱藏，這就是實現數據封裝的概念

要從外部操作private成員，只能通過類內部的public 或者protected成員來實現

 

 

JAVA課第6章 函數

關鍵字 無；

第6天  函數還是比較好理解，就是用另外一個方法來處理一件事情，最後的結果再再返回給調用它的人

 

定義函數，例：

static int circle(int x)  // static 不用管-_-,int 定義這個函數返回的值爲int型，括號內的(int x)爲形式參數，可以在主函數中使用，成爲實際參數。

 

使用函數的例子，這裏用函數來算出圓的周長與面積；已知周長公式是2*PI*R,面積是2*R*R

public class Circle

{

     public static void main(String args[])

    {

       int radius=Integer.parseInt(args[0]);//下面兩句中的(radius)是實際參數，對應函數中的形參

       System.out.println("length="+length(radius); //這裏將調用length函數來計算圓的長度

       System.out.println("length="+area(radius);//這裏調用area的函數來計算面積

    }

static double length(int x)

{

    return 2*3.14*x;

}

 

static double area(int y)

{

  return 2*y*y;

}

 

}

 

基本上是這樣了，還講了些JAVA在內存中存放的概念，即“堆”和“棧”這2個概念，其中堆存放變量的值，等等數據比較大的東西，它的彈性很大，可以無限擴大，但他運行速度低。“棧“的概念是將一些在程序中數據較少的東西，並且彈性低，不過運行效率很高。

 

局部變量：

              局部變量值的是在{}內聲明的變量值能在{}這個作用域內使用,例：

              public static void main(String args[])

              {

                int i=1;

                if(i==1)

                {

                  int c=2;

                  i=i+c;

                }

               System.out.println(i);

              在if {}內定義的c的作用域只在if{}內，在main{}內就不能使用這個變量；

 

 

JAVA第5章 數組(極重要)

關鍵字,new

 

第5天 數組，今天的課終於理解了，可以理解成如果定義一個數組中有10個元素，10個元素分別又代表10個變量，10個變量可以賦值後就可以拿來當普通變量用，可以通過“下標“來使用它。“下標“ 就是 "[]" 中數字。數組中各個元素的數據類型一定得是同樣的。

 

首先看看定義數組的格式把，

 

int GroupNumber[]; //格式

GroupNumber[]=new int [10];//給數組分配10個元素，元素是從0開始，所以這裏元素是0~9，10個

上面2項也可以寫成（更加簡化）   int GroupNumber[]=new int [10] //

 

還有就是直接給數組中的元素附值

int GroupNumber[];{1,2,3,4,5}. //給GroupNumber定義了5個元素，其中每個元素中的值分別是1,2,3,4,5,。這裏又可以換種方式寫，即

int GroupNumber[]=new int [5];

GroupNumber[0]=1;

GroupNumber[1]=2;

GroupNumber[2]=3;

GroupNumber[3]=4;

GroupNumber[4]=5;

//這樣寫看起來很繁瑣阿，不過更加容易理解數組元素是從0開始的，所以這裏數組中的元素就是[0],[1],[2],[3],[4]就到了。。呵呵呵呵~~~

 

2維數組，可以理解爲表格的概念，就是行和列的概念

定義：int GroupNumber[][];      定義數組元素GroupNumber[][]=new int[10][5];

上面的定義意思是說GroupNumber等於有10行，5列，再細化一點

GroupNumber[0]這個數組元素中再另外有5個數組，

GroupNumber[0][0]=10; //GroupNumber數組元素0中包含的數組0賦值爲10；

就這樣，以此推類，就可以完全2維數組的概念了，不過還是很抽象，具體等以後要實際用上多維數組的時候了~~~

另外，直接給2維數組賦值的格式

int GroupNumber[][]={{1,3,5},{5,3,8},{11,-15,8}};

 

命令行參數: (Done)

@Java 應用程序可以從命令行中接收任意數量的參數
@每個參數被視爲字符串分別存儲在main函數的參數數組中
@可以使用雙引號將多個字符串作爲一個整體顯示

例：public class Demo

{ 

  public static void main(String args[])

  {

    for(int k=0;k<args.length;k++);

    System.out.println(args[k]);

  }

}

 

下面可以在命令行中輸入：

java Demo "Welcome to hell wa hahaha" bull shit

輸出的結果爲:

Welcome to hell

bull

shit

 

DONE...................

 

 

Jva課3-4章 結構控制

關鍵字：if-else,swith-case-default,while,do while,for,continue,break!

第3天和第4天 學的控制結構，選擇語句:if-else,swtich-。循環語句:while,do-while,for,其中功能最強的的就是for了，不過有時也用用while,比如下面這個例子

題目：找出第一個2，3，5的倍數，找到後輸出並退出

邏輯:while(!((number%2==0)&&(number%3==0)&&(number%5==0))) 使用while就可與不需要控制範圍....

還有跳轉語句：break和continue。  break跳出整個循環體。符合continue時就結束此循環繼續執行下一次循環。

switch 的格式

switch (表達式)

case '常量或者字符': 語句1

case '常量或者字符': 語句2

case ..........

default:語句n......

 

//for 和 continue的運用

for(num = 1; num <=100; num++)
 {
  if(num % 9 == 0) 
                     continue;
  System.out.println("不能被9整除的數有："+num);

 

結構控制的語法和格式沒問題，還得多練習這些!!

 

Java課1-2章 Java簡史

第1天 Java 的一些發展史與HelloWorld這個程序~ 第1天

           1990 sun公司以James Gosling 爲主的一批人開發了oak語言, 1995年Sun 公司的 HotJava 瀏覽器問世, 將Oak語言更名爲Java.

 

第2天:java中的標識符,關鍵字，運算符，變量，基本數據類型.

           比較麻煩的就是各種運算符了，其中包括了，算數運算符(沒問題)

           關係運算符：==，！=，>，<，等.......返回的值爲一個boolean值（目前感覺一般用於for和while的表達式裏）

           邏輯運算符：&,&&,|,||,^,!.....這裏要注意的就是!這個“反“和^“異或“

           位運算符：~(非),&(與),|(或),^(異或),..這些之運用在int,char,byte,long,short數據類型上,數據爲1時就爲真(true)，數據爲0時就爲假(false).