簡單。生活。享受

● 接續昨日-java連資料庫

Connection=>連線"jdbc"

DriverManager=> 連線"jdbc"

PreparedStatement=>寫入資料庫

=>輸入資料時，是用 PreparedStatement寫入，然後再透過 Connection連接資料庫，經由 DriverManager把輸入的資料丟到資料庫裡，這就是串接

 

Statement=>搭配已讀取資料庫

ResultSet=>搭配已讀取資料庫

 

● 讓使用者輸入的資料可以送至資料庫

 private void okMouseClicked(java.awt.event.MouseEvent evt) {

  String url="jdbc:mysql://localhost:3306/school";

  String user="root";

  String password="123456789";

  int ID=Integer.parseInt(id.getText());

  int CHI=Integer.parseInt(chi.getText());

  int ENG=Integer.parseInt(eng.getText());

  String NAME=name.getText();

  String sql="insert into student(id,name,chi,eng) values(?,?,?,?)";

 

  try{

  Connection conn=DriverManager.getConnection(url, user, password);

  PreparedStatement ps=conn.prepareStatement(sql);

  ps.setInt(1, ID);

  ps.setString(2, NAME);

  ps.setInt(3, CHI);

  ps.setInt(4, ENG);

  ps.executeUpdate();

  System.out.print("ok");

 

  ps.close();

  conn.close();

  }catch(SQLException e){

  System.out.print("no");

  }

  }

**說明：

1.有些連線會寫在建構式，為了不要占用server資源，執行完就做斷線： ps.close(); conn.close();

2.url的說明

jdbc:mysql:=>確認是否有載入java msyql的驅動程式

//localhost:3306=>主機名稱：port

/school=>資料庫名稱

 

● 沒有輸入資料，空白送出，會出現Exception：數字無法格式化

  private void okMouseClicked(java.awt.event.MouseEvent evt) {

  String url="jdbc:mysql://localhost:3306/school";

  String user="root";

  String password="123456789";

  String sql="insert into student(id,name,chi,eng) values(?,?,?,?)";

 

  try{

  int ID=Integer.parseInt(id.getText());

  int CHI=Integer.parseInt(chi.getText());

  int ENG=Integer.parseInt(eng.getText());

  String NAME=name.getText();

  Connection conn=DriverManager.getConnection(url, user, password);

  PreparedStatement ps=conn.prepareStatement(sql);

  ps.setInt(1, ID);

  ps.setString(2, NAME);

  ps.setInt(3, CHI);

  ps.setInt(4, ENG);

  ps.executeUpdate();

  System.out.print("ok");

 

  ps.close();

  conn.close();

 

  }catch(SQLException e){

  msg.setText("編號不可重複");

  }catch(NumberFormatException e){

  msg.setText("資料不可為空白");

  }

  }

 

**說明：

1.要用catch去捕捉Exception

2.在介面上新增一個label位置(variable name)，先不顯示文字

3.將錯誤訊息資料用setText()顯示到介面上

4.因為是在輸入時錯誤，所以getText()都要放到try裡面

5.因為 SQLException只檢查連線到資料庫是否成功和輸入的資料和資料庫設定的規則是否衝突，所以測試連線成功後，後面的catch捕捉到的一定是規則衝突，我們這邊只設定編號不能重複，所以內容可以改為 msg.setText("編號不可重複");

 

●抓資料

1.先做介面，一個顯示button (variable name:show) 和一個顯示文字區域(variable name:ans)

 

2.建立連線，和抓Exception，測試連線ok

  private void showMouseClicked(java.awt.event.MouseEvent evt) {

  String url="jdbc:mysql://localhost:3306/school";

  String user="root";

  String password="123456789";

  try{

  Connection conn=DriverManager.getConnection(url, user, password);

  System.out.print("ok");

  }

  catch(SQLException e){

  }

  }

 

 

