方法的定义与参数和返回值分别为基本数据类型和引用数据类型的各种使用方式

方法的定义与及各种使用方式

1. 方法的概述：
   在我们的日常生活中，方法可以理解为要做某件事情，而采取的解决办法。
   如：小明同学在路边准备坐车来学校学习。这就面临着一件事情（坐车到学校这件事情）需要解决，解决办法呢？可采用坐公交车或坐出租车的方式来学校，那么，这种解决某件事情的办法，我们就称为方法。
   在java中，方法就是用来完成解决某件事情或实现某个功能的办法。
   方法实现的过程中，会包含很多条语句用于完成某些有意义的功能——通常是处理文本，控制输入或计算数值。
   我们可以通过在程序代码中引用方法名称和所需的参数，实现在该程序中执行（或称调用）该方法。方法，一般都有一个返回值，用来作为事情的处理结果。
2. 方法的定义格式：

/*
*修饰符 返回值类型 方法名(参数类型1 参数名1，参数类型2 参数名2 ....){
*代码块
*}
*/
public int getSum(int a, int b)
{
	return a + b;
}

  1. 修饰符：
   1). default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
   2). private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
   3). public : 对所有类可见。使用对象：类、接口、变量、方法。
   4). protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
  2. 返回值类型：
   1). 基本数据类型
   2). 类类型(基本类与抽象类两种)
   3). 接口类型
  3. 方法名：通常使用小驼峰的形式命名，同时要做到望名生义那样，切勿使用拼音命名。
  4. 参数类型：
   1). 基本数据类型
   2). 类类型
   3). 接口类型

3. 当返回值为基本数据类型时：

/**
 * 
 * @Title: getSum
 * @Description: 求俩个数的值
 * @param a
 * @param b
 * @return  int类型的result
 */
	public int getSum(int a, int b) {
		int result = a + b;
		return result;
	}
	/*
	 * 定义格式为：
	 * 修饰符 数据类型 方法名(参数列表){
	 * 		代码块;
	 * return 数据类型;
	 * }
	 */

4. 当传递参数为类类型时：（常用，在以后的面向对象开发时）
   因为在编写程序中，会经常碰到调用的方法要接收的是一个类类型的情况，那么这时，要向方法中传入该类的对象。
   创建一个Student类：

public class Student {
	private String name;
	private int age;
	
	public void study() {
		System.out.println("学生在学习");
	}
}

然后创建一个Text类进行实现：

public class Text {
	public static void main(String[] args) {
		Student student = new Student();
		method(student);
	}
	/*
	 * 定义一个方法method，用来接收一个Student参数
	 * 在方法中调用Student对象的study方法
	 */
	public static void method(Student student){
		student.study();
	}
}

5. 当返回类型为类类型时：

    定义格式：
    修饰符 类类型 方法(参数列表){
      代码块;
      return new 类类型;//因为返回值类型是类类型，所以要使用类类型的对象进行接收
      } 
   

   代码如下所示：

public class Text {
	public static void main(String[] args) {
		Student student = operatorStudent();//因为返回值为Student类型，
		//所以需要使用Student类型接收，或者使用其父类进行接收(也就是多态)
		//实际就是等价于Student student = new Student();
		student.study();
	}
	/*
	 * 定义一个方法operatorStudent，用来接收一个Student对象
	 * 返回值为Student对象
	 */
	public static Student operatorStudent() {
		return new Student();
	}
}

6. 抽象类作为方法的参数：
   今后开发中，抽象类作为方法参数的情况也很多见。当遇到方法参数为抽象类类型时，要传入一个实现抽象类所有抽象方法的子类对象。

    抽象类的定义：
    修饰符 abstract class 类名{
    		成员变量；
    		修饰符 abstract void 方法名(); //切记，抽象类定义的方法是没有方法体的，所以需要
    		//子类进行重写方法进行实现
    }
    抽象类是不能实例化对象的，需要通过子类进行new对象。
   

   代码举例如下：

//抽象类
abstract class Person{
	public abstract void show();
}
//抽象类的子类
class Student extends Person{
	@Override
	public void show() {
		System.out.println("重写了show方法");
	}
}
//测试类
public class Test {
	public static void main(String[] args) {
		//通过多态的方式，创建一个Person类型的变量，而这个对象实际是Student
		Person p = new Student();
		//调用method方法
		method(p);
	}
			
