java程序员从笨鸟到菜鸟之(十)形式参数和返回值问题

1 形式参数

1) 基本类型

形式参数：想要什么样数据类型，在实际传参的时候就传什么数据类型；

①仅以浮点型(float)为例；参数类型为float

实例1：

class Demo {
	// 成员方法
	public float sum(float a, float b) {
		return (a + b);
	}
}

②String类型(不是基本类型，后续会提到)

说明：①形式参数的改变对实际参数没有影响

            ②虽然String是引用类型，但和基本数据类型的效果一样       

2)引用类型

1) 具体类

形式参数：如果形式参数是一个具体类,那么需要创建该类对象，

创建具体类对象的语法格式：类名  引用名=new 类名(参数)；

实例2：

package 可删除的;

class Student {
	public void show() {
		System.out.println("我爱洗澡，皮肤好好......");
	}
}

// 测试类
public class StudentDemo {

	public void method(Student s) {
		/*
		 * 分析：形式参数是一个引用类型; 
		 * 那么需要该类对象:Student student = new Student();
		 * 参数实际传递过程:Student s = student;
		 */
		s.show();
	}
    //主方法入口
	public static void main(String[] args) {
		StudentDemo s = new StudentDemo();
		Student student = new Student();
		s.method(student);
		/*
		 * 开发中常用(匿名对象)
		  s.method(new Student());
		*/

	}
}

说明：通常在实际开发中使用的是匿名对象直接返回该类对象

2) 抽象类

抽象类：如果形式参数是抽象类的情况,那么需要自定义一个抽象类的子类,来进行实例化(创建对象)!

创建对象的实质：抽象类多态!

创建抽象类对象的格式 ：抽象类 引用名=new 子类() ；

实例3：

package 瞎弄;

/*如果形式参数是引用类型:
	  具体类类:如果形式参数是一个具体类,那么需要创建该类对象，
	  抽象类:如果形式参数是抽象类的情况,那么需要自定义一个抽象类的子类,来进行实例化(创建对象)!,创建对象的实质:接口多态!
	  接口:如果形式参数是接口的情况,那么需要自定义一个实现接口的子类来创建对象!实质:抽象类多态!
	*					
	 **/

//声明一个抽象类
abstract class Person {
	public abstract void study();

}

// 定义一个PersonDemo类
class PersonDemo {
	// 成员方法
	public void method(Person p) {
		/*
		 * 明确一点---参数传递过程:Person p=new PersonDemo(); 
		 * 分析：Person是抽象类，不能直接创建对象，
		 * 即：Person p = new Perosn();报错 
		 * 通过抽象类多态(三要素)创建对象
		 * 
		 */
		p.study();// 方法重写
	}
}

// 自定义一个抽象的子类来进行Person的实例化
class Student2 extends Person {

	@Override
	public void study() {
		System.out.println("哎!又到周末了...");
	}

}

// 测试类
public class PersonTest {
	public static void main(String[] args) {
		/*
		 * 需求:调用PersonDemo类中method()方法 
		 * 先创建PersonDemo类的对象：PersonDemo pd = newPersonDemo(); 
		 * 然后调用pd.method()方法 ;
		 * 由于方法中的参数类型是抽象类型，必须创建抽象类子类对象来传参数
		 * 即：Person p = new Student2();
		 * 然后将参数p传入method()中，即:pd.method(p)
		 * 需要使用抽象类多态来实例化:
		 */
		PersonDemo pd = new PersonDemo(); 
		Person p = new Student2();
		pd.method(p);

		// 链式编程:
		new PersonDemo().method(new Student2());
	}
}

3) 接口

接口：如果形式参数是接口的情况,那么需要自定义一个实现接口的子类来创建对象!

创建对象的实质：接口多态！

创建接口的实例：接口 引用=new 实现接口的子类()；

实例4：

//定义一个接口
interface Inter{
	public abstract void love();
}

//定义一个类
class TeacherDemo{
	public void method(Inter i){
		/*接口不能实例化:  
		 *如果一个方法的形式参数是一个接口,那么需要创建该接口的子实现类对象
		 *分析：使用其中的方法，首先要创建TeacherDemo
		 *然后调用method()的方法，根据参数类型传参
		 *实际参数传递：Inter i=new Student3();
		 *理解接口类多态就不难理解这个地方了
		 */
		i.love() ;
	}
}

//接口的子实现类
class Student3 implements Inter{

	@Override
	public void love() {
		System.out.println("又到周末了，耶！");
	}
	
}
//测试类
public class TeacherTest {
	public static void main(String[] args) {
		/*方式1：
		 *需求:需要调用TeacherDemo类中的method()方法
		 *先创建该类对象
		*/
		TeacherDemo td = new TeacherDemo() ;
		/*根据方法中的参数类型
		 *创建该接口对象:通过接口多态
		 **/
		Inter i = new Student3() ; //接口多态
		td.method(i);
		
		//方式2：链式编程
		new TeacherDemo().method(new Student3());
		
		//方式3：匿名内部类创建对象(不用创建借口的子实现类)
		new TeacherDemo().method(new Inter() {
			
			@Override
			public void love() {
				System.out.println("又到周末了，好痛苦！");
				
			}
		});
	
	}
}

