When I helped my son review for his English exam on Thurseday ,  I realized that he didn't memorize new vocabulary.

It took me a lot of time to help him memorize vocabulary.

Helping kids with homework and study is realy a difficult task.

文章標籤
日記 英文寫作 英文

muchone 發表在 痞客邦 留言(0) 人氣()

▲top
c)constructors
1.全部都要執行
2.順序上==>下(父==>子)
3.super(引數)：sup
d)overloading
 
●實作
UML
 
程式
(一)假設A沒有建構式，但school有建構式，compiler會出現錯誤訊息
=>required: String,int
=>因為在new A的時候，會run school的constructor，這時會需要引數，可是A沒有丟給school引數
 
做法：
引數透過子類別的建構式丟給父類別，如果沒有這樣做就不能繼承
A.java
//這個步驟是先接收user key的內容(接收外部資料)
A(String name,int chi){  
//透過super(引數)才會把引數丟給父類別
super(name,chi);          
System.out.println("A班學生");
}
=>注意!!super()中的順序和類型都要和父類別的建構式引數一致
=>在new的時候會先new A(所以引數就放在new A())，可是run是先run school(父類別)
 
school.java
class school{
String name;
int chi;
 
school(String name,int chi){
this.name=name;
this.chi=chi;
System.out.println("新增一位學生school\tname:"+name+"\tchi:"+chi);
}
}
 
*但如果交換System.out.println("A班學生");和super(name,chi);的順序，
compiler會出現次錯誤
=>super要放第一個，因為交換以後，變成先執行子類別在執行父類別的建構式了...
A.java
A(String name,int chi){   
System.out.println("A班學生");
super(name,chi);          
}
 
 
*如果A本身的建構式中也要放入引數
A.java
private int word;
//可以直接放在A()中，這邊的內容不用和school()中的內容一致，只要有包含school()中的內容即可
A(String name,int chi,int word){ 
//重點在super()中的內容要和school()中的內容一樣
super(name,chi);
this.word=word;   //要記得放在super()後面
System.out.println("A班學生\t word:"+word);
}
 
add.java
A a=new A("maggie",80,95);
 
 
 
(二)overloading
假設school有多個建構式(有引數的建構式才會有多個)
school.java
String name;
int chi;
 
school(String name,int chi){
this.name=name;
this.chi=chi;
System.out.println("新增一位學生school\tname:"+name+"\tchi:"+chi);
}
 
school(String name){
this.name=name;
System.out.println("新增一位學生school\tname:"+name);
}
 
*A在繼承時，只需要選一個繼承即可，由super()中的引數判斷是繼承哪一個，但如果兩個都要繼承時，不可以在同一個建構式中寫兩個super()，因super()在同一個建構式中只能使用一次，全部都要繼承，子類別就要拆成好幾個建構式(至少一定要繼承一個)
A(String name,int chi,int word){
super(name,chi);
this.word=word;
System.out.println("A班學生\t word:"+word);
}
A(String name,int word){
     super(name);
this.word=word;
System.out.println("A班學生\t word:"+word);
}
 
(三)A,A_1,和B都繼承
**繼承class之前一定要記得先去看class中的建構式
school.java
class school{
String name;
int chi;
school(String name,int chi){
this.name=name;
this.chi=chi;
System.out.println("新增一位學生school\tname:"+name+"\tchi:"+chi);
     }
school(String name){
this.name=name;
System.out.println("新增一位學生school\tname:"+name);
}
}
 
A.java
class A extends school{
private int word;
A(String name,int chi,int word){
super(name,chi);
this.word=word;
System.out.println("A班學生\t word:"+word);
}
A(String name,int word){
super(name);
this.word=word;
System.out.println("A班學生\t word:"+word);
}
}
 
A_1.java
class A_1 extends A{
     private int access;
     A_1(String name,int chi,int word,int access){
          super(name,chi,word);
          this.access=access;
          System.out.println("A_1組\taccess:"+access);
}
}
=>A_1有兩層要繼承又都有overloading時，只要處理他的上一層(A)建構式，因為school那一層已經由他的父類別(A)處理好了
 
B.java
class B extends school{
private int excel;
B(String name,int chi,int excel){
super(name,chi);
this.excel=excel;
System.out.println("B班學生\t excel:"+excel);
}
}
 
add.java
class add {
public static void main(String args[]){
     A_1 a1=new A_1("maggie",80,95,60);
}
}
 
(6)methods方法
 
1.hsa-a
引用上例：
school加上show()method，A、B、A_1不變
void show(){
System.out.println("school學生");
}
 
去執行時，三個都有繼承show()
A a=new A("maggie",80,95);
a.show();
=>輸出school學生
A_1 a1=new A_1("maggie",80,95,60);
a1.show();
=>輸出school學生
B b=new B("maggie",80,77);
b.show();
=>輸出school學生
 
**當在做a1.show()時順序是，會先去A_1show()找，再去找Ashow()，最後在school找到show()
 
2.overloading
=>名字一樣，引數不一樣
=>上述在同一個class中的overloading規則也適用於父類別和子類別的關係(適用於上下關係)
當school有overloading且A本身又有自己的method=>這樣也適用overloading的規則
school.java
void show(){
System.out.println("school學生");
}
void show(String name){
System.out.println("school學生 姓名:"+name);
}
 
A.java
void show(int word){
this.word=word;
System.out.println("A班學生\t word:"+word);
}
 
在執行時
add.java
school s=new school("maggie");
s.show("kelly");
s.show(85);=>compiler會出現錯誤訊息，因為在查reference只會往上找不會往下找
 
A a=new A("maggie",80,95);
a.show();   //繼承school method
a.show("kent");  //繼承school method
a.show(58); //自己本身的method
 
 
3.override(改寫)
=>名字一樣，引數一樣，類型一樣
=>必須位於不同class(父,子)，如果同一個class compiler就會出錯
當school有一個show()，A下面也有一個show()，名字類型和引數都一樣
 
school.java
void show(){
System.out.println("school學生");
}
 
A.java
void show(){
System.out.println("A");
}
 
add.java
school s=new school("maggie");
s.show();
System.out.println("=====");
A a=new A("maggie",80,95);
a.show();
=>執行時，s.show()是去抓school class的show()，A.show()是去抓A class的show()
**通常發現程式有錯時，作法有兩種
1.找原始碼去改school class中的show()
2.拿不到原始碼，或是不想改變已固定使用的介面，想做微調就好
=>在子類別用overriede的方式來改，可以避免其他繼承同一父類別的子類別被想到
 
傳值類method
在school中新增一傳值類methodd
school.java
int abc(int x){
// 把abc(int x)視為一個變數，return就是"="=>int abc(...)=x的意思 
     return x;  
}
 
如果要改為輸入值+20，而且要從子類別A做調整：
(一)若改為如下
A.java
void abc(int x){  }
=>會出現錯誤訊息，類別不正確，因為當子類別方法的名字和引數都跟父類別相同時，就會自動當作override，就會去檢查類別
 
(二)正確做法
A.java
int abc(int x){
     return x+20;
}
 
