JAVA学习笔记四之方法

JAVA学习笔记四之方法

一、方法的定义和实现

　　１、定义

　　　　方法就是能够完成特定功能的代码块。

　　２、格式

　　　格式：

　　　　　　修饰符 返回值类型 方法名(数据类型 变量1, 数据类型 变量2, …) {

　　　　　　　　方法体;

　　　　　　　　

　　　　　　　　return 返回值;

　　　　　　}

　　３、位置：

　　　　　　在类的大括号里边定义。

　　４、解释：

　　　　　　修饰符：public static(面向对象讲解)

　　　　　　返回值类型：功能结果的数据类型。

　　　　　　方法名：其实就是符合标识符规则的一个名称，方便调用的。

　　　　　　参数：

　　　　　　　　在方法声明上：形式参数 就是接收实际参数的变量

　　　　　　　　在调用的时候：实际参数 就是参与实际运算的数据

　　　　　　方法体：就是按照正常的逻辑完成功能的代码。

　　　　　　return 返回值：返回值就是功能的结果，只不过它由return带到调用这个方法的地方。

　　　　　　　　　　　　　哪里调用，return就把结果返回到哪里。

class FunctionDemo1 {
public static void main(String[] args) {
// 求a和b的和
int a = 3;
int b = 4;
int c = a + b;
System.out.println(c);

// 求x和y的和
int x = 5;
int y = 6;
int z = x + y;
System.out.println(z);

// 这两段代码的功能是相同的
}
}

二、方法的调用

　　１、如果你要想写好一个方法，首先你得明确两个知识点：

　　　　　　返回值类型：知道结果类型。

　　　　　　参数列表：知道有几个数据参与操作。

　

　　２、注意：

　　　　　　方法只有被调用才执行。

　　３、怎么调用呢？

　　　　　　有明确返回值类型的方法调用。

　　　　　　　　A：方式一，单独调用。

　　　　　　　　B：方式二，输出调用,这是有意义的，而且我一般这样用。

　　　　　　　　但是，这种方式不够好，因为谁说我的计算结果一定要输出呢？

　　　　　　　　假如我要拿着这个结果继续进行操作，那就做不了了。

　　　　　　　　C：方式三，赋值调用。推荐方式。

　　　　　　　　人家返回什么类型，你就用什么类型的接收。

　　　　　　　　人家要什么类型的，你就给什么类型的。

　　　　　　　　人家要几个，你就给几个。

class FunctionDemo2 {
//我们要写一个方法：求和方法。对两个整数求和
/*
明确：
返回值类型：int
参数列表：int a, int b
*/
public static int sum(int a, int b) {
int result = a + b;

return result;
}

public static void main(String[] args) {
int x = 10;
int y = 20;

//单独调用，没有意义。
//sum(x, y);

//输出调用
//System.out.println(sum(x, y));

//赋值调用
//人家返回什么类型，你就用什么类型接收。
int z = sum(x, y);
//z += 100;
System.out.println(z);
}
}

　　４、方法注意事项：

　　　　A：方法之间是平级的关系。

　　　　B：方法不能嵌套定义。

　　　　C：参数之间用逗号隔开。

lass FunctionDemo3 {
//比较两个数据是否相同
/*
明确：
返回值类型：boolean
参数列表：int a, int b
*/

//实现方案有多种
//方式1
/*
public static boolean compare(int a, int b) {
if (a == b) {
return true;
}else {
return false;
}
}
*/

//方式2
/*
public static boolean compare(int a, int b) {
boolean flag;

if (a == b) {
flag = true;
}else {
flag = false;
}

return flag;
}
*/

//方式3
public static boolean compare(int a, int b) {
//boolean flag = (a == b) ? true : false;
//return flag;

//改进版
//boolean flag = (a == b);
//return flag;

//最终版
return a == b;
}

public static void main(String[] args) {
int x = 10;
int y = 20;

boolean flag = compare(x, y);
System.out.println(flag);
}
}

　　５、请写一个方法实现获取三个数中的最大值，并在main方法中进行测试。

import java.util.Scanner;

class FunctionDemo4 {
/*
需求：获取三个数中的最大值。

明确：
返回值类型：int
参数列表：int a, int b, int c
*/
public static int getMax(int a, int b, int c) {
//方案一：if语句的嵌套实现
/*
if (a > b) {
if (a > c){
return a;
}else {
return c;
}
}else {
if (b > c) {
return b;
}else {
return c;
}
}
*/

//方案二：把嵌套内的if用三元运算符改进
/*
if (a > b) {
return (a > c ? a : c);
}else {
return (b > c ? b : c);
}
*/

//方案三：三元运算符的嵌套
return ((a > b) ? (a > c ? a : c) : (b > c ? b : c));
}

public static void main(String[] args) {
//封装键盘录入
Scanner sc = new Scanner(System.in);

//输入数据
System.out.println("请输入第一个数据：");
int a = sc.nextInt();
System.out.println("请输入第二个数据：");
int b = sc.nextInt();
System.out.println("请输入第三个数据：");
int c = sc.nextInt();

//调用
int result = getMax(a, b, c);
System.out.println(result);
}
}

