一：形式参数与返回值问题:
1.形式参数： 基本数据类型：
引用数据类型：
1）类(具体类）：
2）抽象类：
3）接口：
类(具体类）：方法的形式参数如果是一个引用类型,并且引用是一个具体类,需要传递的是该类型具体对象。
package org.westos.demo;
//定义Person类
class Person {
public void eat() {
System.out.println("为一天吃三顿饭");
}
}
//定义Student类
class Student {
public void Methond(Person p){//这时Methond()中的形式参数为Person p
p.eat();
}
}
//测试类
public class Demo1 {
//主方法
public static void main(String[] args) {
//创建一个Student类对象
Student s = new Student();
//创建一个Person类对象
Person p = new Person();
s.Methond(p);//通过Student类对象s调用Methon()方法，传递得参数为Person类对象的引用
}
}
抽象类：遇到形式参数是抽象类的解决方式有两种
方式一：传统方式 形参是一个抽象类,那么实际需要该抽象类子类对象 (抽象类多态) ；因为抽象类不能实例化，所以不能像具体类那样直接创建对象，将引用变量进行传递。所以得通过该抽象类子类（抽象类多态）来进行。
package org.westos.demo;
//形参是一个抽象类,那么实际需要该抽象类子类对象 (抽象类多态)
//定义Person1抽象类
abstract class Person1 {
public abstract void show1();
}
//定义一个子类Student1
class Student1 extends Person1 {
public void show1() {
System.out.println("形参是抽象类的引用变量 通过传统方法来解决");
}
}
class StudentMethon {
public void Methon(Person1 p) {
p.show1();
}
}
public class Demo2 {
public static void main(String[] args) {
//创建一个StudentMethon队形
StudentMethon sm = new StudentMethon();
//多态
Person1 p = new Student1();
sm.Methon(p);
}
}
方式二：通过匿名类来解决（推荐使用）
package org.westos.demo;
//通过匿名内部类来方式来解决形参是抽象类的问题
//定义抽象类Person3
abstract class Person3 {
public abstract void show();
}
// 定义StudentMethon3类
class StudentMethon3 {
public void Methon(Person3 p) {
p.show();
}
}
// 测试类
public class Dome3 {
// 主方法
public static void main(String[] args) {
// 创建一个StudentMethon3类对象
StudentMethon3 sm = new StudentMethon3();
// 创建一个Person3类对象
Person3 p = new Person3() {//匿名内部类
public void show() {// 方法重写
System.out.println("形参是抽象类，通过匿名类来解决");
}
};
sm.Methon(p);
}
}
接口：遇到形式参数是抽象类的解决方式有两种
方式一：形参是一个接口类型:需要该接口的子实现类的对象 (接口多态)。 同样和抽象方法一样，接口也不可以进行实例化，所以通过自实现类来解决这个问题。
package org.westos.demo;
//参数类型为接口 传统方式需要该接口的子实现类的对象
//定义一个接口
interface Person4 {
public abstract void show();
}
// 接口的自实现类
class Student4 implements Person4 {
public void show() {
System.out.println("参数为接口类型 通过传统方式解决");
}
}
// 定义一个StudentMethon4类
class StudentMethon4 {
public void Methon(Person4 p) {
p.show();
}
}
// 测试类
public class Demo4 {
// 主方法
public static void main(String[] args) {
// 创建一个StudentMethon4类的对象
StudentMethon4 sm = new StudentMethon4();
// 接口多态
Person4 p = new Student4();
sm.Methon(p);
}
}
方式二：通过匿名内部类来解决（推荐使用）
package org.westos.demo;
//通过匿名内部类来解决参数是接口类型变量的问题
//创建一个接口
interface Person5 {
public abstract void show();
}
// 创建一个StudentMethon5类
class StudentMethon5 {
public void Methon(Person5 p) {
p.show();
}
}
// 测试类
public class Demo5 {
// 主方法
public static void main(String[] args) {
// 创建一个StudentMethon5类对象
StudentMethon5 sm = new StudentMethon5();
// 匿名类
Person5 p = new Person5() {
public void show() {
System.out.println("我的参数是接口 通过匿名内部类来解决");
}
};
sm.Methon(p);
}
}
1.返回值： 基本数据类型：
引用数据类型：
1）类(具体类）：需要该具体类 具体对象(或者匿名对象)
2）抽象类：需要返回的是该子类的对象
3）接口： 需要该接口子实现类对象;
类(具体类)：需要该具体类 具体对象(或者匿名对象)
方式一:传统方式, 创建一个具体类对象
方式二: 采用匿名对象(在参数只使用一次的情况下);
package org.westos.Demo3;
//定义一个具体类
class Student {
public void show() {
System.out.println("我返回的是一个具体类对象");
}
}
// 定义一个StudentMethod类
class StudentMethod {
// 定义一个Method方法 返回值为Student类对象
public Student Method() {
// Student s = new Student();//方式一 传统方式 创建一个Student对象
return new Student();// 方式 二 采用匿名对象
}
}
// 测试类
public class StudentTest {
// 主方法
public static void main(String[] args) {
// 创建一个StudentMethod类对象
StudentMethod sm = new StudentMethod();
// Student s = sm.Method();
// s.show();
sm.Method().show();// 链式编程 sm.Method()返回一定是一个对象
}
}抽象类: 需要返回的是该子类的对象
由于抽象类部可以实例化,所以得通过子类间接得创建对象(抽象类多态)
package org.westos.Demo3;
//定义一个抽象类Person1
abstract class Person1 {
public abstract void show1();
}
// 定义一个Student1类
class Student1 extends Person1 {
public void show1() {
System.out.println("我返回得是一个抽象类");
}
}
// 定义一个StudentMethod1类
class StudentMethod1 {
public Person1 Method1() {// 定义一个Method1方法 返回值为抽象类Person1得对象
Person1 p = new Student1();// 抽象类多态,通过子类间接创建对象
return p;
}
}
// 测试类
public class StudentTest1 {
// 主方法
public static void main(String[] args) {
// 创建一个 StudentMethod1类对象
StudentMethod1 sm = new StudentMethod1();
Person1 p = sm.Method1();
p.show1();
}
}
接口: 需要该接口子实现类对象;
同样和抽象类一样,接口不可以实例化,通过子实现类间接创建对象;
package org.westos.Demo3;
//定义一个接口
interface StuInter {
public abstract void show2();
}
// 定义一个Student2类实现接口StuInter
class Student2 implements StuInter {
public void show2() {
System.out.println("我返回得是一个接口");
}
}
// 定义一个StudentMethod2类
class StudentMethod2 {
public StuInter Method3() {
StuInter i = new Student2();// 通过子实现类创建对象 接口多态
return i;
}
}
// 测试类
public class StudentTest2 {
// 主方法
public static void main(String[] args) {
StudentMethod2 sm = new StudentMethod2();
StuInter s = sm.Method3();
s.show2();
}
}