关于工厂模式的问题!

Question

楼主的意思是不是CalendarFeed实现接口A？如果是的话，在CalendarFeed再加上implements A就可以了，你自己可以试一试看
A a = new CalendarFeed();
a.start()也是可以的。如果不是，那我就不明白你到底要干什么，呵呵~~~

Answer 1

我再贴一次:
public class CalendarFeed implements A
{ private static FeedThread thread;//线程成员 public CalendarFeed() 
{
} public void start() //开启推送服务
{
if (thread == null) 
{
thread = new FeedThread();
thread.start();
}
} public void stop() //结束推送服务
{
thread.running = false;
thread = null;
} public static class FeedThread extends Thread 
{ public boolean running = true; public void run() 
{ while (running) 
{
try
{
                                        //业务逻辑
Thread.sleep(5000);//五秒推送一次
} 
catch (InterruptedException e) 
{
e.printStackTrace();
}
}
}
}
}
interface A{
 void start();
 void stop();
} 
public class FatoryModule{
public A getA(String name){
  if(name.equals("CalendarFeed")){
    return new CalendarFeed();
  }else if(){....}
 }
}
这样对不对呢?

Answer 2

private static FeedThread thread;该线程是每一个类里面的内部类的对象!
接口里面是否要写一个属性?
比如像这样:interface A{
 private static FeedThread thread;
 void start();
 void stop();
} 

Answer 3

interface ballFacotroy {
  void a();
}
footBall implements ballFacotroy {
  void a(){
     ......
}
}BascketBall implements ballFacotroy {
  void a(){
    ..........
}
}test{
  public static void main(){
     ballFacotroy  basketball=new BasketBall();
     ballFacotroy  footBall=new FootBall();
     basketball.a()
     footBall.a()
}
}设计模式心理清楚就可以了，其实不需要为了用设计模式而使用设计模式！

Answer 4

可以啊，不过我看楼主的代码start和stop方法基本上可以做到公用。所以是否可以让FeedThread去继承你的抽象类A(A改成抽象类)，也就是说
abstract class A implements Runnable {
  public boolean running = true;
  public void doSomething();
  public void run() {
     ...
     doSomething();
     ...
  }
}然后CalendarFeed的构造方法public CalendarFeed(A a){}
个人感觉这样更好点。

Answer 5

可以啊，不过我看楼主的代码start和stop方法基本上可以做到公用。所以是否可以让FeedThread去继承你的抽象类A(A改成抽象类)，也就是说
abstract class A implements Runnable {
  public boolean running = true;
  public void doSomething();
  public void run() {
     ...
     doSomething();
     ...
  }
}然后CalendarFeed的构造方法public CalendarFeed(A a){}
个人感觉这样更好点。

Answer 6

private不行，至少得是protected的

Answer 7

哦，由于doSomething是需要子类实现的方法，本体不实现，所以要加前缀abstract你那种定义接口应该可以的，自己多试试下就能找到具体实现方法。有一点就是接口中绝对不能包括私有类型的变量或方法。至于我说的改成抽象类，然后让子类实现其doSomething()的方法，有时间可以想想，我觉得这样写的话，能提高代码重用性，毕竟你那start，stop方法基本上内容都一样了，没必要每个子类都写一遍。

Answer 8

public void run() 
        {            while (running) 
            {
                try
                {    
                  doSomething();//业务逻辑
                    Thread.sleep(5000);//五秒推送一次
                } 
                catch (InterruptedException e) 
                {
                    e.printStackTrace();
                }
            }
        }也就是说抽象类里面的run方法几乎就纯粹调用doSomething()，然后每个子类去实现究竟该干啥事儿。
抽象类中可以实现具体方法，若不想让该方法实现的话，加上前缀abstract。实际上接口是全部一种特殊的抽象类，里面所有的方法都需要子类实现的。
而真正意义上的抽象类则有抽象方法，也可以有已被实现的方法。但是由于java是单继承特性，所以接口、抽象类就要自己看看究竟使用哪种合适了

Answer 9

你说的很对!
start();和stop();基本实现都是一样的!
唯独不一样的就是
 
public static class FeedThread extends Thread 
    {        public boolean running = true;        public void run() 
        {            while (running) 
            {
                try
                {    
                  //业务逻辑
                    Thread.sleep(5000);//五秒推送一次
                } 
                catch (InterruptedException e) 
                {
                    e.printStackTrace();
                }
            }
        }
    }  就是业务逻辑的实现不一样!因为每个模块负责做不同的事情!
就因为它是静态内部类,所以我才不知道该如何去设计那个抽象类!

Answer 10

public class CalendarFeed { private Doing doing;// 线程成员 public CalendarFeed(Doing doing) {
this.doing = doing;
} public void start() // 开启推送服务
{
if (doing != null) {
Thread thread = new Thread(doing);
thread.start();
}
} public void stop() // 结束推送服务
{
doing.running = false;
doing = null;
}

public static void main(String[] args) {
CalendarFeed feed = new CalendarFeed(new FeedThread2());
feed.start();
try {
Thread.sleep(2000);//
} catch (InterruptedException e) {
e.printStackTrace();
}
feed.stop();
}
}abstract class Doing implements Runnable {
protected boolean running = true;

public abstract void doSomething();

public void run() {
while (running) {
try {
doSomething();// 业务逻辑
Thread.sleep(500);// 五秒推送一次
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}class FeedThread1 extends Doing {
public void doSomething() {
System.out.println("this is FeedTread1");
}
}class FeedThread2 extends Doing {
public void doSomething() {
System.out.println("this is FeedTread2");
}
}你试试这东西是不是你想要的效果。