4) 数组(特殊引用类型)(后续会补充)

2 返回值

1) 基本类型

    数组类型(非基本类型，后续会补充)

    String类型(非基本类型，后续会补充)

2)引用类型

1）具体类：

       直接返回该类的对象

实例5：

 

package 可删除的;

class Student {
	public void show() {
		System.out.println("我爱洗澡，皮肤好好......");
	}
}

// 测试类
public class StudentDemo {

	public Student method() {
		/*
		 * 分析：如果方法的返回值类型是一个具体类型;
		 * 需要返回该类型的一个对象
		 * 即：Student s = new Student();
		 * 返回 s
		 * s就代表Student类的对象,把空间地址值(引用)作为参数传递
		 */
		Student s = new Student();
		return s;
		
		/*
		 * 开发常用方式(等价上述)：
		 * 匿名对象：return new Student();   
		*/
	}
    //主方法入口
	public static void main(String[] args) {
		StudentDemo s = new StudentDemo();
		s.method();
		/*开发中常用：
		 *new StudentDemo().method()
		 */
	}
}

2）抽象类

     如果返回值是抽象类型，需要返回的是该抽象类的子类对象

实例6：

package 可删除的;

/**
 * 返回值: 具体类:直接返回该类对象(通常实际开发中使用的是匿名对象) 
 * 抽象类:返回值如果是抽象类,需要的返回是该抽象类的子类对象
 * 接口:返回值如果是接口,需要的返回是实现该接口的子实现类对象
 */

// 抽象类
abstract class Person2 {
	public abstract void show();
}

// 定义PersonDemo2类
class PersonDemo2 {
	public Person2 method() {
		/*
		 * 如果一个方法的返回值是一个抽象类,
		 * 需要的返回是该抽象类的子类对象 
		 * 返回值的传递等价于：
		 * Person2 p = new Teacher() ; 
		 * return p;
		 */
		return new Teacher();//开发中常用
	}
}

// 抽象类的子类
class Teacher extends Person2 {

	@Override
	public void show() {
		System.out.println("老师爱高圆圆,我爱谁呢？...");
	}

}

// 测试类
public class PersonTest2 {
	public static void main(String[] args) {
		/* 
		 * 需求:
		 * 要调用PersonDemo2这个类中的method()方法
		 * 分析：要调用PersonDemo2首先创建对象
		 * 然后调用PersonDemo2类的对象方法，得到一个抽象类Person2的对象
		 * 调用该类对象的方法(涉及方法重写)
		 */
		PersonDemo2 pd = new PersonDemo2();
		Person2 p = pd.method();
		p.show();//方法重写
		System.out.println("----------------");

		//链式编程(开发常用)
		Person2 p2 = new PersonDemo2().method();
		p2.show();
	}
}

3）接口

     如果返回值是接口，需要返回的是实现该接口的子类对象

实例7：

package 可删除的;

/**
 * 返回值:具体类:直接返回该类对象(通常实际开发中使用的是匿名对象) 
 * 抽象类:返回值如果是抽象类,需要的返回是该抽象类的子类对象
 * 接口:返回值如果是接口,需要的返回是实现该接口的子实现类对象
 */

interface Inter1{
	public abstract void show() ;
}

// 定义PersonDemo2类
class PersonDemo2 {
	public Inter1 method() {
		/*
		 * 如果一个方法的返回值是一个接口,
		 * 需要的返回是该接口的子实现类的对象 
		 * 返回值的传递等价于：
		 * Inter p = new Teacher() ; 
		 * return p;
		 */
		return new Teacher();//开发中常用
	}
}

// 接口的子实现类
class Teacher implements Inter1 {

	@Override
	public void show() {
		System.out.println("老师爱高圆圆,我爱谁呢？...");
	}

}

// 测试类
public class PersonTest2 {
	public static void main(String[] args) {
		/* 
		 * 需求:
		 * 要调用PersonDemo2这个类中的method()方法,重写接口中的方法
		 * 分析：要调用PersonDemo2
		 * 首先创建对象，然后调用PersonDemo2类的对象方法
		 * 根据返回值类型返回一个借口的对象
		 * 即：创建一个借口的子实现类对象
		 * 调用该类对象的方法(涉及方法重写)
		 */
		PersonDemo2 pd = new PersonDemo2();
		Inter1 p = pd.method();
		p.show();//方法重写
		System.out.println("----------------");

		//链式编程(开发常用)
		Inter1 p2 = new PersonDemo2().method();
		p2.show();
	}
}

总结：

形式参数是引用类型
①具体类：如果形式参数是一个具体类,那么需要创建该类对象
②抽象类：如果形式参数是抽象类的情况,那么需要自定义一个抽象类的子类,来进行实例化(创建对象)!,创建对象的实质:抽象类多态!
③接口：    如果形式参数是接口情况,那么需要自定义一个接口的子实现类,然后通过接口多态的形式给接口进行实例化!

返回值是引用类型

        ①具体类：直接返回该类对象(通常实际开发中使用的是匿名对象)
        ②抽象类：返回值如果是抽象类,需要的返回是该抽象类的子类对象
        ③接口：    返回值如果是接口,需要的返回是实现该接口的子类对象