**如果superclass的方法有設定封裝權限(權限大小順序：public>protected>default>private)
=>子類別權限要>=父類別
=>如果沒有寫封裝權限就是default
=>只要沒有加private都可以繼承
如果在school中的int abc()封裝權限為protected，在A中的abc()為default
school.java
protected int abc(int x){
return x;
}
A.java
int abc(int x){
return x+20;
}
=>compiler會出現錯誤訊息，A class的封裝權限weaker than school class，
所以要把權限改為protected(相等)或public(大於)school才可以override
A.java
public int abc(int x){
return x+200;
}
 
5.內容
=>super.方法
如果要把繼承於父類別的函數拿去運算出另一個結果
school.java
protected int abc(int x){
return 3*x+100;
}
A.java
public int abc(int x){
return abc(x)+200;
}
=>abc(x)代表superclass的method，x還是帶int x
=>如果直接去執行，會出現一直在跑下列訊息，因為override，造成執行時去找到的是A class本身的abc()，一直呼叫自己造成遞迴(會有stackoverflow 記憶體不斷堆疊的問題)
 
正確做法
當名稱引數都一樣，又要引用上一層同樣的method時，就要用super.method，才不會因為被override造成遞迴的問題但只能引用上一層，上上一層不能引用，void不能這樣用，因為void不能當作值去做運算
A.java
public int abc(int x){
return super.abc(x)+200;
}
 
● Polymorphism  多型(=>用來討論方法的使用)
1)多個class,有共同的父類別
2)使用父類別定義物件名稱=>"new"新增物件(實體化)使用子類別
3)目的:會限制使用的"方法"數量
=>只有定義物件的父類別有定義的方法"名稱"才可使用
=>繼承或"override"
語法：
父類別 物件=new  子類別(); =>父類別和子類別間須有繼承關係
 
 
程式說明
(一)多型的宣告方式
原本new一個物件的方法如下：
add.java
A a = new A();
B b = new B();
C c = new C();
a.show();
b.show();
c.show()
 
*但因為ABC有共同的父類別，可以把左邊改為student，但左右兩邊一定要有繼承關係
add.java
student a = new A();
student b = new B();
student c = new C();
 
*如果這時我們要用a呼叫abc()：
add.java
student a = new A();
student b = new B();
student c = new C();
a.abc();
 
student.java
void show(){
System.out.println("hello student");
}
 
A.java
void show(){
System.out.println("hello student a");
}
void abc(){
System.out.println("hello student a, abc");
}
 
=>compiler時會出現錯誤訊息，因為在做a.abc時,call by reference會先去看左邊的student class是否有abc()，結果student中並沒有abc()method
 
 
(二)想使用子類別的某個方法但父類別沒有時的作法
studetn.java
void show(){
System.out.println("hello student");
}
 
B.java
void abc2(){
System.out.println("hello student b ,abc2");
}
 
add.java
student a = new A();
student b = new B();
student c = new C();
a.abc();
b.abc2();
=>因為在sudent中並沒有abc2()這個方法，所以編譯時在call by reference這個階段時就出現錯誤了
=>如果在使用多型時，父類別沒有的方法，是絕對不能用的，如果一定要用某個子類別有但父類別沒有的方法，就要在父類別中加入該方法但不用寫內容(因為只是要用來被子類別的內容override)
=>故此例要在student中加入void abc2(){}
 
**所以多型的使用又稱為異質宣告，和一般宣告最大的不同，在於方法的限制比較嚴格，只有兩種做法
1.由父類別繼承而來
2.override而來 
=>須注意的是，當call by reference時，是由等號左邊開始找，所有方法都要在父類別找的到compiler才能過，等執行時卻是從等號右邊開始找class中有沒有該方，有override會先做，沒有override就做由父類別繼承而來的方法(因為執行的時候要看記憶體，只有new的時候才會有記憶體，所以執行時從右邊開始找)
 
**所以多型的父類別有索引目錄的概念，個別的子類別都會有父類別所列的方法，然後各自有不同的功能
 
(三)多型的method繼承與method override的實作
*在student和A中都有abc()，但在B和C中都沒abc()
 
student.java
void abc(){
System.out.println("hello student 繼承來的");
}
 
A.java
void abc(){
System.out.println("hello student override");
}
 
add.java
student a = new A();
student b = new B();
student c = new C();
a.abc();
b.abc();
c.abc();
 
outputs
hello student override
hello student 繼承來的
hello student 繼承來的
 
*如果A下面還有A_1，因為也有共同父類別student，所以也能用多型的規則來new，但是當呼叫abc()method時，因為上一層A有abc()method，會直接用A的
 
add.java
student a = new A();
student b = new B();
student c = new C();
student a_1=new A_1();
 
a.abc();
b.abc();
c.abc();
a_1.abc();
 
outputs
hello student override
hello student 繼承來的
hello student 繼承來的
hello student override
 
4)搭配=>陣列使用(因為資料量很多，用來管理名字)
=>多型就是為了搭配陣列以及和後續會提到的抽象類別、interface有關
假設A班有2人B班有2人C班有一人，隨機輸入資料
student.java
void abc(){
System.out.println("hello student");
}
 
A.java
void abc(){
System.out.println("hello student a");
}
 
B.java
void abc(){
System.out.println("hello student b");
}
 
C.java
void abc(){
System.out.println("hello student c");
}
 
add.java
student [] s={
new A(),
new B(),
new A(),
new C(),
new B()
};
for(int i=0;i<s.length;i++){
     s[i].show();
}
//outputs
 
 
文章標籤
overloading 建構 多型 java 建構式 polymorphism

muchone 發表在 痞客邦 留言(1) 人氣()

  • 個人分類：JAVA
▲top

No sooner had I complained my husband worked overtime than I worked overtime.

I got off work at 10:00 pm yesterday.

After eating dinner, it had have been 11:30 pm and I was exhausted.

 

*get off work：下班

文章標籤
日記 英文寫作 英文

muchone 發表在 痞客邦 留言(0) 人氣()

▲top
● static
1.與excel絕對位置觀念一樣
=>在excel中
相對:計算式一樣，但每個計算結果所用的來源資料都不一樣
(每多一筆資料就會多一筆不同的來源)/new的概念
絕對:某一格的內容要一直隨著不同計算結果重複使用，
但不想要每次改變都要一筆一筆資料重作，就拉出表外獨立
($B$1=>代表會鎖住B1位置，計算的時候不會隨著下拉改變)
 
2.class定義時，定義成"唯一"一格，不會隨著"new"物件而配發給每 一筆物件"heap"區，不與物件資料排列
=>只有一格
 
3.存取方式，不需透過物件，只須透過"class"呼叫
=>又稱"類別類"(需透過物件呼叫使用，稱"物件"類)
=>class產生時，還沒new之前，static就已經產生，
所以不用透過new一個物件來產生(由類別來定義產生)
=>所以下例可以一開始就直接寫成fv.money=5000000
*所以在看API 的時候會發現沒有建構式的時候幾乎都是static，因為建構式一定要做new的動作
 
