LY.JAVA面向对象编程.形式参数和返回值

2018-07-09 13:29:16

运动员和教练案例

 /*
     教练和运动员案例(学生分析然后讲解)
         乒乓球运动员和篮球运动员。
         乒乓球教练和篮球教练。
         为了出国交流，跟乒乓球相关的人员都需要学习英语。
         请用所学知识：
         分析，这个案例中有哪些抽象类，哪些接口，哪些具体类。

     整个分析过程，我是通过画图讲解的。
 */
 //定义一个说英语的接口
 interface SpeakEnglish {
     //说英语
     public abstract void speak();
 }

 //定义人的抽象类
 abstract class Person {
     private String name;
     private int age;

     public Person() {}

     public Person(String name,int age) {
         this.name = name;
         this.age = age;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public int getAge() {
         return age;
     }

     public void setAge(int age) {
         this.age = age;
     }

     //睡觉
     public void sleep() {
         System.out.println("人都是要睡觉的");
     }

     //吃饭
     public abstract void eat();
 }

 //定义运动员抽象类
 abstract class Player extends Person {
     public Player() {}

     public Player(String name,int age) {
         super(name,age);
     }

     //学习
     public abstract void study();
 }

 //定义教练抽象类
 abstract class Coach extends Person {
     public Coach() {}

     public Coach(String name,int age) {
         super(name,age);
     }

     //教
     public abstract void teach();
 }

 //定义乒乓球运动员具体类
 class PingPangPlayer extends Player implements SpeakEnglish {
     public PingPangPlayer(){}

     public PingPangPlayer(String name,int age) {
         super(name,age);
     }

     //吃
     public void eat() {
         System.out.println("乒乓球运动员吃大白菜，喝小米粥");
     }

     //学习
     public void study() {
         System.out.println("乒乓球运动员学习如何发球和接球");
     }

     //说英语
     public void speak() {
         System.out.println("乒乓球运动员说英语");
     }
 }

 //定义篮球运动员具体类
 class BasketballPlayer extends Player {
     public BasketballPlayer(){}

     public BasketballPlayer(String name,int age) {
         super(name,age);
     }

     //吃
     public void eat() {
         System.out.println("篮球运动员吃牛肉，喝牛奶");
     }

     //学习
     public void study() {
         System.out.println("篮球运动员学习如何运球和投篮");
     }
 }

 //定义乒乓球教练具体类
 class PingPangCoach extends Coach implements SpeakEnglish {
     public PingPangCoach(){}

     public PingPangCoach(String name,int age) {
         super(name,age);
     }

     //吃
     public void eat() {
         System.out.println("乒乓球教练吃小白菜，喝大米粥");
     }

     //教
     public void teach() {
         System.out.println("乒乓球教练教如何发球和接球");
     }

     //说英语
     public void speak() {
         System.out.println("乒乓球教练说英语");
     }
 }

 //定义篮球教练具体类
 class BasketballCoach extends Coach {
     public BasketballCoach(){}

     public BasketballCoach(String name,int age) {
         super(name,age);
     }

     //吃
     public void eat() {
         System.out.println("篮球教练吃羊肉，喝羊奶");
     }

     //教
     public void teach() {
         System.out.println("篮球教练教如何运球和投篮");
     }
 }

 class InterfaceDemo {
     public static void main(String[] args) {
         //测试运动员(乒乓球运动员和篮球运动员)
         //乒乓球运动员
         PingPangPlayer ppp = new PingPangPlayer();
         ppp.setName("王浩");
         ppp.setAge(33);
         System.out.println(ppp.getName()+"---"+ppp.getAge());
         ppp.eat();
         ppp.sleep();
         ppp.study();
         ppp.speak();
         System.out.println("----------------");
         //通过带参构造给数据(留给你们)

         //篮球运动员
         BasketballPlayer bp = new BasketballPlayer();
         bp.setName("姚明");
         bp.setAge(34);
         System.out.println(bp.getName()+"---"+bp.getAge());
         bp.eat();
         bp.sleep();
         bp.study();
         //bp.speak(); //没有该方法

         //测试教练自己做
     }
 }

形式参数：

　　基本类型：

　　引用类型：

　　　　　　类：

　　　　　　抽象类：

　　　　　　接口：

 /*
     形式参数：
         基本类型(太简单，不是我今天要讲解的)
         引用类型
             类名:(匿名对象的时候其实我们已经讲过了) 需要的是该类的对象
             抽象类:
             接口
 */
 class Student {
     public void study() {
         System.out.println("Good Good Study,Day Day Up");
     }
 }

 class StudentDemo {
     public void method(Student s) { //ss; ss = new Student();  Student s = new Student();
         s.study();
     }
 }

 class StudentTest {
     public static void main(String[] args) {
         //需求：我要测试Student类的study()方法
         Student s = new Student();
         s.study();
         System.out.println("----------------");

         //需求2：我要测试StudentDemo类中的method()方法
         StudentDemo sd = new StudentDemo();
         Student ss = new Student();
         sd.method(ss);
         System.out.println("----------------");

         //匿名对象用法
         new StudentDemo().method(new Student());
     }
 }

形式参数：抽象类

抽象类：需要的是该抽象的类子类对象

 /*
     形式参数：
         基本类型(太简单，不是我今天要讲解的)
         引用类型
             类名:(匿名对象的时候其实我们已经讲过了)需要的是该类的对象
             抽象类:需要的是该抽象的类子类对象
             接口
 */
 abstract class Person {
     public abstract void study();
 }

 class PersonDemo {
     public void method(Person p) {//p; p = new Student();  Person p = new Student(); //多态
         p.study();
     }
 }

 //定义一个具体的学生类
 class Student extends Person {
     public void study() {
         System.out.println("Good Good Study,Day Day Up");
     }
 }

 class PersonTest {
     public static void main(String[] args) {
         //目前是没有办法的使用的
         //因为抽象类没有对应的具体类
         //那么，我们就应该先定义一个具体类
         //需求：我要使用PersonDemo类中的method()方法
         PersonDemo pd = new PersonDemo();
         Person p = new Student();
         pd.method(p);
     }
 }

接口：需要的是该接口的实现类对象

 /*
     形式参数：
         基本类型(太简单，不是我今天要讲解的)
         引用类型
             类名:(匿名对象的时候其实我们已经讲过了)需要的是该类的对象
             抽象类:需要的是该抽象的类子类对象
             接口:需要的是该接口的实现类对象
 */
 //定义一个爱好的接口
 interface Love {
     public abstract void love();
 }

 class LoveDemo {
     public void method(Love l) { //l; l = new Teacher();  Love l = new Teacher(); 多态
         l.love();
     }
 }

 //定义具体类实现接口
 class Teacher implements Love {
     public void love() {
         System.out.println("老师爱学生,爱Java,爱林青霞");
     }
 }

 class TeacherTest {
     public static void main(String[] args) {
         //需求：我要测试LoveDemo类中的love()方法
         LoveDemo ld = new LoveDemo();
         Love l = new Teacher();
         ld.method(l);
     }
 }

返回值类型

　　　　基本类型：

　　　　引用类型：

　　　　　　　　类：返回的是该类的对象

　　　　　　　　抽象类：返回的是该抽象类的子类对象

　　　　　　　　接口：

返回值类型  引用类型：类：返回的是该类的对象

返回值类型  引用类型：抽象类：返回的是该抽象类的子类对象