3.匯入Statement和ResultSet，透過Connection下的 createStatement()物件來和Statement連接，測試ok

  import java.sql.Statement;

  import java.sql.ResultSet; 

 

  private void showMouseClicked(java.awt.event.MouseEvent evt) {

  String url="jdbc:mysql://localhost:3306/school";

  String user="root";

  String password="123456789";

  String sql="select id,name,chi,eng from student";

  try{

  Connection conn=DriverManager.getConnection(url, user, password);

  Statement st=conn.createStatement();

  System.out.print("ok");

  }

  catch(SQLException e){

  }

**說明：

String sql="select id,name,chi,eng from student";

=> select 欄位名稱 from 資料表名稱(因為已經連上資料庫，所以可以省略資料庫名稱)

 

4.找資料和抓資料

  private void showMouseClicked(java.awt.event.MouseEvent evt) {

  String url="jdbc:mysql://localhost:3306/school";

  String user="root";

  String password="123456789";

  String sql="select id,name,chi,eng from student";

  try{

  Connection conn=DriverManager.getConnection(url, user, password);

  Statement st=conn.createStatement();

  ResultSet rs=st.executeQuery(sql);

  rs.next();

  System.out.println("編號:"+rs.getInt("id")+"\t名字:"+

  rs.getString("name")+"\t國文:"+rs.getInt("chi")+"\t英文:"+rs.getInt("eng"));

  System.out.print("ok");

  }

  catch(SQLException e){

  }

  }

**說明：

1.Statement中有一個executQuery(String sql)，可以放入sql語法來找資料庫的資料，

但抓出來的資料類型為ResultSet，因為Statement沒有提供顯示的動作，所以要透過ResultSet 中的getxxxx方法來抓資料出來顯示，這樣一個傳給一個就是串接的概念

2. ResultSet 中的next()是用來判斷目前連線是否有資料，有資料會回true，才會跑下面get方法，如果沒有做這個動作就會有Exception

3.getInt(String columLable)，代表()內要放欄位名稱且為字串 ex: rs.getInt("id")

4.先用System.out.println在主控台測試輸出一筆資料，目前只能一次輸出一筆資料

 

5.要一次能輸出全部資料

  private void showMouseClicked(java.awt.event.MouseEvent evt) {

  String url="jdbc:mysql://localhost:3306/school";

  String user="root";

  String password="123456789";

  String sql="select id,name,chi,eng from student";

  try{

  Connection conn=DriverManager.getConnection(url, user, password);

  Statement st=conn.createStatement();

  ResultSet rs=st.executeQuery(sql);

  while(rs.next()){

  System.out.println("編號:"+rs.getInt("id")+

  "\t名字:"+rs.getString("name")+

  "\t國文:"+rs.getInt("chi")+

  "\t英文:"+rs.getInt("eng"));

  }

  System.out.print("ok");

  }

  catch(SQLException e){

  }

  }

**說明：

第四步驟的做法每次都只能輸出同一筆資料，原因在於判斷哪一筆資料是由rs.next()在做，當此時這筆資料判斷有收到就會執行下一步驟，可是沒有再去判斷下一筆是否有資料，就會一直停留在第一筆，所以變成每執行一次println就要再run一次rs.next()，所以可以用while迴圈來解決這個問題

 

6.改為顯示到使用者介面

while(rs.next()){

  ans.setText("編號:"+rs.getInt("id")+

  "\t名字:"+rs.getString("name")+

  "\t國文:"+rs.getInt("chi")+

  "\t英文:"+rs.getInt("eng"));

  }

**說明：

如果直接這樣改，會只顯示最後一筆，因為每撈出一筆資料就會把上一筆資料給覆蓋過去

 

要做成

 

  import java.util.ArrayList;

 

  private void showMouseClicked(java.awt.event.MouseEvent evt) {

  String url="jdbc:mysql://localhost:3306/school";

  String user="root";

  String password="123456789";

  String sql="select id,name,chi,eng from student";

 

  try{

  Connection conn=DriverManager.getConnection(url, user, password);

  Statement st=conn.createStatement();

  ResultSet rs=st.executeQuery(sql);

  ArrayList<String> x=new ArrayList<String>();

  while(rs.next()){

  x.add("編號:"+rs.getInt("id")+

  "\t名字:"+rs.getString("name")+

  "\t國文:"+rs.getInt("chi")+

  "\t英文:"+rs.getInt("eng")+"\n");

  }

  ans.setText(x.toString());

  System.out.print("ok");

  rs.close();

  st.close();

  conn.close();

 

  }

  catch(SQLException e){

  }

  }

 

**說明：

為了避免被下一筆資料蓋過，改用collection的 ArrayList，把資料收集後全部放在x中，這時x是資料集合的物件，所以不能直接 用setText() 把內容顯示出來，要透過toString()把物件轉成字串                             

 

**另一種做法

  private void showMouseClicked(java.awt.event.MouseEvent evt) {

  String url="jdbc:mysql://localhost:3306/school";

  String user="root";

  String password="123456789";

  String sql="select id,name,chi,eng from student";

 

  try{

  Connection conn=DriverManager.getConnection(url, user, password);

  Statement st=conn.createStatement();

  ResultSet rs=st.executeQuery(sql);

  String s="";

 

  while(rs.next()){

  String a="編號:"+rs.getInt("id")+

  "\t名字:"+rs.getString("name")+

  "\t國文:"+rs.getInt("chi")+

  "\t英文:"+rs.getInt("eng")+"\n";

  s=s+a;

  }

  ans.setText(s);

  System.out.print("ok");

  rs.close();

  st.close();

  conn.close();

  }

  catch(SQLException e){

  }   

 

**說明：

1.先預設變數s為空值

2.把所有的欄位值丟到變數a(區域變數)，再把a丟給s，用setText(s)輸出所有抓出來的資料

 

 

文章標籤

JAVA MySQL jDBC

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

*JAVA與MYSQL實作

1.先建立新的資料庫=>new schema(產生新的資料庫名稱)

 

2.完成後會在左下角看的到資料庫名稱

 

3.新建table

 

4.設定欄位

PK(primary key)：主索引

NN：必填欄位，不可空白

VARCHAR：字元，預設最大45個字元，可調

=>欄位大小寫沒有影響

 

5.設定完成後點左下角的table名稱可以看到欄位標題顯示

 

6.用netbeans建立專案school、student class、做介面

 

7.jDBC

java.SQL.*(和database有關的api都放在這)

Connection=>連線用

DriverManager＝＞連線用

PrepareStatement

*Connection是interface，不能new，要透過 DriverManager的getConnection把連線丟給 Connection

 

=>import三個class

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.PreparedStatement;

 

8.連mysql的語法如下，但這樣寫完發現會出現exception，所以要加上try...catch

且import java.sql.SQLException;

private void okMouseClicked(java.awt.event.MouseEvent evt) {

  String url="jdbc:mysql://localhost:3306/school"; 

  String user="root";

  String password="123456789";

 

  Connection conn=DriverManager.getConnection(url, user, password);

  }

 

 

加上try...catch來檢查資料庫連線是否成功，但還是失敗，因為需要匯入mySQL的驅動程式Connector J，不同程式語言要下載不同的驅動程式

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.PreparedStatement;

import java.sql.SQLException;  

 

  private void okMouseClicked(java.awt.event.MouseEvent evt) {

  String url="jdbc:mysql://localhost:3306/school";

  String user="root";

  String password="123456789";

  try{

  Connection conn=DriverManager.getConnection(url, user, password);

  System.out.print("ok");

  }catch(SQLException e){

  System.out.print("no");

  }

 

  }     

 

匯入驅動程式jar檔

 

匯入後再測試OK，紅色訊息是資料庫的回應，不用管

 

9.建立資料，先設定一個sql語法的變數，insert into 資料表名稱(欄位名,欄位名,...) values(欄位內容,欄位內容,...)，這邊?代表先不給之後再輸入，代表任意字元

 String sql="insert into student(id,name,chi,eng) values(?,?,?,?)";

 

10.傳資料給資料庫要用 PreparedStatement，透過connection把資料轉成同樣為 PreparedStatement 類型

新增資料時要用 PreparedStatement下的method(setInt()，setString())，第一個參數代表欄位的位置，第二個參數代表要輸入的內容

  private void okMouseClicked(java.awt.event.MouseEvent evt) {

  String url="jdbc:mysql://localhost:3306/school";

  String user="root";

  String password="123456789";

  String sql="insert into student(id,name,chi,eng) values(?,?,?,?)";

 

  try{

  Connection conn=DriverManager.getConnection(url, user, password);

  PreparedStatement ps=conn.prepareStatement(sql);

  ps.setInt(1, 1);

  ps.setString(2, "kelly");

  ps.setInt(3, 78);

  ps.setInt(4, 65);

 

  System.out.print("ok");

  }catch(SQLException e){

  System.out.print("no");

  }

  }  

 

11.輸入完成後去執行，按ok button在資料庫會查不到資料，因為還要加上 ps.executeUpdate();，把資料庫內容更新

，之後去資料庫看資料表內容，要記得重新整理，就可以看到輸入的資料

文章標籤

jDBC mysql java 資料庫

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

Generics(泛型)&Collection(集合；收集)=>在java.util

 

●collection=>List-ArrayList( 和陣列一模一樣 )

                            -LinkedList

                  =>Set-HashSet(雜湊)

                           -sort(介面)-TreeSet

**說明

1.List是有順序的，有索引碼，先key先排，可重複資料

2.Set是亂數排序，不允許重複

3.collection、List、Set都是interface

4.sort提供順序

5.Treeset=>資料不允許重複，但有順序

 

(一)Generics(泛型)

1.不定類型

2.<T,E,....>

=>T,E=> 任意英文代號

3.限定使用"WRAPPER"類別與"class"

4.可以用在field、建構式、method

(當要讓使用者在新增時才決定類別時使用)

class Book<T>{

String bookname;

T bookprice;

 

Book(String bookname, T bookprice){

this.bookname=bookname;

this.bookprice=bookprice;

}

 

void show(){

System.out.println("書名:"+bookname+"\t價格:"+bookprice);

}

}

**說明：

1.如果使用者希望價格有時候可以輸入double有時候可以輸入int，改用泛型

2.new的時候由使用者自己定義類型

3.在class name後面寫<任意英文>,要使用泛型的地方都要放一樣的代號

 

class add1{

public static void main(String args[]){

Book<T> b1=new Book<T>("Java",380);

}

}

**說明：

1.如果在new的時候直接在class name後面加上<T>，會出現如上錯誤

2.代表java無法判斷如何新增內容，因為不知道380在這邊應該是甚麼類型，但詳細說明要重新編譯用javac -Xlint add1.java來看，詳細內容如下

3.所以將<T>改為<int>，設定使用者要用int，卻出現錯誤訊息如下，因為需要使用reference=>代表要用class，int是基本類別只能定義變數，要使用wrapper類別(ex:Double,Integer...)才能當作reference，因為wrapper類別既代表整數又有class身分

 

 

正確做法

class add1{

public static void main(String args[]){

Book<Integer> b1=new Book<Integer>("Java",380);

Book<Double> b2=new Book<Double>("android",650);

b1.show();

b2.show();

}

**說明：

但在這邊要注意，如果使用Double這個wrapper類別，輸入時就一定要使用浮點數，不然會出現錯誤訊息，不像基本類別的double可以接受整數

class add1{

public static void main(String args[]){

Book<Integer> b1=new Book<Integer>("Java",380);

Book<Double> b2=new Book<Double>("android",650.3);

b1.show();

b2.show();

}

}

 

多個不定類型時的用法

class Book<T,E>{

String bookname;

T bookprice;

E x;

 

Book(String bookname, T bookprice, E x){

this.bookname=bookname;

this.bookprice=bookprice;

this.x=x;

}

 

void show(){

System.out.println("書名:"+bookname+"\t價格:"+bookprice);

}

}

 

class add1{

public static void main(String args[]){

Book<Integer,Double> b1=new Book<Integer,Double>("Java",380,6.2);

Book<Double,Integer> b2=new Book<Double,Integer>("android",650.3,50);

}

}

 

另外，java7以後改成前面不寫，只寫後面也可以

class add1{

public static void main(String args[]){

Book b1=new Book<Integer,Double>("Java",380,6.2);

Book b2=new Book<Double,Integer>("android",650.3,50);

}

}

 

(二) Collection

1.解決"陣列"數量無法增加的問題

2.將"資料結構"應用寫成"API"應用

3.需搭配"泛型"為"reference"

4.語法：( 收集資料的方式/集合方式要先決定 )

集合方式<類型> 集合物件=new 集合方式<類型>();

=>集合物件指動態陣列

 

a) ArrayList

import java.util.ArrayList;

class add2{

public static void main(String args[]){

ArrayList<Integer> x=new ArrayList<Integer>();

x.add(110);

x.add(20);

x.add(30);

x.add(30);

 

for(Integer o:x){

System.out.println(o);

}

System.out.println("=============");

x.add(20);

x.add(650);

for(Integer o:x){

System.out.println(o);

}

}

}

**說明：

*注意：這邊x的類型是Integer而非 ArrayList， ArrayList是收集資料的方式

1.add()這個方法是從collection繼承給下面所有不同的收集方式，所以全部都可用add()來新增資料

新增資料的方式用add(E)=>看要使用的類型來決定輸入的類型，如上述就是Integer

2.輸入的資料無限制筆數且可重複

3. ArrayList 輸出時的排列方式為，先打進去的資料會排前面

4.ArrayList不能用.length會出現錯誤訊息，所以我們要一個個顯示資料可以用foreach的方式，如果要計算陣列個數則可以用迴圈和count++來做

5.可重複，所以有兩個30

6.可事後增加數量，所以第二次的輸出多兩個內容

7.如果要查記憶體位置，要用x.iterator();這個方法，結果如下：

 

LinkedList

import java.util.ArrayList;

import java.util.LinkedList;

class add2{

public static void main(String args[]){

LinkedList<Integer> x=new LinkedList<Integer>();

x.add(110);

x.add(20);

x.add(30);

x.add(30);

 

for(Integer o:x){

System.out.println(o);

}

System.out.println("=============");

x.add(20);

x.add(650);

for(Integer o:x){

System.out.println(o);

}

System.out.println(x.iterator());

}

}

**說明：

1.要先import class進來

2.輸出結果完全一樣，只有收集資料的方式不同

3. LinkedList和ArrayList差別在於，前者除了list還有一個Queue interface，用途是為了能解省記憶體，但因為java不太管效能，所以很少用

 

HashSet

import java.util.ArrayList;

import java.util.LinkedList;

import java.util.HashSet;

class add2{

public static void main(String args[]){

HashSet<Integer> x=new HashSet<Integer>();

x.add(110);

x.add(20);

x.add(30);

x.add(30);

 

for(Integer o:x){

System.out.println(o);

}

System.out.println("=============");

x.add(20);

x.add(650);

for(Integer o:x){

System.out.println(o);

}

System.out.println(x.iterator());

}

}

**說明：

順序亂數排列，且不重複

 

TreeSet

import java.util.ArrayList;

import java.util.LinkedList;

import java.util.HashSet;

import java.util.TreeSet;

class add2{

public static void main(String args[]){

TreeSet<Integer> x=new TreeSet<Integer>();

x.add(110);

x.add(20);

x.add(30);

x.add(30);

 

for(Integer o:x){

System.out.println(o);

}

System.out.println("=============");

x.add(20);

x.add(650);

for(Integer o:x){

System.out.println(o);

}

System.out.println(x.iterator());

}

}

**說明：

由小到大重新排列，且不重複

 

實作

這次要收集的資料類型是一整張表的資料，而非只有integer或double，所以資料類型變成student class(student類型的資料)

(一)ArrayList和 LinkedList

import java.util.ArrayList;

import java.util.LinkedList;

 

class student {  

private String name;

private int chi;

private int eng;

 

student(String name,int chi,int eng){

this.name=name;

this.chi=chi;

this.eng=eng;

}

 

void show(){

System.out.println("名字:"+name+"\t國文:"+chi+"\t英文:"+eng);

}

 

class add3{

public static void main(String args[]){

//ArrayList<student> s=new ArrayList<student>();

LinkedList<student> s=new LinkedList<student>();

 

s.add(new student("aa",85,77));

s.add(new student("aa1",85,77));

s.add(new student("aa2",86,78));

for (student o:s){

o.show();

}

}

}

 

**說明：

1.用 ArrayList和 LinkedList輸出結果相同

2. 在new的時候，這邊變成要新增一個學生物件 new student("aa",85,77) ，而非一個值

3. foreach的類型也要是student，因要和s同樣類型， 因為把s指給o，所以o也是一個物件，可以直接用o.show()

 

(二)用HashSet，資料不重複

class add3{

public static void main(String args[]){

HashSet<student> s=new HashSet<student>();

s.add(new student("aa",85,77)); 

s.add(new student("aa1",87,97));

s.add(new student("aa2",83,67));

for (student o:s){

o.show();  

}

}

}

**說明：

1.用 HashSet亂數排序

2. 是否重複是看記憶體位置，只要有new就不會重複記憶體位置

 

(三)用HashSet，資料重複

class add3{

public static void main(String args[]){

HashSet<student> s=new HashSet<student>();

s.add(new student("aa",85,77)); 

s.add(new student("aa",85,77));

s.add(new student("aa",85,77));

 

for (student o:s){ 

o.show();  

}

}

}

**說明：

因為HashSet判斷是否重複是由記憶體位址來判斷，而非由輸入的值來判斷，所以還是會有三筆資料

 

(四)用TreeSet

class add3{

public static void main(String args[]){

TreeSet<student> s=new TreeSet<student>();

s.add(new student("aa",85,77)); 

s.add(new student("aa",85,77));

s.add(new student("aa",85,77));

 

for (student o:s){ 

o.show();

}

}

}

**說明：

1.改用TreeSet，可以compiler但是執行出現Exception

2.因為這邊是物件無法直接排序，要排序的話要由現有的欄位中抓一個欄位當作索引欄位(要告訴他要由哪個欄位來排順序)

 

 

正確做法：

import java.util.ArrayList;

import java.util.LinkedList;

import java.util.HashSet;

import java.util.TreeSet;

 

class student implements Comparable<student>{  

private String name;

private int chi;

private int eng;

 

student(String name,int chi,int eng){

this.name=name;

this.chi=chi;

this.eng=eng;

}

 

void show(){

System.out.println("名字:"+name+"\t國文:"+chi+"\t英文:"+eng);

}

public int compareTo(student o){

return this.chi-o.chi;

}

}

 

class add3{

public static void main(String args[]){

TreeSet<student> s=new TreeSet<student>();  

s.add(new student("aa",85,77));

s.add(new student("aa",85,77));

s.add(new student("aa",85,77));

  

for (student o:s){

o.show();

}

}

}

 

**說明：

1. 要繼承comparable interface(用implements),<>中要放要排序的類型物件，因為comparable是泛型

2.因為繼承interface的compareTo()方法，所以要override，故前面要加public和繼承的int，copareTo()裡面要放本身物件(student)，和下一個物件(o)

3.return時，this是物件本身，o是指下一個物件，這邊要指定欄位用國文分數(chi)，

4.語法：this-o，如果：>0由小到大排列，<0由大到小排列，=0不變

5.通常當主索引欄不會重複且可以判斷先後順序者，會用TreeSet來做

6. TreeSet排列是用指定的欄位值來判斷，這邊指定國文分數來判斷，此時三者相同，所以判斷重複，最後會輸出一筆

7.如果改為如下，就會輸出三筆並且照國文分數由小到大排列

s.add(new student("aa",86,77));

s.add(new student("aa",88,77));

s.add(new student("aa",85,77));

 

●泛型與多型應用

1.泛型

2.多型

=>陣列：數量無法增加；集合：可增加(又稱為動態陣列)

 

 

 

import java.util.ArrayList;

import java.util.LinkedList;

import java.util.HashSet;

import java.util.TreeSet;

 

class student implements Comparable<student>{

private String name;

private int chi;

private int eng;

 

student(String name,int chi,int eng){

this.name=name;

this.chi=chi;

this.eng=eng;

}

 

void show(){

System.out.print("名字:"+name+"\t國文:"+chi+"\t英文:"+eng);

}

public int compareTo(student o){

 

return this.chi-o.chi;

}

}

 

class A extends student{

private int word;

A(String name,int chi, int eng ,int word){

super(name,chi,eng);

this.word=word;

}

void show(){

super.show();

System.out.println("\tword:"+word);

}

}

 

class B extends student{

private int excel;

B(String name,int chi, int eng ,int excel){

super(name,chi,eng);

this.excel=excel;

}

void show(){

super.show();

System.out.println("\texcel:"+excel);

}

}

 

class add3{

public static void main(String args[]){

ArrayList<student> s=new ArrayList<student>();  //定義父類別(的資料收集方法)

 

s.add(new A("aa",86,77,88));   //new子類別

s.add(new A("aa2",88,77,76));

s.add(new B("bb",85,77,87));

 

for (student o:s){

o.show();

}

System.out.println("=============");

s.add(new A("aa3",67,87,96));

s.add(new B("bb2",73,84,97));

 

for (student o:s){

o.show();

}

}

}

**說明：

1.在做輸入資料的介面時不可能鎖死資料筆數，所以要用集合不能用陣列

2.這邊只要A和student有繼承關係就能 s.add(new A("aa",86,77,88));

3. for (student o:s)=>forecach的reference還是看student，因為s的reference是student

4.和多型一樣，也是先定義父類別然後new子類別

5.做法和陣列完全一樣，只是改為集合，數量可以增加，陣列的作法為

  student s(定義父類別)={new A("aa3",67,87,96),new B("bb2",73,84,97)};(new子類別)

6.可以事後增加資料

7. 此時還沒有索引碼，所以還沒辦法直接用索引碼找資料

 

3.先用集合建立，再透過Object[]陣列=>集合toArray();  (不一定要做這個步驟)

=>轉回陣列=>製作索引碼

class add3{

public static void main(String args[]){

ArrayList<student> s=new ArrayList<student>();

 

s.add(new A("aa",86,77,88));

s.add(new A("aa2",88,77,76));

s.add(new B("bb",85,77,87));

 

Object[] x=s.toArray();

System.out.println(x[0]);  //輸出記憶體位址

//x[0].show(); //出現如下錯誤

((student)(x[0])).show();

}

}

 

**說明：

1.要把s集合的內容轉為x陣列

2.toArray()會轉成物件類型Obtect class(所有class的共同父類別)

3.如果直接用x[0].show()會找不到，因為編譯時會先去x找show()方法，但x是Object類型，會找不到

4.要把x[0]轉型為student類型(toArray一開始會先把類別拉到最上層(即所有class的父類別Object)，所以要再降為目前的類型)，把 x[0].show();改為((student)(x[0])).show();即可

 

文章標籤

Generics Collection ArrayList LinkedList HashSet TreeSet JAVA

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

●Exception

1)執行上的錯誤=>bug處理

2)捕捉exception

=>try{ ...}catch(異常類型  物件名) {....}

3)多重捕捉