4.使用對象
a)field區屬性
b)methods(如下例的fv.title())
=>當method使用static時要注意，在static method中的變數如果有用到最開始定義的變數(field)，只能用有定義為static的變數，但如果是與上面無關的變數就不需要限定為static
c)inner class內部類別(之後再講)
=>b,c是最主要的應用
 
● 實作:
複利本利和=本金(1+利率)n =>fv=money*Math.pow((1+r),Y);
**加底線代表static
**static說明
money改成static前：
 
fv f1= new fv(1,1000000,0.05,10);
fv f2= new fv(2,1000000,0.01,15);
fv f3= new fv(3,1000000,0.07,5);
f1.show();
f2.show();
f3.show();
 
System.out.println("==============");
 
f1.money=2000000;
f1.show();
f2.show();
f3.show();
 
=>3筆本金是不同的資料，所以改f1.money，其他兩筆不會一起變動
money改成static後：
 
fv f1= new fv(1,1000000,0.05,10);
fv f2= new fv(2,2000000,0.01,15);
fv f3= new fv(3,3000000,0.07,5);
f1.show();
f2.show();
f3.show();
 
System.out.println("==============");
 
f1.money=2000000;
f1.show();
f2.show();
f3.show();
 
 
=>最上面的本金會全部變為3000000，因為static只有一格，資料會被最後一筆改掉
=>下面只要f1.money或 f2.money或 f3.money任一改變全部都會跟著改變( 改成static後，變成絕對位置，(相當於拉出excel表外獨立)，f1.money=f2.money=f3.money，不論誰改變都會同時變動 )
*完整內容
fv.java
class fv{
private int number;
static int money;
private double r;
private int y;
private double fv;
 
fv(int number,double r, int y){
this.number=number;
this.r=r;
this.y=y;
fv=money*Math.pow((1+r),y); //y是(1+r)的次方
}
 
void show(){
 
System.out.println("編號:"+number+
"\t本金:"+money+
"\t年利率:"+r+
"\t年:"+y+
"\t複利本利和:"+(int)fv //去小數
);
}
 
add1.java
fv.money=5000000;
fv f1= new fv(1,0.05,10);
fv f2= new fv(2,0.01,15);
fv f3= new fv(3,0.07,5);
f1.show();
f2.show();
f3.show();
System.out.println("==============");
f1.money=2000000;
f1.show();
f2.show();
f3.show();
 
=>因為年金都相同，所以就不用每次都去輸入這筆資料，可以把constructor中的money都刪除
 
*如果編號要自動跳號
(一)直接把nubmer++
add1.java
fv.money=5000000;
fv f1= new fv(0.05,10);
fv f2= new fv(0.01,15);
fv f3= new fv(0.07,5);
f1.show();
f2.show();
f3.show();
 
fv.java
private int number;
static int money;
private double r;
private int y;
private double fv;
 
fv(double r, int y){
this.number++;
this.r=r;
this.y=y;
fv=money*Math.pow((1+r),y); //y是(1+r)的次方
}
 
=>因為目前number不是static，所以以每一筆編號都是獨立的不是共用的，當f1做完0+1後，f2的編號是獨立的，故還是從0開始做++，f3亦然
 
(二)把number改為static再++
fv.java
private static int number;
static int money;
private double r;
private int y;
private double fv;
=>如果把static加在private和int中，會得到如上結果
=>這邊的做法是當new f1時，number=0+1=1， 當new f2時，number=1+1=2， 當new f3時，number=2+1=3，最後一筆number把前面的都改掉了
 
=>以這個作法如果要每個編號不一樣，就只能在執行的時候馬上秀一筆資料，才不會後面的資料給改掉，但這樣很難跟陣列結合
add1.java
fv f1= new fv(0.05,10);
f1.show();
fv f2= new fv(0.01,15);
f1.show();
fv f3= new fv(0.07,5);
f1.show();
(三)正確做法
fv.java
private int number;
private static int count;
static int money;
private double r;
private int y;
private double fv;
 
fv(double r, int y){
//也可寫成this.number=++count，但++要寫在前面，
//不然會把加之前的資料指過去
count++;
this.number=count;
this.r=r;
this.y=y;
fv=money*Math.pow((1+r),y); //y是(1+r)的次方
}
=>所以number不能用static，要用另外一個變數(count)去加，這樣number就會各自獨立不會共用一個，是每一次count算好就丟給每一個nubmer
 
 
**複利本利和沒有跟著本金而改變的問題處理
問題：
當本金由5000000改為，20000000，複利本利和都沒變
 
add1.java
fv.money=5000000;
fv f1= new fv(0.05,10);
fv f2= new fv(0.01,15);
fv f3= new fv(0.07,5);
f1.show();
f2.show();
f3.show();
System.out.println("==============");
//static直接用類別呼叫，不要再用f1/f2/f3
fv.money=2000000;
f1.show();
f2.show();
f3.show();
 
fv.java
fv(double r, int y){
count++;
this.number=count;
//也可寫成this.number=++count，但++要寫在前面，不然會把加之前的資料指過去
this.r=r;
this.y=y;
//y是(1+r)的次方,這邊的建構是可以不加這個公式，因為下面mehtod有重算
//fv=money*Math.pow((1+r),y); 
}
 
void show(){
fv=money*Math.pow((1+r),y);
System.out.println("編號:"+number+
"\t本金:"+money+
"\t年利率:"+r+
"\t年:"+y+
"\t複利本利和:"+(int)fv //去小數
);
=>因為本利和本來是在建構式中計算(new的時候才會計算)
當本金改變，不會重新計算，解決辦法就是在show()輸出前重新計算一次
 
**如果要做成表格的方式，把標題拉到最上方共用
fv.java
void show(){
  fv=money*Math.pow((1+r),y);
  System.out.println(number+"\t"+money+"\t"+r+"\t"+y+"\t"+(int)fv);
}
static void title(){
  System.out.println("編號\t本金\t年利率\t年\t複利本利和");
}
 
add1.java
fv.money=5000000;
fv.title();
fv f1= new fv(0.05,10);
fv f2= new fv(0.01,15);
fv f3= new fv(0.07,5);
f1.show();
f2.show();
f3.show();
 
System.out.println("==============");
fv.money=2000000;
f1.show();
f2.show();
f3.show();
=>因為title()是static，所以可以直接用fv.title()不需要new
 
**method使用static要注意，在static method中的變數如果有用到最開始定義的變數(field)，只能用有定義為static的變數
eX:把show()改為static，會出現錯誤訊息non-statice varible
static void show(){
fv=money*Math.pow((1+r),y);
System.out.println(number+"\t"+money+"\t"+r+"\t"+y+"\t"+(int)fv);
}
=>因為當在執行show()的時候，會把裡面的變數都當作static來做，如fv.money(ok)、fv.(r)，會用fv直接呼叫，這時呼叫到不是static的變數就會出現錯誤
 
如果改成如下內容，就不會有問題，因為count是static
static void show2(){
     System.out.println("請輸入第"+count+"個");
}
 
 
 
**用Scanner來做
addtest.java
import java.util.Scanner;
class addtest{
public static void main(String args[]){
Scanner sc=new Scanner(System.in);
System.out.println("請輸入資料筆數");
int n=sc.nextInt();
System.out.println("輸入本金:");
fv.money=sc.nextInt();
fv[] f=new fv[n];
for(int i=0;i<f.length;i++)
{
System.out.print("輸入第"+(i+1)+"筆-->利率: ");
double r=sc.nextDouble();
System.out.print(); //換行排版用    
System.out.print("輸入第"+(i+1)+"筆-->年: ");
int y=sc.nextInt();
f[i]=new fv(r,y);
}
fv.title();
for(int i=0;i<f.length;i++)
{
     f[i].show();
}
}
}
=> double的Scanner函式為 nextDouble()
 
● static import：如果要使用的api的功能中，大部分都是static method，可以直接匯入static method，這樣就可以直接使用method不需要再call class，但非屬於static的method不能這樣做，要透過new
ex:Math
import static java.lang.Math.*;
 FV(double r,int y){
  count++;
  this.number=count;
  this.r=r;
  this.y=y;
  fv=money*pow((1+r),y);
 }
=>這邊的路徑是指到Math下的method，而非指到Math，如果不加static而直接用pow()不用Math.pow() 會找不到
● 實作:
static不一定要連database，譬如可以把常用的公式放入一個class，然後method都設定為static，要用的時候直接呼叫，不用每次都要new，
ex:
FV=>複利本利和=本金*(1+利率)n=>FV(m,r,y)
(m,r,y=>先想好要用到的變數)
AR=>圓面積=3.14*rr=>AR(r)
RO=>周長=23.14r=>RO(r)
cal.java
class cal
{
static double FV(int money,double r, int y)
{
return money*Math.pow((1+r),y);
}
static double AR(double r)
{
return 3.14*r*r;
}
static double RO(double r)
{
return 2*3.14*r;
}
}
 
addcal.java
class addcal{
public static void main(String args[]){
System.out.println(cal.FV(10000,0.05,5));
System.out.println(cal.AR(5));
System.out.println(cal.RO(20));
}
}
=>用double小數點可以取到最小比較精準
=>因為有return，所以是傳值類的，故名稱前面要設定類別，而且可以直接print出來
 
● inheritance繼承=>目的:產生父類別
(1)多個class,共同的屬性與規則
(2)superclass=>父類別，subclass=>子類別(順序由上到下的概念)
(3)extends
假設同一個學校有兩個科系a和b 
a.java
class a{
String name;
int chi;
int excel;
void show(){
    System.out.println("姓名:"+name+"\t國文:"+chi+"\texcel:"+excel);
     }
}
b.java
class b{
String name;
int chi;
int word;
void show(){
     System.out.println("姓名:"+name+"\t國文:"+chi+"\tword:"+word);
 }
}
add2.java
class add2{
public static void main(String args[]){
a a1= new a();
b b1= new b();
a1.show();
b1.show();
}
}
=>在同一個機構/系統(這邊是同一個學校)的前提之下，假設規則要改變(ex:chi要改成可以用double)，以上面的做法必須兩個class分別去做修正，如果有很多class就變成要一個一個去改，這樣太浪費時間，可以去抓a和b兩個class定義一樣的規則(共同規則)，放到另外一個class(公因數的概念)
class school{
      String name;
      double chi;
}
=>把a和b的這兩個class中的name和chi刪除，若此時直接compiler add2.java，會出現錯誤訊息，因為在a和b class中找不到上述兩個變數
 
作法：
把a和b class都加上extends school
class a extends school{ .....}
class b extends school{ .....}
=>classs a extends school 稱作：school的內容繼承給a，代表把a要用到的內容/功能放在其他class
(一條線延伸的概念，翻譯成延伸比較好理解)
=>所以new的時候，會找a+extends 中 的內容
 
 
 
(4)is-a=>是否具有此class的類型(包括自己定義的class與父類別)
has-a=>是否擁有使用此"方法"與"field"的權限=>是否有繼承
用下面例子來解釋：
我們用b class產生了一個b1物件，如果想看b1有多少功能(包括本身與繼承而來的功能)可用
 
is-a(類型):
b1 is a b(b1是 b class類型的物件)
b1 is a school (b1是 school class類型的物件)
=> 是call by reference的概念
=>因為查b的時候看到裡面有extends school，代表有繼承school，所以b1 is a school，如果shool上面還有繼承也是要一起抓下來
 
has-a(內容):
b1 has a word
b1 has a name
b1 has a chi
**只要沒有設定權限，就會全部繼承，所以越sub的功能越多，越super的功能越少
*繼承時因為很多層，如果用notepad++開發要每一個class都compiler一次不然run會有問題
*繼承的好處=>共同規則只要改一次就好
 
(5)constructor 建構式
a)全部都要執行,一定要執行
b)順序由父類別====>子類別(有上到下)
(一) school有一個建構式，但a沒有建構式的狀況下
school.java
String name;
int chi;
school(){
     System.out.println("我是父類別的建構式");
}
 
