设计思维原创造型设计鸭子

『肆』 问一部动画片,主角是鸭子

怪鸭历险记
英国动画片《怪鸭历险记》

【原 片 名】Count Duckula

【出品年代】1988年

【出品公司】Cosgrove-Hall Proctions

【国别归属】英国

【剧集总数】65集

【内容简介】怪鸭故事情节荒诞离奇，颠覆了传统故事中对恶魔的描述，虽然在音乐和画面上营造出一种令人毛骨悚然的气氛，但是恰恰这些设计却成为了故事搞笑的手段，使故事充满了强烈的对比。全剧的所有人物都是禽鸟造型。达寇拉，是居住在特兰斯瓦尼亚城堡里吸血伯爵。虽然暴露于阳光或者被木桩刺透心脏都会让他死去，但是他却能够通过一种神秘的仪式再次地复活。然而，当最近一次仪式举行的时候，本该倒入棺材的血液错被错拿成了蕃茄汁――于是，重生的达寇拉伯爵变成为了一只只会吃素、略有点神经质的绿鸭子。他有两个仆人：雨果，是一只年迈的老鹰，一辈子都在这个城堡里做管家，对达寇拉家族忠心耿耿。 女仆南妮负责照顾达寇拉伯爵的饮食起居，不爱走门，总是撞墙而入，令人哭笑不得。 达寇拉伯爵还有一个死敌葛斯威恩博士，在原著中是著名的除妖大侠范海辛，在这部动画片里，却成了一个戴眼镜的鸭子，他发誓要除掉吸血鬼伯爵，执著地追杀达寇拉。还有四个大笨贼，他们总是觉得这个城堡里会有宝藏，可是没有一次得逞。达寇拉伯爵居住的城堡很神奇，可以瞬间移动，所以达寇拉总是能够随心所欲的到世界各地冒险，但是城堡的移动是有时间限制的，时间一到，自动回到特兰斯瓦尼亚。 故事就是围绕着这些人物展开的，一次又一次冒险旅行，一个又一个搞怪的情节，带我们走进这个恐怖的鸭子世界。这个故事里面充满了笑料与调侃，有一种无厘头式的幽默，是对英国传统故事的改编，让人以一种轻松的心情来观看吸血鬼主题的动画片，带给了我们非常多的欢笑。

『伍』 大黄鸭的设计灵感

有传言称霍夫曼设计大黄鸭的灵感来源于鸭子舰队的故事：1992年，一艘从中国出发的货轮打算穿越太平洋抵达美国华盛顿州的塔科马港，但途中遇到强风暴，一个装满2.9万只浴盆玩具的货柜坠入大海并破裂，里面的黄色鸭子、蓝色海龟和绿色青蛙漂浮到海面上，形成了一支庞大的“鸭子舰队”，从此随波逐流，从中国漂洋过海到了美国和英国海岸。
故事虽然很美好，但霍夫曼对此坚决否认：“不不，这完全是一个流言。我去了一个荷兰的博物馆，从绘画作品中找到灵感，我从一幅画中看到了一个小黄鸭的设计。我的灵感都是来源于一些艺术作品，我已经不记得是哪幅具体的作品，都是一些风景画，我是比较倾向于从一些绘画作品中获取灵感，然后再进行自己的艺术创作。”

『陆』 小鸭子的思维导图怎么画

可以自己在网上搜衣服，嘶哑小鸭子思维导图自己在网上搜。

『柒』 软件设计模式鸭子模拟器

假设我们需要设计出各种各样的鸭子，一边游泳戏水， 一边呱呱叫。很明显这时我们需要设计了一个鸭子超类（Superclass），并让各种鸭子继承此超类。

public abstract class Duck {
public void Swim() {
//会游泳
}
public abstract display();//各种外观不一样，所以为抽象
public void Quack() {
//会叫
}
}
每一只鸭子就继承Duck类
public class MallardDuck extends Duck {
public void display() {
// 外观是绿色的
}
}
public class RedheadDuck extends Duck{
public void display(){
// 外观是红色的
}
}
好了，我们完成这些后，但是发现我们需要有一些鸭子是会飞的，应该怎么修改呢？
也许你要说这很简单，在Duck类里面直接加入一个fly()方法，不就可以了。

public abstract class Duck {
public void Swim() {
//会游泳
}
public abstract display();//各种外观不一样，所以为抽象
public void Quack() {
//会叫
}
public void fly(){
//会飞
}
}
这时你会发现所有的鸭子都变成了会飞的,很明显这是不对了，例如橡皮鸭显然就不是了。
你也许想到了另一种方法，在会飞的鸭子类里才添加该方法不就可以了嘛，

