形式参数和返回值问题案例
形式参数的问题案例
程序示例
/*
形式参数：
基本数据类型（以前说过，这里不说了）：byte、short、int、long、float、double、char、boolean
引用数据类型：
类：当类作为方法的形式参数的时候，实际上需要的是该类的对象的地址值
抽象类：当抽象类作为方法的形式参数的时候，使用抽象多态的形式创建对象，实际上需要的是该抽象类子类实现对象的地址值
接口：当接口作为方法的形式参数的时候，使用接口多态创建对象，实际上需要的是该接口的实现类的对象的地址值
数组：（以前说过，这里不说了）
*/
//引用数据类型——类
class Student{
public void study(){
System.out.println("好好学习天天向上");
}
}
class StudentDemo{
//将来看到当一个类作为形式参数类型的时候
//实际上传的是该类的对象的地址值
public void fun(Student student){ //Student student = new Student();
student.study();
}
}
public class StudentTest {
public static void main(String[] args) {
StudentDemo sd = new StudentDemo();
//使用匿名对象传参
sd.fun(new Student());
}
}
//引用数据类型——抽象类
abstract class Person{
public abstract void study();
}
class Student2 extends Person {
@Override
public void study() {
System.out.println("好好学习天天向上");
}
}
class PersonDemo{
//将来看到当一个抽象类作为形式参数类型的时候
//实际上需要的是子类实现对象的地址值，利用多态的性质
public void fun(Person person){ //Person person = new Student2()
person.study();
}
}
public class PersonTest {
public static void main(String[] args) {
PersonDemo personDemo = new PersonDemo();
personDemo.fun(new Student2());
}
}
//引用数据类型——接口
interface Person2{
public abstract void study();
}
class Teacher implements Person2{
@Override
public void study() {
System.out.println("好好学习天天向上");
}
}
class TeacherDemo{
//将来看到当一个接口作为形式参数类型的时候
//实际上需要的是该接口的实现类的对象的地址值，利用接口多态的性质
public void fun(Person2 person2){ // Person2 person2 = new Teacher();
person2.study();
}
}
public class TeacherTest {
public static void main(String[] args) {
TeacherDemo td = new TeacherDemo();
td.fun(new Teacher());
}
}
返回值的问题案例
程序示例
/*
返回值的问题：
基本数据类型：（以前说过这里不说了）
引用数据类型：
类：当类作为方法的返回值的时候，实际上返回的是该类的对象的地址值
抽象类：当抽象类作为方法的返回值的时候，实际上需要返回的是该抽象类子类的对象的地址值
接口：当接口作为方法的返回值的时候，实际上需要返回的是实现该接口的类的对象
数组：（以前说过这里不说了）
*/
//引用数据类型——类
class Student3{
public void study(){
System.out.println("好好学习天天向上");
}
}
class StudentDemo3{
//当类作为方法的返回值类型的时候，返回是实际上是该类对象的地址值
public Student3 fun(){
Student3 s = new Student3();
return s;
//或者这样也可以
// return new Student3();
}
}
public class StudentTest2 {
public static void main(String[] args) {
StudentDemo3 sd = new StudentDemo3();
Student3 s = sd.fun();
s.study();
}
}
//引用数据类型——抽象类
abstract class Person3{
public abstract void study();
}
class PersonDemo3{
//当抽象类作为方法的返回值的时候，实际上需要返回的是该抽象类子类的对象的地址值
public Person3 getPerson(){
//抽象类不能实例化
// Person3 person3 = new Person3();
// return person3;
// Doctor doctor = new Doctor();//这样也可以，但是建议你返回需要什么类型，就用什么类型去创建
Person3 person3 = new Doctor();
return person3;
}
}
class Doctor extends Person3{
@Override
public void study() {
System.out.println("医生学习医术");
}
}
public class PersonTest2 {
public static void main(String[] args) {
PersonDemo3 pd3 = new PersonDemo3();
Person3 person3 = pd3.getPerson(); //Person3 person3 = new Doctor();
person3.study();
}
}
//引用数据类型——接口
interface PlayGame{
public abstract void playLoL();
}
class Teacher2 implements PlayGame{
@Override
public void playLoL() {
System.out.println("老师打英雄联盟");
}
}
class TeacherDemo2{
//当接口作为方法的返回值的时候，实际上需要返回的是实现该接口的类的对象
public PlayGame getPlayGame(){
PlayGame pg = new Teacher2();
return pg;
}
}
public class TeacherTest2 {
public static void main(String[] args) {
TeacherDemo2 td2 = new TeacherDemo2();
// PlayGame pg = td2.getPlayGame(); // PlayGame pg = new Teacher2();
// pg.playLoL();
//可以改成：
// TeacherDemo2 td2 = new TeacherDemo2();
// PlayGame pg = new TeacherDemo2().getPlayGame();
//还可以改成
//链式编程(后面大家会学习scala,spark,flink)
new TeacherDemo2().getPlayGame().playLoL();
}
}
