Teamview 簡便的遠端桌面軟體

一個簡單易用的遠端桌面軟體，
不需註冊也不需要知道對方IP位址，可突破防火牆封鎖
就可遠端連線控制對方電腦或讓對方遠端控制自己電腦，
也可作兩台電腦間的檔案傳輸

參考文章(下載)：Teamviewer 免安裝中文版
##ShowAll##

JAVA筆記-覆寫equals()與hashCode()

之前寫Collection，看到這兩個方法，就很想使用
但要用的近乎人意，卻要很費一番功夫

沒有被覆寫的equals是比較兩物件的參考位置，物件不同則傳回false
若要比對兩物件屬性內容值，則要自己覆寫
並且也一併覆寫hashCode，不同物件會有不同hash code
若兩物件equals()相等，hashCode()也必須相等，否則可能會有錯誤問題
尤其是Hash-Based Collection會用到

/* equals()覆寫例子 */

public boolean equals(Object obj) {

  //若同一物件則true
  if (this == obj) return true;

  //getClass()會可用來判斷物件是否屬於同一類別
  if(obj != null && getClass() == obj.getClass()){
    if(obj instanceof Ball) {
      Ball ball = (Ball)obj;
      //比對屬性內容值
      if (tradeMark.equals(ball.tradeMark) &&
          kind.equals(ball.kind) &&
          color.equals(ball.color)) {
        return true;
      }
    }
  }
  return false;
}


覆寫hashCode()不容易，
使用jakarta所提供的HashCodeBuilder類別，
下載commons-lang-2.1.jar，
看到這裡，懶惰的我，也想放棄了，
真的要用到再說吧！

/* hashCode()覆寫例子 */

import org.apache.commons.lang.builder.HashCodeBuilder;//加入外掛

public int hashCode() {
  return new HashCodeBuilder(17, 37). //應放入兩個質數
    append(tradeMark). //利用append()加入參與的物件變數
    append(kind).
    append(color).
    toHashCode(); //最後取得hash code數值
}


JAVA筆記-initializer實做區塊

{...}單獨放在class內是用來初始實做區塊
分為兩種instance initialize、static initialize

在instance initialize區塊，
編譯器會將其內部的程式碼複製到每個建構子中，
若原initialize區塊和instance initialize區塊中有定義相同的變數
則會以initialize的定義為主，
而該變數不會被instance initialize的定義覆蓋

至於static initialize則不會被複製到建構子中，會用來初始化靜態變數，
static initialize不能存取一般的instance物件變數，
但instance initialize是可存取static和non-static的成員變數

public class InitializerSample {
  String id;
  int birthday;
  String name;
  static int money;

  InitializerSample() {}
  InitializerSample(int kind) {}

  //instance initialize
  {
    id = "A123456789";
    birthday = 20050101;
    name = "pcschool";
  }

  //static initialize
  static {
    money = 10000;
  }
}



JAVA筆記-多個繼承時，使用型別轉換要注意

進行物件型別轉換時，多個繼承容易撰寫錯誤，
未避免執行風險，加上instanceof判斷式

class Animal extends Organism{...}
class Mammalian extends Animal{...}
Animal animal = null;
if(new Mammalian() instanceof Animal){
  animal = (Animal)new Mammalian();
}
##ShowAll##

JAVA筆記-靜態內部類別的存取權限

一般類別+內部類別+static的存取關係真是複雜
難怪當初看JAVA我會不由自主的想先跳過
沒事不要寫這麼複雜關係的程式碼，
如果要用到一本書要放在旁邊就是了

靜態外部類別的內部類別同樣是被放在Global記憶體區塊，
所以內部類別不管有沒有宣告static，都可互相看見而存取
(其實一般使用靜態類別時，本身內部就沒有設定static，
成員變數本來就互相看見，多設定一道static，
它還是放在Global記憶體內，當然還是會可以看見)