a.java
int excel;
void show(){
     System.out.println("姓名:"+name+"\t國文:"+chi+"\texcel:"+excel);}
 
add2.java
a a1= new a();
a1.show();
 
 
(二) school有一個建構式，但a也有一個建構式的狀況下
school.java
String name;
int chi;
school(){
     System.out.println("我是父類別的建構式");
}
 
a.java
int excel;
a(){
     System.out.println("我是子類別的建構式");
}
void show(){
     System.out.println("姓名:"+name+"\t國文:"+chi+"\texcel:"+excel);
}
 
add2.java
a a1= new a();
a1.show();
 
=>在new a的時候，會先去查a class有沒有父類別，如果有，會去看繼承內容和是否有建構式，有建構式就會先做父類別的建構式再做a的建構式，如果school上還有父類別，會再往上找(即由上往下)
 
 
● 之後寫程式，盡量main的內容越少越好，都放在static class
 
文章標籤
static java extends inheritance 繼承 superclass subclass is-a has-a constructor 建構式

muchone 發表在 痞客邦 留言(1) 人氣()

  • 個人分類：JAVA
▲top

My husband worked overtime for days on end.

I had to go home by myself and I was not uesd to going home alone. 

Hope my husband could go home with me today.

 

*for days on end：for many days

文章標籤
日記 英文寫作 英文

muchone 發表在 痞客邦 留言(0) 人氣()

▲top
(四)初始值(化)的方式(java.util.Arrays)
**陣列一定要有位址(記憶體)才能做資料
2){ }=>動態輸出=>自己決定初始值
(動態建立初始值的方式)
語法：類型[]陣列名={值,...,...,...}; =>陣列類型和值的類型要一致
EX:
如果使用new建立陣列，填值得時候要一筆一筆建立(如下)，
當資料很多又同時都要輸入值，一筆一筆去改初始值很麻煩，就要用動態建立
chi[0]=65;
 
**{}會配給記憶體，但只會做到stack，不會給heap區，
如下{}沒給值，可以compiler但是執行會出現exception
int []chi={};
System.out.println(chi);
System.out.println(chi[0]); //因為還沒有產生chi[0]
 
