零基础学Java——小白的Java之路(4)
方法
方法是一段可以重复调用的代码块,这个代码块实现了某个功能,当我们的程序中需要这一个功能的时候,调用这个方法即可,不再需要重复书写这个功能的代码。
方法的定义格式
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
示例代码
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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 最大的区别。
运行结果:
示例代码
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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 }
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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(数据类型 变量名称:数组名称){
……….
}
示例代码
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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 }
定义一个整数数组并初始化,编写两个方法分别获取这个数组的最大值和最小值。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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个数字,每个数字之间用空格或“,”隔开。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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 }
编写方法,交换两个变量的值。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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 }