응집도_(logical cohesion)

응집도 (cohesion)

논리적 응집도 (logical)

논리적 응집력이란 모듈의 일부가 논리적으로 분류되어 자연스럽지 만 똑같은 것을 수행하도록 분류되기 때문입니다.

InputStream 패턴 루틴화 아래는 InputStream 클래스

package java.io;

public abstract class InputStream implements Closeable {


   private static final int MAX_SKIP_BUFFER_SIZE = 2048;

   public abstract int read() throws IOException;

   public int read(byte b[]) throws IOException {
       return read(b, 0, b.length);
   }

   public int read(byte b[], int off, int len) throws IOException {
       if (b == null) {
           throw new NullPointerException();
       } else if (off < 0 || len < 0 || len > b.length - off) {
           throw new IndexOutOfBoundsException();
       } else if (len == 0) {
           return 0;
       }

       int c = read();
       if (c == -1) {
           return -1;
       }
       b[off] = (byte)c;

       int i = 1;
       try {
           for (; i < len ; i++) {
               c = read();
               if (c == -1) {
                   break;
               }
               b[off + i] = (byte)c;
           }
       } catch (IOException ee) {
       }
       return i;
   }


   public long skip(long n) throws IOException {

       long remaining = n;
       int nr;

       if (n <= 0) {
           return 0;
       }

       int size = (int)Math.min(MAX_SKIP_BUFFER_SIZE, remaining);
       byte[] skipBuffer = new byte[size];
       while (remaining > 0) {
           nr = read(skipBuffer, 0, (int)Math.min(size, remaining));
           if (nr < 0) {
               break;
           }
           remaining -= nr;
       }

       return n - remaining;
   }

   public int available() throws IOException {
       return 0;
   }

   public void close() throws IOException {}

   public synchronized void mark(int readlimit) {}

   public synchronized void reset() throws IOException {
       throw new IOException("mark/reset not supported");
   }

   public boolean markSupported() {
       return false;
   }

}