　　６、无返回值的方法的调用

　　　　一个方法如果没有明确的返回值类型，就用void表示。

　　　　void类型的方法如何调用呢？

　　　　　　A：单独调用 可以

　　　　　　B：输出调用 不可以

　　　　　　C：赋值调用 不可以

　　　　需求：请写一个方法，输出一句话：给我10块钱。

class FunctionDemo5 {
/*
需求：请写一个方法，输出一句话：给我10块钱。

明确：
返回值类型：void
参数列表：空参数
*/
public static void printSentence() {
System.out.println("给我10块钱。");
}

/*
需求：请写出一个函数，输出我传递过来的一个字符串。

明确：
返回值类型：void
参数列表：String s
*/
public static void printString(String s) {
System.out.println(s);
}

public static void main(String[] args) {
//单独调用
printSentence();

//输出调用
//System.out.println(printSentence());
//FunctionDemo2.java:29: 错误: 此处不允许使用 '空' 类型

//赋值调用
//void v = printSentence();
//FunctionDemo2.java:33: 错误: 非法的表达式开始

//带参数的调用
printString("给我10块钱。");
}
}

　　７、请写一个方法，实现输出nn乘法表。（n的取值1-9）

　　　　然后在main方法中进行测试。

　　　　如果一个变量由两个字符组成，这两个字符的大小写要求一致。

import java.util.Scanner;

class FunctionDemo6 {
/*
需求：请写一个方法，实现输出nn乘法表。（n的取值1-9）

明确：
返回值类型：void
参数列表：int n
*/
public static void printnn(int n) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + "*" + i + "=" + j*i + "\t");
}

System.out.println();
}
}

public static void main(String[] args) {
Scanner sc = new Scanner(System.in);

System.out.println("请输入一个数据：");
int n = sc.nextInt();

printnn(n);
}
}

三、方法的重载

　　１、由于我们要求对方法取名做到：见名知意。

　　　　所以，sum2，sum3这样的名字就是有问题的。不满足这个要求。

　　　　java针对这种情况：功能一样，而参数不同的方法，可以让它们的方法名称一样。

　　　　这种做法被称为：方法重载。

　　　　方法重载：

　　　　　　方法名相同，参数列表不同。跟返回值无关。

　　　　　　参数列表：个数不同，或者类型不同。

　　　　需求：写一个方法，实现求数据的和。

class FunctionDemo7 {
//两个数据的和
public static int sum(int a, int b) {
return a + b;
}

/*
//三个数据的和
public static int sum2(int a, int b, int c) {
return a + b + c;
}

//四个数据的和
public static int sum3(int a, int b, int c, int d) {
return a + b + c + d;
}
*/

//三个数据的和
public static int sum(int a, int b, int c) {
return a + b + c;
}

//四个数据的和
public static int sum(int a, int b, int c, int d) {
return a + b + c + d;
}

public static float sum(float a, float b) {
return a + b;
}

public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 30;
int d = 40;
float x = 3.8f;
float y = 4.5f;

/*
//输出调用
System.out.println("sum(int a, int b)：" + sum(a, b));
System.out.println("sum2(int a, int b, int c)：" + sum2(a, b, c));
System.out.println("sum3(int a, int b, int c, int d)：" + sum3(a, b, c, d));
*/

System.out.println("sum(int a, int b)：" + sum(a, b));
System.out.println("sum(int a, int b, int c)：" + sum(a, b, c));
System.out.println("sum(int a, int b, int c, int d)：" + sum(a, b, c, d));
System.out.println("sum(float a, float b)：" + sum(x, y));
}
}

　　２、请自己写几个方法，分别实现int类型，short类型，long类型，byte类型的两个数据是否相等。

　　　　最后在main方法中进行测试。

class FunctionDemo8 {
/*
public static boolean compare(int a, int b) {
System.out.print("int：");
return a == b;
}
*/

public static boolean compare(short a, short b) {
System.out.print("short：");
return a == b;
}

public static boolean compare(long a, long b) {
System.out.print("long：");
return a == b;
}

public static boolean compare(byte a, byte b) {
System.out.print("byte：");
return a == b;
}

public static void main(String[] args) {
//这个测试走的是谁呢？
//走的是int类型的那个比较，因为整数，默认是int类型。
//没有int就向上匹配
System.out.println(compare(10, 20));
}
}