3)比較new和{}的差別
new會配給記憶體，且給索引值和初始值(即heap區)
{}只會配給記憶體(只做到stack，但沒給heap區)
=>{}是打一個值就出現一個
 
=>new則是一次出現全部
 
 
**使用 java.util.Arrays的sort()來排序，
會把數字從小到大，文字(限定英文)從a到z排列
ex:(要記得先在class上面import java.util.Arrays;)
int []chi={100,70,88,64,33};
System.out.println(chi);
System.out.println(chi[0]);
for(int i=0;i<5;i++){
     System.out.println(chi[i]);
}
System.out.println("=========================");
Arrays.sort(chi);  //用Arrays裡的sort功能把chi陣列重新排列
for(int i=0;i<5;i++){
     System.out.println("chi["+i+"]="+chi[i]);
}
 
**使用binarySearch()來查陣列中是否有我們需要的資料，
binarySearch()是傳值類的method，所以執行完會產生一個值，
要指定如何輸出這個值
int []chi={100,70,88,64,33};
//要先做排列再查資料不然查出來的結果會怪怪的，
//另外srot()是void不傳值類的method
Arrays.sort(chi);  
for(int i=0;i<5;i++){
     System.out.println("chi["+i+"]="+chi[i]);
}
//要給的參數(要查的陣列名稱,要查找的資料)
System.out.println(Arrays.binarySearch(chi,64));
System.out.println(Arrays.binarySearch(chi,71));
=>當查找之後有資料，就會把查到的索引碼回傳(chi[1]=64)
=>但如果找不到資料，會去跟陣列的資料作比對排列，
像例子中71應該是排在索引碼3的位置，也就是第四個，
它會對應到負整數第四個位置，也就是-4(取負的索引碼)
=>所以只要回傳的值為負的，就代表找不到資料
 
(五)length=>查詢陣列的元素個數(可以用在迴圈的限制條件上)
int []chi={100,70,88,64,33};
System.out.println(chi.length);
for(int i=0;i<chi.length;i++){
     System.out.println(chi[i]);
}
 
(六)多維陣列
語法：類型[][]陣列名=new 類型[n][m];
=>分組的概念
=>組織圖有幾階段分組就會有幾個[][]
=>多維陣列中的[][]位置可以改變ex: int[] grade []
ex:有3個人，每個人有國文和英文兩個成績
(一)可以分成兩組，國文和英文，每組有三個人
int[]chi=new int[3];
int[]eng=new int[3];
 
(二)用多維陣列簡化作法
int[][]grade=new int[2][3];  
=>在記憶體中的做法就是，先找到grade array，
發現裡面有兩組陣列(chi和eng)，再看陣列裡面，各有3個元素
**第一層就是第一個[]，第二層就是第二個[]，
所以上面代表先分2組，每組3個(由2個陣列組合而成)
**如果是[3][2]則代表先分3組，每個組別裡面有2個元素(由3個陣列組合而成)，
與上述是不同的
=>畫成組織圖如下
 
=>組織圖如下:陣列表示應為school[3][2][3]
 
*看多維陣列的記憶體位址，如上例grade[0]和grade[1]兩組陣列都有記憶體位址
=>陣列的stack和heap排列方式與物件相同
 
*用巢狀迴圈run
動態：
int[][]陣列名稱={{xx,xxx,xx},{xx,xxx,xx}}(以兩組為例)
=>代表先分兩組，每組有3個元素
int[][]grade={{56,77,88},{66,73,91}};  
for(int x=0;x<2;x++){
  for(int y=0;y<3;y++){
    System.out.println("grade["+x+"]["+y+"]="+grade[x][y]);
  }
}
**如果直接用int[][]grade={56,77,88,66,73,91}
=>會出現錯誤訊息，因為前面是2維，後面是1維
 
