零基础学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

示例代码

  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){
 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){
 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){
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){
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){
54             System.out.println(arr[i]);   
55         }
56     }
57 }

字符串1

 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 }

字符串2

 

 

新特性

在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;i23             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){
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){
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){
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 }

第五题

 

转载于:https://www.cnblogs.com/xiaomiesang/p/8547735.html