java函数调用（JAVA中定义了函数，有返回值，怎么调用）

本文目录

• JAVA中定义了函数，有返回值，怎么调用
• java中含参函数怎么调用
• java函数调用(在一个类中怎么调用另一个类的变量和函数)
• java函数调用问题
• Java 函数调用
• Java中如何调用函数和自定义函数
• java中的函数调用怎么理解
• java中一个函数如何多次调用另一个函数
• java 在主函数中调用函数的方法
• java 调用函数有几种方法

JAVA中定义了函数，有返回值，怎么调用

sum是在方法中，当这个方法执行完之后，sun就消失了。调用的话可以在主方法或者其他方法中定义
int
sum
=
add（1,2）；返回值就赋值给新的sum了。至于打印的话，直接在return前面加个输出语句就行了。
system.out.println(“sum是：“+sum);

java中含参函数怎么调用

系统不会在调用有参构造方法的时候自动调用无参构造方法。需要自己手工实现
1、在有参构造函数中调用无参构造函数
例如：
public
class
ta{
public
ta(){//定义无参构造函数
}
public
ta(int
a){//定义有参构造函数
this();//调用无参构造函数
}}

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;

// Score score = new Score;

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;

}

}

}

java函数调用问题

调用静态方法可以直接用类名，调用非静态方法必须用对象。

举例如下：

public class A {
    // 静态方法
    public static void a1() {
        System.out.println(“静态方法“);
    }
    // 非静态方法
    public void a2() {
        System.out.println(“非静态方法“);
    }
}

测试类：

public class Test {
    // main方法也是静态的
    public static void main(String args) {
    
           // 创建对象
        A aa = new A();
        
        // 通过类名访问
        A.a1();
        
        // 通过对象访问
        aa.a2();
    }
}

运行结果：

Java 函数调用

public class Test {
    // 主函数
    public static void main(String args) {
        Frame();
    }
    // 定义窗体
    static void Frame() {
        JFrame fra = new JFrame();
        fra.setTitle(“圈插图“);
        fra.setVisible(true);
        fra.setSize(300, 300);
        fra.setBackground(Color.GREEN);
//      JFrame中默认是有添加ContentPane窗体对象，当你将这个容器设置为不可见时就可以看到你设置的背景色了
        fra.getContentPane().setVisible(false);
    }
}

Java中如何调用函数和自定义函数

调用函数

System.out.println(“hello world“);

println即为函数，out为是输出对象，System为java系统类。

java是面向对象语言，调用非静态方法时，需要创建一个类的对象才能调用方法；

调用静态方法时，直接用类名调用即可。

import java.util.Array; //调用其他包下的方法时需要导包

Array.sort(arr); //Array是工具类，方法都为静态方法

定义函数

修饰符 返回值类型 方法名(参数类型 参数名){

...
方法体
...    

return 返回值

;}

方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

• 修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。

• 返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。

• 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。

• 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

• 方法体：方法体包含具体的语句，定义该方法的功能。

注意： 在一些其它语言中方法指过程和函数。一个返回非void类型返回值的方法称为函数；一个返回void类型返回值的方法叫做过程。

拓展内容

java

Java源程序（.java文件）——》java字节码文件（.class文件）——》由解释执行器（java.exe）将字节码文件加载到java虚拟机（jvm）——》字节码文件（.class）就会在java虚拟机中执行。

Java的基本包
java.lang 其中包含有：
接口：Comparable、Cloneable、Runable等
类：八个基本数据类型封装类、Math、Runtime、Object、String、StringBuffer、Thread、Exception等

java中的函数调用怎么理解

函数调用可以理解为：
你想去买一样东西，这时，可能会叫你的秘书去帮你买它。
您的秘书可能不熟悉市场，这时她委任采购部门去帮她购买你需要的东西。
不好意思，昨天有事匆忙留下一段，还有一段没有完成。。。
在JAVA中怎么使用 什么时候能用到？
我就大致的回答一下吧。如果不合心意，还请谅解！
OOP强调低耦合，高内聚。单一职责原则。还有许多模式以及原则，使你的系统富有弹性，易于扩展，修改，维护。
内聚就是一个模块内各个元素彼此结合的紧密程度，高内聚就是一个模块内各个元素彼此结合的紧密程度高。
所谓高内聚是指一个软件模块是由相关性很强的代码组成，只负责一项任务，也就是常说的单一责任原则。
耦合：一个软件结构内不同模块之间互连程度的度量(耦合性也叫块间联系。指软件系统结构中各模块间相互联系紧密程度的一种度量。模块之间联系越紧密，其耦合性就越强，模块的独立性则越差，模块间耦合的高低取决于模块间接口的复杂性，调用的方式以及传递的信息。) 对于低耦合，粗浅的理解是：
一个完整的系统，模块与模块之间，尽可能的使其独立存在。
也就是说，让每个模块，尽可能的独立完成某个特定的子功能。
模块与模块之间的接口，尽量的少而简单。
如果某两个模块间的关系比较复杂的话，最好首先考虑进一步的模块划分。
这样有利于修改和组合。
引用：

java中一个函数如何多次调用另一个函数

java中要多次调用函数（方法），无参数的函数（方法）只需写上函数名即可，有参数的函数（方法）把参数传进来即可。
具体事例代码如下：
public class Demo {
public static void main(String args) {
int a = a(2);//第一次调用
int b = a(4);//第二次调用
}
private static int a(int i){
return i;
}
}
要注意的是：在调用没有返回值的函数（方法）时，不能给变量赋值，因为函数（方法）本身没有返回值，就没有值赋值给变量了。

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

　　调用方法：先生成一个对象，用“对象.方法()”的方式调用。
　　调用说明：java中的main方法是静态的，用于程序的入口，在静态方法中无法调用非静态方法，只能调用静态方法。想调用静态方法的话就要先生成该类的一个对象，通过对象调用非静态方法。
　　调用举例：
　　public class A{
　　public static void main(String args){
　　A a = new A();
　　a.aaa();
　　}
　　public void aaa(){}
　　}

java 调用函数有几种方法

方法有四种类型public protect default private（在类内部使用时 ，这四种都可以用方法名称直接调用）
你这里说的两种方法的调用是public方法的类外部调用方式
super，调用父类的方法
this.调用对象自己的方法