=>try{...} catch(異常類型  物件名) {....}

 

4)exception api分類

throwable

=>error

    =>stackOverFlow(遞迴)

    =>....                 

=>exception

    =>RuntimeException

    =>(非 RuntimeException ) 

**說明：

1. java.lang.throwable=>只做兩個動作1.中斷2.拋訊息，其他條件都由繼承的子類別來做

2.error=>嚴重錯誤

3.exception=>異常=>可不修改程式碼=>加說明

4. RuntimeException=>JRE設定好，自動檢查(自動捕捉)，可不加 try{ ...}catch() {....}也可

=>unchecked，可以編譯，不用捕捉也看的到，只是使用者不知道

5. 非 RuntimeException=>JRE沒有設定自動捕捉訊息=>一訂要加 try{ ...}catch() {....}

=>checked=>不能編譯，要加try{}catch(){}才能編譯，即要自己做檢查機制

6.建構式中如果有throws，會啟動該throw下的exception去檢查

 

import java.util.Scanner;

class ex1{

public static void main(String args[]){

Scanner sc=new Scanner(System.in);

int n=sc.nextInt();

for(int i=0;i<n;i++){

     System.out.println("hello");

}

}

}

**說明：

1.java.util.InputMismatchException這個exception是runtime的

2.查的方式是去api看Scanner下的nextInt()，有一個throws，下面有exception

