方法
方法是一段可以重复调用的代码块，这个代码块实现了某个功能，当我们的程序中需要这一个功能的时候，调用这个方法即可，不再需要重复书写这个功能的代码。
方法的定义格式
public static <返回值类型> <方法名>(<参数类型> <参数名>,... ){
方法体；
[return 表达值]
注意：返回值类型为void的时候，方法没有返回值，return可以省略
}
格式说明：
public 表示公共的，修饰的方法可以在任意类中使用。
static 表示静态的，修饰的方法可以通过类名直接调用，如若在同一个类中，类名可以省略，直接通过方法名调用。
返回值类型 表示通过调用方法可以得到的结果的数据类型，它可以是Java数据类型中的任意数据类型。
void是个特殊的返回值类型，它表示这个方法完成功能，但是不返回，所以当返回值类型为void的时候，return可以省略。
如果返回值是某个具体的数据类型，则表示这个方法完成后会返回一个具体值，那么在方法体的最后需要用一个return语句返回这个值。
方法名称 表示方法的名字，应该符合标识符规范
参数列表 表示这个方法要完成功能需要参照的数据。
定义方法时称作形参，调用方法时需要给出具体的参数值称作实参。实参与形参一一对应。
一个方法可以有多个参数，用逗号隔开。如：
参数类型1 参数名字1，参数类型2 参数名字2……
方法体 放在{}中，是实现方法功能的代码块。
如果方法不包含参数，且没有返回值，我们称为无参无返回值的方法。
方法的使用分为两步：
第一步，定义方法
例如：下面代码定义了一个方法名为 show ，没有参数，且没有返回值的方法，执行的操作为输出 “ welcome to Java. ”
注意：
方法体放在一对大括号中，实现特定的操作
方法名主要在调用这个方法时使用，需要注意命名的规范，一般采用第一个单词首字母小写，其它单词首字母大写的形式
第二步，调用方法
当需要调用方法执行某个操作时，可以先创建类的对象，然后通过 对象名.方法名(); 来实现
例如：在下面的代码中，我们创建了一个名为 hello 的对象，然后通过调用该对象的 show( ) 方法输出信息
public class HelloWorld {
public static void main(String[] args) {
// 创建对象，对象名为hello
HelloWorld hello = new HelloWorld();
// 调用方法
hello.show();
}
//定义方法
public void show() {
System.out.println("Welcome to Java.");
}
}
运行结果为：Welcome to Java.
如果方法不包含参数，但有返回值，我们称为无参带返回值的方法。
例如：下面的代码，定义了一个方法名为 calSum ，无参数，但返回值为 int 类型的方法，执行的操作为计算两数之和，并返回结果
public int calcSum{
int a=5;
int b=12;
int sum=a+b;
return sum;
}
在 calSum( ) 方法中，返回值类型为 int 类型，因此在方法体中必须使用 return 返回一个整数值。
调用带返回值的方法时需要注意，由于方法执行后会返回一个结果，因此在调用带返回值方法时一般都会接收其返回值并进行处理。如：
public class HelloWorld {
public static void main(String[] args) {
// 创建名为hello的对象
HelloWorld hello = new HelloWorld();
// 调用方法并接收方法的返回值，保存在变量sum中
int sum = hello.calcSum();
System.out.println("和为：" + sum);
}
// 定义无参带返回值的方法
public int calcSum() {
int a= 5;
int b =12;
int sum =a + b;
// 使用return返回值
return sum;
}
}
运行结果为：和为：17
不容忽视的“小陷阱”：
1、 如果方法的返回类型为 void ，则方法中不能使用 return 返回值！
public void showInfo(){
return "Java";
}
2、 方法的返回值最多只能有一个，不能返回多个值
public int getInfo(){
int score1=94;
int score2=87;
return score1,score2;
}
3、 方法返回值的类型必须兼容，例如，如果返回值类型为 int ，则不能返回 String 型值
public int getInfo(){
String name="java";
return name;
}
有时方法的执行需要依赖于某些条件，换句话说，要想通过方法完成特定的功能，需要为其提供额外的信息才行。例如，现实生活中电饭锅可以实现“煮饭”的功能，但前提是我们必须提供食材，如果我们什么都不提供，那就真是的“巧妇难为无米之炊”了。我们可以通过在方法中加入参数列表接收外部传入的数据信息，参数可以是任意的基本类型数据或引用类型数据。
我们先来看一个带参数，但没有返回值的方法：
public void show(String name){
System.out.println("欢迎您，"+name);
}
上面的代码定义了一个 show 方法，带有一个参数 name ，实现输出欢迎消息。
调用带参方法与调用无参方法的语法类似，但在调用时必须传入实际的参数值
对象名.方法名（实参1，实参2，......，实参n）
很多时候，我们把定义方法时的参数称为形参，目的是用来定义方法需要传入的参数的个数和类型；把调用方法时的参数称为实参，是传递给方法真正被处理的值。
一定不可忽视的问题：
1、 调用带参方法时，必须保证实参的数量、类型、顺序与形参一一对应
2、 调用方法时，实参不需要指定数据类型
3、 方法的参数可以是基本数据类型，如 int、double 等，也可以是引用数据类型，如 String、数组等
4、 当方法参数有多个时，多个参数间以逗号分隔
如果方法既包含参数，又带有返回值，我们称为带参带返回值的方法。
例如：下面的代码，定义了一个 show 方法，带有一个参数 name ，方法执行后返回一个 String 类型的结果
public String show(String name){
return "欢迎你，"+name;
}
调用带参带返回值的方法：
HelloWorld hello =new HelloWorld();
String welcome =hello.show("java");
System.out.println(welcome);
结果为：欢迎你，java
示例代码
1 //方法是可以重复使用的代码块 2 public class MethodTest{ 3 4 //定义 5 /* 6 public static <返回值类型> <方法名>(<参数类型> <参数名>,... ){ 7 8 方法体； 9 [return 表达值] 10 注意：返回值类型为void的时候，方法没有返回值，return可以省略 11 } 12 public 表示公共的，修饰的方法可以在任意的类当中使用 13 static 表示静态的，修饰的方法可以通过类名直接调用，如若在同一个类中，类名可以省略 14 返回值类型 可以是Java中任何数据类型，如果没有返回值，返回值类型为viod 15 方法名称 符合标识符定义规则 16 参数列表 定义在()中，如果没有参数可以不写，但()不能省略 17 方法体 完成功能的代码，注意return的使用 18 19 20 */ 21 //调用 22 /* 23 方法名称(实际参数); 24 */ 25 26 //无参无返回值方法 27 public static void print(){ 28 29 System.out.println("********"); 30 } 31 32 public void show(){ 33 34 System.out.println("学习 Java 编程"); 35 } 36 37 //有参有返回值方法 38 public static int add(int a,int b){ 39 40 return a+b; 41 } 42 43 public static double avg(double x,double y){ 44 45 double z=(x+y)/2; 46 return z; 47 } 48 49 //main() Java程序执行的入口 50 public static void main(String args[]){ 51 52 //调用方法print 53 //直接静态方法名调用 54 print(); 55 //类名调用 56 MethodTest.print(); 57 //创建类的对象调用 58 MethodTest hello = new MethodTest(); 59 hello.show(); 60 61 int num1=2; 62 int num2=3; 63 System.out.println(add(num1,num2)); 64 65 double c =90; 66 double d =59.5; 67 double e=avg(c,d); 68 System.out.println("平均值为"+e); 69 70 int arr[]=new int[3]; 71 arr[0]=1; 72 arr[1]=2; 73 arr[2]=3; 74 int s=sum(arr); //实参写数组的名称 75 System.out.println("和为"+s); 76 int m=max(arr); 77 System.out.println("最大值为"+m); 78 79 double[] arr1 =getArr(4); 80 for(int i =0;i<arr1.length;i++){ 81 82 System.out.print(arr1[i]+","); 83 } 84 85 86 } 87 88 //数组作为方法的参数 89 public static int sum(int[] arr){ 90 91 int s=0; 92 for(int i=0;i<arr.length;i++){ 93 94 s+=arr[i]; 95 } 96 return s; 97 } 98 99 public static int max(int[] arr){ 100 101 int max=arr[0]; 102 for(int i =0;i<arr.length;i++){ 103 104 if(arr[i]>max){ 105 max=arr[i]; 106 } 107 } 108 return max; 109 } 110 111 //返回值类型是数组 112 public static double[] getArr(int n){ 113 114 double arr[]=new double[n]; 115 for(int i =0;i<arr.length;i++){ 116 arr[i]=Math.random(); 117 } 118 return arr; 119 } 120 }
字符串
在程序开发中字符串无处不在，如用户登陆时输入的用户名、密码等使用的就是字符串。其实，在前面的章节中我们就已经使用了字符串，例如我们在控制台中输出的 "Hello World"
在 Java 中，字符串被作为 String 类型的对象处理。 String 类位于 java.lang 包中。默认情况下，该包被自动导入所有的程序。
创建 String 对象的方法：
String s1="java";
String s2=new String();
String s3=new String("java");
String 对象创建后则不能被修改，是不可变的，所谓的修改其实是创建了新的对象，所指向的内存空间不同。
String 类提供了许多用来处理字符串的方法，例如，获取字符串长度、对字符串进行截取、将字符串转换为大写或小写、字符串分割等，下面我们就来领略它的强大之处吧。
String 类的常用方法：
结合代码来熟悉一下方法的使用：
运行结果：
友情提示：
1. 字符串中字符的索引从0开始，范围为 0 到 字符串长度-1
2. 使用 indexOf 进行字符或字符串查找时，如果匹配返回位置索引；如果没有匹配结果，返回 -1
3. 使用 substring(beginIndex , endIndex) 进行字符串截取时，包括 beginIndex 位置的字符，不包括 endIndex 位置的字符
那么，“==” 和 equals() 有什么区别呢？
==: 判断两个字符串在内存中首地址是否相同，即判断是否是同一个字符串对象
equals(): 比较存储在两个字符串对象中的内容是否一致
PS：字节是计算机存储信息的基本单位，1 个字节等于 8 位， gbk 编码中 1 个汉字字符存储需要 2 个字节，1 个英文字符存储需要 1 个字节。所以我们看到上面的程序运行结果中，每个汉字对应两个字节值，如“学”对应 “-47 -89” ，而英文字母 “J” 对应 “74” 。同时，我们还发现汉字对应的字节值为负数，原因在于每个字节是 8 位，最大值不能超过 127，而汉字转换为字节后超过 127，如果超过就会溢出，以负数的形式显示。
在Java中，除了可以使用 String 类来存储字符串，还可以使用 StringBuilder 类或 StringBuffer 类存储字符串，那么它们之间有什么区别呢？
String 类具有是不可变性。
程序运行时会额外创建一个对象，保存数据，当频繁操作字符串时，就会额外产生很多临时变量。使用 StringBuilder 或 StringBuffer 就可以避免这个问题。至于 StringBuilder 和StringBuffer ，它们基本相似，不同之处，StringBuffer 是线程安全的，而 StringBuilder 则没有实现线程安全功能，所以性能略高。因此一般情况下，如果需要创建一个内容可变的字符串对象，应优先考虑使用 StringBuilder 类。
那么如何定义 StringBuilder 类的对象呢？ 我们来看下面的代码：
// 创建一个StringBuilder对象，用来存储字符串
StringBuilder hobby=new StringBuilder("java");
StringBuilder 类提供了很多方法来操作字符串：
例如：在下面的示例代码中，创建了 StringBuilder 对象，用来存储字符串，并对其做了追加和插入操作。这些操作修改了 str 对象的值，而没有创建新的对象，这就是 StringBuilder 和 String 最大的区别。
运行结果：
示例代码
1 //字符串 字符的序列 2 //String类 创建后不再修改的字符串常量 3 //StringBuffer 可以修改的字符串变量 4 5 public class StringTest{ 6 7 public static void main(String args[]){ 8 9 //定义字符串 10 String hello ="hello world!"; 11 12 //length() 获取字符串的长度 13 System.out.println("字符串的长度是："+hello.length()); 14 15 //charAt(int 索引) 获取字符串中的指定的字符 16 char ch =hello.charAt(0); 17 System.out.println("ch="+ch); 18 19 //intdexOf(int ‘ch’) 返回指定字符在字符串中的首次出现的索引,如果不存在返回-1 20 int idx =hello.indexOf(‘l‘); 21 while(idx!=-1){ 22 23 System.out.println("idx="+idx); 24 idx = hello.indexOf(‘l‘,idx+1); 25 } 26 27 //toUpperCase() 全部转大写，结果以新的字符串返回，原字符串内容不变 28 String hello_new=hello.toUpperCase(); 29 System.out.println("hello="+hello); 30 System.out.println(hello_new); 31 32 //toLowerCase() 全部转小写 33 34 //trim 将字符串前后包含的空白字符去掉 35 String str2 = " test 1 "; 36 String str2_new=str2.trim(); 37 System.out.println(str2); 38 System.out.println(str2_new); 39 40 //substring(int 起始索引,int 结束索引) 41 String str3=hello.substring(0,2); 42 System.out.println(str3); 43 44 //equals(String 另一个字符) 比较两个字符串内容是否相同 45 boolean b1=hello.equals("hello world!"); 46 System.out.println(b1); 47 48 //valueOf() 其他类型数据转换成字符串 49 //split 50 String str5 = "Hello world java haha"; 51 52 String[] arr = str5.split(" "); 53 for(int i=0;i<arr.length;i++){ 54 System.out.println(arr[i]); 55 } 56 } 57 }
1 //equals 和 ==比较 2 public class StringTest2{ 3 4 public static void main(String args[]){ 5 6 String a="hello"; 7 String b="hello"; 8 String str1=new String("hello"); 9 String str2=new String("hello"); 10 System.out.println(str1+"--"+str2); 11 12 //equals(String 另一个字符) 比较内容 13 System.out.println(str1.equals(str2)); 14 15 //== 比较是否为同一个对象,通过比较内存地址是否相同来判断是否为同一对象 16 System.out.println(a==b); 17 } 18 }
新特性
在JDK5.0之后，Java中为了方便开发，引入了大量的新特性，这次主要介绍：可变参数、foreach输出。
一个方法在调用的时候必须根据其规定的参数传递参数，规定了5个，就必须传递五个，但是在JDK5.0之后，为了让方法更加具有灵活性，使用了可变参数，在调用方法的时候可以给出任意个数的实参。
可变参数的方法定义:
返回值类型 方法名称(参数类型…参数名称){}
数组的输出，一般都会使用for循环输出，为了方便数组的输出，提供了一种foreach语法，其语法 的使用格式如下，会遍历数组的元素。
for(数据类型 变量名称:数组名称){
……….
}
示例代码
1 //可变参数 2 //foreach 3 4 public class Test{ 5 6 //可变参数 7 /* 8 方法名称(参数类型...参数名){} 9 */ 10 11 //foreach输出 12 /* 13 for(数据类型 变量名：数组名){ 14 15 16 } 17 //注意数据类型和数组的数据类型一致 18 */ 19 public static void test(int... a){ 20 System.out.println(a.length); 21 int sum=0; 22 /*for(int i=0;i<a.length;i++){ 23 sum+=a[i]; 24 } 25 */ 26 for(int a1:a){ 27 sum+=a1; 28 System.out.println(a1); 29 } 30 System.out.println("sum="+sum); 31 32 } 33 34 public static void main(String args[]){ 35 test(5,6,67,6767,78); 36 37 } 38 }
练习
输入一句话，取反输出，按以下两种方式。例如：输入的是hello java，输出为java hello、avaj olleh。
1 //输入一句话，取反输出，按以下两种方式。例如：输入的是hello java，输出为java hello、avaj olleh。 2 import java.util.Scanner; 3 public class HWday3Test1{ 4 5 public static void main(String args[]){ 6 7 System.out.print("请输入一句话："); 8 9 Scanner scan=new Scanner(System.in); 10 11 String a=scan.nextLine(); 12 13 out(a); 14 15 16 17 } 18 public static void out(String number) { 19 20 String[] numbers = number.split(" "); 21 22 StringBuffer sb = new StringBuffer(); 23 24 for (int i = numbers.length -1; i >= 0; i--) { 25 26 sb.append(numbers[i]); 27 28 if(i > 0) { 29 30 sb.append(" "); 31 } 32 } 33 System.out.println(sb.toString()); 34 35 char[] ch = new char[number.length()]; 36 37 sb = new StringBuffer(); 38 39 for (int i =0 ; i<ch.length;i++){ 40 41 ch[i]=number.charAt(i); 42 } 43 44 for (int i = ch.length - 1; i >= 0; i--) { 45 46 sb.append(ch[i]); 47 } 48 System.out.println(sb.toString()); 49 } 50 51 52 }
定义一个整数数组并初始化，编写两个方法分别获取这个数组的最大值和最小值。
1 //定义一个整数数组并初始化，编写两个方法分别获取这个数组的最大值和最小值。 2 3 public class HWDay3Test2{ 4 5 public static void main(String args[]){ 6 7 int[] arr={3,23,45,65464,778}; 8 9 min(arr); 10 11 max(arr); 12 } 13 14 public static void min(int[] arr){ 15 16 int min=arr[0]; 17 for(int i =0;i<arr.length;i++){ 18 19 if(arr[i]<min){ 20 min=arr[i]; 21 } 22 } 23 System.out.println("最小值为："+min); 24 } 25 26 public static void max(int[] arr){ 27 28 int max=arr[0]; 29 for(int i =0;i<arr.length;i++){ 30 31 if(arr[i]>max){ 32 max=arr[i]; 33 } 34 } 35 System.out.println("最大值为："+max); 36 } 37 }
编写方法，打印1-100之间所有的偶数，每行显示10个数字，每个数字之间用空格或“,”隔开。
1 //编写方法，打印1-100之间所有的偶数，每行显示10个数字，每个数字之间用空格或“,”隔开。 2 public class HWDay3Test3{ 3 4 public static void main(String args[]){ 5 6 show(); 7 } 8 9 public static void show(){ 10 11 int count=1; 12 13 for(int i=1;i<=100;i++){ 14 15 if(count>10){ 16 17 System.out.println(); 18 count=1; 19 } 20 if(i%2==0){ 21 22 count++; 23 System.out.print(i+"\\t"); 24 } 25 26 } 27 } 28 }
编写方法，将数字字符（‘1‘）转换成对应的数字（1）。如果可以转换，返回对应的数字；如果不能转换，则返回-1。
1 //编写方法，将数字字符（‘1‘）转换成对应的数字（1）。如果可以转换，返回对应的数字；如果不能转换，则返回-1。 2 import java.util.Scanner; 3 public class HWDay3Test4{ 4 5 public static int change(char a){ 6 7 if(a>=‘0‘&&a<=‘9‘){ 8 9 return a-48; 10 } 11 else{ 12 13 return -1; 14 } 15 } 16 17 public static void main(String args[]){ 18 19 System.out.print("请输入一个字符："); 20 21 Scanner scan=new Scanner(System.in); 22 23 char a =scan.next().charAt(0); 24 25 int b=change(a); 26 27 System.out.println(b); 28 } 29 }
编写方法，交换两个变量的值。
1 //编写方法，交换两个变量的值。 2 import java.util.Scanner; 3 public class HWDay3Test5{ 4 5 public static void main(String args[]){ 6 7 Scanner scan=new Scanner(System.in); 8 9 System.out.print("输入变量a："); 10 11 String a = scan.next(); 12 13 System.out.print("输入变量b："); 14 15 String b =scan.next(); 16 17 change(a,b); 18 } 19 20 public static void change(String a,String b){ 21 22 String c = a; 23 24 System.out.println("交换前：a="+a); 25 26 System.out.println("交换前：b="+b); 27 28 a=b; 29 30 b=c; 31 32 System.out.println("交换后：a="+a); 33 34 System.out.println("交换后：b="+b); 35 } 36 }