public   class  PrintOS 
{
	 public   static   void  main( final  String[] args) 
	{
		String osName = System.getProperty("os.name") ;
		 if  (osName.equals("SunOS") || osName.equals("Linux")) 
		{
			System.out.println("This is a UNIX box and therefore good.") ;
		} 
		 else   if  (osName.equals("Windows NT") || osName.equals("Windows 95")) 
		{
			System.out.println("This is a Windows box and therefore bad.") ;
		} 
		 else  
		{
			System.out.println("This is not a box.") ;
		}
	}
}

 public   class  PrintOS {
     public   static   void  main( final  String[] args) {
        String osName = System.getProperty("os.name");
         if  (isUnix(osName)) {
            processUnix();
        }  else   if  (isWindows(osName)) {
            processWindows();
        }  else  {
            processUnknown();
        }
    }

     private   static   void  processUnknown() {
        System.out.println("This is not a box.");
    }

     private   static   boolean  isWindows(String osName) {
         return  osName.equals("Windows NT") || osName.equals("Windows 95");
    }

     private   static   void  processWindows() {
        System.out.println("This is a Windows box and therefore bad.");
    }

     private   static   boolean  isUnix(String osName) {
         return  osName.equals("SunOS") || osName.equals("Linux");
    }

     private   static   void  processUnix() {
        System.out.println("This is a UNIX box and therefore good.");
    }
}

 public   class  PrintOS {
     public   static   void  main( final  String[] args) {
        findOSByName(System.getProperty("os.name")).process();
    }

     private   static  OS findOSByName(String osName) {
         for  (OS os :  new  OS[]{ new  Unix(),  new  Windows(),  new  Unknown()}) {
             if  (os.isMatch(osName)) {
                 return  os;
            }
        }
         throw   new  InternalError();
    }

     interface  OS {
         boolean  isMatch(String osName);

         void  process();
    }

     static   class  Unknown  implements  OS {
         public   boolean  isMatch(String osName) {
             return  true;
        }

         public   void  process() {
            System.out.println("This is not a box.");
        }
    }

     static   class  Windows  implements  OS {
         public   boolean  isMatch(String osName) {
             return  osName.equals("Windows NT") || osName.equals("Windows 95");
        }

         public   void  process() {
            System.out.println("This is a Windows box and therefore bad.");
        }
    }

     static   class  Unix  implements  OS {
         public   boolean  isMatch(String osName) {
             return  osName.equals("SunOS") || osName.equals("Linux");
        }

         public   void  process() {
            System.out.println("This is a UNIX box and therefore good.");
        }
    }
}

 public   class  PrintOS {
     public   static   void  main( final  String[] args) { 
        //Сказка?
        OSes.findByName(System.getProperty("os.name")).process();
    }
}

 interface  OS {
     boolean  isMatch(String osName);

     void  process();
}

 class  OSes {
     static  OS[] registred =  new  OS[]{ new  Unix(),  new  Windows(),  new  Unknown()};

     public   static  OS findByName(String osName) {
         for  (OS os : registred) {
             if  (os.isMatch(osName)) {
                 return  os;
            }
        }
         throw   new  InternalError();
    }

     static   class  Unknown  implements  OS {
         public   boolean  isMatch(String osName) {
             return  true;
        }

         public   void  process() {
            System.out.println("This is not a box.");
        }
    }

     static   class  Windows  implements  OS {
         public   boolean  isMatch(String osName) {
             return  osName.equals("Windows NT") || osName.equals("Windows 95");
        }

         public   void  process() {
            System.out.println("This is a Windows box and therefore bad.");
        }
    }

     static   class  Unix  implements  OS {
         public   boolean  isMatch(String osName) {
             return  osName.equals("SunOS") || osName.equals("Linux");
        }

         public   void  process() {
            System.out.println("This is a UNIX box and therefore good.");
        }
    }
}

 public   class  PrintOS {
     public   static   void  main( final  String[] args) {
        OSes.findByName(System.getProperty("os.name")).process( new  PrintMessageVisitor());
    }

     private   static   class  PrintMessageVisitor  implements  OSes.Visitor {
         public   void  visit(OSes.Unix unix) {
            System.out.println("This is a UNIX box and therefore good.");
        }

         public   void  visit(OSes.Windows windows) {
            System.out.println("This is a Windows box and therefore bad.");
        }

         public   void  visit(OSes.Unknown unknown) {
            System.out.println("This is not a box.");
        }
    }
}

 interface  OS {
     boolean  isMatch(String osName);

     void  process(OSes.Visitor visitor);
}

 class  OSes {
     static  OS[] registred =  new  OS[]{ new  Unix(),  new  Windows(),  new  Unknown()};

     public   static  OS findByName(String osName) {
         for  (OS os : registred) {
             if  (os.isMatch(osName)) {
                 return  os;
            }
        }
         throw   new  InternalError();
    }

     interface  Visitor {

         void  visit(Unknown unknown);

         void  visit(Windows windows);

         void  visit(Unix unix);
    }

     static   class  Unknown  implements  OS {
         public   boolean  isMatch(String osName) {
             return  true;
        }

         public   void  process(Visitor visitor) {
            visitor.visit( this );
        }
    }

     static   class  Windows  implements  OS {
         public   boolean  isMatch(String osName) {
             return  osName.equals("Windows NT") || osName.equals("Windows 95");
        }

         public   void  process(Visitor visitor) {
            visitor.visit( this );
        }
    }

     static   class  Unix  implements  OS {
         public   boolean  isMatch(String osName) {
             return  osName.equals("SunOS") || osName.equals("Linux");
        }

         public   void  process(Visitor visitor) {
            visitor.visit( this );
        }
    }
}

 public   class  PrintOS {
     public   static   void  main( final  String[] args) {
        OSes.findByName(System.getProperty("os.name")).process( new  PrintMessageVisitor());
    }

     private   static   class  PrintMessageVisitor {
        @OS.Type(OSes.Unix. class )
         public   void  unixGood() {
            System.out.println("This is a UNIX box and therefore good.");
        }

        @OS.Type(OSes.Windows. class )
         public   void  windowsBad() {
            System.out.println("This is a Windows box and therefore bad.");
        }

        @OS.Type(OSes.Unknown. class )
         public   void  foo() {
            System.out.println("This is not a box.");
        }
    }
}


 abstract   class  OS {
     private   static  Object[] emptyArray =  new  Object[]{};

     public   abstract   boolean  isMatch(String osName);

     public   final   void  process(Object visitor) {
         for  (Method method : visitor.getClass().getMethods()) {
            OS.Type annotation = method.getAnnotation(OS.Type. class );
             if  (annotation !=  null  && annotation.value().equals( this .getClass())) {
                 try  {
                    method.invoke(visitor, emptyArray);
                }  catch  (Exception e) {
                     throw   new  InternalError(); //TODO;
                }
            }
        }
    }

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    @ interface  Type {
         Class  value();
    }
}


 class  OSes {
     static  List<OS> registred =  new  ArrayList<OS>();

     private  OSes() {
    }

     static  {
         for  ( Class  clazz : OSes. class .getClasses()) {
             if  (OS. class .isAssignableFrom(clazz)) {
                 try  {
                    register((OS) clazz.newInstance());
                }  catch  (Exception e) {
                     throw   new  InternalError(); //TODO;
                }
            }
        }
    }

     public   static   void  register(OS os) {
        registred.add(os);
    }

     public   static  OS findByName(String osName) {
         for  (OS os : registred) {
             if  (os.isMatch(osName)) {
                 return  os;
            }
        }
         return  Unknown.INSTANCE;
    }

     public   static   class  Unknown  extends  OS {
         public   final   static  OS INSTANCE =  new  Unknown();

         public   boolean  isMatch(String osName) {
             return  false;
        }
    }

     public   static   class  Windows  extends  OS {
         public   boolean  isMatch(String osName) {
             return  osName.equals("Windows NT") || osName.equals("Windows 2003");
        }
    }

     public   static   class  Unix  extends  OS {
         public   boolean  isMatch(String osName) {
             return  osName.equals("SunOS") || osName.equals("Linux");
        }
    }
}

 public   class  PrintOS {
     public   static   void  main( final  String[] args) {
         new  OSContainer().resolve(System.getProperty("os.name")).process( new  MessagePrinter());
    }

     private   static   class  OSContainer  extends  AbstractOSContainer {

         public   static   class  Windows  extends  OS {
             public   boolean  isMatch(String osName) {
                 return  osName.equals("Windows NT") || osName.equals("Windows 2003");
            }
        }

         public   static   class  Unix  extends  OS {
             public   boolean  isMatch(String osName) {
                 return  osName.equals("SunOS") || osName.equals("Linux");
            }
        }
    }

     private   static   class  MessagePrinter {
        @OS.Type(OSContainer.Unix. class )
         public   void  unixGood() {
            System.out.println("This is a UNIX box and therefore good.");
        }

        @OS.Type(OSContainer.Windows. class )
         public   void  windowsBad() {
            System.out.println("This is a Windows box and therefore bad.");
        }

        @OS.Type(OS.Unknown. class )
         public   void  foo() {
            System.out.println("This is not a box.");
        }
    }
}