3.點任何一個exception進去看，可以看到繼承關係，這些都是屬於RuntimeException

 

 

舉例

import java.util.Scanner;

class ex1{

public static void main(String args[]){

Scanner sc=new Scanner(System.in);

try{

System.out.println("請輸入陣列數量");

int m=sc.nextInt();

int[] x=new int[m];

System.out.println("請輸入索引號碼");

 //new java.util.InputMismatchException()

int n=sc.nextInt();        

 //new java.lang.IndexOutOfBoundsException() 

x[n]=100;                            

//new java.lang.ArithmeticException()

System.out.println(10/n);

for(int i=0;i<n;i++){

     System.out.println("hello");

}

}catch(java.util.InputMismatchException e){

     System.out.println("輸入整數");

}catch(java.lang.ArithmeticException e){

     System.out.println("分母不可為0");

}

catch(java.lang.IndexOutOfBoundsException e){

     System.out.println("索引號碼錯誤，要n-1");

}

}

}

**說明：

當出現異常的時候，其實就是在那個步驟時，new了一個exception(因為exception是class=>是物件)，然後new完的建構式去做中斷和丟訊息的動作，當出現catch時，就會等待直到把exception物件丟給指定的變數這個例子的指定變數為e)，收到以後就會轉換成去執行catch內的內容

 

