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;

}

}

}