方法

方法是一段可以重复调用的代码块，这个代码块实现了某个功能，当我们的程序中需要这一个功能的时候，调用这个方法即可，不再需要重复书写这个功能的代码。

方法的定义格式

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 classMethodTest{3

4 //定义

5 /*

6 public static ( ,... ){7

8 方法体；9 [return 表达值]10 注意：返回值类型为void的时候，方法没有返回值，return可以省略11 }12 public 表示公共的，修饰的方法可以在任意的类当中使用13 static 表示静态的，修饰的方法可以通过类名直接调用，如若在同一个类中，类名可以省略14 返回值类型 可以是Java中任何数据类型，如果没有返回值，返回值类型为viod15 方法名称 符合标识符定义规则16 参数列表 定义在()中，如果没有参数可以不写，但()不能省略17 方法体 完成功能的代码，注意return的使用18

19

20 */

21 //调用

22 /*

23 方法名称(实际参数);24 */

25

26 //无参无返回值方法

27 public static voidprint(){28

29 System.out.println("********");30 }31

32 public voidshow(){33

34 System.out.println("学习 Java 编程");35 }36

37 //有参有返回值方法

38 public static int add(int a,intb){39

40 return a+b;41 }42

43 public static double avg(double x,doubley){44

45 double z=(x+y)/2;46 returnz;47 }48

49 //main() Java程序执行的入口

50 public static voidmain(String args[]){51

52 //调用方法print53 //直接静态方法名调用

54 print();55 //类名调用

56 MethodTest.print();57 //创建类的对象调用

58 MethodTest hello = newMethodTest();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

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

94 s+=arr[i];95 }96 returns;97 }98

99 public static int max(int[] arr){100

101 int max=arr[0];102 for(int i =0;i

104 if(arr[i]>max){105 max=arr[i];106 }107 }108 returnmax;109 }110

111 //返回值类型是数组

112 public static double[] getArr(intn){113

114 double arr[]=new double[n];115 for(int i =0;i

方法

字符串

在程序开发中字符串无处不在，如用户登陆时输入的用户名、密码等使用的就是字符串。其实，在前面的章节中我们就已经使用了字符串，例如我们在控制台中输出的 "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 classStringTest{6

7 public static voidmain(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

字符串1

1 //equals 和 ==比较

2 public classStringTest2{3

4 public static voidmain(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 }

字符串2

新特性

在JDK5.0之后，Java中为了方便开发，引入了大量的新特性，这次主要介绍：可变参数、foreach输出。

一个方法在调用的时候必须根据其规定的参数传递参数，规定了5个，就必须传递五个，但是在JDK5.0之后，为了让方法更加具有灵活性，使用了可变参数，在调用方法的时候可以给出任意个数的实参。

可变参数的方法定义:

返回值类型   方法名称(参数类型…参数名称){}

数组的输出，一般都会使用for循环输出，为了方便数组的输出，提供了一种foreach语法，其语法 的使用格式如下，会遍历数组的元素。

for(数据类型 变量名称:数组名称){

……….

}

示例代码

1 //可变参数2 //foreach

3

4 public classTest{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

26 for(inta1:a){27 sum+=a1;28 System.out.println(a1);29 }30 System.out.println("sum="+sum);31

32 }33

34 public static voidmain(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 importjava.util.Scanner;3 public classHWday3Test1{4

5 public static voidmain(String args[]){6

7 System.out.print("请输入一句话：");8

9 Scanner scan=newScanner(System.in);10

11 String a=scan.nextLine();12

13 out(a);14

15

16

17 }18 public static voidout(String number) {19

20 String[] numbers = number.split(" ");21

22 StringBuffer sb = newStringBuffer();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 = newStringBuffer();38

39 for (int i =0 ; i

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 classHWDay3Test2{4

5 public static voidmain(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

19 if(arr[i]

26 public static void max(int[] arr){27

28 int max=arr[0];29 for(int i =0;i

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 classHWDay3Test3{3

4 public static voidmain(String args[]){5

6 show();7 }8

9 public static voidshow(){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 importjava.util.Scanner;3 public classHWDay3Test4{4

5 public static int change(chara){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 voidmain(String args[]){18

19 System.out.print("请输入一个字符：");20

21 Scanner scan=newScanner(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 importjava.util.Scanner;3 public classHWDay3Test5{4

5 public static voidmain(String args[]){6

7 Scanner scan=newScanner(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 voidchange(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 }

第五题