零基础学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 类的常用方法:

零基础学Java——小白的Java之路(4)_第1张图片

结合代码来熟悉一下方法的使用:

零基础学Java——小白的Java之路(4)_第2张图片

零基础学Java——小白的Java之路(4)_第3张图片

运行结果:

零基础学Java——小白的Java之路(4)_第4张图片

零基础学Java——小白的Java之路(4)_第5张图片

友情提示:

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 类提供了很多方法来操作字符串:

零基础学Java——小白的Java之路(4)_第6张图片

例如:在下面的示例代码中,创建了 StringBuilder 对象,用来存储字符串,并对其做了追加和插入操作。这些操作修改了 str 对象的值,而没有创建新的对象,这就是 StringBuilder 和 String 最大的区别。

零基础学Java——小白的Java之路(4)_第7张图片

运行结果:

示例代码

 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

你可能感兴趣的:(零基础学Java——小白的Java之路(4))