本帖最后由 ksh 于 2015-8-25 22:41 编辑
/*
创建
接口 Move 抽象方法 move
接口 Stay 抽象方法 stay
抽象类 Animal 构造方法Animal 成员方法 animal move
抽象类 Plant 构造方法Plant 成员方法 plant stay
具体类 Cat 成员方法 execute move exhibit display show
具体类 Rose 成员方法 execute stay exhibit display show
动物系列演示【形式参数】是引用类型
植物系列演示【返回值类型】是引用类型
/*
形式参数：
基本类型
引用类型
类名:(匿名对象的时候其实我们已经讲过了)需要的是该类的对象
抽象类:需要的是该抽象的类子类对象
接口:需要的是该接口的实现类对象//接口是一个抽象类
*/
/*
返回值类型
基本类型:(基本类型太简单，我不准备讲解)
引用类型：
类:返回的是该类的对象
抽象类:返回的是该抽象类的子类对象
接口:返回的是该接口的实现类的对象
*/
interface Move{
public abstract void move(); //接口的扩展的抽象方法必须有void，方法重写后无void
}
interface Stay{
public abstract void stay();//接口的抽象方法，无方法体，实现子类必须重写该方法。
}
abstract class Animal{
private String name;
public Animal(){};
public void animal(){
System.out.println("【Animal】animal：我是动物，有愿望。");
}
public void move(){//方法重写
System.out.println("我是Animal，我会动。");
}
}
abstract class Plant{
private String name;
public Plant(){};
public void plant(){
System.out.println("【Plant】plant：我是植物，可以种植。");
}
public void stay(){//方法重写
System.out.println("【Plant】stay：我是Plant，我不会动。");
}
}
class Cat extends Animal implements Move{
public void move(){//方法重写
System.out.println("【Cat】move：我是Cat，我跑得快，能抓老鼠。");
}
public void execute(){
System.out.println("【Cat】execute：我是具体实现类Cat");
}
//*******************************************
//动物系，测试参数类型
//*******************************************
public void exhibit (Rose r){//①形式参数是类Rose//需要的是该类的对象
r.execute();//打印：【Rose】execute：我是具体实现类Rose
}
public void display(Plant p){//②形式参数是抽象类Plant//需要的是子类的对象
p.plant(); //打印：【Plant】plant：我是植物，可以种植。
}
public void show(Stay s){//③形式参数是接口Stay//需要的是接口的实现类对象
s.stay();//打印：【Rose】stay：我是Rose，我很静，我很漂亮。
}
}
class Rose extends Plant implements Stay{
public void stay(){//方法重写
System.out.println("【Rose】stay：我是Rose，我很静，我很漂亮。");
}
public void execute(){
System.out.println("【Rose】execute：我是具体实现类Rose。");
}
//*******************************************
//植物系，测试返回值类型
//*******************************************
public Cat exhibit(){ //④返回值类型是类Cat//返回的是Cat的一个对象。
return new Cat();//等价于 Cat cn = new Cat(); return cn;//这里是匿名返回
}
public Animal display(){//⑤返回值类型是抽象类Animal//返回的是Animal的子类对象。
return new Cat(); //等价于Animal an = new Cat();//return an;
}
public Move show(){//⑥返回值类型是接口Move//返回的是Move的子类对象。
return new Cat(); //等价于Move mn = new Move();//return mn;
}
}
class Test{
public static void main(String[]args){
//①形式参数是类//Cat的exhibit方法里，形式参数是类Rose//需要的是该类的对象
//需求：调用Cat的exhibit方法，通过exhibit方法调用Rose的execute方法
Cat c1 = new Cat();
Rose r1 = new Rose();
new Cat().exhibit(new Rose());
c1.exhibit(r1); //①形式参数是类Rose//打印：【Rose】execute：我是具体实现类Rose
//new Cat().exhibit(new Rose());
//回忆匿名对象
new Cat().exhibit(new Rose());//打印：【Rose】execute：我是具体实现类Rose
System.out.println("*---------------------------------*");
//②形式参数是抽象类Plant//Cat的method方法里，形式参数是抽象类Plant//需要的是子类的对象
//需求：调用Cat的display方法，通过display方法调用Plant的plant方法
Cat c2 = new Cat();
Plant p1 = new Rose(); //抽象类Plant作为引用类型的参数，不能实例化，只能通过子类间接实例化
c2.display(p1);//打印：【Plant】plant：我是植物，可以种植。
new Cat().display(new Rose());
System.out.println("*---------------------------------*");
//new Cat().display(new Rose());
//③形式参数是接口Stay//Cat的perform方法里，形式参数是接口Stay//需要的是接口的实现类对象
//需求：调用Cat的show方法，通过show方法调用Stay的stay方法，该方法被实现类Rose重写。
Cat c3 = new Cat();
Stay s1 = new Rose();//接口Stay是抽象类，作为引用类型的参数，不能实例化，只能通过子类间接实例化
c3.show(s1);
new Cat().show(new Rose());
System.out.println("*---------------------------------*");
//new Cat().show(new Rose());
//④返回值类型是类Cat//在Rose的exhibit方法里，返回值类型是Cat//返回的是Cat的一个对象。
//需求：通过调用Rose的exhibit方法创建对象，调用方法。
Rose r4 = new Rose();
Cat c4 = r4.exhibit(); //调用exhibit创建对象进行接收。
c4.execute();//打印：【Cat】execute：我是具体实现类Cat
new Rose().exhibit().execute();
System.out.println("*---------------------------------*");
//new Rose().exhibit().execute();
//⑤返回值类型是抽象类Animal//在Rose的method方法里，返回值类型是Animal//返回的是Animal的一个子类对象
//需求：通过调用Rose的display方法创建对象，调用方法。
Rose r5 = new Rose();
Animal a5 = r5.display();
a5.animal();
new Rose().display().animal();
System.out.println("*---------------------------------*");
//new Rose().display().animal();
//⑥返回值类型是接口Move//在Rose的perform方法里，返回值类型是Move//返回的是Move的一个子类对象
//需求：通过调用Rose的show方法创建对象，调用方法。
Rose r6 = new Rose();
Move m6 = r6.show();
m6.move();
new Rose().show().move();
System.out.println("*---------------------------------*");
//new Rose().show().move();
System.out.println("参数引用类型都是需要一个对象用 new Rose()");
System.out.println("*---------------------------------*");
new Cat().exhibit(new Rose());
new Cat().display(new Rose());
new Cat().show(new Rose());
System.out.println("*---------------------------------*");
System.out.println("*链式编程：每次调用方法完毕后，返回值类型是一个对象*");
System.out.println("*---------------------------------*");
new Rose().exhibit().execute();//【Cat】execute：我是具体实现类Cat"
new Rose().display().animal();//【Animal】animal：我是动物，有愿望。");
new Rose().show().move();//【Cat】move：我是Cat，我跑得快，能抓老鼠。");
}
}
|
|
收藏
淘帖
踩
