在課堂上使用一個靜態值extends

-2

我想使用一個方法使用一個常數，根據她被調用的類。對不起，這個不好解釋，這裏有一個例子：在課堂上使用一個靜態值extends

public class Mom{ 
    public void execute(parameters){ 
     // Some actions 
     String nf = String.format(C_CARS) 
    } 
} 

public class Son1 extends Mom{ 
    private static final String C_CARS=" myFormat " 
} 


public class Son2 extends Mom{ 
    private static final String C_CARS=" myFormat2 " 
} 

public static void main(String[] args){ 
    Son1 son1=new Son1(); 
    Son2 son2=new Son2(); 
    son1().execute(myparameters); 
    son2().execute(myparameters); 
}

我願做這樣的事情，有沒有辦法？這裏的問題是C_CARS在Mom類中是未知的。

來源

2017-10-19 C.Norris

媽媽班是Son1和Son2班的超級班。因此，子類變量不能在超類中訪問。 – Karan

即使Java字段是多態的，你如何期望這種方法對'class Son3 extends Mom {/ * no constant * /}'有效？ –

覆蓋Son1和Son2類中的'execute'方法。 – Karan

這是不繼承在Java中是如何工作的。

您需要保證Mom的所有實例都有一個值。通過一個實例方法來完成，例如

public abstract class Mom{ 
    public void execute(parameters){ 
    String nf = String.format(getCCars()); 
    } 
    protected abstract String getCCars(); 
}

然後在子類實現：

class Son1 extends Mom { 
    @Override protected String getCCars() { 
    return "something"; 
    } 
}

也有一些是與你的面向對象的設計。

請記住：Son1類的每個實例也是Mom的實例。但在現實世界中，大多數兒子都不是母親。

extends在這裏使用是不正確的。

來源

2017-10-19 07:33:26

您不能以這種方式覆蓋變量。使用方法代替：

abstract public class Mom { 
    abstract protected String cCars(); 

    public void execute(parameters){ 
     // Some actions 
     String nf = String.format(cCars()) 
    } 
} 

public class Son1 extends Mom{ 
    private static final String C_CARS=" myFormat "; 

    @Override 
    protected String cCars() { 
     return C_CARS; 
    } 
}

或者，你可以在Mom提供一個默認的實現，那麼就沒有必要使類和方法抽象。

來源

2017-10-19 07:30:45 Henry

請勿使用static，否則會帶來麻煩。

public class Mom { 
    private final String cCars; 
    protected Mom(String cCars) { 
     this.cCars = cCars; 
    } 
    public void execute(parameters){ 
     // Some actions 
     String nf = String.format(cCars) 
    } 
} 

public class Son1 extends Mom { 
    public Son1() { 
     super(" myFormat "); 
    } 
} 


public class Son2 extends Mom { 
    public Son2() { 
     super(" myFormat2 "); 
    } 
}

來源

2017-10-19 07:31:11

這不能工作，因爲超類無法訪問它的子類的成員。此外，你不能重寫一個變量，就像你可以覆蓋方法一樣。請使用下面的代碼代替它：

public static abstract class Mom { 
    public void execute() { 
     System.out.println(getCCars()); 
    } 

    abstract String getCCars(); 
} 

public static class Son1 extends Mom { 

    @Override 
    String getCCars() { 
     return " myFormat "; 
    } 
} 

public static class Son2 extends Mom { 

    @Override 
    String getCCars() { 
     return " myFormat2 "; 
    } 
} 

public static void main(String[] args) { 
    Son1 son1 = new Son1(); 
    Son2 son2 = new Son2(); 
    son1.execute(); 
    son2.execute(); 
}

這是您在java中使用它的方式。

我測試了上面的代碼。它編譯併產生期望的結果。

來源

2017-10-19 07:32:16 Twometer

標記爲static的字段屬於該類而不是實例。另外，C_CARS在Son1與C_CARS在Son2沒有任何關係。

實現這樣的東西的方式是這樣的：
```
class Mom { 
    public abstract String getCCars(); 
} 
```
接着的Mom每個方興未艾必須重寫getCCars()方法。

您還可以在Mom的構造函數中接受字符串cCars。然後，每個方興未艾必須調用Mom定義的超級構造函數：

class Mom { 

    final String cCars; 

    Mom(String cCars) { 
     this.cCars = cCars; 
    } 

    void execute(String parameters) { 
     System.out.println(this.cCars); 
    } 
} 

class Son1 { 

    Son1() { 
     super("MyFormat"); // We have to call the super constructor 
    } 
}

來源

2017-10-19 07:32:21

在課堂上使用一個靜態值extends

回答

相關問題