Java 简单的UML图…这个布局正确吗？

我第一次为Java入门课程创建了一个UML图。我很难确定我的类是否正确地相互指向

吉他课应该指向测试课吗？另外，吉他课应该在测试课的左边吗？非常感谢您的指点，谢谢

（我没有足够的参考点插入图像）

代码如下

package guitartest;

import java.util.Scanner;

public class Guitar {

// Declare variables 
private int numberOfStrings;
private String stringName;
private boolean isTuned;
private boolean isPlaying;
private boolean isPlucking;


// Construct a guitar and set boolean fields to "false"
public Guitar(){
    this.isTuned = false;
    this.isPlaying = false;
    this.isPlucking = false;
}   // end constructor


// Prompt user to enter number of strings 
public int getNumberOfStrings() {
    Scanner sc = new Scanner(System.in);

    // Loop continues until a positive integer is entered
    do {
        System.out.println("Enter number of strings in integer format");
        while (!sc.hasNextInt()) {
            System.out.println("Error! That's not a number!");
            sc.next();
        }    // end while
        numberOfStrings = sc.nextInt();
     }    // end do-while loop
     while (numberOfStrings <= 0); 
    return numberOfStrings;
}   // end method getNumberOfStrings

// Prompt user to enter string names
public String getStringName() {
    Scanner sc = new Scanner(System.in);

    // Loop continues until all strings are named
    for (int i = 0; i < numberOfStrings; i++){
        System.out.println("Enter string name"); 
        // Error if input is not a character
        while (!sc.hasNext("[A-Za-z]")) {
            System.out.println("Error! That's not a character!");
            sc.next();
         }
        stringName = sc.next();
    }   // end for loop
    return stringName;
}   // end method getStringName

// Verifies tuning status
public boolean tuneInstrument(){
    return isTuned;
}   // end method tuneInstrument

// Tune guitar
public void setTuned(boolean isTuned) {
    this.isTuned = isTuned;
}   // end method setTuned

// Verifies instrument is playing
public boolean playInstrument(){
    return isPlaying;
}   // end method playInstrument

// 
public void startPlayingInstrument(){
    isPlaying = true;
}   // end method startPlayingInstrument

public boolean pluckInstrument(){
    return isPlucking;
}   // end method pluckInstrument

public void startPlucking(){
    isPlucking = true;
}   // end method startPlucking

// Stop instrument
public void stopInstrument(){
    isPlaying = false;
}   // end method stopInstrument

}   // end class Guitar

package-guitartest；
导入java.util.Scanner；
公共级吉他{
//声明变量
私有整数字符串；
私有字符串字符串名称；
私有布尔值不一致；
私有布尔显示；
私有布尔运算；
//构造一个吉他并将布尔字段设置为“false”
公共吉他（）{
this.isTuned=false；
this.isplay=false；
this.isPlucking=false；
}//结束构造函数
//提示用户输入字符串数
public int getNumberOfStrings（）{
扫描仪sc=新的扫描仪（System.in）；
//循环继续，直到输入正整数
做{
System.out.println（“以整数格式输入字符串数”）；
而（！sc.hasnetint（））{
System.out.println（“错误！那不是数字！”）；
sc.next（）；
}//结束时
numberOfStrings=sc.nextInt（）；
}//结束do while循环
虽然（numberOfStrings您有一个主要问题-方向不应该是从
GuitarTest
到
GuitarTest
，而是相反-从
GuitarTest
到
GuitarTest
（因为您在测试中使用
GuitarTest
）。此外，您还忘记了GuitarTest.main的参数（很明显，但不是很重要）

@米莱斯马在评论中指出，我最初是不正确的，我同意他的看法：

吉他手确实用过吉他，但那是“依赖”关系。
（在本例中，从客户到供应商绘制虚线
吉他手对吉他，这意味着，如果吉他换了，吉他手必须
然而，我不认为在函数体中使用吉他是一个错误
依赖项。（如果将Guitar用作方法的参数、返回类型等，
那么依赖性就得到了保证。）嗯，没有关系
中间

最好查看@milesma答案，它更正确。
吉他手和吉他类不应该有关联关系

如果您有一个“GuitarCase”类（和一个“Cover”类），定义如下：

package guitartest;

import java.util.Scanner;
// Scanner is in the java.util package

public class GuitarTest {

public static void main(String[] args) {

    // Create 10 guitar objects
    Guitar[] guitar = new Guitar[10];

    for (int i = 0; i < guitar.length; i++){
        guitar[i] = new Guitar();


    // Call methods in Guitar class
    guitar[i].getNumberOfStrings(); 
    guitar[i].getStringName();

    System.out.println("Is the guitar tuned? " + guitar[i].tuneInstrument());
    System.out.println("Guitar is being tuned. Please wait...");
    guitar[i].setTuned(true);
    System.out.println("Is the guitar tuned? " + guitar[i].tuneInstrument());

    System.out.println("Is the guitar playing? " + guitar[i].playInstrument());
    System.out.println("Please wait for guitar to play...");
    guitar[i].startPlayingInstrument();
    System.out.println("Is the guitar playing? " + guitar[i].playInstrument());

    System.out.println("Is the guitar being plucked? " + guitar[i].pluckInstrument());
    System.out.println("Please wait for guitar to be plucked...");
    guitar[i].startPlucking();
    System.out.println("The guitar is playing and being plucked. " + guitar[i].pluckInstrument());

    System.out.println("Stopping guitar from playing...");
    guitar[i].stopInstrument();
    System.out.println("Is the guitar playing? " + guitar[i].playInstrument());
    }   // end for loop

}   // end method main


}   // end class GuitarTest

public class GuitarCase{
    public Guitar g;
    public Cover  c = new Cover();
}

然后吉他和吉他之间应该有一个关联，关联端（在吉他端）有角色“g”；吉他和封面之间应该有一个组合，关联端（在封面端）有角色“c”

我甚至不想在图表上显示GuitarTest，因为你可以将主要功能放在吉他本身。
为什么使用吉他数组？你的吉他类不应该有用户界面代码。这些代码应该在其他地方，比如GuitarTest tester类的主方法中。谢谢你的批评。我的项目描述要求我创建一个对象的10个实例（我想是为了证明我理解如何创建和使用数组）。将getNumberOfStrings和getStringName方法的扫描器和循环移动到GuitarTest类的主方法是否合适？我不知道将它们放在何处……我所熟悉的大多数吉他都有一定数量的弦，6。也有例外，特别是12弦吉他，但我想你可以设置构造函数中的字符串是一个常量。吉他字符串名称也是如此。此外，你的getter方法中有ui代码，很抱歉，这很疯狂。不要这样做。-1：不对。从UML模型中，
guitarest
类可以导航到
GuitarTest
类，这是错误的。你从UML po中做对了除了一个主要问题外，我想这就是uml模型的全部要点。…。@sasha.sochka，GuitarTest确实使用了吉他，但这是“依赖性”关系。（在本例中，从客户到供应商画一条虚线，从GuitarTest到吉他，这意味着，如果吉他改变，GuitarTest必须改变）；但是，我不认为在函数体中使用Guitar是一种依赖关系（如果将Guitar用作方法的参数、返回类型等，则依赖关系是有保证的）.IMHO，两者之间没有关系。@milesma，我想删除此答案，但无法删除，因为它已被接受。我在答案中添加了您的评论，现在我将要求作者将您的答案标记为已接受以删除我的答案。