*使用.length
ex:
int[][]grade={{56,77,88,99 } , { 66,73,91,63}};
System.out.println(grade); 
System.out.println(grade[0]);
System.out.println(grade[0][0]);
*[[I=>兩個[[代表有兩層陣列，有幾個就代表有幾層陣列
不論是查 grade 或grade[0]結果都是
[[I@..... 或[I@0000=>代表後面都是接記憶體位置，
只有 grade[0][0]才是值
=>只有查到最後一層才會是值，前面都只會查到記憶體位置
ex:
int[][]grade={{56,77,88,99 } , { 66,73,91,63}};
System.out.println(grade.length);  //outputs 2
System.out.println(grade[0].length); //outputs 3
*grade.length，查出來結果為2是因為grade的下是兩組陣列：
 length是線性的，只能查一層
 grade[0].length，查出來的結果為3，因為兩組陣列中每一組都是3個元素
應用到迴圈(一) 
=>迴圈中x代表第一個[]，y代表第二個[]
int[][]grade={{56,77,88,99},{66,73,91,63}};
for(int x=0;x<grade.length;x++){
for(int y=0;y<grade[x].length;y++){
     System.out.println("grade["+x+"]["+y+"]="+grade[x][y]);
}
}
(二)如果兩組內的元素數量不同，用.length就不需要調整迴圈
int[][]grade={{56,77},{88,99,66,73,91,63}};
for(int x=0;x<grade.length;x++){
     for(int y=0;y<grade[x].length;y++){
         System.out.println("grade["+x+"]["+y+"]="+grade[x][y]);
     }
}
 
 
(七)值;位址=>"="  (java中做這個事為了回收記憶體;null)，要判斷是值還是位址的換算
1)傳值=>passed by values
2)傳址=>passed by address
=>判斷"="兩邊是值還是位置，如果是值，會把資料copy過去，但如果是位置，
會把左邊的位置砍掉(回收記憶體)，因此左邊的資料會消失，要非常注意!!
當y=x時，會有兩種狀況：
若只是資料copy，則x還是x，y還是y，兩者沒有關聯
若是y被x取代，則當y改變，x也會改變
 
(一)用變數來看
int x=10;
int y=20;
System.out.println("x="+x);
System.out.println("y="+y);
System.out.println("==========");
y=x;
System.out.println("x="+x);
System.out.println("y="+y);
System.out.println("==========");
y=30;
System.out.println("x="+x);
System.out.println("y="+y);
=>當y=x時，因為x和y都代表一個值，是把x的資料copy給y的動作 ，所以當y=1時，x1[0]還是=1
 
(二)用陣列來看
int[]x1={1,2,3};
int[]y1={4,5,6};
System.out.println("x1="+x1);
System.out.println("y1="+y1);
System.out.println("==========");
System.out.println("x1[0]="+x1[0]);
System.out.println("y1[0]="+y1[0]);
y1[0]=x1[0];
System.out.println("x1[0]="+x1[0]);
System.out.println("y1[0]="+y1[0]);
y1[0]=100;
System.out.println("x1[0]="+x1[0]);
System.out.println("y1[0]="+y1[0]);
System.out.println("==========");
=> y1[0]=x1[0];是做資料copy的動作，所以當y1[0]=100時，x1[0]還是=1
 
 
y1=x1;
System.out.println("x1="+x1);
System.out.println("y1="+y1);
System.out.println("x1[0]="+x1[0]);
System.out.println("y1[0]="+y1[0]);
y1[0]=100;
System.out.println("x1[0]="+x1[0]);
System.out.println("y1[0]="+y1[0]);
=>當y1=x1時，是把y1指到x1的位址，所以會發現y1和x1的記憶體位置相同了，
這時去print x1[0]和y1[0]都會=1
=>再讓y1[0]=100;則 x1[0]和y1[0]都會變成100，因為是相同的記憶體位置
 
**java回收記憶體的方式：因為值都沒有記憶體，有記憶體都會常駐，如果都沒有使用還是會暫ram的空間
(一)用指定位址的方式，把y1刪除
int[]x1={1,2,3};
=>x1,y1代表位址，x1[0],y1[0]代表值
int[]y1={4,5,6};
y1=x1;
(二)用null的方式，直接把y1回收
int[]x1={1,2,3};
int[]y1={4,5,6};
System.out.println("x1="+x1);
System.out.println("y1="+y1);
y1=null;
System.out.println("x1="+x1);
System.out.println("y1="+y1);
 
(八)Java的陣列個數為固定，無法事後增加
int[] x={10,20,30,52};
for(int i=0;i<x.length;i++)
{
     System.out.println(x[i]);
}
System.out.println(x[4]);
System.out.println(x); //改變前的x
x=new int[10];
System.out.println(x); //改變後的x
for(int i=0;i<x.length;i++)
{
     System.out.println(x[i]);
}
=>可以compiler，但是記憶體位置改變了，等於產生了新的陣列
=>代表把新的位置傳給x，把原本的資料給砍掉了(不要舊的陣列要換一個新的陣列)
=>新的陣列所有值都變成初始值了
若再去查x[4]，System.out.println(x[4]);=>會出現exception
 
(九)與物件導向結合應用
1.先定義陣列=>名稱為統一(決定數量)
2.物件再個別新增內容=>實體化
實例(一)：建置一個會員資料庫，有三個欄位name,add,tel
靜態做法：
addmember.java
假設我們要輸入一百筆資料，輸出時不用陣列變成要一筆一筆輸出太麻煩
(一)
member aa=new member("aab1","city","123456789");
member dd=new member("aab2","city","123456789");
member cc=new member("aab3","city","123456789");
aa.show();
dd.show();
cc.show();
=>如果要用陣列，先判斷是否為同一組
=>因為aa/dd/cc都是用同一張表member有共同的reference，可以用陣列來做
 
(二)
class addmember{
     public static void main(String args[]){
          member[] m1=new member[3];
     }
}
=>member[] m1代表用member這張表作一個陣列，
new member[3]則代表先決定數量，此時m會配有記憶體
=>m[0]/m[1]/m[2]是三個物件而不是變數，
但這時候new只做了一件事就是定義三個物件的名字為 m[0]/m[1]/m[2]，
並沒有配記憶體
=>如果這時候去print m[0]，會出現null
=>當陣列結合物件時，第一次new是定義名字的動作，
個別物件要再new一次才能決定記憶體位置，如下：
 
member[] m=new member[3]; //等於是做上面(一)等號左邊命名的動作
//這邊開始才是做(一) 等號右邊new的動作
m[0]=new member("aab1","city","123456789");  
m[1]=new member("aab2","city","123456789");
m[2]=new member("aab3","city","123456789");
for(int i=0;i<m.length;i++){
     m[i].show();
}
 
 
**兩次new與配給記憶體的步驟
(1)第1次new時，只是用一個記憶體位址存放 m[0]/m[1]/m[2]這三個名字，
但沒有配給記憶體
(2)第2次new時，才會配給記憶體位址和heap區
 
**單獨使用new的說明
member aa=new member("aab1","city","123456789");
new member("aab2","city","123456789"); //可以compiler
System.out.println(aa);
System.out.println(new member("aab2","city","123456789"));
=>兩筆資料在java中都視為已完成，第2筆會丟一個位址出來，
所以可以print，且print會show記憶體位置
 
member aa=new member("aab1","city","123456789");
new member("aab2","city","123456789");
aa.show();
new member("aab2","city","123456789").show();
=>因為第2筆也是新增一個物件(物件就會有記憶體位址)，
因為有記憶體位置所以可以做.show()
=>因為機器判斷時看的不是aa這個名字，而是記憶體位址
 
動態作法
addmember.java
member[] m={
new member("aab1","city","123456789"),
new member("aab2","city","123456789"),
new member("aab3","city","123456789"),
new member("aab4","city","123456789")};
 
for(int i=0;i<m.length;i++){
     m[i].show();
}
=>如果只有 member[] m={};，這時只會配給記憶體位置，不會配給索引碼
實例(二)：
UML和流程圖
需要做s[0]~s[3]，共4筆
student.java
class student{
private String name;
private int chi;
private int eng;
private int sum;
private double ave;
 
student(String name,int chi,int eng){
if(chi>=0 && chi <=100 && eng>=0 && eng <=100){
this.name=name;
this.chi=chi;
this.eng=eng;
sum=chi+eng;
ave=sum/2.;
}else{
     System.out.println("國文英文分數需介在0~100");
}
}
void show(){
System.out.println("姓名:"+name+
"\t國文:"+chi+
"\t英文:"+eng+
"\t總分:"+sum+
"\t平均:"+ave);
}
}
addstudent.java
class addstudent{
public static void main(String args[]){
student[] s ={
new student("kelly",90,100),
new student("kent",87,78),
new student("sylvie",73,55) ,
new student("maggie",100,63)
};
for(int i=0;i<s.length;i++){
       s[i].show();
}
}
}
*用scanner作互動(用scanner不能用動態)
addstudent.java
import java.util.Scanner;
class addstudent1 {
public static void main(String args[]) {
     Scanner sc=new Scanner(System.in);
     System.out.println("請輸入人數");
     int n=sc.nextInt();
     student[] s=new student[n];
     for(int i=0;i<s.length;i++) {
         System.out.print("第"+(i+1)+"的姓名");
         String name=sc.next();
         System.out.print("第"+(i+1)+"的國文");
         int chi=sc.nextInt();
System.out.print("第"+(i+1)+"的英文");
int eng=sc.nextInt();
s[i]=new student(name,chi,eng);
}
for(int i=0;i<s.length;i++) {
     s[i].show();
}
     }
}
=>這邊的name,chi,eng可以用區域變數，
因為輸入後就會把值丟給s[0],s[1],s[2],s[3]，完成後就消失沒有關係
 
 
 
 
 
 
 
 
 
 
 
 
 
 
文章標籤
java arrays value

muchone 發表在 痞客邦 留言(0) 人氣()

  • 個人分類：JAVA
▲top

Today is my son's birthday but we don't celebrate it. 

However, we were going to eat teppanyaki to celebrated his birthday and he got a Lego Boost for a birthday preseant yesterday.

Then he took around 3 hours to assemble the robot and to learn how to command the robot. 

 

*teppanyaki ：鐵板燒

文章標籤
日記 英文寫作 英文

muchone 發表在 痞客邦 留言(0) 人氣()

▲top
● 實作練習
UML
流程圖
1.school(名，國，英);
2.
 
add.java
class add
{
 public static void main(String args[])
 {
  school s1=new school("abc",-75,78);
  s1.show(); 
 }
}
 
school.java
class school{
private String name;
private int chi;
private int eng;
private int sum;
private double ave;
 
school(String name,int chi,int eng){
if(chi>=0 && chi<=100 && eng>=0 && eng<=100){
this.name=name;
this.chi=chi;
this.eng=eng;
sum=chi+eng;
ave=sum/2.;     //如果使用變數不能直接加"."要先括號起來再加
}else{
          System.out.println("國英分數須介在0~100");
}
}
void show(){
System.out.println("姓名:"+name+
"\t國文:"+chi+
"\t英文:"+eng+
"\t總分:"+sum+
"\t平均:"+ave);
}
}
 
**建構式都會會訂規則，所以在看reference時一定要先看，因為建構式在new的時候一定會執行
狀況1.如果沒有建構式school，但是add.java卻給了引數，會出現下列錯誤訊息
required(需要):no arguments=>不需要引數
 
狀況2.如果有建構式school，但是add.java卻沒有給引數，會出現下列錯誤訊息
required(需要):String,int,int=>需要三個引數
 
 
(5)Overloading(多載化;多種狀況)=>建構式名稱一樣，但是設計多種狀況，稱為多載化
=>名稱一樣
=>引數不一樣，幾個建構式名稱相同，就是要用()中的引數來區別
=>單選，每new一次只能選一個規則來使用
ex:假設有些狀況，只是要先填名字其他資料後續補上，所以有第二個規則，只需輸入名字，就另外再建立一個新的costructor
school.java
school(String name,int chi,int eng){
if(chi>=0 && chi<=100 && eng>=0 && eng<=100){
this.name=name;
this.chi=chi;
this.eng=eng;
sum=chi+eng;
ave=sum/2.;
}else{
     System.out.println("國英分數須介在0~100");
}
}
school(String name){
     this.name=name;
}
add.java
school s1=new school("kelly",50,75); //new一次選一種規則使用
school s2=new school("david"); //new一次選一種規則使用
s1.show();
s2.show();
 
 
ex:
school(String name,int chi,int eng){
if(chi>=0 && chi<=100 && eng>=0 && eng<=100){
this.name=name;
this.chi=chi;
this.eng=eng;
sum=chi+eng;
ave=sum/2.;
}else{
     System.out.println("國英分數須介在0~100");
}
}
school(String name){
     this.name=name;
}
school(String name,int chi) { ...}
school(int chi, String name) { ...}
school(String x, int y,int z , int a) {... }
school(String x , int y) { ...}
**假設有上述這麼多規則，多載化的區別包含類型(資料類型)、
  數量(需要輸入的引數數量)、順序(各個引數的排序)，
  如果完全相同就會出現錯誤訊息如下
  所以最後一個是錯的，因為和第三個類型數量及順序都重複了，
  變數的名稱則沒有任何影響
 
● Methods方法(其他語言稱函式)
(一)java api
(二)內部函式庫=>java.lang.*;
=>預設直接載入，直接存取(java api把最常使用的函式都放在java.lang)
ex:
System.out.println(Math.PI);
//找到lang下的math class中field，有PI，
//因為是static開頭，存取時不需要加上new，可以直接使用
 
ex:
System.out.println(Math.abs(-10));  //outputs 10
//outputs 1024.0 (因為類型為double所以會有小數點)
System.out.println(Math.pow(2,10));
 
*abs()=>絕對值
 random()=>亂數
 pow(a,b)=>a的b次方
 
(三)外部函式庫=>非java.lang.*都算
a)絕對路徑(若沒告知路徑會當作在java.lang中)
b)import(在class之前要先把要用的函式位置寫好)
=>也可以寫作import java.util.*，但不建議這麼做，因為後續程式碼很多，
要找問題時要看那些功能可以直接找上面，若沒一項項列出會增加查文件的困難度
import java.util.Scanner; //需要寫到Scanner這個class為止
class add
{
 public static void main(String args[])
 {
  //java.util.Scanner sc = new java.util.Scanner(System.in);
 //=>加了import就不需要指定路徑
  Scanner sc=new Scanner(System.in);
  school s1=new school("name",75,78);
  school s2=new school("aaa");
  s1.show();
  s2.show();
 }
}
 
(四)常用的api函式
a)java.util.*;
b)java.io.*; =>之後和field和dtabase一起講
c)java.SQL.*; =>之後和field和dtabase一起講
 