public class MallardDuck extend Duck{
public void display(){
// 外观是绿色的
}
public void fly(){
//会飞
}
}
这个方法看起来是很不错，可是有很多种鸭子都会飞的时候，代码的复用性很明显是不够好的,你不得不在
每一个会飞的鸭子类里去写上同一个fly()方法,这可不是个好主意.
可能你又想到另一个方法：采用继承和覆盖，在Duck类里实现fly()方法，在子类里如果不会飞的就覆盖它

public abstract class Duck {
public void Swim() {
//会游泳
}
public abstract display();//各种外观不一样，所以为抽象
public void Quack(){
//会叫
}
public void fly(){
//会飞
}
}
//橡皮鸭吱吱叫，不会飞
public class RubberDuck extend Duck{
public void quack(){
//覆盖成吱吱叫
}
public void display{
//外观是橡皮鸭
}
public void fly{
//什么也不做
}
}

这样我们真实现了确实能飞的鸭子才可以飞起来了，看起来主意不错！问题到这儿似乎得到了解决
但我们现在有了一种新的鸭子，诱铒鸭(不会飞也不会叫),看来需要这样来写
public class DecoyDuck extend Duck{
public void quack(){
//覆盖，变成什么也不做
}
public void display(){
//诱饵鸭
}
public void fly(){
//覆盖，变成什么也不做
}
}

每当有新的鸭子子类出现或者鸭子新的特性出现，就不得不被迫在Duck类里添加并在所有子类里检查可能需要覆盖fly()和quark()...这简直是无穷尽的恶梦。所以，我们需要一个更清晰的方法，让某些（而不是全部）鸭子类型可飞或可叫。让鸭子的特性能有更好的扩展性。
用一下接口的方式把fly()取出来，放进一个Flyable接口中，这样只有会飞的鸭子才实现这个接口，当然我们也可以照此来设计一个Quackbable接口，因为不是所有的鸭子都会叫,也只让会叫的鸭子才去实现这个接口.
但这个方法和上面提到的在子类里去实现fly一样笨，如果几十种都可以飞，你得在几十个鸭子里去写上一样的fly(),如果一旦这个fly有所变更，你将不得不找到这几十个鸭子去一个一个改它们的fly()方法。
因为改变鸭子的行为会影响所有种类的鸭子，而这并不恰当。Flyable与Quackable接口一开始似乎还挺不错， 解决了问题（ 只有会飞的鸭子才继承Flyable） ， 但是Java的接口不具有实现代码， 所以继承接口无法达到代码的复用。这意味着：无论何时你需要修改某个行为，你必须得往下追踪并修改每一个定义此行为的类。
策略模式的第一原则：找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。 好吧，回头看一下这个Duck类，就我们目前所知，除了fly()和quack()的问题之外，Duck类还算一切正常，主要是鸭子的行为总是可能变化的，让我们头痛就在于这些行为的变化，那我们就把这些行为独立出来。
为了要把这两个行为从Duck 类中分开， 我们将把它们自Duck 类中取出，建立一组新类代表每个行为。我们建立两组类（完全远离Duck类），一个是「fly」相关的，一个是「quack」相关的，每一组类将实现各自 的动作。比方说，我们可能有一个类实现「呱呱叫」，另一个类实现「吱吱叫」，另一个类实现「安静」。我们利用接口代表每组行为，比方说， FlyBehavior来代表飞的行为，QuackBehavior代表叫的行为，而让每一种行为具体类来实现该行为接口。
在此，我们有两个接口，FlyBehavior和QuackBehavior，还有它们对应的类，负责实现具体的行为：

public interface FlyBehavior {
public void fly();
}
public class FlyWithWings implements FlyBehavior{
public void fly{}{
//实现鸭子飞行
}
}
public class FlyNoWay implements FlyBehavior{
public void fly{}{
//什么也不做，不会飞
}
}
public interface QuackBehavior{
public void quack();
}
public class Quack implements QuackBehavior{
public void quack(){
//实现鸭子呱呱叫
}
}
public class Squeak implements QuackBehavior{
public void quack(){
//实现鸭子吱吱叫
}
}
public class MuteQuack implements QuackBehavior{
public void quack(){
//什么也不做，不会叫
}
}

