女娲造人Java代码女娲造人游戏 _女娲

mvc模式和工厂设计模式是同一层次上的概念简单工厂模式（Simple Factory Pattern）女娲造人Java代码，又称静态工厂模式（Static Factory Pattern）。举两个例子以快速明白Java中女娲造人Java代码的简单工厂模式：
女娲抟土造人
话说：“天地开辟，未有人民，女娲抟土为人。”女娲需要用土造出一个个的人，但在女娲造出人之前，人的概念只存在于女娲的思想里面。
女娲造人，这就是简单工厂模式的应用。
首先，在这个造人的思想里面，有几个重要的角色：女娲本身、抽象的人的概念和女娲所造出的一个个具体的人。
1.）女娲是一个工厂类，也就是简单工厂模式的核心角色。
2.）具休的一个个的人，包括张三，李四等。这些人便是简单工厂模式里面的具体产品角色
3.）抽象的人是最早只存在于女娲的头脑里的一个想法，女娲按照这个想法造出的一个个具体的人，便都符合这个抽象的人的定义。换言之，这个抽象的想法规定了所有具体的人必须都有的接口（特征或者功能）
注意：女娲与张三，李四属于创建依赖关系，上图箭头应该是虚线（实现代表关联关系）。而张三，李四与人属于实现关系，上图三角形头的箭头也应该是虚线（实线代表继承关系）。
理解了上面的这些东西，再来理解下面的例子，对照理解，相信看完这篇文章，便对java简单工厂模式有一个很好的理解：
有一个农场公司，专门向市场销售各类水果，在这个系统里需要描述下列水果：
葡萄　Grape
草莓　Strawberry
苹果　Apple
水果与其他植物不同，最终可以采摘食用，那么一个自然的做法是建立一个各种水果都适用的接口，以便与其他农场里的植物区分开来，
此时，则是为水果类声明了一个接口，表现在代码上：
public interface Fruit
{
//种植
public void plant();
//生长
public void grow();
//收获
public void harvest();
}
水果接口规定出所有的水果必须实现的接口，包括任何水果类必须具备的方法plant(),grow(),和harvest();
Apple类是水果类的一种，因此它实现了水果接口所声明的所有方法。另处，由于苹果是多年生植物，因此多出一个treeAge性质，描述苹果的树龄。代码如下所示：
/**
*
* 类名称：Apple
* 类描述：农场苹果类
*
*/
public class Apple implements Fruit
{
/**
* 苹果为多年生植物
*/
private int treeAge;
/* (non-Javadoc)
* @see fac.Fruit#grow()
*/
@Override
public void grow()
{
System.out.println("苹果开始生长。。。");
}
/* (non-Javadoc)
* @see fac.Fruit#harvest()
*/
@Override
public void harvest()
{
System.out.println("苹果开始收获。。。");
}
/* (non-Javadoc)
* @see fac.Fruit#plant()
*/
@Override
public void plant()
{
System.out.println("苹果种入农场。。。");
}
public int getTreeAge()
{
return treeAge;
}
public void setTreeAge(int treeAge)
{
this.treeAge = treeAge;
}
}
同理，葡萄　Grape：
public class Grape implements Fruit
{
/**
* 葡萄分为有籽无籽
*/
private boolean seedless;
/* (non-Javadoc)
* @see fac.Fruit#grow()
*/
@Override
public void grow()
{
System.out.println("葡萄开始生长。。。");
}
/* (non-Javadoc)
* @see fac.Fruit#harvest()
*/
@Override
public void harvest()
{
System.out.println("葡萄开始收获。。。");
}
/* (non-Javadoc)
* @see fac.Fruit#plant()
*/
@Override
public void plant()
{
System.out.println("葡萄种入农场。。。");
}
public boolean isSeedless()
{
return seedless;
}
public void setSeedless(boolean seedless)
{
this.seedless = seedless;
}
}
草莓　Stuawberry：
public class Strawberry implements Fruit
{
/* (non-Javadoc)
* @see fac.Fruit#grow()
*/
@Override
public void grow()
{
System.out.println("草莓开始生长。。。");
}
/* (non-Javadoc)
* @see fac.Fruit#harvest()
*/
@Override
public void harvest()
{
System.out.println("草莓开始收获。。。");
}
/* (non-Javadoc)
* @see fac.Fruit#plant()
*/
@Override
public void plant()
{
System.out.println("草莓种入农场。。。");
}
}
农场园丁也是系统的一部分，由一个类来代表，FruitGardener类，代码如下：
public class FruitGardener
{
public static Fruit factory(String which) throws Exception
{
if(which.equalsIgnoreCase("apple"))
{
return new Apple();
}
else if(which.equalsIgnoreCase("grape"))
{
return new Grape();
}
else if(which.equalsIgnoreCase("strawberry"))
{
return new Strawberry();
}
else
{
throw new Exception("抱歉，本农场不生产此种水果");
}
}
}
这下，农场一片繁荣景象了。来年一定是个丰收年。
这时有客户来果园查看情况，和园丁说，给女娲造人Java代码我们介绍下你的水果吧。于是园?。?
类描述：来农场订购水果，看水果情况的客户
public class Client
{
public static void main(String[] args) throws Exception
{
FruitGardener fruitGardener = new FruitGardener();
Fruit apple = fruitGardener.factory("apple");
apple.grow();
Fruit strawBerry = fruitGardener.factory("strawberry");
strawBerry.harvest();
Fruit ddd = fruitGardener.factory("ddd");
ddd.plant();
}
}
简述JAVA中继承实现代码复用看看下面这个例子，就会明白了：JAVA中继承可以实现代码复用，
由于在父类中已经定义的方法，被子类继承以后，就可以使用，实现了代码的复用
class Father{
private int moneyDollar=300;
int moneyHK=200;
int add(int x,int y){
return x y;
}
}
class Son extends Father{
int moneyRMB=800;
public void changMoneyHK(int x){
moneyHK=x;
}
public void changMoneyRMB(int x){
moneyRMB=x;
}
int subs(int x,int y){
return x-y;
}
}
class GrandSon extends Son{
int multi(int x,int y){
return x*y;
}
}
public class Example5_1{
public static void main(String args[]){
int a=5,b=3;
Son son=new Son();
GrandSon sunzi=new GrandSon();
son.changMoneyHK(666);
son.changMoneyRMB(5000);
System.out.println("儿子的港币是继承的属性,当前的值是:" son.moneyHK);
System.out.println("儿子的人民币是新增的属性,当前的值是:" son.moneyRMB);
System.out.printf("减法是儿子新增的功能,%d-%d等于%d\n",a,b,son.subs(a,b));
System.out.printf("加法是儿子继承的功能,%d %d等于%d\n",a,b,son.add(a,b));
System.out.println("孙子的港币和人民币都是继承的属性,,当前的值是:");
System.out.println("港币:" sunzi.moneyHK " 人民币:" sunzi.moneyRMB);
System.out.printf("乘法是孙子新增的功能,%d*%d等于%d\n",a,b,sunzi.multi(a,b));
System.out.printf("加法是孙子继承的功能,%d %d等于%d\n",a,b,sunzi.add(a,b));
System.out.printf("减法是孙子继承的功能,%d-%d等于%d\n",a,b,sunzi.subs(a,b));
}
}
c中， this指的当前对象，到底何为当前？怎样判断当前？如下代码：站在语言角度上来说，this指针是相对于对象来说的。this指向当前对象。首先你要分清类和对象的区分。类是模型、设计模板。对象是将类实例化。比如女娲造人，当初想象了一个人的模型，但是只是在脑子里想，并没有出现。这时等于有了类。一旦造出来一个人，这就叫实例化一个对象。每个人设定都会说“我叫某某某” 。这个我，就是指向当前讲话的人。明白这个就基本上明白this了。
JAVA中，类、对象、实体、实体类、实体对象之间存在怎样的联系？？请高手做形象的解释。类: java中的类一般来存放实现了某些功能的代码代码片段，是程序的基础元素
对象：对象是一个很抽象的概念，比如一个java类实例化以后可以称为一个对象对象一般指的就是一个类创建出来的实例比如
public class A{}
那么 A是一个类
A a =new A();
那么这里的a 指的就是A这个类的实例也就是对象通过对象a可以访问A类下面的非私有字段和方法
实体类:一般会与实体对象一起出现对应数据库或者其他数据源中的一张表俗称为一个对象
这里的实体类对象和实体类打个简单的比方
实体类就好像事一张白纸白纸的获得要从厂商那边取得也就是我们去买在程序里就是用的关键字new当new了以后就好像是我们从生产厂商那里买来了一张白纸当然白纸上什么都没有
有了这张白纸以后我们就可以在白纸上给它赋值让它独一无二也就是对实体类进行封装数据
每一张白纸从我们购买的时候都是一样的对象都是一个字都没有的白纸但是后来通过业务处理使得白纸上都有了自己的东西也就是对象实体中的数据封装
还可以把实体类比作一个模板创建出来的实例对象都是跟这个模板一样的至于模板里面填写的内容那就要看你的赋值了就拿最简单的简历来说一般都会有简历模板我们从网上下载一个简历模板就是创建了一个实体类的对象而这个简历模板就相当于一个实体类接下来我们对下载下来的模板进行操作也就是对实体类对象进行操作对实体类对象操作是不会影响实体类的这个例子里面应该一目了然然后根据个人信息不同我们再模板上填写的信息也不同比如姓名年龄等等按照个人的信息来填写所以就会产生实体类的对象的属性不同相信这样解释你应该可以理解了吧关键还是要靠多写训练熟能生巧运用以后才能知道这些东西存在的奥妙
java工厂模式，懂的人进举两个例子以快速明白Java中的简单工厂模式：
女娲抟土造人
话说：“天地开辟，未有人民，女娲抟土为人。”女娲需要用土造出一个个的人，但在女娲造出人之前，人的概念只存在于女娲的思想里面。
女娲造人，这就是简单工厂模式的应用。
首先，在这个造人的思想里面，有几个重要的角色：女娲本身、抽象的人的概念和女娲所造出的一个个具体的人。
1.）女娲是一个工厂类，也就是简单工厂模式的核心角色。
2.）具休的一个个的人，包括张三，李四等。这些人便是简单工厂模式里面的具体产品角色
3.）抽象的人是最早只存在于女娲的头脑里的一个想法，女娲按照这个想法造出的一个个具体的人，便都符合这个抽象的人的定义。换言之，这个抽象的想法规定了所有具体的人必须都有的接口（特征或者功能）
　其UML类图出下所示：
理解了上面的这些东西，再来理解下面的例子，对照理解，相信看完这篇文章，便对java简单工厂模式有一个很好的理解：
有一个农场公司，专门向市场销售各类水果，在这个系统里需要描述下列水果：
　葡萄　Grape
　草莓　Stuawberry
　苹果　Apple
水果与其他植物不同，最终可以采摘食用，那么一个自然的做法是建立一个各种水果都适用的接口，以便与其他农场里的植物区分开来，
此时，则是为水果类声明了一个接口，表现在代码上：
1publicinterfaceFruit {
2// 生长
3voidgrow();
4// 收获
5voidharvest();
6// 种植
7voidplant();
8 }
9
10
水果接口规定出所有的水果必须实现的接口，包括任何水果类必须具备的方法plant(),grow(),和harvest();
Apple类是水果类的一种，因此它实现了水果接口所声明的所有方法。另处，由于苹果是多年生植物，因此多出一个treeAge性质，描述苹果的树龄。代码如下所示：
packagefac;
publicclassAppleimplementsFruit { // 通过implements实现接口Fruit
privateinttreeAge;
publicvoidgrow() {
log( " Apple is growing " );
}
publicvoidharvest() {
log( " Apple has been harvested " );
}
publicvoidplant() {
log( " Apple ha been planted " );
}
publicstaticvoidlog(String msg) {
System.out.println(msg);
}
publicintgetTreeAge() {
returntreeAge;
}
publicvoidsetTreeAge( inttreeAge) {
this .treeAge = treeAge;
}
}
同理，葡萄　Grape：
package fac;
public class Grape implements Fruit{
private boolean seedless;
public void grow(){
log("Grape is growing.");
}
public void harvest(){
log("Grape has been harvested");
}
public void plant(){
log("Grape ha been planted");
}
public static void log(String msg){
System.out.println(msg);
}
public boolean isSeedless() {
return seedless;
}
public void setSeedless(boolean seedless) {
this.seedless = seedless;
}
}
草莓　Stuawberry：
package fac;
public class Strawberry implements Fruit{
【女娲造人Java代码女娲造人游戏】public void grow(){
log("Strawberry is growing");
}
public void harvest(){
log("Strawberry has been harvested");
}
public void plant(){
log("Strawberry has been planted");
}
public static void log(String msg){
System.out.println(msg);
}
}
农场园丁也是系统的一部分，由一个类来代表，FruitGardener类，代码如下：
package fac;
public class FruitGardener{
public static Fruit factory(String which)throws Exception{
if(which.equalsIgnoreCase("apple")){
return new Apple();
}else if(which.equalsIgnoreCase("strawberry")){
return new Strawberry();
}else if (which.equalsIgnoreCase("grape")){
return new Grape();
}else{
throw new Exception("Bad fruit request");
}
}
}
这时有人来果园玩，和园丁说，给我们介绍下你的水果吧。于是园?。?
package fac;
public class People {
public static void main(String[] args) throws Exception {
FruitGardener fg=new FruitGardener();
Fruit ap=fg.factory("Apple");
ap.grow();
Fruit gp=fg.factory("Grape");
gp.plant();
Fruit dd=fg.factory("ddd");//抛出Bad fruit request异常
}
}
（注：以上代码在JDK5.0，Myeclise3.2下编译通过）
类比两个例子，园丁就相当于女娲，而水果就相当于具体的人，接口水果类就相当于存在于类女娲思想里的人的抽象概念。
由以上两个例子可得出，简单工厂模式需要由以下角色组成：
接口
接口的实现类（简单工厂模式里面的具体产品角色）
工厂
理解了以下两个例子，再来看第三个例子：
注意对比以下三个实例的不同
实例1：
package org.jzkangta.factorydemo01;
//定义接口
interface Car{
public void run();
public void stop();
}
//具体实现类
class Benz implements Car{
public void run(){
System.out.println("Benz开始启动了。。。。。");
}
public void stop(){
System.out.println("Benz停车了。。。。。");
}
}
//具体实现类
class Ford implements Car{
public void run(){
System.out.println("Ford开始启动了。。。");
}
public void stop(){
System.out.println("Ford停车了。。。。");
}
}
//工厂
class Factory{
public static Car getCarInstance(){
return new Ford();
}
}
public class FactoryDemo01 {
public static void main(String[] args) {
Car c=Factory.getCarInstance();
c.run();
c.stop();
}
}
实例二：
package fac;
//定义接口
interface Car{
public void run();
public void stop();
}
//具体实现类
class Benz implements Car{
public void run(){
System.out.println("Benz开始启动了。。。。。");
}
public void stop(){
System.out.println("Benz停车了。。。。。");
}
}
class Ford implements Car{
public void run(){
System.out.println("Ford开始启动了。。。");
}
public void stop(){
System.out.println("Ford停车了。。。。");
}
}
//工厂
class Factory{
public static Car getCarInstance(String type){
Car c=null;
if("Benz".equals(type)){
c=new Benz();
}
if("Ford".equals(type)){
c=new Ford();
}
return c;
}
}
public class FactoryDemo02 {
public static void main(String[] args) {
Car c=Factory.getCarInstance("Benz");
if(c!=null){
c.run();
c.stop();
}else{
System.out.println("造不了这种汽车。。。");
}
}
}
实例三：
interface Car{
public void run();
public void stop();
}
class Benz implements Car{
public void run(){
System.out.println("Benz开始启动了。。。。。");
}
public void stop(){
System.out.println("Benz停车了。。。。。");
}
}
class Ford implements Car{
public void run(){
System.out.println("Ford开始启动了。。。");
}
public void stop(){
System.out.println("Ford停车了。。。。");
}
}
class Toyota implements Car{
public void run(){
System.out.println("Toyota开始启动了。。。");
}
public void stop(){
System.out.println("Toyota停车了。。。。");
}
}
class Factory{
public static Car getCarInstance(String type){
Car c=null;
try {
c=(Car)Class.forName("org.jzkangta.factorydemo03." type).newInstance();//利用反射得到汽车类型
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return c;
}
}
public class FactoryDemo03 {
public static void main(String[] args) {
Car c=Factory.getCarInstance("Toyota");
if(c!=null){
c.run();
c.stop();
}else{
System.out.println("造不了这种汽车。。。");
}
}
}
对比三个实例：
实例一，虽然实现了简单工厂，但每次只能得到一种汽车，如果我们想换一种，就得修改工厂，太不方便，而实例二则改变了这种情况，便得我们可以按照我们的需要更换汽车，但我们所更换的汽车必须是实现类中有的，如果我们想要增加一种汽车的时候，我们还是得更改工厂，通过改进，实例三利用反射机制，得到汽车类型，这样当我们需要增加一种新的汽车时，就无需要再修改工厂，而只需要增加要实现的类即可。也就是说要增加什么样的汽车直接增加这个汽车的类即可，而无需改变工厂。从而达到了工厂分离的效果。
关于女娲造人Java代码和女娲造人游戏的介绍到此就结束了，不知道你从中找到你需要的信息了吗？如果你还想了解更多这方面的信息，记得收藏关注本站。

女娲造人Java代码女娲造人游戏

推荐阅读

八卦的现代意思

vivo|红米K40S就是海外版小米11T！16G+512G卖4599，到底贵不贵？

精灵鼠小弟的内容简介

新冠疫苗|为何新冠疫苗低剂量组比高剂量组更有效？牛津与阿斯利康称“需要大量调查”

为什么120斤看着很瘦

电商行业还有什么电商模式，o2o模式的特点是什么

小学家长希望与建议20字家长建议怎么写20字

我离牛人更近了一步

2022拼多多最新6级黑卡口令拼多多黑卡是怎么回事

vb.net求第几周 vb的weekday函数

夏季有哪些食疗养心方法

和平精英海岛竞速抽奖礼包在哪领和平精英海岛竞速抽奖礼包领取方法

Android基础（常用布局和数据存储）

章泽天近况怎么样？

深圳写字楼空租越来越多,后面会不会改成豪华公寓岀租？

太子参怎么炖汤

Scratch中制作一个动画人物的操作教程

三伏天晒背是每天都晒吗

菠菜怎么种菠菜啥时候种产量高

75度酒精能燃烧吗

女娲造人Java代码 女娲造人 游戏

推荐阅读

女娲造人Java代码女娲造人游戏