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)具体类:
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();
}
}
总结:
形式参数是引用类型
①具体类:如果形式参数是一个具体类,那么需要创建该类对象
②抽象类:如果形式参数是抽象类的情况,那么需要自定义一个抽象类的子类,来进行实例化(创建对象)!,创建对象的实质:抽象类多态!
③接口: 如果形式参数是接口情况,那么需要自定义一个接口的子实现类,然后通过接口多态的形式给接口进行实例化!
返回值是引用类型
①具体类:直接返回该类对象(通常实际开发中使用的是匿名对象)
②抽象类:返回值如果是抽象类,需要的返回是该抽象类的子类对象
③接口: 返回值如果是接口,需要的返回是实现该接口的子类对象