方法
概念
简单的说，方法就是完成特定功能的代码块；
- 在很多语言里面都有函数的定义；
- 函数在java中被称为方法；
- 格式：
修饰符 返回值类型 方法名（参数类型 参数名1，参数类型 参数名2......）{
函数体；
return 返回值；
}
详细解释：
修饰符：目前就用public static。后面我们再详细的讲解其他的修饰符。
返回值类型：就是功能结果的数据类型；
方法名：符合命名规则即可。方便调用；
参数：（1）实际参数：就是实际参与运算的；
（2）形式参数：就是方法定义上的，用于接受实际参数的。
参数类型：就是参数的数据类型；
参数名：就是变量名；
方法体语句：就是完成功能的代码；
return：结束方法的；
返回值：就是功能的结果，由return带给调用者；
方法不调用不执行；
package com.manman.cn;
/**
* 方法：完成特定功能的代码块
* 注意：在很多语言里面有函数的定义，而在java中函数被称为方法；
* @author 小漫画
*做两个数之和
*
*
*如何调用呢？（有明确返回值的调用）
*A：单独调用，一般来说没有意义，所以不推荐；
*B：输出调用，但是不够好，因为我们可能需要针对结果进行进一步的操作；
*C：赋值调用，推荐方案；
*/
public class fangfa {
public static void main(String[] args) {
int x=10;
int y=20;
/**
* 方式1：单独调用
* sum(x,y);
* 方式2：输出调用
* System.out.println(sum(x,y));
*/
//方式3：赋值调用
int result=sum(x, y);
//result在这里可以进行操作
System.out.println(result);
}
public static int sum(int a,int b){
//int c=a+b;
return a+b;
}
}
结果
练习1：请输出两个数字的最大值（用调用方法的格式）
package com.manman.cn;
import java.util.Scanner;
/*
* 键盘录入两个数据，返回两个数中的最大值
*/
public class fanhuiMax {
public static void main(String[] args) {
Scanner scanner =new Scanner(System.in);
System.out.println("请输入第一个数据：");
int a=scanner.nextInt();
System.out.println("请输入第二个数据：");
int b=scanner.nextInt();
int result=Max(a, b);
System.out.println("这两个数字中的最大值是："+result);
}
public static int Max(int a,int b){
return a>b?a:b;
}
}
结果
练习二：键盘录入两个数据，比较两个数是否相等；
package com.manman.cn;
import java.util.Scanner;
/**
* 分析：比较两个数是否相等结果是一个boolean类型。
* @author 小漫画
*
*/
public class fanhuiEqual {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.println("请输入您的第一个数字：");
int a=scanner.nextInt();
System.out.println("请输入您的第二个数字：");
int b=scanner.nextInt();
boolean equal=Equall(a, b);
System.out.println(equal);
}
/**
* 需求：比较；两个数是否相等
* 两个明确：返回值是boolean类型
* 参数列表：int a,int b
*/
public static boolean Equall(int a,int b){
return a==b?true:false;
}
}
结果
练习三：键盘录入三个数据，返回三个数中的最大值；
package com.manman.cn;
import java.util.Scanner;
public class fanhui3Max {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.println("请输入您的第一个数据：");
int a=scanner.nextInt();
System.out.println("请输入您的第二个数据：");
int b=scanner.nextInt();
System.out.println("请输入您的第三个数据：");
int c=scanner.nextInt();
int result=get3Max(a, b, c);
System.out.println("您输入的三个数中的最大值为："+result);
}
public static int get3Max(int a,int b,int c){
return (a>b)?(a>c?a:c):(b>c?b:c);
}
}
结果
练习四：在控制台输出如下形状：
要求
package com.manman.cn;
/**
* 写一个什么样子的方法呢？写一个m行n列的代码
* 两个明确：
* 返回值类型：这个时候没有明确的返回值，不写东西还不行，所以，这里记住是void
* 参数列表：int m,int n
* void类型返回值的方法调用：
* 只能单独调用，如下：
*
* @author 小漫画
*
*/
public class youhuashuchuStar {
public static void main(String[] args) {
getStar(4,5);
}
public static void getStar(int m,int n){
for(int x=0;x<m;x++){
for(int y=0;y<n;y++){
System.out.print("*");
}
System.out.println();
}
}
}
结果
练习五：
键盘录入行数和列数，输出对应的星形
package com.manman.cn;
import java.util.Scanner;
public class ScannerStar {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.println("请输入您所需要的行数：");
int a=scanner.nextInt();
System.out.println("请输入您所需要的列数：");
int b=scanner.nextInt();
System.out.println("您需要的图案是：");
name(a, b);
}
public static void name(int m,int n) {
for(int x=0;x<m;x++){
for(int y=0;y<n;y++){
System.out.print("*");
}
System.out.println();
}
}
}
结果
练习五：键盘录入一个数据n（1<=n<=9），输出对应的nn乘法表
package com.manman.cn;
import java.util.Scanner;
public class Scanner99biao {
public static void main(String[] args) {
Scanner scanner =new Scanner(System.in);
System.out.println("请输入一个1~9的数字：");
int n=scanner.nextInt();
biao99(n);
}
public static void biao99(int n){
for(int x=1;x<n;x++){
for(int y=1;y<=x;y++){
System.out.print(y+"*"+x+"="+x*y+"\t");
}
System.out.println();
}
}
}
结果
方法重载
- 概述：在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可。
- 特点：
与返回值类型无关，只看方法名和参数列表。
在调用时，虚拟机通过参数列表的不同来区分方法。
例一：比较两个数据是否相等，参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，并在main方法中进行测试。
package com.manman.cn;
/*
* 比较两个数据是否相等，
* 参数类型分别为两个byte类型，
* 两个short类型，两个int类型，
* 两个long类型，并在main方法中进行测试。
*/
public class chongzai {
public static void main(String[] args) {
//测试
byte b1=3;
byte b2=4;
System.out.println(compare(b1, b2));
//测试
short s1=4;
short s2=4;
System.out.println(compare(s2, s1));
//测试
int a1=10;
int a2=11;
System.out.println(compare(a1, a2));
//测试
long l1=45;
long l2=45;
System.out.println(compare(l1, l2));
}
public static boolean compare(byte a,byte b) {
return a==b;
}
public static boolean compare(short a,short b) {
return a==b;
}
public static boolean compare(int a,int b) {
return a==b;
}
public static boolean compare(long a,long b) {
return a==b;
}
}
结果
数组
定义格式：
格式1：数据类型[] 数据名；
格式2：数据类型 数组名[];
这样定义完成之后的数据是一个没有值的数组。
数组的初始化方式：
- 动态初始化：初始化只能指定数组长度，由系统为数组分配初始值。
格式：数据类型[] 数组名=new 数据类型[数组长度]
eg:int[] arr=new int[3]; - 静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组的长度。
eg:int[] arr = new int[]{1,2,3}//长度为3.
或者：int[] arr={1,2,3}.
遍历数组
我们可以使用循环语句：
package com.manman.cn;
//数组的遍历：依次输出数组中的每一个元素
public class shuzubianli {
public static void main(String[] args) {
//定义数组，使用静态定义
int[] arr={1,2,3};
/*
* 获取每一个元素
* 如何获取？可以通过索引来获取
* 可以通过循环来获取
*/
for(int x=0;x<arr.length;x++){
System.out.println(arr[x]);
}
}
}
获取数组的长度使用的是.length,然后通过使用for循环遍历数组。
如果使用方法的调用，我们要明确的是：
（1）返回值类型是void
（2）参数列表：int[] arr
package com.manman.cn;
//数组的遍历：依次输出数组中的每一个元素
public class shuzubianli {
public static void main(String[] args) {
int[] arr1={1,2,3,4,5,6};
Array1(arr1);
}
public static void Array1(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
结果
遍历数组中的最大值
先给一个空间，然后依次比较，谁大留谁。
package com.manman.cn;
public class shuzuMax {
public static void main(String[] args) {
//定义数组
int[] arr={1,5,8,2,9};
//获取数组中的最大值
//从数组中任意的找一个元素作为参照物
int max=arr[0];
//遍历数组
for(int x=1;x<arr.length;x++ ){
if(max<arr[x]){
max=arr[x];
}
}
System.out.println(max);
}
}
结果
改进代码，使用调用方法的 办法输出最大值
package com.manman.cn;
public class shuzuMax {
public static void main(String[] args) {
//定义数组
int[] arr={1,5,8,2,9};
int max =getMax(arr);
System.out.println(max);
}
public static int getMax(int[] arr){
int max=arr[0];
for (int i = 0; i < arr.length; i++) {
if(max<arr[i]){
max=arr[i];
}
}
return max;
}
}
这里一定要注意返回类型时int；
数组的逆序
package com.manman.cn;
public class shuzunixu {
public static void main(String[] args) {
int[] arr={1,2,3,4,5,6};
nixu(arr);
Array1(arr);
}
public static void nixu(int[] arr){
for(int x=0;x<arr.length/2;x++){
int temp=arr[x];
arr[x]=arr[arr.length-1-x];
arr[arr.length-1-x]=temp;
}
}
public static void Array1(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]);
}
}
}
先进行逆序操作，然后再将逆序后的数组遍历打印。
