1

所以我在学习Java。我最多constructors，和处理classes。我在理解他们的工作/用途时遇到了一些问题？我相信它们的使用类似于函数调用，在调用时将参数传递给函数？

我的这种想法正确吗？

例如：

class test{
    void durp(String input){
        System.out.print(input);
    }
}

如果我要在我的主类中创建一个对象，如下所示：

test object = new test("hey");

它会hey作为字符串传递给durp()

这个对吗？

4

7 回答 7

3

如果我要在我的主类中创建一个对象，如下所示： test object = new test("hey"); 它会将“嘿”作为字符串传递给 durp() 对吗？

不，因为您的方法durp()不是构造函数。它只是属于该类的一个方法，可以从创建的活对象中调用。

public class Test {
    /** this is a constructor */
    public Test() {
    } 

    /** this is also a constructor with a parameter */
    public Test(String arg1) { 
        System.out.println(arg1); 
    } 

    /** this is a method of Test */
    public void derp() {
    }
}

您可以从 oracle 阅读有关构造函数的本教程

于 2013-09-28T11:56:56.150 回答
1 
class Test{

     // this is a constructor (name is same as class and no return type)
    public Test(String input){
      // some code here
   }

  // this is a method 
  public void durp(String input){
   // some code
  } 

 public static void main(String[] args){
       Test test = new Test("hey"); // calls constructor
  }

}
于 2013-09-28T11:53:50.313 回答
1

Java 构造函数只是看起来像函数*，但实际上它们非常不同：

  • 当对象完全初始化时调用方法；当对象不存在时调用构造函数
  • 方法不能改变final类的变量；对于构造函数，这是他们目的的一部分
  • 方法可能返回不同的东西；构造函数什么都不返回
  • 方法调用可以用在各种表达式中；构造函数只能作为new表达式的一部分调用。

构造函数必须遵循特殊的命名约定：它们的名称必须与类的名称匹配。在你的情况下，那将是test. 通常，构造函数的任务是设置类的成员变量。鉴于您的test类没有此类变量，您不需要构造函数**：像这样的简单调用就足够了：

new test().drup("hello");

*在 Java 中，“函数调用”的正确术语是“方法调用”，尽管具有其他编程语言背景的程序员经常交替使用这两个术语。

**当类没有定义自定义构造函数时，会为您提供一个不带参数的默认构造函数。

于 2013-09-28T12:02:15.397 回答
1

在 Java 中，对象是被构造的。每次创建一个新对象时，都会调用至少一个构造函数。每个类都有一个构造函数，尽管如果您不显式创建一个，编译器会为您构建一个。关于构造函数的规则有很多，让我们关注基本的声明规则。这是一个简单的例子：

 class Tets{
   protected Test() { } // this is Test's constructor
   protected void Test() { } // this is a badly named,
   // but legal, method
 }

首先要注意的是构造函数看起来非常像方法。一个关键的区别是构造函数不能永远，永远，永远，有一个返回类型......永远！然而，构造函数声明可以具有所有正常的访问修饰符，并且它们可以接受参数（包括 var-args），就像方法一样。关于构造函数的另一个重要规则是，它们必须与声明它们的类具有相同的名称。构造函数不能被标记为静态的（它们毕竟与对象实例化相关联），它们不能被标记为最终的或抽象的（因为它们不能被覆盖）。以下是一些合法和非法的构造函数声明：

 class Foo2 {
    // legal constructors
    Foo2() { }
    private Foo2(byte b) { }
    Foo2(int x) { }
    Foo2(int x, int... y) { }
    // illegal constructors
    void Foo2() { } // it's a method, not a constructor
    Foo() { } // not a method or a constructor
    Foo2(short s); // looks like an abstract method
    static Foo2(float f) { } // can't be static
    final Foo2(long x) { } // can't be final
    abstract Foo2(char c) { } // can't be abstract
    Foo2(int... x, int t) { } // bad var-arg syntax
}

访问https://java.net/downloads/jfjug/SCJP%20Sun%20Certified%20Programmer%20for%20Java%206-0071591060.pdf

于 2013-09-28T12:03:59.077 回答
0

在 OOP 中，构造函数是将生命注入类的东西。方法（在 OOP 中它们是方法，而不是函数）只是使用已经存在的对象（之前使用构造函数创建）执行某些操作。每个类都有其默认构造函数（无参数构造函数），除非您重新定义自己的构造函数。在你的情况下：

class Test{
   String durp;
   public Test(String anInput)
   {
      this.durp = anInput;
   }

   void durp(){
      System.out.print(input);
   }
}

此时，您的代码中的其他地方应该有一个构造类的方法，例如：

Test test = new Test("hey");
test.durp() // prints "hey" (without quote)

注意：由于命名约定类名总是以大写和驼峰符号（即ThisIsMyClass）开头，在这种情况下Test。争论的范围很广，你需要学习很多新东西。

于 2013-09-28T12:09:09.297 回答
0

您需要学习核心 java 基础知识，它会告诉您有关带参数的构造函数。

class test{

public test(String s)
{
   durp(s);
}

 void durp(String input){

  System.out.print(input);

} 
  public static void main(String args[])
  {
   test obj=new test("hey");
 }
 }
于 2013-09-28T11:55:27.007 回答
0

java 中的构造函数用于构造对象，例如，您想设置 durp 的值（不是 durp()，因为那是一种方法），您可以将构造函数用于此类任务。

我想你想要这样的东西：

class Test {
    private String durp;

    public Test(String durp) {
        //set value of durp
        this.durp = durp;
    }

    //function for getting durp string.
    //Use getDurp() rather than durp() in java.
    public String getDurp() {
        return durp;
    }
}
于 2013-09-28T11:59:57.307 回答