	//定义一个方法method，用来接收一个Person类型对象，在方法中调用Person对象的show方法
	public static void method(Person p){//抽象类作为参数
		//通过p变量调用show方法,这时实际调用的是Student对象中的show方法
		p.show();	
}
}

7. 抽象类作为方法返回值：
   抽象类作为方法返回值的情况，也是有的，这时需要返回一个实现抽象类所有抽象方法的子类对象。如下代码演示：

abstract class Person{
			public abstract void show();
}
class Student extends Person{
	@Override
	public void show() {
		System.out.println("重写了show方法");
	}
}
//测试类
public class Test {
	public static void main(String[] args) {
		//调用method方法，获取返回的Person对象
		Person p = method();
		//通过p变量调用show方法,这时实际调用的是Student对象中的show方法
		p.show();
	}
			
	//定义一个方法method，用来获取一个Person对象，在方法中完成Person对象的创建
	public static Person method(){
		Person p = new Student();
		return p;
	}
}

8. 接口作为方法参数：
   当遇到方法参数为接口类型时，那么该方法要传入一个接口实现类对象。

    接口的定义格式：
    修饰符 interface 接口名{
    		成员变量；
    		抽象方法;
    }
    接口无法实例化，只能由实现接口的类来实现接口中的方法。
    当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类
    类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。
    实现一个接口的语法，可以使用这个公式：
    ...implements 接口名称[, 其他接口名称, 其他接口名称..., ...]
   

//定义接口Study
interface Study{
			public abstract void studyEnglish();
		}
//定义接口的实现类Student
class Student implements Study{
	@Override
	public void studyEnglish() {
		System.out.println("学生正在学习英语");
	}
}
//测试类
public class Test {
	public static void main(String[] args) {
		//通过多态的方式，创建一个Study类型的变量，而这个对象实际是Student
		Study s = new Student();
		//调用method方法
		method(s);
	}
			
	//定义一个方法method，用来接收一个Study类型对象，在方法中调用Study对象的studyEnglish方法
	public static void method(Study study){//接口作为参数
		//通过study变量调用studyEnglish方法，这时实际调用的是Student对象中的studyEnglish方法
		study.studyEnglish();
	}
}

9. 接口作为方法返回值：

//定义接口Study
interface Study{
			public abstract void studyEnglish();
		}
//定义接口的实现类Student
class Student implements Study{
	@Override
	public void studyEnglish() {
		System.out.println("学生正在学习英语");
	}
}
//测试类
public class Test {
	public static void main(String[] args) {
		//调用method方法，获取返回的拥有英语学习能力的学生对象 
		Study s = method();//此处实际等于多态的调用 父类类型 变量名 = new 子类类型();
						   //Study s = new Student();
		//通过s变量调用studyEnglish方法,这时实际调用的是Student对象中的studyEnglish方法
		s.studyEnglish();
	}
			
	//定义一个方法method，用来接收一个具有英语学习能力的对象，并在方法中完成学生的创建
	public static Study method(){//接口作为返回值
		Student s = new Student();
		return s;
}

总结：

1. 当方法的返回值为基本数据类型时，return 的一定也是基本数据类型。
2. 当方法的返回值为类类型时，return 的一定也是类类型的对象，也就是 new 类类型()，如果是抽象类就是new 抽象类的任意子类类型。
3. 当方法的返回值为接口类型时，return 的一定也是接口的实现类对象，也就是 new 实现类类型()，此处可以为任意接口的实现类类型。
4. 当方法的参数为基本数据类型时，传递的也一定是基本数据类型。
5. 当方法的参数为类类型时，要把类类型的对象传递过去，如果数据是只使用一次，不用重复使用的话，可以选择使用匿名对象进行传递，否则使用正常的对象实例化的方式传递。
6. 在定义接口和抽象类时，要记住的是接口和抽象类不能实例化对象，因为他们没有具体的实现方法，在编写抽象类的子类时要重新父类的所有抽象方法，否则需要定义为抽象类，接口也是同理。