5)非RuntimeException(編譯時就會提醒你)

a)一定要捕捉，方式有二

=>try....catch

=>throws(拋出)

b)一般定義在2個部分

=>constructors

=>methods

 

舉例，使用java.io.File=>class File是用來開檔案或資料夾

=>會先chk是否有一樣的檔名，true or false，有一樣就不動作，沒有就產生新的檔，有Exception

=>為非runtimeexception

import java.io.File;

class ex2{

public static void main(String args[]){

//在c下面新增一個txt檔，這裡只是先new物件，產生檔案要用method

File f=new File("c:/a.txt");

f.createNewFile();

}

}

 

**說明：

1.編譯時產生error，所以要改程式碼

2.錯誤訊息：需要被捕捉(try....catch...)或被拋出(throws)

3.因為有IOException，但沒有跟編譯器說要怎麼處理

 

作法一：try...catch自己寫說明

import java.io.File;

import java.io.IOException;

class ex2{

public static void main(String args[]){

try{

File f=new File("c:/a.txt");

f.createNewFile();

}catch(IOException e){

     System.out.println("無法新增");

}

}

}

**說明：

會出現無法新增，因為c:會有權限問題無法寫入，把寫入位置改為c:/java/14/a.txt即可

 

作法二：throws，不用寫說明

mport java.io.File;

import java.io.IOException;

class ex2{

public static void main(String args[]) throws IOException{

File f=new File("c:/a.txt");

f.createNewFile();

}

}

 

**說明：

1.改用throws，就是在method後面加上throws 異常類別，如上，如果有多個，可用","隔開

2.用throws以後編譯可過，執行時會自動出現說明，但只有dos介面看的到，一般使用者視窗介面就看不到

3.有時用在檢查程式，判斷是否之後要寫說明

 

c)自訂Exception(非RuntimeException)

1.使用 Exception(針對方法) (Exception要在main執行時用)

=>內容

     =>使用if(沒有中斷機制)

     =>throw new Exception();

=>方法或建構式：throws Exception

用if但不加exception

class student{

String name;

int chi;

int eng;

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;

}

}

void show(){

System.out.println("名:"+name+

"\t國文:"+chi+

"\t英文:"+eng

);

}

}

class add{

public static void main(String args[]){

student[] s={

new student("kent",200,91),

new student("maggie",86,92),

new student("derek",85,93)

};

for(int i=0;i<s.length;i++){

s[i].show();

}

}

}

**說明：

1.用if在建構式先做判斷，沒有加else，所以如果超過這個範圍就不更新資料，用初始值

2.但是當輸入的內容超過範圍，程式還是會跑完全部，而非停在出錯的 new student("kent",200,91)

3.如過用exception就會在出錯的 new student("kent",200,91)停止，不會繼續run，當後面資料和前面資料有關聯時，用exception比較適合

用exception+if

class student{

String name;

int chi;

int eng;

student(String name,int chi,int eng) throws Exception {

if(chi>=0 &&chi<=100 && eng>=0 &&eng<=100){

this.name=name; 

this.chi=chi;

this.eng=eng;

}else{

throw new Exception();   

}

}

void show(){

System.out.println("名:"+name+

"\t國文:"+chi+

"\t英文:"+eng

);

}

}

**說明：

1.exception要搭配if來使用，放在else中，代表如果沒有符合條件，就把exception()這個物件丟出去給使用student建構式的人

2.但假設沒有在 student(String name,int chi,int eng)後面加上 throws Exception，就會出現如上錯誤訊息，代表需要捕捉或拋出

3.所以要在 student(String name,int chi,int eng)後面加上 throws Exception，代表從student拋出去

4.thorows Exception是在等else裡面的new Exception產生

5.如果在else{}中只寫new Exception()，前面沒有加throw，會只在else{}中產生沒有辦法丟出去，因為生命週期，所以要加上throw才能丟出去給建構式外的throws接收 

** 這邊的Exception其實是用java.lang.Exception class(裡面有包含自訂exception的功能)

使用我們自己訂的Exception

class add{

public static void main(String args[]){

student s1=new student("kent",87,91);

}

}

**說明：

在main執行我們自己做的exception，也是要捕捉，不然會出現錯誤，因為非runtime

 

class add{

public static void main(String args[]){

try{

     student s1=new student("kent",87,91);

}catch(Exception e){

}

}

**說明：

所以要用try...catch或throws

使用try...catch和throws兩個的差別     

 

class student{

String name;

int chi;

int eng;

student(String name,int chi,int eng) throws Exception{

if(chi>=0 &&chi<=100 && eng>=0 &&eng<=100){

this.name=name;

this.chi=chi;

this.eng=eng;

     }else{

         throw new Exception();

     }

}

student(int chi,int eng) {

try{

if(chi>=0 &&chi<=100 && eng>=0 &&eng<=100){

this.chi=chi;

this.eng=eng;

}else{

     throw new Exception();

}

}catch(Exception e){

     System.out.println("國文英文分數,0~100");

}

 

}

void show(){

System.out.println("名:"+name+

"\t國文:"+chi+

"\t英文:"+eng

);

}

}

 

(狀況一：add沒有加 throws Exception 或 try...catch)

class add{

public static void main(String args[]){

     //因為main沒有加throws Exception所以compiler會出現錯誤

     //student s1=new student("kent",870,91); 

    //出現 國文英文分數,0~100

student s2=new student(870,91);        

     }

}

 

(狀況二：add有加throws Exception 或 try...catch)

class add{

public static void main(String args[]){

    try{

student[] s={

new student("kent",87,91),   //see 說明4.

new student(86,92),          //see 說明5.

new student("derek",85,93),

};

for(int i=0;i<s.length;i++){

     s[i].show();

}

}catch(Exception e){

     System.out.println("分數:0~100");

}

}

}

**說明

1.如果在寫建構式或方法時，exception是透過throws Exception來處理，則解說要在執行的時候寫在main裡=>此時如果main方法沒有寫throws Exception，編譯就會過不了

2.也可以在寫建構式或方法時， exception 不要透過throws Exception來處理，而是直接在建構式中寫好解說(try...catch寫在建構式中)，可以編譯

3.通常contructor會用try...catch加在裡面，method會用throws Exception的方式

4.在狀況二中，若改為 new student("kent",-87,91)，會outputs "分數:0~100"

5.但在狀況二中，若改為 new student(-86,92)，則會outputs如下內容，先在輸入-86那筆資料的建構式做中斷，然後其他資料還是繼續可以跑，並且跑下面的迴圈，因為try...catch寫在建構式中，生命週期在該筆資料寫入後就結束了，不影響其他筆資料的輸入

**在建構式中的try catch是針對每一筆填入的資料中斷，其他筆資料會繼續做，但放在main中就要確定全部資料都對不然就會中斷不能再填資料，通常前者的用法會用在web讓user填寫資料，因為會同時多人一起進行，不能一個寫錯就全部中斷，只能針對每一筆資料做判斷不影響其他筆資料

例：

假設此時有兩個method，但規則不同，如果同時有兩個不同method出現Exception該如何判斷catch要抓哪個?

 

class student2{

String name;

int chi;

int eng;

student2(String name,int chi,int eng) {

if(chi>=0 &&chi<=100 && eng>=0 &&eng<=100){

this.name=name;

this.chi=chi;

this.eng=eng;

}

}

int sum1(int chi,int eng) throws Exception{

if(chi>=0 &&chi<=100 && eng>=0 &&eng<=100){

this.chi=chi;

this.eng=eng;

     return chi+eng;

}else{

     throw new Exception();

}

}

int sum2(int chi,int eng) throws Exception{

if(chi>=0 &&chi<=200 && eng>=0 &&eng<=200){

this.chi=chi;

this.eng=eng;

return chi+eng;

}else{

     throw new Exception();

}

}

void show(){

System.out.println("名:"+name+"\t國文:"+chi+ "\t英文:"+eng );

}

}

 

class add2{

