Java學習筆記－進階類別（Class）

類別（Class）－進階

繼承

若要將類別a繼承類別b的成員變數、方法，則需在宣告類別時加上extends：

class a extends b

繼承他類別（父類別）的類別（子類別）將會擁有其所有的成員。

super

當父類別有建構子時，子類別須以super(建構子)給予父類別建構子。
當子類別的成員方法與父類別的成員方法衝突時，須在使用父類別成員方法時於前面加上super.。

範例：

class test1{
        private int x, y;
        public test1(int x, int y){
                this.x = x;
                this.y = y;
        }
        public void getValue(){
                System.out.println("x = " + x);
                System.out.println("y = " + y);
        }
}
class test2 extends test1{
        private int z;
        public test2(int x, int y, int z){
                super(x, y);
                this.z = z;
        }
        public void getValue(){
                super.getValue();
                System.out.println("z = " + z);
        }
}
public class example{
        public static void main(String[] args){
                test2 x = new test2(3, 5, 8);
                x.getValue();
        }
}

靜態（static）

當成員宣告為靜態時，將不受主程式宣告影響，只會有一個。

程式

輸出

class test{
        private static int count = 0;
        public test(){
                count ++;
        }
        public void getCount(){
                System.out.println("Count: " + count);
        }
}
public class example{
        public static void main(String[] args){
                test x = new test();
                x.getCount();
                test y = new test();
                y.getCount();
                test z = new test();
                z.getCount();
        }
}

Count: 1
Count: 2
Count: 3

final
- 宣告在類別
  當final宣告在類別上時，該類別將無法被繼承。
- 宣告在函數
  當final宣告在函數上時，子類別將無法覆寫。
- 宣告在變數
  當final宣告在變數上時，該變數將被定義為常數，無法再進行修改。
protected
使用方法與public（公開）、private（隱藏）相同，功能為僅供父類別與子類別使用，可說是介於public與private之間。

抽象（Abstract）

定義類別時，可以僅宣告方法名稱而不輸入方法內容，這種方法成為抽象方法，
而包含了抽象方法的類別則稱為抽象類別。

範例：

程式

輸出

abstract class AbstractTest{
        private int x;
        public abstract void getX();
}
class test extends AbstractTest{
        private int x;
        public test(int x){
                this.x = x;
        }
        public void getX(){
                System.out.println("x = " + x);
        }
}
public class example{
        public static void main(String[] args){
                test x = new test(3);
                x.getX();
        }
}

x = 3

多形（Polymorphism）

多形（Polymorphism）是物件導向程式設計的重要觀念，可以讓應用程式更容易擴充。
因為不須針對不同資料型態分別建立類別，而是繼承一個基礎類別來建立同名方法，
如此就可以處理不同資料型態，當要新增新的資料型態也變得十分容易。

範例：

程式

abstract class shape{
        protected double value;
        public abstract void volume();
}
class ball extends shape{
        public ball(double radius){
                value = (4/3)* Math.PI * Math.pow(radius, 3);
        }
        public void volume(){
                System.out.println("球體積：" + value);
        }
}
class cube extends shape{
        public cube(double length, double width, double height){
                value = length * width * height;
        }
        public void volume(){
                System.out.println("立方體體積：" + value);
        }
}
class pyramid extends shape{
        public pyramid(double surface, double height){
                value = (surface * height)/3;
        }
        public void volume(){
                System.out.println("錐體體積：" + value);
        }
}
public class example{
        public static void main(String[] args){
                shape s;
                ball b = new ball(5.0);
                cube c = new cube(4.0, 8.0, 7.0);
                pyramid p = new pyramid(14.0, 4.0);
                for(int i=1;i<=3;i++){
                        if(i == 1)
                                s = b;
                        else if(i == 2)
                                s = c;
                        else
                                s = p;
                        s.volume();
        }
}

輸出

球體積：392.6990816987241
立方體體積：224.0
角錐體積：18.666666666666668

巢狀類別（Nested Classes）

如同成員變數與成員方法一樣，類別的成員也能是成員類別。

注意：成員類別的成員不得宣告為static。

範例：

程式

輸出

class OuterClass{
        private int outerNum;
        public OuterClass(int outerNum){
                this.outerNum = outerNum;
        }
        public void printOuterNum(){
                System.out.println(outerNum);
        }
        class InnerClass{
                private int innerNum;
                public InnerClass(int innerNum){
                        this.innerNum = innerNum;
                }
                public void printInnerNum(){
                        System.out.println(innerNum);
                }
}
public class example{
        public static void main(String[] args){
                OuterClass outer = new OuterClass(25);
                outer.printOuterNum();
                OuterClass.InnerClass inner = outer.new InnerClass(5);
                inner.printInnerNum();
        }
}

25
5

介面（Interface）

介面（Interface）可以建立單一物件多型態以及提供多重繼承的功能。

範例（搭配抽象類別）：

程式

abstract class shape{
        public double x, y;
}
interface AreaInterface{
        final double PI = Math.PI;
}
class circle extends shape implements AreaInterface{
        private double radius;
        public circle(double x, double y, double radius){
                this.x = x;
                this.y = y;
                this.radius = radius;
        }
        public void area(){
                System.out.println("x = " + x);
                System.out.println("y = " + y);
                System.out.println("radius = " + radius);
                System.out.println("園面積：" + (PI * radius * radius));
        }
public class example{
        public static void main(String[] args){
                circle c = new circle(5.0, 7.0, 8.0);
                c.area();
                System.out.println("PI = " + AreaInterface.PI);
        }
}

輸出

x = 5.0
y = 7.0
radius = 8.0
園面積：201.06192982974676
PI = 3.141592653589793

套件（API）

套件為將相關的類別與介面做集合，如此一來不但能達到保護的功能，更能讓使用上更加方便。

範例（多個檔案至於同一package中）：

程式

package package_test

shape.java

public interface shape{
void area();
}

circle.java

public class circle implements shape{
        private double radius;
        public circle(double radius){
                this.radius = radius;
        }
        public void area(){
                System.out.println("圓面積： + Math.PI * radius * radius);
        }
}

rectangle.java

public class rectangle implements shape{
        private double length, width;
        public circle(double length, width){
                this.length = length;
                this.width = width;
        }
        public void area(){
                System.out.println("矩形面積： + length * width);
        }
}

packageExam.java

import package_test.circle;
import package_test.rectangle;
public class packageExam{
        public static void main(String[] args) {
                circle c = new circle(6.0);
                rectangle r = new rectangle(10.0, 15.0);
                c.area();
                r.area();
        }
}

輸出

圓面積：113.09733552923255
矩形面積：150.0

類別（Class）－進階

繼承

super

靜態（static）

final

宣告在類別

宣告在函數

宣告在變數

protected

抽象（Abstract）

多形（Polymorphism）

巢狀類別（Nested Classes）

介面（Interface）

套件（API）