实际上这样的设计，我们已经可以让飞行和呱呱叫的动作被其他的对象复用，因为这些行为已经与鸭子类无关了。如果我们新增一些行为，也不会影响到既有的行为类，也不会影响有已经使用到飞行行为的鸭子类。
好了，我们设计好鸭子的易于变化的行为部分后，该到了整合鸭子行为的时候了。
这时我们该想到策略模式的另一个原则了：
针对接口编程，而不是针对实现编程。
首先， 在鸭子中加入两个实例变量，分别为「flyBehavior」与「quackBehavior」，声明为接口类型（ 而不是具体类实现类型）， 每个变量会利用多态的方式在运行时引用正确的行为类型（ 例如：FlyWithWings 、Squeak...等）。我们也必须将Duck类与其所有子类中的fly()与quack()移除，因为这些行为已经被搬移到FlyBehavior与 Quackehavior类中了，用performFly()和performQuack()取代Duck类中的fly()与quack()。

public abstract class Duck(){
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public void swim(){
//会游泳
}
public abstract void display();//各种外观不一样，所以为抽象
public void performQuack(){
quackBehavior.quack();
}
public void performFly(){
flyBehavior.fly();
}

}
很容易，是吧？想进行呱呱叫的动作，Duck对象只要叫quackBehavior对象
去呱呱叫就可以了。在这部分的代码中，我们不在乎QuackBehavior 接口的对象到底是什么，我们只关心该对象
知道如何进行呱呱叫就够了。
好吧！ 现在来关心如何设定flyBehavior 与quackBehavior的实例变量。
看看MallardDuck类：
public class MallardDuck extends Duck {
public MallardDuck() {
\\绿头鸭使用Quack类处理呱呱叫，所以当performQuack() 被调用，就把责任委托给Quack对象进行真正的呱呱叫。
quackBehavior = new Quack();
\\使用FlyWithWings作为其FlyBehavior类型。
flyBehavior = new FlyWithWings();
}
}
所以，绿头鸭会真的『呱呱叫』，而不是『吱吱叫』，或『叫不出声』。这是怎么办到的？当MallardDuck实例化时，它的构造器会
把继承来的quackBehavior实例变量初始化成Quack类型的新实例（Quack是QuackBehavior的具体实现类）。同样的处理方式也可以用在飞行行为上： MallardDuck 的构造器将flyBehavior 实例变量初始化成FlyWithWings 类型的实例（
FlyWithWings是FlyBehavior的具体实现类）。
输入下面的Duck类（Duck.java） 以及MallardDuck 类MallardDuck.java），并编译之。
public abstract class Duck {

//为行为接口类型声明两个引用变量， 所有鸭子子类（在同一个packge）都继承它们。
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public Duck() {
}
public abstract void display();
public void performFly() {
flyBehavior.fly();//委托给行为类
}
public void performQuack() {
quackBehavior.quack();//委托给行为类
}
public void swim() {
System.out.println("All cksfloat, even decoys!");
}
}

public class MallardDuck extends Duck {
public MallardDuck() {
quackBehavior = newQuack();
flyBehavior = newFlyWithWings();
}
public void display() {
System.out.println("I’m a real Mallard ck");
}
}
输入FlyBehavior接口（FlyBehavior.java）与两个行为实现类（FlyWithWings.java与FlyNoWay.java），并编译之。
public interface FlyBehavior {//所有飞行行为类必须实现的接口
public void fly();
}
public class FlyWithWings implements FlyBehavior {//这是飞行行为的实现， 给「真会」飞的鸭子用 .. .
public void fly() {
System.out.println("I’m flying!!");
}
}
public class FlyNoWay implements FlyBehavior {//这是飞行行为的实现， 给「不会」飞的鸭子用（ 包括橡皮鸭和诱饵鸭）
public void fly() {
System.out.println("I can’t fly");
}
}

输入QuackBehavior接口（QuackBehavior.java)及其三个实现类（Quack.java、MuteQuack.java、Squeak.java），并编译之。
public interface QuackBehavior {
public void quack();
}
public class Quack implements QuackBehavior {
public void quack() {
System.out.println(“Quack”);
}
}
public class MuteQuack implements QuackBehavior {
public void quack() {
System.out.println(“<< Silence >>”);
}
}
public class Squeak implements QuackBehavior {
public void quack() {
System.out.println(“Squeak”);
}
}
输入并编译测试类（MiniDuckSimulator.java）

