Question

我还是java的新手，所以请耐心等待。

我无法理解为什么我只能从某些类/ places /访问属于某个对象实例的某些方法/函数。一旦我创建了一个对象的实例，然后按下“。”点。运算符它没有显示我想要使用的所有方法，（我希望看到对象类继承和实现的所有方法。）

例如：

    // In a junit test class, I make an instance of the class DailyLog which takes 2 
    // integers   
    private DailyLog log; // which seems fine for now, but when I add on the next
    // line:                         
    log = new DailyLog (5,500); // It gives me an error on the semicolon on the line 
    // above  saying "-  Syntax error on token ";", , expected"

我不明白为什么它不会让我创建DailyLog的实例并设置它的参数...？

问题2：如果我只保留第一行代码，然后在同一个类的方法中设置log的参数，它可以让我设置它的参数，但是当我按下“。” operator，它没有显示size函数，这是我想要使用的函数。 - 我以为它会从超类中继承大小，为什么不让我使用呢？

问题3：我在dailyLog类中有一个名为variance的方法，另一个叫做numInsertions，我需要在variance方法中使用numInsertions方法，但是当我在下面写时，我唯一可以获得numInsertions方法的方法是通过另一种方法，这将无法工作，因为我需要访问numInsertions方法直接将其值分配给b，而不是通过另一种方法，因为这将改变它的值。

      public Integer variance() throws SimulationException{
          Integer a = log.

我认为它可能与范围有关，当我有另一个类创建dailyLog的实例时，当我按下“.counter”时，它提供了一些方法来使用daulyLog类和它的超类，但不是全部。我觉得这很令人困惑，感谢帮助，谢谢。

UPDATE **

也许在这里添加更多代码将有助于说明我的问题：

public class dailyLog implements Log{

private Integer userLogSize1;
private Integer maxEnt;
private ArrayList<Integer> log = new ArrayList<Integer>();

public dailyLog (Integer userLogSize, Integer maxEntry) throws SimulationException{
    if ((userLogSize<= 0 || maxEntry <= 0)){
        throw new SimulationException("message goes here");}
        this.log = new ArrayList<Integer>(userLogSize);
        for (Integer i = 0; i <= userLogSize; i++){
            log.add(null);}
        userLogSize1= userLogSize;
        maxEnt = maxEntry;
    }

public Integer numInsertions(){
       Integer total = 0;
    for (Integer i = 0; i < log.size(); i++){           
         if (log.get(i) != null){
            total++;}}
    return total;}

//  *** below I want to write log.numentries but i cannot, why it this? I can only write
// log.get(numentries()) but that gives the wrong answer.


public Integer variance() throws SimulationException{
    if (log.size() == 0){
        throw new SimulationException ("Put message here");}
    Integer a = log.get(0);
    Integer b;
    Integer d = log.get(1);
    if (d == null){
        b = log.get(numInsertions()-1);}        
    else {b = log.get(numInsertions()-2);}
    Integer c = log.get(userLogSize1-1);
    if ( c == null){
        return a - b;}
        return a-c;}
}

Answer 1

我认为您在Java中看到了不同的保护级别。对于类的成员和方法，通常有四个保护级别：private, public, protected, package-private。如果方法或对象没有前缀为关键字private, public, protected，则默认为package-private。

private的方法或类成员只能在声明它的同一个类中引用。

public的方法或类成员只能从任何包中的任何类引用。

protected的方法或类成员只能从同一个类和子类中引用。

package-private的方法或类成员只能在同一个包中引用。如果您正在使用default包进行开发（也就是说，您尚未声明包），那么您的代码通常会像处理public一样处理包私有，因为所有类都默认为默认包。

以下是reference，此处为another question，用较少的词语解释了相同的想法。

Answer 2

如果你试图将一个方法从一个类传递给另一个类，并且你不想让它成为静态的，这意味着它将在所有实例中共享，你可以在一个类中创建一个新的实例。不同的阶级。例如，假设您有课程 A 和课程 B ：

public class A {
private int a;
private void setA(int a) {
    this.a = d;

和B级：

public class B {
private int b;
private void setB(int b) {
    this.b = b;

所以我可以通过从中调用构造函数来调用所有类A的方法：

public class B {
///Constructor line
private A a = new A();
A.setA(10);
System.out.println(A.a);   ///should print 10

Answer 3

您需要了解修饰符（即私有，公共，受保护和包级别）。类的每个字段和类的方法（静态和非静态）都有一个修饰符。如果你没有指定一个，那么它就是＆＃34;包级别＆＃34;。您不必在代码块（例如方法体）内指定修饰符，因为假设此类变量的范围是内部块。只是块范围的一个简单示例，以下内容在Java中是合法的：

public int foo(){
    {
        int max = 0;
        for(int i = 0; i < 10; ++i)
            if(i > max)
                max = i;
    }
    final int max = -10;
    return max;
}

简而言之，您有以下内容（请注意，构造函数将被视为以下方法）：

public：任何可以访问此方法或字段的内容。对于字段，这意味着任何类都可以设置此字段，除非它被声明为final。您应该非常知道，即使是声明为final的对象也可以被修改（例如数组或任何其他可变对象）。对于方法，这只是意味着任何类都可以调用此方法。
private：只有此类可以访问此字段或方法。这意味着您可以修改这些字段或调用这些方法的唯一位置在此类文件中。这个类的一个实例可以访问来自该类的另一个实例的字段（通过在该类的主体内部编写的引用该类的其他对象实例的方法）。
protected： 在与此类或相同的包中的任何类此类的子类（可以单独存在） package）可以直接访问受保护的字段或方法。
包级别：要指定包级访问权限，您根本不指定任何修饰符（即public，private或protected ... nothing）。在这种情况下，此包中的任何类都可以访问此字段或方法。

更好的问题是你什么时候应该使用哪个？大多数方法应该是公开的，大多数字段应该是私有的一般规则。你应该非常厌倦那些声称这些东西是为了安全的人。确保对象数据完整性的 only 方式是仅返回原始值或不可变对象或可变对象的副本。作为一个简单的例子，我们假设您实现了一个ArrayList（一个动态数组）。在内部，您可能有一个数组对象，例如private int [] arr。如果在任何公共方法中返回此数组对象，则存在调用类修改内部数组并使ArrayList不一致的风险。

我会遵循以下准则：

字段

public：如果字段也是最终且是不可变对象或基元，则只声明字段为public。这应该用于永远不会改变的持久对象（即一旦在构造函数中设置了这个公共最终字段永远不会改变）。
protected：这应主要用于抽象类。这是抽象类声明了一个数据结构，它的子类可以使用和引用（和 modify ）。如果这类似于列表，那么将它声明为最终可能仍然是合适的（这是子类可以修改但不能重新分配的内容）。
包级别：这应该主要由包中的辅助类使用。它们通常不应该是最终的（尽管它们是类似于列表的东西）。作为一个简单的例子。如果实现堆，您可能希望堆节点保存有关它们存储的元素以及它们在堆的数组中的位置的信息。堆真的负责设置它，因此通过声明它的包级别，您的堆实现可以直接访问和重新分配诸如每个堆节点的堆索引和堆值之类的东西。
私人：私人字段最常见。大多数字段应该是私有的。这意味着此类文件中的仅方法可以修改或重新分配此字段。当您想要保证类的行为时，应该使用此方法。如果您使用任何其他修饰符，则此类数据的行为可能由其他类决定。

至于方法，它非常简单。公共方法应该是任何类都可以调用来查询对象而不破坏对象的数据完整性的东西（即该方法不应该能够将对象置于不一致状态，这意味着公共方法应该不 i>，一般来说，返回可变字段）。私有，受保护和包级别的方法都应该是辅助方法，用于改进模块化。基本上它取决于＆＃34;谁＆＃34;你相信。如果该方法是私有的，那么您只信任此类来正确调用它。如果是软件包级别，那么您只信任此软件包中的类以正确调用该方法。最后，如果它受到保护，那么你只需要信任这个包和子类中的类来正确调用这个方法。

从差异类中访问方法，newb

3 个答案: