黑马程序员技术交流社区

标题: java基础语法之方法详解 [打印本页]

作者: liangwaqi 时间: 2017-10-26 16:18
标题: java基础语法之方法详解
java中，如何调用方法
很多初学者在学习“方法”时，弄得很头晕，下面总结下，如何调用各种各样的方法。
先分两个方面来说明
1、先区分有哪些方法
2、针对每一种方法，怎么去调用

先来看看，如何区分方法有哪些
在java中，一般来说，方法就分为3种：
a、构造方法
b、普通方法
c、静态方法

下面是对以上3种方法的区分办法：
1、如果一个方法没有返回值类型（如果有返回值类型，它会在方法名左边出现），并且方法的名称和类名一模一样，那么这个方法就是构造方法
2、如果一个方法，有返回值类型，或者返回值类型是void，并且方法声明上没有static关键字，那么这个方法就是普通方法
3、如果一个方法，有关键字static，那么这个方法就是静态方法

如果上面3点看着有点吃力，那可以看下面的直观格式：
a、构造方法的格式：
权限修饰符构造方法名(参数列表){
方法体
}
b、普通方法格式：
权限修饰符返回值类型方法名(参数列表){
方法体
}
c、静态方法格式：
权限修饰符 static 返回值类型方法名(参数列表){
方法体
}

接下来开始说，如何去调用
注意：
1、由于怎么定义方法、怎么调用方法，都属于语法的内容，也就是java语言开发团队定义的规则，就好像是规章制度一样，人人必须遵守，所以为了快速学习，使用者就不要去想为什么这样定义、为什么这么调用的问题了，等你熟练了，你自然就会明白这些事情，目前就按照规则办事情先。
2、调用格式有好几种，这里只介绍一部分，掌握这一部分就足够。

下面是每种方法的调用格式，每一种格式，初学者都必须死记硬背下来，没有背下来的，就写不出代码。
a、构造方法按照下面格式调用：
格式1：new 构造方法名(参数列表);
格式2：类名  对象名 = new 构造方法名(参数列表);
注意：这里的对象名，其实就是一个变量名

b、普通方法按照下面格式调用：
格式1：对象.方法名(参数列表);    //返回值类型是void的时候采用这个格式
格式2：返回值类型  变量名 = 对象.方法名(参数列表);
注意：由此可见，普通方法不管用哪一种格式来调用，都需要提前准备好一个对象（也就是说要先调用构造方法，因为调用构造方法后，就得到一个对象，参考构造方法的调用格式）

c、静态方法按照下面格式调用：
格式1：类名.方法名(参数列表);    //返回值类型是void的时候采用这个格式
格式2：返回值类型  变量名 = 类名.方法名(参数列表);
注意：由此可见，静态方法的调用，不需要创建对象，直接类名来调用即可，也强烈要求通过类名来调用

接下来，开始各种代码
下面代码，由于篇幅有限，所以定义方法时，就写方法声明（即方法中，包含方法名的那一行代码），不写方法体了，因为只需要知道方法声明，就能知道怎么调用方法了：

假设有一个类 Demo。在这个类中有如下方法：
1、构造方法的调用如下(这些方法，都符合构造方法的格式，所以这些方法属于构造方法)
既然是构造方法，那调用格式有两个：
格式1：new 构造方法名(参数列表);
格式2：类名  对象名 = new 构造方法名(参数列表);

public Demo(){...}
上面方法，这样来调用：
第一种（采用格式1）：new 构造方法名(参数列表);
new Demo( ); //写完了，就这样调用！这种格式创建出来的对象，就叫匿名对象
第二种（采用格式2）：类名对象名 = new 构造方法名(参数列表);
Demo d1 = new Demo( ); //通过格式2创建出来的对象，叫做“有名字的对象”，对象名就是“d1

public Demo(int num){...}
这时候，方法上有参数了，按照一个原则来调用即可，原则：参数列表需要什么参数，需要几个参数，需要参数的顺序是什么，我们写代码时，就按照参数列表来传递参数即可（它需要什么参数，程序员就给什么参数即可）
第一种（采用格式1）：new 构造方法名(参数列表);
Demo(120); //因为参数是int类型，所以随便传递一个int类型的参数进来即可（120就是int类型的一个数字）

第二种（采用格式2）：类名对象名 = new 构造方法名(参数列表);
Demo d = new Demo(240);

public Demo(String str){...}
第一种（采用格式1）：new 构造方法名(参数列表);
new Demo("abc"); //因为参数列表是String str，也就是说，参数列表“规定”我们必须传递一个字符串进来，所以我就随便传递了一个字符串（“abc”）作为参数了
第二种（采用格式2）：类名对象名 = new 构造方法名(参数列表);
Demo d = new Demo("kkk");

public Demo(Person p){...}
第一种（采用格式1）：new 构造方法名(参数列表);
Person p = new Person( );
new Demo(p); //由于这个构造方法的参数列表中，参数类型是 Person，是一个类名，表明我们调用的时候，需要传递Person对象，或者Person的子类对象进来

Student stu = new Student( ); //Student是Person的子类
new Demo(stu);             //stu是Person的子类Student 创建出来的对象，所以stu也可以作为参数传递给这个构造方法

第二种（采用格式2）：类名对象名 = new 构造方法名(参数列表);
Demo d1 = new Demo(new Person( )); //把Person的匿名对象，作为参数
Demo d2 = new Demo(new Student( )); //把Student的匿名对象，作为参数

public Demo(int[ ] arr){...}
第一种（采用格式1）：new 构造方法名(参数列表);
int[ ] arr = {111,222,333};
new Demo(arr); //由于这个构造方法的参数列表是int[ ] arr，表明我们传递参数时，需要传递1个 int数组对象，所以我在前面就首先准备好了一个int数组对象（就是前面的arr）
第二种（采用格式2）：类名对象名 = new 构造方法名(参数列表);
int[ ] array = {3232, 4545, 6767};
Demo d = new Demo(array);

public Demo(String[ ] arr){...}
第一种（采用格式1）：new 构造方法名(参数列表);
String[ ] arr = {"aaa", "bbb", "ccc"};
new Demo(arr); //由于这个构造方法的参数列表是String[ ] arr，表明我们传递参数时，需要提前准备好一个字符串数组，所以调用前，我就准备好了前面的字符串数组{"aaa", "bbb", "ccc"};
第二种（采用格式2）：类名对象名 = new 构造方法名(参数列表);
String[ ] kkk = {"aaa", "bbb", "ccc"};
Demo d = new Demo(kkk);

public Demo(Person[ ] arr){...}
第一种（采用格式1）：new 构造方法名(参数列表);
Person[ ] personArr = {new Person( ),  new Person( ), new Person( )};
Demo(personArr); //由于这个构造方法的参数列表是Person[ ] arr，表明我们传递参数时，需要提前准备好一个Person数组，前面的personArr就是我准备好的Person数组
第二种（采用格式2）：类名对象名 = new 构造方法名(参数列表);
Person[ ] personArr = {new Person( ),  new Person( ), new Person( )};
Demo d = Demo(personArr);

2、普通方法的调用如下
//由于method01到method07方法，返回值类型都是void，所以这几个方法，只能采用格式1：对象.方法名(参数列表);

public void method01(){....}

//针对上面的方法，下面代码演示了怎么去调用该方法：

Demo d1 = new Demo( ); //创建对象的代码。d1，就是创建出来的对象
d1.method01( ); //这行调用方法的代码，就符合格式了：对象.方法名(参数列表);可见，必须提前准备好一个对象（d1）

new Demo( ).method01( ); //这行代码，也符合格式：对象.方法名(参数列表);  可见，new Demo()就是对象（匿名对象）

public void method02(int num1, int num2){....}
Demo d = new Demo();
d.method02(123, 777); //由于method02方法需要2个int类型的参数，所以调用时，需要传递2个int的数字即可。

public void method03(String str, boolean flag){....}
Demo d = new Demo();
d.method03("aaa", true); //这里传递参数时，需要一一对应，"aaa"对应参数列表中的str，true对应flag

public void method04(Person p1,  Person p2){....}
Demo d = new Demo();
Person px = new Person();
Person py = new Person();
d.method04(px, py); //由于method04方法，需要2个参数，依次是Person对象、Person对象，所以我在调用时，提前准备好了2个Person对象

public void method05(int[ ] arr){....}
Demo d = new Demo();
int[] array = {11,22,33,44,55};
d.method05(array);

public void method06(String[ ] arr,  int count){....}
Demo d = new Demo();
String[] strArr = {"aaa","bbb","ccc"};
int count = 666;
d.method06(strArr, count); //strArr对应method06的第一个参数，count对应第二个参数（仍然符合参数需要什么类型的参数，我就传递什么类型的参数）

public void method07(Person[ ] arr){....}
Demo d = new Demo();
Person[] arr = {new Person(), new Person(), new Person()}; //提前准备好一个Person数组
d.method07(arr);

//接下来，返回值类型不是void的普通方法，统一使用格式2：返回值类型  变量名 = 对象.方法名(参数列表);
public int method08( ){....}
Demo d = new Demo();
int num = d.method08( ); //非构造方法的方法名左边的东西，就叫做返回值类型，这里，int就是method08方法的返回值类型
System.out.println(num); //一般来说，拿到返回值num了，是需要进行下一步处理，例如在这里，我打印了

public String method09( ){....}
Demo d = new Demo();
String str = d.method09(); //method09方法的返回值类型是String，所以这里我用String，来接收method09的返回值
System.out.println(str);

public Person method10( ){....} //返回值类型是Person，是一个类名，表明调用该方法时，可以用Person类接收，也可以用Person的父类来接收
Demo d = new Demo();
Person p = d.method10();
System.out.println(p);

Object obj = d.method10(); //由于Object是Person的父类，所以也可以用Object来接收method10方法的返回值
System.out.println(obj);

public int[ ] method11( ){....} //返回值类型是int[]
Demo d = new Demo();
int[] arr = d.method11(); //返回值是一个数组，所以作为一个有好奇心的人，会好奇数组中有什么元素，所以下面我开始遍历数组了
for(int i=0; i<arr.length; i++){
System.out.println(arr[i] + " ");
}

public String[ ] method12( ){....}
Demo d = new Demo();
String[] arr = d.method12();
for(int i=0; i<arr.length; i++){
System.out.println(arr[i] + " ");
}

public Person[ ] method13( ){....}
Demo d = new Demo();
Person[] arr = d.method13();
for(int i=0; i<arr.length; i++){
System.out.println(arr[i] + " ");
}

3、静态方法的调用如下
method14到method19，返回值类型不是void类型，所以统一使用格式2：返回值类型  变量名 = 类名.方法名(参数列表);
public static int method14( ){....}
int num = Demo.method14();
System.out.println(num); //由于我很好奇num等于多少，所以这里就直接输出了

public static String method15( ){....}
String str = Demo.method15();
System.out.println(str);

public static Person method16( ){....}
Person p = Demo.method16();
String name = p.getName(); //获取p的姓名
System.out.println(name);  //打印姓名

public static int[ ] method17( ){....}
int[] arr = Demo.method17();
System.out.println(arr.length); //这次挺好奇arr数组的长度是多少，所以我只打印它的长度了

public static String[ ] method18( ){....}
String[] arr = Demo.method18();
System.out.println(arr[0]); //我只想打印arr数组的第一个元素，所以就不遍历这个数组了

public static Person[ ] method19( ){....}
Person[] arr = Demo.method19();
Person p = arr[0]; //我不想遍历数组，只想获取第一个元素的名字
String name = p.getName(); //获取名字
System.out.println(name); //打印出来，看看名字是什么

//method20方法的返回值类型是void，所以只能用格式1：类名.方法名(参数列表);
public static void method20( ){....}
Demo.method20();

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2