public class MiniDuckSimulator {
public static void main(String[] args) {
Duck mallard = new MallardDuck();
mallard.display();
//这会调用MallardDuck继承来的performQuack() ，进而委托给该对象的QuackBehavior对象处理。（也就是说，调用继承来的quackBehavior的quack()）
mallard.performQuack();
//至于performFly() ，也是一样的道理。
mallard.performFly();
}
}
运行结果：
I’m a real Mallard ck
Quack
I’m flying!!

虽然我们把行为设定成具体的类（通过实例化类似Quack 或FlyWithWings的行为类， 并指定到行为引
用变量中），但是还是可以在运行时轻易地改变该行为。
所以，目前的作法还是很有弹性的，只是初始化实例变量的作法不够弹性罢了。
我们希望一切能有弹性，毕竟，正是因为一开始的设计的鸭子行为没有弹性，才让我们走到现在这条路。
我们还想能够「指定」行为到鸭子的实例， 比方说， 想要产生绿头鸭实例，并指定特定「类型」的飞行
行为给它。干脆顺便让鸭子的行为可以动态地改变好了。换句话说，我们应该在鸭子类中包含设定行为的方法。
因为quackBehavior实例变量是一个接口类型，所以我们是能够在运行时，透过多态动态地指定不同的QuickBehavior实现类给它。
我们在鸭子子类透过设定方法（settermethod）设定鸭子的行为，而不是在鸭子的构造器内实例化。
在Duck类中，加入两个新方法：从此以后，我们可以「随时」调用这两个方法改变鸭子的行为。

public strate class Duck(){
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public void setFlyBehavior(FlyBehavior fb) {
flyBehavior = fb;
}
public void setQuackBehavior(QuackBehavior qb) {
quackBehavior = qb;
}

}
好了，让我们再制造一个新的鸭子类型：模型鸭（ModelDuck.java）
public class ModelDuck extends Duck {
public ModelDuck() {
flyBehavior = new FlyNoWay();//初始状态，我们的模型鸭是不会飞的。
quackBehavior = new Quack();//初始状态，我们的模型鸭是可以叫的.
}
public void display() {
System.out.println("I’m a modelck");
}
}
建立一个新的FlyBehavior类型（FlyRocketPowered.java）
public class FlyRocketPowered implements FlyBehavior {
// 我们建立一个利用火箭动力的飞行行为。
public void fly() {
System.out.println("I’m flying with arocket!");
}
}

改变测试类（MiniDuckSimulator.java），加上模型鸭，并使模型鸭具有火箭动力。
public class MiniDuckSimulator {
public static void main(String[] args) {
Duck mallard = new MallardDuck();
mallard.performQuack();
mallard.performFly();
Duck model = new ModelDuck();
//第一次调用performFly() 会被委托给flyBehavior对象（也就是FlyNoWay对象），该对象是在模型鸭构造器中设置的。
model.performFly();
//这会调用继承来的setter 方法，把火箭动力飞行的行为设定到模型鸭中。哇咧！ 模型鸭突然具有火箭动力飞行能力。
model.setFlyBehavior(new FlyRocketPowered());
//如果成功了， 就意味着模型鸭动态地改变行为。如果把行为的实现绑死在鸭子类中， 可就无法做到这样。
model.performFly();
}
}
运行一下，看下结果
I’m a real Mallard ck
Quack
I’m flying!!
I’m a model ck
I can’t fly
I’m flying with a rocket!
如同本例一般，当你将两个类结合起来使用，这就是组合（composition）。这种作法和『继承』不同的地方在于，
鸭子的行为不是继承而来，而是和适当的行为对象『组合』而来。
这是一个很重要的技巧。其实是使用了策略模式中的第三个设计原则， 多用组合，少用继承。
现在来总结一下，鸭子的行为被放在分开的类中，此类专门提供某行为的实现。
这样，鸭子类就不再需要知道行为的实现细节。
鸭子类不会负责实现Flyable与Quackable接口，反而是由其他类专门实现FlyBehavior与QuackBehavior，
这就称为「行为」类。由行为类实现行为接口，而不是由Duck类实现行为接口。
这样的作法迥异于以往，行为不再是由继承Duck超类的具体实现而来， 或是继承某个接口并由子类自行实现而来。
(这两种作法都是依赖于「实现」， 我们被实现绑得死死的， 没办法更改行为,除非写更多代码)。
在我们的新设计中， 鸭子的子类使用接口（ FlyBehavior与QuackBehavior）所表示的行为，所以实际的实现不会被
绑死在鸭子的子类中。（ 换句话说， 特定的实现代码位于实现FlyBehavior与QuakcBehavior的特定类中）,这样我们就获得了更大的灵活性和可扩展性。

