求版主叫我搭建程序框架

[酷酷啦啦xsx]

比如说一个项目需要几个java
A,B,C,D
A是主程序
B是一个都需要用的类

所以我现在是在A里创建B的实例，且创建C,D的实例，同时在创建C,D的实例是把B的实例传进C,D的构造函数里面。然后A,C,D就都可以共有B里面的方法，属性

新手用c语言的逻辑这么做的，好像程序是可以实现功能，但是不知道大家是怎么做的，总感觉这么做不好

版主指导下

[suciver]

没有使用spring这样的aop解耦的,基本就是用这种组合的方式

[酷酷啦啦xsx]

引用 1 楼 suciver 的回复:

没有使用spring这样的aop解耦的,基本就是用这种组合的方式

也是直接传递new出来的对象？

[suciver]

引用 2 楼 XSX127 的回复:

[quote=引用 1 楼 suciver 的回复:] 没有使用spring这样的aop解耦的,基本就是用这种组合的方式

也是直接传递new出来的对象？ [/quote] 看情况而定,有些对象可能只要初始化一次会单例模式,有些对象可能是每个线程一份

[forgetsam]

引用 5 楼 XSX127 的回复:

[quote=引用 4 楼 mooodo 的回复:] 在Java程序里，好的设计讲究“高内聚、低耦合”。高内聚暂不说，低耦合就是要让类与类之间的相互依赖最少。比如你这个例子里，假如A创建B的目的仅仅是为了在创建C和D的时候使用，那么为什么不让C和D自己去创建B呢？这样A不再依赖B，使得整体耦合度降低。 如果A现在是创建C和D，今后换一个环境则是创建E和F，则将C和D中抽取出接口，让A去引用接口，让C和D去实现接口，这叫“依赖反转原则”。

如果C和D都创建B的话，那么就不是共享B的属性 了，而是各自一个B 大神能不能给我一个你的简单代码，我学习下框架[/quote] 非得用一个B就用单例。

[酷酷啦啦xsx]

引用 6 楼 forgetsam 的回复:

[quote=引用 5 楼 XSX127 的回复:] [quote=引用 4 楼 mooodo 的回复:] 在Java程序里，好的设计讲究“高内聚、低耦合”。高内聚暂不说，低耦合就是要让类与类之间的相互依赖最少。比如你这个例子里，假如A创建B的目的仅仅是为了在创建C和D的时候使用，那么为什么不让C和D自己去创建B呢？这样A不再依赖B，使得整体耦合度降低。 如果A现在是创建C和D，今后换一个环境则是创建E和F，则将C和D中抽取出接口，让A去引用接口，让C和D去实现接口，这叫“依赖反转原则”。

如果C和D都创建B的话，那么就不是共享B的属性 了，而是各自一个B 大神能不能给我一个你的简单代码，我学习下框架[/quote] 非得用一个B就用单例。[/quote] 这只是简单的描述，问题是java内部文件之间怎么耦合，公用

[-阿克蒙德-]

看样子，版主很忙……

[充满诗意的联盟]

引用 7 楼 XSX127 的回复:

[quote=引用 6 楼 forgetsam 的回复:] [quote=引用 5 楼 XSX127 的回复:] [quote=引用 4 楼 mooodo 的回复:] 在Java程序里，好的设计讲究“高内聚、低耦合”。高内聚暂不说，低耦合就是要让类与类之间的相互依赖最少。比如你这个例子里，假如A创建B的目的仅仅是为了在创建C和D的时候使用，那么为什么不让C和D自己去创建B呢？这样A不再依赖B，使得整体耦合度降低。 如果A现在是创建C和D，今后换一个环境则是创建E和F，则将C和D中抽取出接口，让A去引用接口，让C和D去实现接口，这叫“依赖反转原则”。

如果C和D都创建B的话，那么就不是共享B的属性 了，而是各自一个B 大神能不能给我一个你的简单代码，我学习下框架[/quote] 非得用一个B就用单例。[/quote] 这只是简单的描述，问题是java内部文件之间怎么耦合，公用[/quote] 是否分别创建还是公用关键看需求。比如B是一个值对象，传给C或D时携带的数据各不同，则分别创建。如果仅仅是共用B的方法，可以静态调用，如工具类。 如果B是一个需要在C和D中连续传递的值对象就比较麻烦，可能还是得先在A中创建

[酷酷啦啦xsx]

引用 9 楼 mooodo 的回复:

[quote=引用 7 楼 XSX127 的回复:] [quote=引用 6 楼 forgetsam 的回复:] [quote=引用 5 楼 XSX127 的回复:] [quote=引用 4 楼 mooodo 的回复:] 在Java程序里，好的设计讲究“高内聚、低耦合”。高内聚暂不说，低耦合就是要让类与类之间的相互依赖最少。比如你这个例子里，假如A创建B的目的仅仅是为了在创建C和D的时候使用，那么为什么不让C和D自己去创建B呢？这样A不再依赖B，使得整体耦合度降低。 如果A现在是创建C和D，今后换一个环境则是创建E和F，则将C和D中抽取出接口，让A去引用接口，让C和D去实现接口，这叫“依赖反转原则”。