     public static void main(String args[]){

student2[] s={

new student2("kent",87,91),

new student2("maggie",86,92),

};

for(int i=0;i<s.length;i++){

     s[i].show();

}

try{

     System.out.println(s[0].sum1(60,90)+s[0].sum2(70,80)+s[1].sum1(60,90)+s[1].sum2(70,80));

}catch(Exception e){

     //同時違反兩個規則時，如何判斷要show 0~100 或 0~200

     System.out.println("0~200");  

}

}

}

 

**說明：

1. 要修改分數後再加總，要兩個人都對了才能加總，

2.通常exception都會用在傳值類的method

3.用自訂Eexception

4.要把不同method的檢驗機制放進Exception中，但Exception只能中斷，不過可以提供繼承，把中斷功能繼承給子類別，見下方說明

2.繼承Exception=>自訂Exception Class

class check extends Exception{

check (String msg){

     System.out.println("需介於"+msg);

}

}

 

class student2{

String name;

int chi;

int eng;

student2(String name,int chi,int eng) {

if(chi>=0 &&chi<=100 && eng>=0 &&eng<=100){

this.name=name;

this.chi=chi;

this.eng=eng;

}

}

int sum1(int chi,int eng) throws check{

if(chi>=0 &&chi<=100 && eng>=0 &&eng<=100){

this.chi=chi;

this.eng=eng;

return chi+eng;

}else{

     throw new check("0~100");

}

}

int sum2(int chi,int eng) throws check{

if(chi>=0 &&chi<=200 && eng>=0 &&eng<=200){

this.chi=chi;

this.eng=eng;

return chi+eng;

}else{

     throw new check("0~200");

}

}

void show(){

System.out.println("名:"+name+

"\t國文:"+chi+

"\t英文:"+eng

);

}

}

 

class add2{

public static void main(String args[]){

student2[] s={

new student2("kent",87,91),

new student2("maggie",86,92),

};

for(int i=0;i<s.length;i++){

     s[i].show();

}

try{

     System.out.println(s[0].sum1(60,80)+s[0].sum2(70,280)+s[1].sum1(60,90)+s[1].sum2(70,80));

}catch(check e){  

}

}

}

**說明：

1. check已經自動繼承Exception的中斷功能

2.要記得把class Exception都改成class check，因為已經繼承了改使用class check

3.catch(check e)，這邊如果改成Exception e也可以，而因為多型的概念(Exception 是所有自訂Exception class的共同父類別)=>多型的宣告方式；Exception e=new check()，這邊又是e=new check()，所以換成Exception e也會正確執行

**實例

=>業績<500000時，獎金比=0

=>業績>=500000時，獎金比=0.03

class check1 extends Exception{

check1(String msg){

     System.out.println(msg);

}

}

 

class money {

private String name;

private int x;

private int m;

 

money(String name,int x) throws check1{

if(x>=0){

this.name=name;

this.x=x;

if(x>=500000){

     m=(int)(18000+x*0.03);

}else{

     m=18000;

}

}else{

     throw new check1("業績需大於0");

}

}

 

     void show(){

     S     ystem.out.println("名:"+name+"\t業績:"+x+"\t實領薪資:"+m);

     }

}

class add3{

public static void main(String args[]) throws check1{

     money m1=new money("kelly",560000);

     m1.show();

}

}

**說明：

因為在check1中已經有寫說明了，所以在main程式中不需要再用try...catch來寫說明

同上例，如果事後想要修改業績，因為x為private，所以要寫method來改

void change(int x) throws check1{

if(x>=0){

this.name=name;

this.x=x;

if(x>=500000){

     m=(int)(18000+x*0.03);

    }else{

          m=18000;

    }

}else{

     throw new check1("業績修改需大於0");

}

}

 

class add3{

public static void main(String args[]) throws check1{

money m1=new money("kelly",560000);

m1.show();

m1.change(-6000);

m1.show();

}

}

 

**說明

1.加一個change() method，一樣要做判斷，調整一下判斷顯示的訊息

2如果用錯誤的業績數字輸入修改，此時會自動抓取change()中的判斷

3.outputs為 業績修改需大於0

 

 

 

 

 

 

 

文章標籤

java exception try..catch

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

1.CAL.jar

2.說明文件

ARea(長，寬)=>矩形面積

CARea(半徑)=>圓面積

FV(本金,利率,年)=>本金*(1+利率)年

money(業績)=>獎金比

50萬以上     3%

0~50萬       0

 

本薪=18000

本薪+獎金

*有畫底線所以都是static的

 

●結合昨天的homework.jar和使用者介面

1. 設計版面

2.先匯入昨天完成的jar檔，還要import進來，設定button clicked

3.double要用Double.parseDouble(); 如果要轉字串也可以用String.valueOf()

4.加入程式碼

  private void cal1MouseClicked(java.awt.event.MouseEvent evt) {

  double H=Double.parseDouble(h.getText());

  double W=Double.parseDouble(w.getText());

  area.setText("面積："+math.ARea(H, W));

  }

 

  private void cal2MouseClicked(java.awt.event.MouseEvent evt) {

  double R1=Double.parseDouble(r1.getText());

  carea.setText("圓面積："+math.CARea(R1));

  }

 

  private void cal3MouseClicked(java.awt.event.MouseEvent evt) {

  int P=Integer.parseInt(p.getText());

  double R2=Double.parseDouble(r2.getText());

  int Y=Integer.parseInt(y.getText());

  fv.setText("總計："+company.FV(P, R2, Y));

  }

 

