本文目录一览:
- 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;
}
}
}