java调用函数,java调用函数需要声明吗

本文目录一览：

• 1、java如何调用另个程序的main函数
• 2、java 函数调用
• 3、java中的函数调用怎么理解？
• 4、java中含参函数怎么调用
• 5、java 在主函数中调用函数的方法
• 6、java函数调用(在一个类中怎么调用另一个类的变量和函数)

java如何调用另个程序的main函数

Main方法是用static修饰的，有2种方法可以调用：

1、类名.main(参数);

2、new创建实例，实例.main(参数);

这个地方注意必须传递字符串数组的参数 或者 null ！另外举一个用反射机制调用Main方法的例子。

这个类是被调用的main方法类：

Java代码：

public class Run

{

public static void main(String[] args)

{

String str=args[0]+”Hello World”;

System.out.println(str);

}

}

下面是调用main方法的类：

Java代码：

public class JobRun

{

public static void main(String[] args)

{

String idStr = “YAya”;

try

{

Method method = Run.class.getMethod(“main”, String[].class);

method.invoke(null, (Object) new String[] { idStr });

}

catch (Exception e)

{

e.printStackTrace();

}

}

}

扩展资料：

main方法是一个特殊的方法，是程序执行的入口，一个Java程序从main方法开始执行。Java虚拟机在执行Java程序之前会事先分配一个主线程，然后在主线程里面执行我们这个main方法。

线程就是一个程序里面不同的执行路径！总之，就记住，Java程序从main方法开始执行，

比如：

public static void main(String[] args) {

System.out.println(“nihao”);

}

在这里当程序运行的时候，从main方法进来，然后做的第一件事就是System.out.println(“nihao”);

注意： main方法执行结束，程序也就执行结束了！

参考资料：百度百科-Java

百度百科-main函数

java 函数调用

貌似你的第一个类和后面的代码没什么联系吧。然后你把第二个类的代码写了两次。如果我没看错的话，应该是完全一样的。然后你在第二个类中将一个函数递归调用，并把参数原封不动地传来传去。估计是你打错了吧。你想写的是不是

gouzao_hanshudaoyong1.java:

public class gouzao_hanshudaoyong1 {

int a = 123;

void hanshu_1() {

System.out.print(“hanshu_1” + a);

}}

gouzao_hanshudaoyong2.java:

class gouzao_hanshudaoyong2{

public static void main(String[] args) {

hanshu_2(new gouzao_hanshudaoyong1());

}

public static void hanshu_2(gouzao_hanshudaoyong1 g)

{g.hanshu_1();}

}

如果是这样的话，运行结果应该是hanshu_1123

如果不是，请把你的问题说的清楚点，或者说明一下你的程序是要干嘛

java中的函数调用怎么理解？

函数调用可以理解为：

你想去买一样东西，这时，可能会叫你的秘书去帮你买它。

您的秘书可能不熟悉市场，这时她委任采购部门去帮她购买你需要的东西。

不好意思，昨天有事匆忙留下一段，还有一段没有完成。。。

在JAVA中怎么使用 什么时候能用到？

我就大致的回答一下吧。如果不合心意，还请谅解！

OOP强调低耦合，高内聚。单一职责原则。还有许多模式以及原则，使你的系统富有弹性，易于扩展，修改，维护。

内聚就是一个模块内各个元素彼此结合的紧密程度，高内聚就是一个模块内各个元素彼此结合的紧密程度高。

所谓高内聚是指一个软件模块是由相关性很强的代码组成，只负责一项任务，也就是常说的单一责任原则。

耦合：一个软件结构内不同模块之间互连程度的度量(耦合性也叫块间联系。指软件系统结构中各模块间相互联系紧密程度的一种度量。模块之间联系越紧密，其耦合性就越强，模块的独立性则越差，模块间耦合的高低取决于模块间接口的复杂性，调用的方式以及传递的信息。) 对于低耦合，粗浅的理解是：

一个完整的系统，模块与模块之间，尽可能的使其独立存在。

也就是说，让每个模块，尽可能的独立完成某个特定的子功能。

模块与模块之间的接口，尽量的少而简单。

如果某两个模块间的关系比较复杂的话，最好首先考虑进一步的模块划分。

这样有利于修改和组合。[1]

引用：

代码的话，我就不多说了。自己估量估量，就知道是怎么回事了。

java中含参函数怎么调用

系统不会在调用有参构造方法的时候自动调用无参构造方法。需要自己手工实现

1、在有参构造函数中调用无参构造函数

例如：

public

class

ta{

public

ta(){//定义无参构造函数

}

public

ta(int

a){//定义有参构造函数

this();//调用无参构造函数

}}

java 在主函数中调用函数的方法

调用方法：先生成一个对象，用“对象.方法()”的方式调用。

调用说明：java中的main方法是静态的，用于程序的入口，在静态方法中无法调用非静态方法，只能调用静态方法。想调用静态方法的话就要先生成该类的一个对象，通过对象调用非静态方法。

调用举例：

public class A{

public static void main(String[] args){

A a = new A();

a.aaa();

}

public void aaa(){}

}

java函数调用(在一个类中怎么调用另一个类的变量和函数)

import java.util.Scanner;

public class Student {// 带有主函数的类，Score类在下面

String name;

Score score = new Score();// 此句有重大嫌疑 nested class object as an attribute, no mistake here!

public String introduce() {

return (name + “\t” + score.java + “\t” + score.db + “\t” + score.c

+ “\t” + score.sum() + “\t” + score.avg());// name之后的全部显示为0

}

public static void main(String args[]) {

Student stu[] = new Student[10];

// Score score[] = new Score[10];

Scanner in = new Scanner(System.in);

for (int i = 0; i 3; i++) {

stu[i] = new Student();

// score[i] = new Score();

System.out.println(“学生” + (i + 1) + “的名字：”);

stu[i].name = in.next();

System.out.println(“学生” + (i + 1) + “java成绩：”);

stu[i].score.java = in.nextFloat();

// score[i].java = in.nextFloat();

System.out.println(“学生” + (i + 1) + “DB成绩：”);

// score[i].db = in.nextFloat();

stu[i].score.db = in.nextFloat();

System.out.println(“学生” + (i + 1) + “C语言成绩：”);

stu[i].score.c = in.nextFloat();

// score[i].c = in.nextFloat();

}

System.out.println(“姓名\tjava成绩\tDB成绩是\tc语言成绩\t总成绩\t平均成绩”);

for (int j = 0; j 3; j++) {

System.out.println(stu[j].introduce());

}

}

public class Score {// score类

float java, db, c;

public float sum() {

float ssum = java + db + c;

return ssum;

}

public float avg() {

return sum() / 3;

}

}

}