  private void cal4MouseClicked(java.awt.event.MouseEvent evt) {

  int M=Integer.parseInt(m.getText());

  money.setText("實領："+company.money(M));

  }

 

 

5.完成畫面

 

*小數位數的問題可回到CAL.math去修改，重新轉jar就可以用，不需要再import一次

 

*把text field=>properties=>enable勾取取消，則user不能輸入

 

 

6.轉成可執行檔，先在這個完成的介面專案的properties選run，指定main class的位置，再clean and build 一次就可以直接開啟該.jar檔

 

*如果到別台電腦不能開啟這個執行檔，應該是因為沒有安裝jre

 

●Java常用api

1.java.lang.*

2.exception/error(異常)(bug)

(一)執行上的錯誤

a)error=>程式碼直接重寫

b)exception=>加錯誤訊息，一般api文件都會加上exception

**與if最大差別，exception會強制中斷程式執行

 

(二)異常訊息的捕捉

try{

     有問題的程式碼...

}

catch(異常類型  物件變數)

{

     要顯示的錯誤訊息

}

import java.util.Scanner;

class ex1{

public static void main(String args[]){

Scanner sc=new Scanner(System.in);

int n=sc.nextInt();

     for(int i=0;i<=10;i++)

     {

          System.out.println("i="+i+"\thello");

     }

}

}

**說明：

假設輸入的是小數，出現exception如上

1.代表在執行nextInt()時就出現錯誤(ex1.java:5代表錯誤在第5行)，此時就中斷程式不會在往下run for...

2.exception in thread "main" java .util.InputMismatchException;=>執行緒 main出現exception，是被 java .util.InputMismatchException發現的

3.at...，代表這四個scanner的功能都有加上 java .util.InputMismatchException 這個文件的檢查功能

 

正確做法

import java.util.Scanner;

import java.util.InputMismatchException;

class ex1{

public static void main(String args[]){

Scanner sc=new Scanner(System.in);

try{

int n=sc.nextInt();

for(int i=0;i<=10;i++)

{

     System.out.println("i="+i+"\thello");

}

}catch(InputMismatchException e){

     System.out.println("請輸入整數");

}

}

}

**說明

1.在 sc.nextInt()這邊中斷的時候，會new一個exception，再透過"e"這個物件變數抓下來

2.有問題的程式碼一定要放在try裡面不然會抓不到

 

(三)多個異常訊息的捕捉，但是單選，只要有一個符合就會中斷程式

try{程式碼....}

catch(異常1 物件){....}

catch(異常2 物件){....}

import java.util.Scanner;

import java.util.InputMismatchException;

class ex1{

public static void main(String args[]){

     Scanner sc=new Scanner(System.in);

try{

int n=sc.nextInt();

System.out.println("10/n"+10/n);

for(int i=0;i<=10;i++)

{

     System.out.println("i="+i+"\thello");

}

}catch(InputMismatchException e){

     System.out.println("請輸入整數");

}

}

}

 

**說明：

如果輸入0，會被java.lang.AbstractMethodError抓出來整數不能為0的問題

 

正確

import java.util.Scanner;

import java.util.InputMismatchException;

class ex1{

public static void main(String args[]){

Scanner sc=new Scanner(System.in);

try{

int n=sc.nextInt();

System.out.println("10/n"+10/n);

for(int i=0;i<=10;i++)

{

System.out.println("i="+i+"\thello");

}

}catch(InputMismatchException e){

     System.out.println("請輸入整數");

}catch(AbstractMethodError e){

     System.out.println("分母不能為0");

}

}

}

**說明：

e為區域變數所以不會互相影響

 

3.泛型&集合 collection=>8/11

4.io(input/output)=>保留資料

=>file/database

5.thread 執行緒

 

 

文章標籤

api exception try catch 泛型 集合 collection java

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

●package套件(資料夾)

public =>可開放權限到不同套件(資料夾)

protected =>可開放權限到不同套件

deafult=>可開放權限到同一個套件

private =>可開放權限到同一個class

import(只要不是放在java.lang全部都要import)=>但import進來不一定要用來做繼承

 

*實作案例