靜態類別本身是沒有this指標，也不需要new建立實體
但靜態內部類別的non-static成員會有this指標指向自己，
(這一段話我感到有點含糊，靜態內部類別裡的non-static成員為什麼會有this指標？)
所以靜態內部類別可以同時定義static和non-static成員，
因此，也可用new來建立靜態內部類別的實體

class MyOuter {
  private int x = 7;
  static private int sx = 9;

  static class MyStatic {
    private int x = 77;
    static private int sx = 99;
    public void fooA() { // non-static member
      System.out.println("static inner class A.");
      System.out.println(sx); //
      System.out.println(MyOuter.sx); //
      System.out.println(x); //
      System.out.println(this.x); //
      //static inner class中沒有MyOuter的this指標
      //System.out.println(MyOuter.this.x);
    }

    public static void fooB() { // static member
      System.out.println("static inner class B.");
      System.out.println(sx);
      System.out.println(MyOuter.sx);
    }
  }
}

public class StaticInnerClass {
  public static void main(String[] args) {
    //MyOuter.MyStatic.fooB();
    MyOuter.MyStatic s = new MyOuter.MyStatic();
    s.fooA();
    s.fooB();
  }

執行結果：
99
9
77
77

99
9

JAVA筆記-用匿名內部類別來實作介面

內部類別沒有實際練習過，雖然看懂了用法，
但還是感到含糊，不知道要在怎樣的情況下運用
適合用在程式只會用到一次就不需再使用類別的情況
##ReadMore##
interface Pet {
  void skill();
  void move();
}
public class AnonymousClass {
  public static void main(String[] args) {
    Pet p = new Pet()
    {
      public void skill(){
        System.out.println("我會握手 !");
      }
      public void move(){
        System.out.println("我會跑步 !");
      };
    };
    p.skill();
    p.move();
  }
}


JAVA筆記-import static

只是讓程式少打幾個字，方便程式設計師撰寫程式更清楚明瞭
使用import static的最後指向必須是靜態成員
##ReadMore##
import
import java.lang.System;

out.println("hallo");

import static
import static java.lang.System.out;

out.println("hallo");


JAVA筆記-列舉當一般類別，可用抽象方法和實做

列舉用抽象方法，需自行透過覆寫來實作
public enum Operator {
  //------> 利用匿名類別來實做operate(int x) <------   //加入()的撰寫   PLUSONE(){ int operate(int x){ return x;} },   //可省略()的撰寫   ABS{ public int operate(int x){return x;} };   //抽象方法   abstract int operate(int x); }
列舉可實做介面，但未開放使用繼承
public enum Orderenum implements OrderInterface{}
##ShowAll##

JAVA筆記-列舉當一般類別，可加入方法和屬性

列舉也是類別，當作外部類別時可加入屬性和方法，
但列舉的值必須先宣告，且列舉設定完內容要加分號
且編譯器不會自動加上static final修飾字
##ReadMore##
public enum OrderEnum {
  STOCKNO(2330),
  STOCKPRICE(45.5),
  STOCKQTY(10), //有參數，由OrderEnum(double d)建構子實作
  IDENTIFY(); //無參數，由OrderEnum()建構子實作

  private OrderEnum() { //列舉建構子一定是private
    System.out.println("A");
  }

  OrderEnum(double d) { //列舉建構子會編譯成private
    System.out.println("B");
  }

  public int id; //屬性

