如何操作java中的類

Question

我知道sereval編程語言。其中大多數是腳本語言，如lua，perl，JS，ruby et.c.

但是最近，我開始用Java編程，這個工作很安靜。所以我一直在想JS中存在的某個函數。構造函數的原型，即。爲了進一步理解我的問題，我將以JS爲例。假設你想創建一個狗的應用程序。

function dog(){ 
this.property1 = value; 
this.propertr2 = value2; 
this.propertyN = valueN; 
//et.c. 
} 

//now, I will create sereval instances of the constructor in JS 

var snoopy = new dog(); 
var buddy = new dog(); 

和要命的一部分，我知道JS是可以動態改變 構造的信息和所有是構造 的（因爲它是所謂的實例JS）與原型關鍵字如下：

dog.prototype.bark = function() { 
console.log("Woof!"); 
}; 

而這，不僅改變了信息的回合構造函數，以便每一隻用構造函數創建的狗都會知道如何吠叫，它也會發生變化，以便構造函數的所有實例都可以獲取原型插入的信息，在這種情況下教狗如何吠叫。至極，我們可以在下面的例子中看到：

var someOtherDog = new dog(); 
someOtherDog.bark(); //output will be: Woof! 
snoopy.bark();  //output will also be: Woof! 
buddy.bark();  //you guest it! it will also be: Woof! 

所以用這個原型關鍵字JS我可以操縱的構造及其實例。現在，我的問題是：

如何操作java中的類和它們的實例？這甚至可能嗎？ ，如果是的話;我應該怎麼做才能在java中做這樣的事情？

class dog 
{ 
    private String hairColor; 
    public dog() 
    { 
     hairColor = "Brown"; 
    } 
    public static void main (String args[]) 
    { 
     dog snoopy = new dog(); 
     dog buddy = new dog(); 
     //now, how do I manipulate the class like I did in JS? 
    } 
} 

Answer 1

如果需要，您可以隨時創建匿名類。

假設你有一個類：

class Dog { 
    String name; 
    Dog(String name) { this.name = name; } 
    void bark() { System.out.println(name + " says 'woof!'"); } 

    public static void main(String...args) { 
     Dog snoopy = new Dog("snoopy"); 
     snoopy.bark(); 
    } 

} 

這裏的結果

c:\files\j>javac Dog.java 

c:\files\j>java Dog 
snoopy says 'woof!' 

現在夥計，他不說緯 - 他說汪！因此，我們即時創建一個像這樣

class Dog { 
    String name; 
    Dog(String name) { this.name = name; } 
    void bark() { System.out.println(name + " says 'woof!'"); } 

    public static void main(String...args) { 
     Dog snoopy = new Dog("snoopy"); 
     snoopy.bark(); 
     Dog buddy = new Dog("buddy") { 
      @Override void bark() { System.out.println(name + " says 'ruff!'"); } 
     }; 
     buddy.bark(); 
    } 

} 

如果你想永久改變每條狗在

c:\files\j>javac Dog.java 

c:\files\j>java Dog 
snoopy says 'woof!' 
buddy says 'ruff!' 

導致，則變得更加困難，但可以通過策略模式來完成。

比方說，我們有以下

abstract class BarkingStrategy { 
    public abstract void doBark(Dog dog); 
} 

class TypicalBarkingStrategy extends BarkingStrategy { 
    public void doBark(Dog dog) { System.out.println(dog.getName() + " says 'woof!'"); } 
} 

class AggressiveBarkingStrategy extends BarkingStrategy { 
    public void doBark(Dog dog) { System.out.println(dog.getName() + " says 'Rrrruff!'"); } 
} 

class Dog { 
    // notice this is static - that means it belongs to the class itself, not 
    // any particular instance of it - similar to prototype 
    static BarkingStrategy bark = new TypicalBarkingStrategy(); 
    String name; 
    Dog(String name) { this.name = name; } 
    String getName() { return name; } 
    void bark() { bark.doBark(this); } 
} 

然後，你可以做以下

public static void main(String...args) { 
    Dog snoopy = new Dog("snoopy"); 
    snoopy.bark(); 
    Dog.bark = new AggressiveBarkingStrategy(); 
    snoopy.bark(); 
} 

這導致在JavaScript

c:\files\j>javac Dog.java 

c:\files\j>java Dog 
snoopy says 'woof!' 
snoopy says 'Rrrruff!' 

Answer 2

的事情是，無論是LUA和JavaScript是基於原型，Java不是。你可以使用反射來完成類似的事情，但不能在JavaScript的層面上完成。 Reflection

Answer 3

繼承由原型鏈來實現。基本上，當在snoopy對象中找不到bark時，可以在其原型snoopy.prototype中查找。如果在那裏找到，則使用該版本。如果沒有（例如，當調用bark.toString()時），遍歷原型鏈直到找到具有該成員的原型。原型本身是在所有'實例'之間共享的，因爲它只是一個普通對象，您可以稍後添加或刪除成員。

Java中的繼承是基於類的。除非您重新編譯並重新加載整個班級，否則無法在運行時從班級定義中添加或刪除成員。這是一種不同的編程模式，這意味着您必須使用其他技術和模式對其進行編程（略）不同。