如果C和D都创建B的话，那么就不是共享B的属性 了，而是各自一个B 大神能不能给我一个你的简单代码，我学习下框架[/quote] 非得用一个B就用单例。[/quote] 这只是简单的描述，问题是java内部文件之间怎么耦合，公用[/quote] 是否分别创建还是公用关键看需求。比如B是一个值对象，传给C或D时携带的数据各不同，则分别创建。如果仅仅是共用B的方法，可以静态调用，如工具类。 如果B是一个需要在C和D中连续传递的值对象就比较麻烦，可能还是得先在A中创建[/quote] class A{ public static B b; public a{ b=new B(); } public static void main(){ A a = new A(); } } class C{ a.b.方法(); } class D{ a.b.方法(); } 大神看下上面的模型，看别人的

[充满诗意的联盟]

在Java程序里，好的设计讲究“高内聚、低耦合”。高内聚暂不说，低耦合就是要让类与类之间的相互依赖最少。比如你这个例子里，假如A创建B的目的仅仅是为了在创建C和D的时候使用，那么为什么不让C和D自己去创建B呢？这样A不再依赖B，使得整体耦合度降低。 如果A现在是创建C和D，今后换一个环境则是创建E和F，则将C和D中抽取出接口，让A去引用接口，让C和D去实现接口，这叫“依赖反转原则”。

[酷酷啦啦xsx]

引用 4 楼 mooodo 的回复:

在Java程序里，好的设计讲究“高内聚、低耦合”。高内聚暂不说，低耦合就是要让类与类之间的相互依赖最少。比如你这个例子里，假如A创建B的目的仅仅是为了在创建C和D的时候使用，那么为什么不让C和D自己去创建B呢？这样A不再依赖B，使得整体耦合度降低。 如果A现在是创建C和D，今后换一个环境则是创建E和F，则将C和D中抽取出接口，让A去引用接口，让C和D去实现接口，这叫“依赖反转原则”。

如果C和D都创建B的话，那么就不是共享B的属性 了，而是各自一个B 大神能不能给我一个你的简单代码，我学习下框架

[充满诗意的联盟]

分几种情况： 1.B方法仅仅是一个方法而未读取B中任何属性和状态，这时可以将B中的方法设计成静态方法，如：

public class DateUtil {
  public static Date getNow(){...}
}
public class A {
  DateUtil.getNow();
  ...
  C c = new C();
  D d = new D();
}
public class C {
  DateUtil.getNow();
}
public class D {
  DateUtil.getNow();
}

[充满诗意的联盟]

2.B是一个类似值对象的东西，携带很多数据，并且每次都不一样。这时需要A从某个地方获取B，或者自己创建B，然后传递给C和D，这时C和D可以设计成某个接口，通过注入依赖载入其实现类：

public class DateValue {
  private Date date;
  //get与set方法
  public int getMonth(){...}
}
public class A {
  //从某处获得DateValue，或者自己创建
  int month = dateValue.getMonth();
  C c = new C(dateValue);
  D d = new D(dateValue);
}

[充满诗意的联盟]

如果B中的状态比较少，就1，2个，也可以这样设计：

public class DateUtil {
  public static int getMonth(Date date){...}
}
public class A {
  C c = new C();
  D d = new D();
  c.方法(date);
  d.方法(date);
}
public class C {
  public 方法(date){ DateUtil.getMonth(date);
}
public class D {
  public 方法(date){ DateUtil.getMonth(date);
}

[酷酷啦啦xsx]

引用 14 楼 mooodo 的回复:

如果B中的状态比较少，就1，2个，也可以这样设计：

public class DateUtil {
  public static int getMonth(Date date){...}
}
public class A {
  C c = new C();
  D d = new D();
  c.方法(date);
  d.方法(date);
}
public class C {
  public 方法(date){ DateUtil.getMonth(date);
}
public class D {
  public 方法(date){ DateUtil.getMonth(date);
}

嗯，学习了

[充满诗意的联盟]

3.如果B虽然有状态，但是对整个系统的状态，则可以将属性写成静态变量。然而实际设计不用这样，因为在Spring中配置的类默认都是单例。既然是单例就与静态没有什么区别：

public class SysContext { private Date date; //get和set方法 public int getMonth(){...} } public class A { private C c; private D d; //get和set方法 } public class C { private SysContext sysContext; //get和set方法 sysContext.getMonth(); } public class D { private SysContext sysContext; //get和set方法 sysContext.getMonth(); } [/code] 最后记得将其配置在Spring中 //不能练习发3个以上回复

[caodaoyou]