(五)自訂方法method(自訂函式)
1)語法：類型 方法名稱(引數){ 步驟 }
*引數區域和全域的區別與建構式一樣=>要判斷時一樣可以使用this
2)類型：
a)傳值=>void
b)不傳值=>return(與"="一樣)
ex:如果輸入成績時輸錯了，不能再使用school的constructor
 
(狀況一)如果直接再用一次new school=>會出現下列錯誤訊息，s1已經定義了
school s1=new school("kelly",50,75);
school s1=new school("kelly",50,75);
s1.show();
 
(狀況二)如果用s2 來new school=>則s1和s2會變成兩個不同人
school s1=new school("kelly",50,75);
school s2=new school("kelly",50,75);
s1.show();
 
(正確狀況)
add.java
school s1=new school("kelly",50,75);
s1.show();  //修改前
s1.change(70,75);
s1.show();  //修改後
class.java =>加上下列內容
void change(int chi,int eng){
this.chi=chi;
this.eng=eng;
sum=chi+eng;
ave=sum/2.;
}
ex:如果有兩個人的資料都錯了修改後，要修改後的加總
 
1.如果直接用System.out.println(s1.change(80,75)+s2.change(77,75))，會出現下列錯誤訊息
因為void只能執行method中的步驟，不能做加減乘除的運算，因為它不是值也不是變數(做加減乘除運算時，左右兩邊都要是值或變數，但目前兩邊都是步驟)
 
2.如果需要把method的結果拿來做運算，執行完畢可把它視作變數，因此要使用變數的規則來定義=>即要定義類型(ex:int,String...)
所以跟變數一樣，要給初始值，如果沒給初始值，會出現錯誤訊息(missing return statement)如下
int change2(int chi,int eng){
this.chi=chi;
this.eng=eng;
sum=chi+eng;
ave=sum/2.;
}
 
3.正確做法：這邊return sum的意思是，把sum指定給 int change2(int chi,int eng)，讓他可以做加減乘除
**return就和"="的用法一模一樣
school.java
int change2(int chi,int eng){
this.chi=chi;
this.eng=eng;
sum=chi+eng;
ave=sum/2.;
return sum; //return後面可放值、變數或計算式，但後面指定內容的類型必須和一開始 int change2(int chi,int eng)的類型相同
}
 
add.java
school s1=new school("kelly",50,75);
school s2=new school("joanne",50,75);
s1.show();
s2.show();
System.out.println("兩人的總分和為:"+(s1.change2(80,63)+s2.change2(77,70)));
s1.show();
s2.show();
 