UML：(#：protected)

1.先建立資料夾

=>專案下很多個資料夾，用dos去編譯會習慣停在專案的最上層位置，然後編譯時指定路徑

 

**做interface student2的說明

a.指定路徑要在最前面加上package，這樣java才找的到路徑，從專案最上面開始寫 ，如：package school.stu;

b.這就是一個school專案，找的方式是school中的stu中的student2.class

c.以後做資料夾要習慣在最前面指定路徑

2.開始寫 A.class

狀況一：

A.java

package school.sa;

class A extends student {

     private int chi;

}

**說明

1.如果如上作法，會發現錯誤訊息，代表找不到student class，因為java會先去school.sa找這個class，找不到就會去java.lang找，但還是找不到就出現上述訊息

2.所以要指定路徑，使用import，寫在package和class中間

3.寫import要寫到class name為止

 

正確寫法：

A.java

package school.sa;

import school.stu.student;

class A extends student {

     private int chi;

}

 

狀況二

A.java

package school.sa;

import school.stu.student;

class A extends student {

     private int chi;

}

**說明

1.import後還是出現錯誤訊息，因為要對方授權了才能使用student class(因為在不同資料夾)

2.所以在student class前加上public=>public class student{...}

 

狀況三

**說明

1.開放了student class的權限以後，還是有錯誤訊息，因為student的建構式不是public，super不能存取不同套件的建構式()

2. 查完class就會去查建構式所以要一起改不然無法繼承，所以改成public student(String name){ this.name=name; }

 

implements student2的做法比照上述辦理

student2.java

package school.stu;

public interface student2{  }

 

A.java

package school.sa;

import school.stu.student;

import school.stu.student2;

class A extends student implements student2{....}

 

**說明

A.class要implements interface student2也是如上做法，先import並開放權限

 

2.寫B.class，做法與A.class同，留意資料夾位置即可

B.java

package school.sb;

import school.stu.student;

import school.stu.student2;

 

class B extends student implements student2{

private int eng;

B (String name,int eng){

super(name);

this.eng=eng;

}

}

 

3.先測試一下上述內容，編寫main程式

狀況一

add.java

package school.main;

class add{

public static void main(String args[]){

     student s=new student("kent");

}

}

**說明

1.出現錯誤訊息，找不到student class

2.所以要加入import school.stu.student;

 

狀況二

//要測試show()功能

add.java

package school.main;

import school.stu.student;

class add{

public static void main(String args[]){

student s=new student("kent");

System.out.println(s.show());

}

}

**說明

1.加了以後還是有錯誤訊息，因為show()的權限還沒開放

2.即使在class前面加了public也不代表裡面的內容都一起開放權限了，要改成如下：

public String show(){ return "名:"+name; }

3.在dos執行時，寫路徑的方式要調整，因為要送到java虛擬主機，所以要寫成java  school.main.add

 

class A比照 class student辦理

A.java

package school.sa;

import school.stu.student;

import school.stu.student2;

public class A extends student implements student2{

private int chi;

public A(String name,int chi){

super(name);

this.chi=chi;

}

}

 

add.java

package school.main;

import school.stu.student;

import school.sa.A;

class add{

    public static void main(String args[]){

student s=new student("kent");

System.out.println(s.show());

A a=new A("MAGGIE",80);

System.out.println(a.show());

}

}

**說明

1.要先import A的路徑

2.在A class和A的建構式前面加上public

 

4.把A.class對父類別做override

A.java

package school.sa;

import school.stu.student;

import school.stu.student2;

 

public class A extends student implements student2{

private int chi;

public A(String name,int chi){

super(name);

this.chi=chi;

} public String show(){

     return super.show()+"\t國文:"+chi;

}

}

**說明：

add.java不用改，就可輸出=>名:MAGGIE   國文:80

 

5. 把B.class對父類別做override

B.java

package school.sb;

import school.stu.student;

import school.stu.student2;

 

public class B extends student implements student2{

private int eng;

public B (String name,int eng){

super(name);

this.eng=eng;

}

public String show(){

     return super.show()+"\t英文:"+eng;

}

}

 

**說明：

1.add.java加入下述內容

B b=new B("may",87);

System.out.println(b.show());

2輸出=>名:may   英文:87

 

6.完成A_1.class，並在add測試

A_1.java

package school.sa;

import school.stu.student2;

 

public class A_1 extends A implements student2{

private int math;

public A_1(String name,int chi,int math){

super(name,chi);   

this.math=math;

}

public String show(){

     return super.show()+"\t數學:"+math;

}

}

 

add.java

package school.main;

import school.stu.student;

import school.sa.A;

import school.sb.B;

import school.sa.A_1;

class add{

public static void main(String args[]){

student s=new student("kent");

System.out.println(s.show());

 

A a=new A("MAGGIE",80);

System.out.println(a.show());

 

B b=new B("may",87);

System.out.println(b.show());

 

A_1 a1=new A_1("ANDY",65,91);

System.out.println(a1.show());

       }

}

 

**說明：

1.因為A_1和A放在同一個資料夾，所以不需要import A

2.add也要記得import A_1

3. A_1的建構是繼承A，要記得super()中是兩個引數

 

**注意：

假設把A_1 class放到A.java下會出現下列訊息

因為當有package時，多個class要寫在同一個檔，只能有一個public，如果要寫另外public一個要重新宣告一個檔

 

protected的說明，在studetn class加上一個protected的show2()

student.java 加上

protected String show2(){

return "name:"+name;

}

 

A.java 改成

public String show(){

return show2()+"\t國文:"+chi;

}

 

add.java 加上

student s=new student("kent");

System.out.println(s.show2());

執行時=> 出現錯誤訊息

 

正確做法 

add.java

A a=new A("MAGGIE",80);

System.out.println(a.show());

 

**說明：

1.protected和public都可以透過import來給不同資料夾的class使用

2.兩者的差別在於使用時，protected限定給子類別繼承用，沒有開放透過new物件的方式來存取，所以要使用就要寫一個子類別去繼承他來用

3.所以用a.show()就不會有問題，因為在A class已經繼承show2()來用

 

● 用netbeans做上述例子

1.建立school_2專案，這邊的是專案名稱，而非上述的package最上層名稱

2.在src下=>new=>java package，把資料夾建立好

3.在資料夾下新增class：

interface：new=>java interface

一般class：new=>java class

4.輸入程式碼

**找錯誤可以直接看紅色燈泡，或是點可以在主控台看詳細的錯誤訊息

**view=>show line-numbers勾選才會出現行數編號

**view=>show non-printable characters如果勾選會如下圖，出現段落標記符號

*@override，代表下方的method有作override，可加可不加

● 製作

1.做JAR檔

2.寫說明文件，註解寫法/**..../，因為要給人家用的是建構式和method(field鎖死了)，所以寫在建構式前面

/**

*@參數(ex:author/version/para)

*/

3.練習

package school.sa;

import school.stu.student;

import school.stu.student2;

/**

 *

 * @author:maggie

 * @version:1.0

 * @學員管理系統<br>測試一下換行

 *

 */

public class student {

  private String name;

  public student(String name){

  this.name=name;

  }

/**

 *

 * @return：return the name user input

 */

  public String show(){

  return "名:"+name;

  }

 

說明：

1.之後轉黨會自動轉成html格式，所以可套用html語法ex:斷行要用<br>不是直接按enter，但不可套css

2.package和import不需要說明，所以說明要寫在package和class中間

3.說明要放在要解說的建構式或method前，只要打/**+enter就會自動跳出註解

 

4.轉檔：project名稱上按右鍵=>generate javadoc

=>預設會用ie打開這個轉好的檔案，如果沒有打開，可以到專案資料夾(school2)下的dist/javadoc找index.htm

=>return的說明出現了，但是@author和@version的說明沒出現

 

5.因為預設@author和@version是關閉的，所以要在專案上按右鍵=>properties=>Documenting=>勾選這兩個選項後才會出現

=>也可在這邊設定private是否要顯示，和設定瀏覽器上的網頁名稱

=>設定好關閉ie，重新做generate javadoc

 

**API=>Application Interface/應用程式介面(ex:Netbeans，eclipse)

實際上我們在用的應該是API的函式庫，就是放在jdk/lib下的內容

我們寫出來的class最後也會轉成jar檔(一個封裝壓縮檔，裡面放很多class)

 

7.轉為jar檔，先全部重新編譯一次，按上方的掃把工具，或是在project上面按右鍵選clean and build，下方出現此訊息代表轉檔完成

8.轉檔完後會把dist下的javadoc刪除，所以轉檔完後要再generate javadoc一次，要用的時候就把*.jar和javadoc一起copy出來用

 

9.要拿來使用，先開一個全新的project test，然後新增一個main.java

=>假設我們想要用student的show()功能，直接import school.stu.student;會出現找不到(因為是去java.lang找)

=>要在專案右鍵選properties=>Libraries=>Add JAR/Folder 指定jar檔的路徑

以後自己寫好的jar都可以這麼做

=>如果要用A就要import A， 要用B就要import B

 

---

  ● wrapper類別(包覆類別)

針對基本類別設計一個class出來，可以定義普通變數，也可以提供method(因為本身是class)，有些甚至有建構式

=>這些method主要拿來轉型(casting)用(ex:字串轉整數)

=>在java.lang可查

ex:

Byte x=10; 和 byte x=10; 兩個一樣都只是用來定義普通變數

parseByte(String s)=>把String 轉成 byte等級的類型

=>通常是拿來把字串轉其他類別，因為鍵盤輸入的都是字串

 

ex:以昨天的netbeans練習為例 

  String Name=name.getText();

  //Interger class下的parseInt()method

  int Chi=Integer.parseInt(chi.getText());

  int Eng=Integer.parseInt(eng.getText());

  System.out.println("姓名:"+Name+

  "\n國文:"+Chi+

  "\n英文:"+Eng+

  "\n總分:"+(Chi+Eng));

  

● jar檔

靜態=>將class功能import來用

動態=>有main程式，可以直接操作

 

● 昨天範例要顯示加總內容，使用setText():void，內容限定字串(輸出輸入都要是字串，只有中間計算才轉換類型)

1.先把panel和textarea使用者畫面設計好，variable name設定為show

2.把原本的System.out.println改為show.setText();

  String Name=name.getText();

  int Chi=Integer.parseInt(chi.getText());

  int Eng=Integer.parseInt(eng.getText());

  show.setText("姓名:"+Name+

  "\n國文:"+Chi+

  "\n英文:"+Eng+

  "\n總分:"+(Chi+Eng));

 

 

文章標籤

javadoc jar java package wrapper

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