// Support ---------------------------------------------------------------------

 abstract   class  OS {
     public   final   static  OS UNKNOWN =  new  Unknown();

     private   static  Object[] emptyArray =  new  Object[]{};

     public   abstract   boolean  isMatch(String osName);

     public   final   void  process(Object visitor) {
         for  (Method method : visitor.getClass().getMethods()) {
            OS.Type annotation = method.getAnnotation(OS.Type. class );
             if  (annotation !=  null  && annotation.value().equals( this .getClass())) {
                 try  {
                    method.invoke(visitor, emptyArray);
                }  catch  (Exception e) {
                     throw   new  InternalError(); //TODO;
                }
            }
        }
    }

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    @ interface  Type {
         Class  value();
    }

     public   static   class  Unknown  extends  OS {
         public   boolean  isMatch(String osName) {
             return  false;
        }
    }
}

 class  OSes {
     private  List<OS> registred =  new  ArrayList<OS>();

     public   void  register(OS os) {
        registred.add(os);
    }

     public  OS findByName(String osName) {
         for  (OS os : registred) {
             if  (os.isMatch(osName)) {
                 return  os;
            }
        }
         return  OS.UNKNOWN;
    }
}

 class  AbstractOSContainer {
     private  OSes oses =  new  OSes();

     public  AbstractOSContainer() {
        initOSesFromInnerClasses();
    }

     private   void  initOSesFromInnerClasses() {
         for  ( Class  clazz :  this .getClass().getClasses()) {
             if  (OS. class .isAssignableFrom(clazz)) {
                 try  {
                    oses.register((OS) clazz.newInstance());
                }  catch  (Exception e) {
                     throw   new  InternalError(); //TODO;
                }
            }
        }
    }

     public  OS resolve(String osName) {
         return  oses.findByName(osName);
    }
}

 private  String osName;

 public   class  PrintOS {
     public   static   void  main( final  String[] args) {
        System.out.println(OS.findByName(System.getProperty("os.name")).getMessage());
    }
}

 class  OS {
     public   static   final  String WINDOWS = "Windows";
     public   static   final  String UNIX = "Unix";
     public   static   final  String UNKNOWN = "Unknown";

     private  String name;

     public  OS(String name) {
         this .name = name;
    }

     public  String getName() {
         return  name;
    }

     public  String getMessage() {
         if  (getName().equals(UNIX)) {
             return  "This is a UNIX box and therefore good.";
        }  else   if  (getName().equals(WINDOWS)) {
             return  "This is a Windows box and therefore bad.";
        }  else  {
             return  "This is not a box.";
        }
    }

     public   static  OS findByName(String osName) {
         if  (isUnix(osName)) {
             return   new  OS(WINDOWS);
        }
         if  (isWindows(osName)) {
             return   new  OS(UNIX);
        }
         return   new  OS(UNKNOWN);
    }

     public   static   boolean  isWindows(String osName) {
         return  osName.equals("Windows NT") || osName.equals("Windows 2003");
    }

     public   static   boolean  isUnix(String osName) {
         return  osName.equals("SunOS") || osName.equals("Linux");
    }
}

     public   static  OS findByName(String osName) {
         if  (isUnix(osName)) {
             return   new  OS(WINDOWS);
        }
         if  (isWindows(osName)) {
             return   new  OS(UNIX);
        }
         return   new  OS(UNKNOWN);
    }