*return也可單獨運用，有傳值回來，只是沒有拿來做運算
school s1=new school("kelly",50,75);
school s2=new school("joanne",50,75);
s1.show();
s2.show();
s1.change2(80,63);
s1.change2(77,70);
s1.show();
s2.show();
3)Overloading(規則與建構式同)=>目的是為了盡量用最少的單字做最多的事
**與建構式的差別在於，建構式不需要給類型，且只有new的時候要用建構式，事後要修改都用method
=>規則和constructor一樣，用()中的內容來區別，只用引數的類型、數量和順序做判斷，傳值(void)不傳值(return)也不列入考慮
ex:
void change(int chi,String name) { ...}
void change(String name,int chi){ ...}
int change(int x, String y){return 100;}
void change(int x, String y) { ...}
最後兩個都和第一個數量、類型、順序一樣，所以無法compiler，是否傳值不列入考慮
 
*加上method和overloading以後重畫一次UML如下：
● 實作練習-薪資與獎金(針對業務員)
1)輸入=>姓名和業績
2)底薪：18,000
3)業績/獎金比
150萬以上         7%
100萬~150萬     5%
50萬~100萬      3%(0.03)
0~50萬             0%
=>獎金=業績*獎金比
4)Database
姓名:name
業績:x1
獎金比:x2
獎金:x3
底薪:x4
實領薪資:x5
 
5)UML和流程圖
salary.java
class salary{
private String name;
private int x1;
private double x2;
private int x3;
private int x4;
private int x5;
 
salary(String name, int x1){if(x1>=1500000){  //從大的開始判斷
     x2=0.07;
    //如果沒有把this.x1=x1放在if中，當x1<0時還是會顯示，
    //無法過濾，設定後如<0，println時就會直接把x1帶初始值
     this.x1=x1;      
}else if(x1>=1000000 && x1<1500000){
     x2=0.05;
     this.x1=x1;     
}else if(x1>=500000 && x1<1000000){
     x2=0.03;
     this.x1=x1;  
}else if(x1>=0 && x1<500000){
     x2=0;
     this.x1=x1;   
}else{
     System.out.println("業績必需>=0");
}
this.name=name; //要區分區域或全域，所以要加this
 //因為x2為double，但x3為int，所以這邊要做轉型
x3=(int)(x1*x2);  
x4=18000; //因為是固定數，也可在上面定義變數時直接設定好
x5=x4+x3;
}
void show(){
System.out.println("姓名:"+name+
"\t業績:"+x1+
"\t獎金比:"+x2+
"\t獎金:"+x3+
"\t底薪:"+x4+
"\t實領薪資:"+x5);
}
add2.java
class add2{
public static void main(String args[]){
salary sc = new salary("kelly",700000);
sc.show();
}
}
 
如果要使用Scanner，做法如下：
addtest.java
public static void main(String args[]){
    //new就是把Scanner的所有東西全部丟給sc
java.util.Scanner sc = new java.util.Scanner(System.in);  
System.out.println("請輸入姓名");
String y1=sc.next();
System.out.println("請輸入業績");
int y2=sc.nextInt();
salary sc2 = new salary(y1,y2);
sc2.show();
}
 
● Array(陣列)
(一)變數名(陣列簡單說就是分類的命名)；相同類型的多個變數；同一機構，同一組
=>避免使用太多英文名稱命名，增加複雜度，可以用一個"共同"名稱代表全體，個別再以"暫數"索引碼區別，限定整數
=>分組的概念
=>陣列具有物件的特性，是因為也是使用new的規則(有配記憶體)
 
int[] chi;=>這樣compiler可以過，但如果把它print出來會有下列錯誤訊息
 
因為int chi[];=>此時尚未產生陣列，要透過new才會產生記憶體位置
int chi[]=new[3];
System.out.println(chi);
產生如下訊息，這裡"["代表的是陣列，"I"代表int，@15db9742代表所在記憶體位置
=>可以想成產生3個空白的格子並且配有int大小和初始值(如果是class每格的大小可能不同，因為資料類型不同，但這邊資料類型相同所以每格大小相同)
=>初始值和class一樣=>int:0，double:0.0，boolean:false，String:null
 
(二)語法：類型[ ] 陣列名 = new 類型[n]; n=數量；個數 ，編碼從0開始，[0]、 [1]、....
=>int[] chi的[]代表這是一個陣列類型，chi才是陣列名稱
=>chi[0]會先找chi即記憶體位置，然後再找[0]編號
int[]chi=new int [3]; //等號兩邊的類型必須相同
System.out.println(chi[0]);
System.out.println(chi[1]);
System.out.println(chi[2]);
 
(三)輸出陣列的值
1)for(; ; ) =>有索引碼
2) for-each 加強型 =>沒有索引碼
語法：for(類型 變數:陣列)
**foreach的類型必須和陣列的類型相同
public static void main(String args[]){
int chi[]=new int[3];
for(int x=0;x<3;x++){    //這邊的int指的是索引碼是int
     System.out.println(chi[x]);
}
for(int o:chi){   //這邊的int指的是o必須為int所以要和陣列的類型相同
     System.out.println(o);
}
}
**這邊o:chi的":"會先去判斷chi有無資料，如果有，就會把找到的第一個值指定給o，然後再回去chi看還有沒有資料，如果有再把找到的第二個值指定給o，若是沒有找到就是false，就會停止run
 
(四)初始值(化)的方式
1)new=>靜態輸出，只要有new就會有記憶體(即實體化)
 =>new先給 =>new只給記憶體位址不給初始值
=>事後再更新
ex:各種初始值
int
int chi[]=new int[3];
for(int x=0;x<3;x++){
     System.out.println(chi[x]);
}
System.out.println("======================");
for(int o:chi){
     System.out.println(o);
}
double
double chi[]=new double[3];
for(int x=0;x<3;x++){
     System.out.println(chi[x]);
}
System.out.println("======================");
for(double o:chi){
     System.out.println(o);
}
boolean
boolean chi[]=new boolean[3];
for(int x=0;x<3;x++){
     System.out.println(chi[x]);
}
System.out.println("======================");
for(boolean o:chi){
     System.out.println(o);
}
String
for(int x=0;x<3;x++){
     System.out.println(chi[x]);
}
System.out.println("======================");
for(String o:chi){
     System.out.println(o);
}
 
2){ }=>動態輸出=>0801
 
 
文章標籤
java overloading 多載 method 函式庫

muchone 發表在 痞客邦 留言(0) 人氣()

  • 個人分類：JAVA
▲top

My son has not done exercise engough since he went to elementary school.

Hence he sat in on a taekwondo class this morning.

And I was glad he liked the takewondo class. 

 

sit in on a class：試聽/試上課

文章標籤
日記 英文寫作 英文

muchone 發表在 痞客邦 留言(0) 人氣()

▲top

I went to the International Spring Travel Fair with my family today.

I never knew that the Travel Fair was so much fun because this was the first time I went to a Travel Fair.

At the end of the Fair, my son and I both got lots of freebies.

文章標籤
日記 英文寫作 英文

muchone 發表在 痞客邦 留言(0) 人氣()

▲top
«1...141516 1718...22