『捌』 美团骑手头盔上为什么有只小鸭子

美团外卖头盔上是“袋鼠耳朵”，因为美团外卖Logo就是一只袋鼠。

实际上美团外卖早就推出袋鼠耳朵头盔了。据有关媒体报道，美团外卖自2018年起，就在每年7月17日骑士节给外卖骑手发放袋鼠头盔。2020起，美团更是将袋鼠头盔发展出多种周边，开始面向大众消费者销售。

这实际上就是商业活动中的品牌形象打造，说通俗些就是打造“头盔ip”。说白了，就是让消费者一看到这个袋鼠耳朵形象，就立刻能想起美团外卖。然后等到了饭点，大家选择美团外卖。

(8)设计思维原创造型设计鸭子扩展阅读：

袋鼠耳朵是产品思维下的品牌升级：

当美团的袋鼠耳朵引起第一波讨论之时，美团官方公众号发文《美团，全球最大的袋鼠耳朵加工厂》，官方认证并发售袋鼠耳朵，苹果风的海报设计，更是一本正经地卖萌。承诺所得用于骑手子女的大病支持计划，显现了可爱耳朵背后的责任感。

除了最直观的外卖食品与APP中的系列操作，骑手的送餐环节是美团与用户最直接的接触点，整个服务流程是连贯的。而美团这次正是在产品的最后一公里发力，在终端为触达用户的骑手们配上袋鼠耳朵，进而引发共鸣与讨论。

『玖』 整个鸭场的建设图 谢谢

鸭舍是鸭场的主体部分，完整的平养鸭场，必须由鸭舍、鸭滩（陆地运动场）和水围（水上运动场）３个部分组成。第一步，建鸭舍鸭舍分临时性简易鸭舍和长期性固定鸭舍两大类。农户养鸭大都用简易鸭舍，大中型鸭场大都用固定鸭舍。简易鸭舍一般以毛竹做架，房顶部和四周都用茅草帘围盖。这种草舍的优点是建造快，投资省，适用面广，各种类型的鸭都可以养，而且保温性能好，夏天可卸下四周的草帘，通风凉爽，冬天用草帘将四壁加厚盖严，达到冬暖夏凉的要求。长期性固定鸭舍一般采用砖瓦水泥结构，有固定的门窗，按一定的规格设计，坚固耐用，抗御自然灾害能力强，建成后使用时期较长，但一次性投资较多。鸭舍建筑面积要根据饲养密度而定。单位面积内，冬季可提高饲养密度，适当多养些，反之，夏天要少养些；大面积的鸭舍，饲养密度适当大些，小面积的鸭舍，饲养密度适当小些；运动场大的鸭舍，饲养密度可大一些，运动场小的鸭舍，饲养密度应小一些。第二步，建鸭滩鸭滩又称陆地运动场，一端紧连鸭舍，一端直通水围，是鸭群采食、梳理羽毛和休息的场所，面积应超过鸭舍１倍以上。鸭滩略向水面倾斜，以利排水；鸭滩的地面最好浇水泥，也可以是夯实的泥地，但必须平整，不能坑坑洼洼，以免蓄积污水（有的鸭场把喂鸭后剩下的贝壳、螺蛳壳等，平铺在泥地的鸭滩上，这样，即使在大雨过后，鸭滩也不会积水）；鸭滩连接水面处，做成一个倾斜的小坡，此处是鸭群入水和上岸必经之地，使用率极高，还易受到水浪冲击，很容易坍塌凹陷，必须用石块砌好，浇上水泥，把坡面修理平整、坚固并深入水中，方便鸭群上下水。鸭滩上可种植落叶乔木或落叶果树（如葡萄等），并用水泥砌成１米高的围栏，以免鸭子入内啄伤幼树枝叶，同时可防止高浓度的鸭粪肥水渗入树根而腌死树木。第三步，建水围水围即水上运动场，是鸭洗澡、交尾和嬉耍的场所，面积不能小于鸭滩。考虑到枯水季节水面要缩小，如条件许可，应尽量把水围扩大些，以利鸭群运动。在鸭舍、鸭滩、水围的连接处，均需用围栏围成一体，使每一单间都自成一个独立体系，以便种鸭不互相走乱混杂。围栏在陆地上的高度为６０－８０厘米，水上围栏的上沿高度应超过最高水位５０厘米，下沿最好深入河底或低于最低水位５０厘米，以防种鸭串群。

『拾』 鸭子大棚最好图片怎样设计

没有说最好的，只有最合适的，一般要看地形，鸭子数量。