  public boolean submit(){ //方法
    return true;
  }
}


JAVA筆記-enum列舉，switch應用

//會自動轉成Week.Monday.ordinal()，用int比對，數值由0遞升
switch(Week.Monday){
  case Monday:
    System.out.println(Week.Monday);
    break;
}
##ShowAll##

JAVA筆記-enum列舉，宣告與輸出

宣告範例：
public enum Week {Sun, Mon, Tue, Wed, Thu, Fri, Sat}

編譯器會將列舉自動加上public、static、final的修飾，
即不被繼承、定義後資料無法更改

輸出值範例：
//輸出單一字串
System.out.print(Week.Sunday);

//輸出列舉內全部字串
Week[] week = Week.values(); //將列舉轉成陣列使用
for(int i=0; i<week.length; i++) //取得列舉長度
  System.out.print(week[i] + ", ");


覆寫toString()，因值而異的類實作
enum Grade {
  A{public String toString(){return "a"}}, B, C, D
}
System.out.print(Week.A); //結果輸出的是a


JAVA筆記-介面與抽象類別的差異

介面與抽象類別內的皆可宣告抽象方法，
且不可直接建立實體，必須由其他類別來實作出來，
所以也容易混淆

目的上 =>
interface是制定訊息接收者的規格，模擬類別的多重繼承
abstract class則是制定部分物件的規格，並且制定訊息接收者的規格，為多型作準備。

使用上 =>
interface用來被實作，abstract class則是用來被繼承

概念上 =>
abstract class：
可以想像手機物件基本上該有哪些功能，然後將那些功能名稱定義好，
一定也有一些功能是所有手機都一樣的！也可以先都寫好。　　　　　
定義好之後，開發手機軟體的廠商就可以依據這些已定義好的method來撰寫
interface：
顧名思義就是不同系統、或是不同世界的中介橋樑，　　　
只注重介面格式，而不理會實作內容。　　　
如：人跟電腦的溝通介面是什麼？螢幕、鍵盤、滑鼠等...　　　　　
人跟手機的溝通介面是什麼？螢幕、鍵盤等...　　　
所以一個物件可以有很多個介面，像手機的鍵盤面板，　　　
今天高興換紅色，明天工作開心換藍色，
因為介面是一樣的，所以可以隨便更換面板。

差異上 =>
1.
interface的方法全都是抽象方法
abstract則有一般方法和抽象方法
抽象方法指的是沒有「實作」出來的方法
2.
interface與abstract類別都不能直接用來建立物件實體，
必須由一個標準類別來繼承它，實作其抽象方法，
然後再以此建立物件實體。
3.
interface可多重繼承interface
abstract只能單一繼承
3.
interface沒有建構子
abstract有建構子
4.
interface沒有內建的super與this變數
abstract有內建的super與this變數
5.
interface的成員變數全都是static final型式
abstract類別的成員變數比照一般類別
6.
interface內的方法只可封裝public、default
abstract內的方法只可封裝public、default、protected
7.
需要使用迂迴的方式去找出實體類別間的對應關係，
所以與抽象類別的速度相比之下較為緩慢

介面與類別一起使用的參考想法 =>
先為了某些機制建立一個介面，然後再設計一個抽象類別實作這個介面

JAVA筆記-abstract class抽象類別，由子類別實作

宣告型式：
[存取修飾元] abstract class 類別名稱 [implements ...] [extends ...]

抽象類別由子類別用extends來實作，不可用new建立實體
抽象類別內的方法可以使用一般方法和抽象方法，
而抽象方法要加abstract，
並且不可用private，因為子類別無法實作沒有道理

abstract class Car {
  public void power(){}
  abstract void move();
}
public class Tank extends Car{
  public void move(){
    Syatem.out.println("Track");
  }
}


JAVA筆記-final的意義

1. final+屬性 => 一經定義後，就不可再變更值(即常數)
2. final+方法 => 不可再被覆寫
3. final+類別 => 不可再被繼承

JAVA筆記-interface介面，解決多重繼承問題

為一種標準、規範，只是做規格、功用的定義宣告
由於extends不能單一繼承一般類別，為了達到多重繼承的目的，
在介面類別中可以多重繼承介面類別，來模擬一般類別的多重繼承
多重繼承寫法：extends 介面類別1, 介面類別2 ,介面類別3 ...
必須全部都是介面類別
介面宣告寫法：[存取權限] interface 介面名稱 [extends ...]

使用介面的類別用implements來實作，不可用new建立實體
且全部方法都會編譯成抽象方法
實作介面寫法：[存取權限] class 類別名稱 implements [extends ...]


public interface Pet {
  String attr = "cute"; //必須給予初值
  void skill(); //不能實作函式
  void move(); //不能實作函式
}

javac會自動編譯成下方程式碼
public interface Pet {
  public static final String attr = "cute";
  public abstract void skill();
  public abstract void move();
}

所以存取權限必須只能用default和public，否則會錯誤


下方程式碼寫了一個Dog來實做Pet
public class Dog implements Pet{
  public void skill(){
    System.out.println("玩球");
  }
  public void move(){
    System.out.println("跑跑跳跳");
  }
  public static void main(String[] args) {
    Dog dog = new Dog();
    dog.skill();
    dog.move();
  }
}


JAVA筆記-instanceof多型使用方法

用不同型別的宣告，建立繼承物件的實體，
使用的是實做物件的函式與屬性
##ReadMore##
/******************
Animal: move()
Bird: move()
Cat: move()、skill()
Tiger: skill()
Bird、Cat繼承Animal
Tiger繼承Cat
*******************/

class Animal {
  public void move() {
    System.out.println("移動...");
  }
}
class Cat extends Animal {
  public void move() {
    System.out.println("跑跑跳跳...");
  }
  public void skill() {
    System.out.println("洗澡...");
  }
}
class Bird extends Animal {
  public void move() {
    System.out.println("蹦蹦飛飛...");
  }
}
class Tiger extends Cat {
  public void skill() {
    System.out.println("守獵...");
  }
}

public class Zoo {
  public static void main(String[] args) {

    //ex1
    Tiger a = new Tiger();
    t.skill; //呼叫Tiger的method
    t.move; //呼叫Tiger的method

    //ex2
    Cat c = new Tiger();
    c.skill; //呼叫Tiger的method
    c.move; //呼叫Tiger的method

    //ex3
    Animal a = new Tiger();
    a.move; //呼叫Tiger的method
    a.skill; //編譯錯誤
    //Animal型別沒有skill()，無法使用Tiger的函式

    /*********************
    //ex4
    Animal a = new Tiger();
    ((Tiger)a).skill; //呼叫Tiger的method
    ((Brid)a).move; //編譯正確
    //但是Tiger並不是繼承Brid，執行時會錯誤
    //必須加上條件式if(a instanceof Brid)，傳回false則代表不可轉型
    //instanceof是用來判斷某個類別是否實作了某個介面
    *********************/
  }
}
  


JAVA筆記-extends繼承關係下的建構子

class Father {
  Father(){System.out.println("A")};
}

class Son extends Father{
  Son(){
    //super();//自動加入在建構子第一行，而執行super建構子
    System.out.println("B")};
}

public class Example{
  public static void main(String[] args){
    Son son = new Son();
  }
}

##ReadMore##
結果輸出：
A
B

PS：若super類別的建構子有需要參數，則必須自行輸入，否則可能錯誤
       在static中，沒有this和super的參照，所以不能用這兩個相關指令

Adobe Flash Player 看線上影片必備安裝

上網必備，作業系統沒有內建Adobe Flash Player就直接安裝吧！

參考文章(下載)：Adobe Flash Player 離線安裝版（內建 IE、Firefox 版及移除工具）

Http File Server(HFS) HTTP的檔案伺服器

類似FTP Server，但這套軟體傳輸速度比較不穩定
基本上FTP Server上該有的功能幾乎都具備
好處是可以直接用IE呈現，架站非常簡單，也不需額外使用客戶端軟體
臨時傳檔給朋友最方便，那還需要FTP嗎？

最好使用2.2以上英文版本，網頁上會有folder archive的字串
可讓使用者直接在網頁上打包下載整個資料夾
而且更重要的是還可編輯HTML網頁，這軟體真大心的

參考文章(下載)：HFS 檔案伺服器