[작성자:] thkmon

자바 그림에서 글자 찾기

원하는 텍스트, 폰트종류, 폰트크기를 input하면
화면 상에서 해당 글자를 찾아내는 메소드를 만들었음
한계점은 정확히 폰트 종류, 폰트 크기, 자간이 같아야만 찾아낸다는 점이다.

1. 텍스트를 그림(bufferdImage)으로 만든다. 이를 스몰이미지라고 하자.

2. 현재 화면을 스크린샷 찍는다. 빅 이미지라고 하자.

3. 스물 이미지가 빅 이미지에 포함되어 있는지 확인한다(4중 포문).

이 때, 가장 처음 발견된 폰트색깔을 기억한 후

뒤에 나오는 폰트색깔과 일치하는지를 점검한다.

(이렇게 하면 찾는 글자가 검은색이든 흰색이든 찾아낼 수 있다)

한계: 정확히 같은 폰트종류와 크기, 자간이어야만 찾아낸다.

——————————————————————————-

package com;

import javax.imageio.ImageIO;

public class SecondClass {

public static void main(String[] args) {

//그림1을 얻어옴
BufferedImage bimg=txtToImg(“글자인식”, “돋움”, 16);//16);

//스크린샷 찍음
BufferedImage scrn=screenShot();

//그림1과 스크린샷을 비교
boolean includ=includeImg(scrn, bimg);

System.out.println(includ);
}
//////////////////////////////////////////////////////////////
//글자를 그림으로 변경
public static BufferedImage txtToImg(String str,String fontName,int fontSize){
//int fontSize=i+1;
//String str=”휴지통”;

BufferedImage img = new BufferedImage(fontSize*str.length(), (int)(fontSize*1), BufferedImage.TYPE_INT_RGB);

Graphics2D graphics = img.createGraphics();

//흰색으로 색칠
graphics.fillRect(0, 0, fontSize*str.length(), (int)(fontSize*1));
//graphics.setBackground(new Color(255,100,50));
graphics.setColor(new Color(0,0,0));
graphics.setFont(new Font(fontName, 0, fontSize));

//글자를 출력
graphics.drawString(str, 0, (int)(fontSize*0.9));

File file=new File(“c:/a/make.bmp”);
try{
    ImageIO.write(img, “bmp”, file);
}catch(Exception ex){System.out.println(ex.getMessage());}

return img;
}
///////////////////////////////////////////////////////////
//화면 스크린샷을 버퍼드 이미지에 저장하는 메소드
public static BufferedImage screenShot(){
//스크린샷하기
BufferedImage scrn=null;//버퍼드이미지 선언
try{
   //해상도 구하기
   Dimension screenSize=Toolkit.getDefaultToolkit().getScreenSize();

   //스크린샷 찍기
   Robot robot=new Robot();
   scrn=robot.createScreenCapture(new Rectangle(0, 0, (int)screenSize.getWidth(), (int)screenSize.getHeight()));

   //스크린샷 파일화
   //ImageIO.write(scrn, “bmp”, new File(“c:/a/res.bmp”));

}catch(Exception ex){System.out.println(ex.getMessage());}
return scrn;
}
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
//큰 그림에 작은 그림이 속하는지(포함하는지) 검사하는 메소드
public static boolean includeImg(BufferedImage bigImg, BufferedImage smImg){
boolean res=false;

for(int xs=0;xs<bigImg.getWidth()-smImg.getWidth();xs++){
   for(int ys=0;ys<bigImg.getHeight()-smImg.getHeight();ys++){

int fontColor=-9999;

    //System.out.println(xs+” “+ys+”를 검사”);
    for(int i=xs;i<xs+smImg.getWidth();i++){
     for(int j=ys;j<ys+smImg.getHeight();j++){
      //System.out.println(i+” “+j);
    //같으면
    int bigRGB=bigImg.getRGB(i, j);
    int smallRGB=smImg.getRGB(i-xs, j-ys);

    Color bigClr=new Color(bigRGB);
    Color smallClr=new Color(smallRGB);

    if(smallRGB==-1){//작은 그림이 흰색이라면 배경
    //폰트 색이 지정되어있지 않다면 스킵
       if(fontColor==-9999){//폰트색이 지정되어있지 않다면
        res=true;
        continue;
       }
       else{
        //폰트 색이 지정되어 있다면
        if(bigRGB!=fontColor){
         //폰트색과 배경색이 다르다면 스킵
         res=true;
               continue;
        }
        else{
         //폰트색과 배경색이 같으면 안됨
         res=false;
            break;
        }
       }
    }
    else{//작은 그림이 흰색이 아니라면 글자
       if(fontColor==-9999){//폰트색이 지정되어있지 않다면
        fontColor=bigRGB;//큰그림의 현재색을 기억함(이것이 폰트색 기준이됨)
        res=true;
        continue;
       }
       else{
        //폰트색이 지정되어 있다면
        if(bigRGB==fontColor){
         //지정색과 같을 경우엔 스킵
         res=true;
               continue;
        }
        else{
         res=false;
            break;
        }
       }
    }
     }
     if(res==false){break;}//다르면 나감
    }
    if(res==true){

     System.out.println(“발견좌표:”+xs+”,”+ys+” w:”+smImg.getWidth()+” h:”+smImg.getHeight());

       BufferedImage scrn=null;//버퍼드이미지 선언
       try{
        //스크린샷 찍기
        Robot robot=new Robot();
        scrn=robot.createScreenCapture(new Rectangle(xs, ys, smImg.getWidth(), smImg.getHeight()));

        //스크린샷 파일화
        ImageIO.write(scrn, “bmp”, new File(“c:/a/result.bmp”));

       }catch(Exception ex){System.out.println(ex.getMessage());}

     break;
    }
   }
   if(res==true){break;}
}
return res;
}

}

자바 그림비교 메소드 (bufferedImage 비교)

bufferedImage를 비교하는 메소드는 다음과 같다. 이 메소드는 그림 두 개가 크기(getWidth, getHeight)와 색상값(getRGB)이 완벽히 같은지 비교한다.

//버퍼상의 이미지 두 개를 비교하는 메소드
boolean bufferedImagesEqual(BufferedImage img1, BufferedImage img2) {
     if (img1.getWidth() == img2.getWidth() && img1.getHeight() == img2.getHeight()) {
         for (int x = 0; x < img1.getWidth(); x++) {
             for (int y = 0; y < img1.getHeight(); y++) {
                 if (img1.getRGB(x, y) != img2.getRGB(x, y))
                     return false;
             }
         }
     } else {
         return false;
     }
     return true;
}

————————————————————————————————–

이를 발전시키면 작은 그림이 큰 그림에 포함되는지 확인하는 메소드를 만들 수 있다.

버퍼상의 이미지 두 개를 비교해서 큰 이미지 속에 작은 이미지가 포함하는지 알아낼 수 있다.

package com;

import java.awt.Dimension;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.io.File;

import javax.imageio.ImageIO;

public class SecondClass {

public static void main(String[] args) {


  //그림1을 얻어옴
  BufferedImage bimg=null;
  try{
   File file=new File(“c:/a/00.bmp”);
   bimg=ImageIO.read(file);
  }catch(Exception ex){System.out.println(ex.getMessage());}


  //스크린샷 찍음
  BufferedImage scrn=screenShot();

  //그림1과 스크린샷을 비교
  boolean includ=includeImg(scrn, bimg);

  System.out.println(includ);
}

//화면 스크린샷을 버퍼드 이미지에 저장하는 메소드
public static BufferedImage screenShot(){
  //스크린샷하기
  BufferedImage scrn=null;//버퍼드이미지 선언
  try{
   //해상도 구하기
   Dimension screenSize=Toolkit.getDefaultToolkit().getScreenSize();

   //스크린샷 찍기
   Robot robot=new Robot();
   scrn=robot.createScreenCapture(new Rectangle(0, 0, (int)screenSize.getWidth(), (int)screenSize.getHeight()));

   //스크린샷 파일화
   //ImageIO.write(scrn, “jpeg”, new File(“c:/a/res.jpeg”));

  }catch(Exception ex){System.out.println(ex.getMessage());}
  return scrn;
}

//큰 그림에 작은 그림이 속하는지(포함하는지) 검사하는 메소드
public static boolean includeImg(BufferedImage bigImg, BufferedImage smImg){
  boolean res=false;

  for(int xs=0;xs<bigImg.getWidth()-smImg.getWidth();xs++){
   for(int ys=0;ys<bigImg.getHeight()-smImg.getHeight();ys++){

    //System.out.println(xs+” “+ys+”를 검사”);
    for(int i=xs;i<xs+smImg.getWidth();i++){
     for(int j=ys;j<ys+smImg.getHeight();j++){
      //System.out.println(i+” “+j);
      if(bigImg.getRGB(i, j)!=smImg.getRGB(i-xs, j-ys)){
       //픽셀값을 비교해서 다르면 체크
       res=false;
       break;
      }
      else{
       res=true;
      }
     }
     if(res==false){break;}//다르면 나감
    }
    if(res==true){
     System.out.println(“발견좌표:”+xs+”,”+ys+” w:”+smImg.getWidth()+” h:”+smImg.getHeight());
     break;
    }
   }
   if(res==true){break;}
  }
  return res;
}

}

파워자바 1장

Write Once, Run Everywhere!

자바파일 –(컴파일러)–>바이트 코드 –(자바 가상기계)–> 윈도우, 리눅스, Mac 어디서든 실행

ex) Hello.java –(컴파일러)–>Hello.class –(자바 가상기계)–> Hello

1. JSP(자바 서버 페이지) : HTML 안에 자바코드가 있음. 웹페이지와 사용자가 상호작용 가능.

2. 자바 애플릿: 웹서버로부터 다운로드되어서 클라이언트 컴퓨터에서 실행되는 프로그램. 웹브라우저 안에서 출력됨.

3. 자바 서블릿: 웹서버에서 동작하는 서버모듈. 클라이언트의 요구를 받아서 서버에서 처리 한 후 실행결과를 HTML으로 전송한다.

4. 자바빈즈: 자바로 작성된 컴포넌트. 애플리케이션을 만들기 위한 일종의 빌딩 블록. 결합 가능, 재사용 가능. 컴포넌트(빈즈)를 조립하면 빠르게 애플리케이션 작성 가능하다.

자바 문자열을 그림으로 만들기

실행결과:

package com;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;

import javax.imageio.ImageIO;

public class MainClass {

public static void main(String[] args) {
  // TODO Auto-generated method stub

  for(int i=0;i<50;i++){
   int fontSize=i+1;
   String str=”휴지통”;

   BufferedImage img = new BufferedImage(fontSize*str.length(), (int)(fontSize*1.2), BufferedImage.TYPE_INT_RGB);
   Graphics2D graphics = img.createGraphics();

   graphics.setBackground(new Color(255,100,50));
   graphics.setColor(new Color(255,255,255));
   graphics.setFont(new Font(“굴림”, 0, fontSize));

   //글자를 출력
   graphics.drawString(str, 0, fontSize);

   File file=new File(“c:/a/b”+i+”.jpeg”);
   try{
    ImageIO.write(img, “jpeg”, file);

   }catch(Exception ex){System.out.println(ex.getMessage());}
  }

}

————————-

BufferedImage img = new BufferedImage(fontSize*str.length(), (int)(fontSize*1), BufferedImage.TYPE_INT_RGB);

에서 *1.1 을 *1 로 바꾸고,
graphics.drawString(str, 0, (int)(fontSize*0.9));

에서 fontSize를 하면 *0.9하면 그림 여백을 더 없앨 수 있음.

graphics.fillRect(0, 0, fontSize*str.length(), (int)(fontSize*1));

하면 배경을 하얗게 만들 수 있음.

2015년 8월 30일

자바 해상도 구하기

Dimension screenSize=Toolkit.getDefaultToolkit().getScreenSize();

2015년 8월 24일

크기조절되는 반투명 창(JFrame)

package com;

import java.awt.Color;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;

import javax.swing.JFrame;

public class FormCtrl {

public static void main(String[] args) {
new FormMeasure();
}

}

class FormMeasure extends JFrame{

int mode;
int preMx;
int preMy;

public FormMeasure(){
  setSize(300, 300);
  //setBackground(new Color(255,10,10));

  setUndecorated(true);//프레임 없애기
  setForeground(new Color(0, 0, 255));
  getContentPane().setBackground(new Color(0, 0, 255));//파란색
  setOpacity(0.2f);//반투명


  //setResizable(false);//최대화 불가능
  setVisible(true);

  preMx=0;
  preMy=0;

  addMouseMotionListener(new MouseMotionListener() {

   @Override
   public void mouseMoved(MouseEvent e) {
    // TODO Auto-generated method stub
    //System.out.println(“움직임”);
   }

   @Override
   public void mouseDragged(MouseEvent e) {
    int gap=20;

    int newMx=e.getX();
    int newMy=e.getY();

    //width를 조절하는 경우
    if(mode==1){
     int wid=getBounds().width+newMx-preMx;
     if(wid<40) wid=40;
     if(newMx<0) wid=40;

     setBounds(getBounds().x,
       getBounds().y,
       wid,
       getBounds().height);
     preMx=newMx;
    }
    //height를 조절하는 경우
    else if(mode==2){
     int hei=getBounds().height+newMy-preMy;
     if(hei<40) hei=40;
     if(newMy<0) hei=40;

     setBounds(getBounds().x,
       getBounds().y,
       getBounds().width,
       hei);
     preMy=newMy;
    }
    //width와 height를 둘 다 조절하는 경우
    else if(mode==3){
     int wid=getBounds().width+newMx-preMx;
     if(wid<40) wid=40;
     if(newMx<0) wid=40;

     int hei=getBounds().height+newMy-preMy;
     if(hei<40) hei=40;
     if(newMy<0) hei=40;

     setBounds(getBounds().x,
       getBounds().y,
       wid,
       hei);
     preMx=newMx;
     preMy=newMy;
    }
    //창을 이동하는 경우(일반 드래그)
    else if(mode==10){
     //일반 드래그
     setBounds(getBounds().x+newMx-preMx,
       getBounds().y+newMy-preMy,
       getBounds().width,
       getBounds().height);
    }

   }
  });

  addMouseListener(new MouseListener() {

   @Override
   public void mouseReleased(MouseEvent e) {
    // TODO Auto-generated method stub

   }

   @Override
   public void mousePressed(MouseEvent e) {
    // TODO Auto-generated method stub

    //경계선에서 20픽셀 이내이면 크기조절
    int gap=20;

    preMx=e.getX();
    preMy=e.getY();

    //click=true;
    if(preMx>getBounds().width-gap && preMy>getBounds().height-gap){
     //오른쪽 아래 꼭지점
     mode=3;
    }
    else if(preMx>getBounds().width-gap){
     //오른쪽 끝선
     mode=1;

    }
    else if(preMy>getBounds().height-gap){
     //아래쪽
     mode=2;

    }
    else{
     mode=10;
    }


   }

   @Override
   public void mouseExited(MouseEvent e) {
    // TODO Auto-generated method stub

   }

   @Override
   public void mouseEntered(MouseEvent e) {
    // TODO Auto-generated method stub

   }

   @Override
   public void mouseClicked(MouseEvent e) {
    // TODO Auto-generated method stub

   }
  });
}
}

2015년 8월 19일

Swing JTextArea 에서 라인 교환(줄바꿈)

alt+위방향키(alt+↑)를 누르면 현재 라인과 위 라인이 교환되고, alt+아래방향키(alt+↓)를 누르면 현재 라인과 아래 라인이 교환되는 메소드를 만들었다. exchangeTxt(String txt, int o1, int o2, int n1, int n2)이다. 우선 txt에 전체 텍스트, o1과 o2에는 텍스트 일부(A)의 처음과 끝 지점, n1고 n2에는 다른 텍스트 일부(B)의 처음과 끝 지점을 쓰면 나머지 텍스트는 그대로인채 A 부분과 B 부분이 바뀐다.

package com;

import java.awt.Color;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

import javax.swing.JFrame;
import javax.swing.JTextArea;
import javax.swing.text.BadLocationException;

public class MainClass{

public static void main(String[] args) {
MainForm mf=new MainForm();
}
}

class MainForm extends JFrame{

public String exchangeTxt(String txt, int o1, int o2, int n1, int n2){
  //old->new
  StringBuffer oldt=new StringBuffer(txt);
  StringBuffer newt=new StringBuffer();

  newt.append(oldt.substring(0,o1));

  newt.append(oldt.substring(n1,n2));
  if(!newt.substring(newt.length()-1).equals(“\n”)){
   newt.append(“\n”);
   System.out.println(“마지막줄이므로 \\n추가“);
  }
  newt.append(oldt.substring(o1,o2));

  newt.append(oldt.substring(n2));

  return newt.toString().trim();
}

JTextArea jta;

public MainForm() {

  jta=new JTextArea();
  jta.setBackground(Color.white);
  jta.setBounds(10, 10, 260, 300);

  jta.addKeyListener(new KeyListener() {

   @Override
   public void keyTyped(KeyEvent e) {
    // TODO Auto-generated method stub

   }

   @Override
   public void keyReleased(KeyEvent e) {
    //Alt+아래 화살표키
    if(e.isAltDown() && e.getKeyCode()==40){
     try {
      //현재 커서가 위치한 곳이 몇 번째 줄인지 알아내기
      int line=jta.getLineOfOffset(jta.getCaretPosition());

      if(line<jta.getLineCount()-1){
       //현재 라인: 현재 커서가 있는 라인의 처음부터 끝까지를 자름
       int start=jta.getLineStartOffset(line);
       int end=jta.getLineEndOffset(line);

       //다음 라인: 다음 줄의 처음부터 끝까지를 자름
       int start2=jta.getLineStartOffset(line+1);
       int end2=jta.getLineEndOffset(line+1);

       //현재라인과 다음라인을 교체함
       jta.setText(exchangeTxt(jta.getText(), start, end, start2, end2));

       //다음 라인(line+1) 끝에 커서를 위치함 (마지막에 -1을 하는 이유는 마지막 부분이 \n이기 때문
       jta.setCaretPosition(jta.getLineEndOffset(line+1)-1);
      }
      else{
       System.out.println(“가장 아랫줄입니다”);
      }

     } catch (BadLocationException e1) {e1.printStackTrace();}

    //Alt+위 화살표키
    }else if(e.isAltDown() && e.getKeyCode()==38){
     try {
      //현재 커서가 위치한 곳이 몇 번째 줄인지 알아내기
      int line=jta.getLineOfOffset(jta.getCaretPosition());

      if(line>0){
       //이전 라인: 현재 커서가 있는 라인 바로 이전 라인의 처음부터 끝까지를 자름
       int start=jta.getLineStartOffset(line-1);
       int end=jta.getLineEndOffset(line-1);

       //현재 라인: 현재 커서가 있는 라인의 처음부터 끝까지를 자름
       int start2=jta.getLineStartOffset(line);
       int end2=jta.getLineEndOffset(line);

       //이전라인과 현재라인을 교체함
       jta.setText(exchangeTxt(jta.getText(), start, end, start2, end2));

       //이전 라인(line-1) 끝에 커서를 위치함 (마지막에 -1을 하는 이유는 마지막 부분이 \n이기 때문
       jta.setCaretPosition(jta.getLineEndOffset(line-1)-1);
      }
      else{
       System.out.println(“가장 윗줄입니다”);
      }

     } catch (BadLocationException e1) {e1.printStackTrace();}
    }
   }

   @Override
   public void keyPressed(KeyEvent e) {
    // TODO Auto-generated method stub

   }
  });

  getContentPane().setLayout(null);
  setSize(300,400);
  getContentPane().add(jta);

  setVisible(true);
}
}

원하는 윈도우 찾고 포커스하기(getHwnd)

getHwnd라는 메소드를 직접 만들었다. 우선, 띄워져 있는 윈도우 목록을 전부 찾을 수 있는 EnumWindows 을 활용해 창을 전부 조사한다. 이후 클래스 네임, 제목표시줄 등을 이용해 핸들값(HWND)을 얻는다. 얻은 핸들값에 대해 ShowWindow를 사용해서 최소화 복원을 하고, SetForegroundWindow를 사용해서 윈도우를 포커스한다.

찾는 법은 핸들의 클래스네임, 제목표시줄, x좌표 세 가지를 이용해 찾을 수 있다.

(1) 클래스네임으로 윈도우 찾기

HWND hwnd=m.getHwnd(“IEFrame”,null,null);

라고 쓰면 “IEFrame”, 즉 인터넷 익스플로러를 찾는다.

(2) 제목표시줄로 윈도우 찾기

HWND hwnd=m.getHwnd(null,”네이버”,null);

라고 쓰면 제목표시줄에 “네이버”라는 스트링이 포함된 창을 찾는다. indexOf를 사용했다.

(3) 창의 x좌표로 윈도우 찾기

HWND hwnd=m.getHwnd(null,null,500);

라고 쓰면 창의 x좌표가 500보다 같거나 큰 창을 불러온다. 만약 -500을 주면 500보다 같거나 작은 창을 불러온다.

주의할 점은 여러 개의 핸들이 해당되어도 단 한개의 핸들(HWND)만 리턴된다는 점이다. 그러므로 (1),(2),(3)의 조합을 섞어 사용하여 한 개의 핸들만 띄워질 수 있도록 해야 한다.

참고)showWindow

SW_HIDE 0 보이지 않도록 한다.

SW_SHOWNORMAL 1 윈도우를 보이도록 하되 최대화 or 최소화 되어있다면 원래상태로 되돌린다.

SW_SHOWMINIMIZED 2 윈도우를 활성화 하고 최소화 한다.

SW_MAXIMIZE 3 최대화 한다.

SW_SHOWNOACTIVATE 4 윈도우를 보이도록 하지만 활성화 하지 않는다.

SW_SHOW 5 윈도우를 보이도록 한다.

SW_MINIMIZE 6 최소화 한 후 이전 윈도우를 활성화한다.

SW_SHOWMINNOACTIVE 7 윈도우를 최소화 하지만 활성화 하지는 않는다.

SW_SHOWNA 8 윈도우를 보이도록 하지만 활성화 하지는 않는다.

SW_RESTORE 9 원 상태로 되돌린다.

SW_SHOWDEFAULT 10 윈도우 생성시의 Flag 값에 따라 설정합니다.

SW_FORCEMINIMIZE 11 최소화 한다.

package com;

import com.sun.jna.Native;
import com.sun.jna.Pointer;
import com.sun.jna.platform.win32.*;
import com.sun.jna.platform.win32.WinDef.HWND;
import com.sun.jna.platform.win32.WinDef.RECT;
import com.sun.jna.platform.win32.WinUser.WNDENUMPROC;

public class MainClass {

public static void main(String[] args) {
MainClass m=new MainClass();

HWND hwnd=m.getHwnd(null,”getnum2″,null);
if(hwnd!=null){
  User32.INSTANCE.ShowWindow(hwnd,9);//최소화 되어있을 경우 복원
  User32.INSTANCE.SetForegroundWindow(hwnd);
}
else{
  System.out.println(“윈도우를 찾을 수 없습니다.”);
}
}

public String wcls;
public String wtitle;
public static Integer wx;
public static HWND res;

public HWND getHwnd(String cls,String title, Integer x){

res=null;
wcls=cls;
wtitle=title;
wx=x;

try{
User32.INSTANCE.EnumWindows(new WNDENUMPROC() {
int count = 0;

             public boolean callback(HWND hWnd, Pointer arg1) {
                 char[] windowText = new char[512];
                 User32.INSTANCE.GetWindowText(hWnd, windowText, 512);
                 String wText = Native.toString(windowText);
                 RECT rectangle = new RECT();
                 User32.INSTANCE.GetWindowRect(hWnd, rectangle);

                 //숨겨져 있는 창은 제외하고 찾는다. 최소화 되어있는 창은 포함한다.
                 //rectangle.left값이 -32000일 경우 최소화되어 있는 창이다.
                 if (wText.isEmpty() ||
                    !(User32.INSTANCE.IsWindowVisible(hWnd))) {
                    return true;
                 }

                 //핸들의 클래스 네임 얻기
                 char[] c=new char[512];
                 User32.INSTANCE.GetClassName(hWnd, c, 512);
                 String clsName=String.valueOf(c).trim();

                 //조건 세 개를 만족하면, 핸들을 돌려줌
                 int check=0;

                 //조건1: 요청 클래스네임이 널이거나, 클래스네임과 일치할 경우 체크를 증가
                 if(wcls==null){//”IEFrame”
                check++;
                 }
                 else if(clsName.equals(wcls)){ //&& wcls!=null
                check++;
                 }

                 //조건2: 제목표시줄이 널이거나, 원하는 글자가 포함되어 있다면 체크를 증가
                 if(wtitle==null){
                check++;
                 }
                 else if(wText.indexOf(wtitle)>=0){
                check++;
                 }

                 //조건3
                 if(wx==null){
                //널이라면 안적은걸로 간주
                check++;
                 }
                 else if(wx>0){
                if(rectangle.left>=wx){
                   //wx가 500이라면 x좌표가 500 이상인 창만 합격
                   check++;
                }
                 }
                 else if(wx<0){
                if(rectangle.left<=(-wx)){
                   //wx가 -500이라면 x좌표가 500 이하인 창만 합격
                   check++;
                }
                 }
                 //조건 3개를 충족했다면 핸들을 돌려줌
                 if(check==3){
                 res=hWnd;

                 System.out.println(
                          “hwnd:”+hWnd+”,”+
                          “번호:” + (++count) + “,텍스트:” + wText+”,”+
                          “위치:(“+rectangle.left+”,”+rectangle.top+”)~(“+rectangle.right+”,”+rectangle.bottom+”),”+
                          “클래스네임:”+clsName+”,”+
                          “상태:”+User32.INSTANCE.IsWindowVisible(hWnd));
                 }
                 return true;
             }
         }, null);

}catch(Exception ex){System.out.println(ex.getMessage());}

return res;

}

}

작업표시줄 제목으로 윈도우 찾고 포커스하기 (FindWindow, SetForegroundWindow)

기존의 방식은 (1)클래스 네임 또는 (2)제목표시줄로 윈도우 핸들을 얻고(FindWindow), 포커스를 하는(SetForegroundWindow) 방식이었다.

package com;

import java.awt.Robot;

import com.sun.jna.platform.win32.User32;
import com.sun.jna.platform.win32.WinDef;

public class MainClass {

public static void main(String[] args) {

  WinDef.HWND hWnd;//윈도우 핸들
  try{
    //로봇 선언
   Robot robot=new Robot();

   //메모장이 켜졌는지 검사
   hWnd=null;
   while(hWnd==null){
    System.out.println(“메모장을 찾는 중입니다”);
    robot.delay(500);
    //hWnd = User32.INSTANCE.FindWindow(“Notepad”, null);
    hWnd = User32.INSTANCE.FindWindow(null, “제목 없음 – 메모장”);
   }
   User32.INSTANCE.SetForegroundWindow(hWnd);
  }catch(Exception ex){System.out.println();}
}
}

하지만 위 소스의 단점은 “제목 없음 – 메모장” 이라고 작업표시줄 상의 풀 네임을 정확히 적어야 한다는 것이었다.

아래는 이를 개선한 소스이다. 현재 띄워진 모든 창들을 가져온 후, indexof 를 활용하여 핸들을 얻는다.

이렇게 하면 “제목 없음 – 메모장”이라는 풀 네임이 아니라 “제목”, “제목 없”. “제목 없음”.. 만으로도 핸들을 찾을 수 있다.

package com;

import java.awt.List;
import java.awt.Robot;
import java.util.ArrayList;

import com.sun.jna.Native;
import com.sun.jna.Pointer;
import com.sun.jna.platform.win32.*;
import com.sun.jna.platform.win32.Netapi32Util.User;
import com.sun.jna.platform.win32.WinDef.HDC;
import com.sun.jna.platform.win32.WinDef.HWND;
import com.sun.jna.platform.win32.WinDef.RECT;
import com.sun.jna.platform.win32.WinUser.WNDENUMPROC;

public class MainClass {

public static void main(String[] args) {
  MainClass m=new MainClass();
  User32.INSTANCE.SetForegroundWindow(m.getHwndByName(“제목 없음”));
}

private String str=””;
private HWND res=null;

public String getStr() {
  return str;
}
public void setStr(String str) {
  this.str = str;
}
public HWND getRes() {
  return res;
}
public void setRes(HWND res) {
  this.res = res;
}

public HWND getHwndByName(String str){
  HWND res=null;
  setStr(str);

  try{
   User32.INSTANCE.EnumWindows(new WNDENUMPROC() {
             int count = 0;
             String str=””;

             public boolean callback(HWND hWnd, Pointer arg1) {
                 char[] windowText = new char[512];
                 User32.INSTANCE.GetWindowText(hWnd, windowText, 512);
                 String wText = Native.toString(windowText);
                 RECT rectangle = new RECT();
                 User32.INSTANCE.GetWindowRect(hWnd, rectangle);
                 // get rid of this if block if you want all windows regardless
                 // of whether
                 // or not they have text
                 // second condition is for visible and non minimised windows
                 if (wText.isEmpty() || !(User32.INSTANCE.IsWindowVisible(hWnd)
                         && rectangle.left > -32000)) {
                     return true;
                 }

                 //핸들의 클래스 네임 얻기
                 char[] c=new char[512];
                 User32.INSTANCE.GetClassName(hWnd, c, 512);
                 String clsName=String.valueOf(c).trim();

                 if(wText.indexOf(getStr())>=0){
                 //원하는 글자가 포함되어 있다면 핸들값을 set함
                 setRes(hWnd);

                  System.out.println(
                          “hwnd:”+hWnd+”,”+
                          “번호:” + (++count) + “,텍스트:” + wText+”,”+
                          “위치:(“+rectangle.left+”,”+rectangle.top+”)~(“+rectangle.right+”,”+rectangle.bottom+”),”+
                          “클래스네임:”+clsName);

                 }
                 return true;
             }
         }, null);

  }catch(Exception ex){System.out.println(ex.getMessage());}

  return getRes();

}

}

[JAVA] JNA 실행중인 윈도우 핸들 모두 얻기(EnumWindows)

현재 실행중인 모든 윈도우 핸들의 정보를 출력하는 JAVA JNA 코드.

Github 주소 : https://github.com/thkmon/BBShowAllHwndInfos.git

package com.thkmon.bbwin.main;

import java.util.ArrayList;

import com.sun.jna.Native;
import com.sun.jna.Pointer;
import com.sun.jna.platform.win32.User32;
import com.sun.jna.platform.win32.WinDef.HWND;
import com.sun.jna.platform.win32.WinDef.RECT;
import com.sun.jna.platform.win32.WinUser.WNDENUMPROC;
import com.sun.jna.ptr.IntByReference;

public class BBShowAllHwndInfos {
privatestatic ArrayList<String> hwndInfoList = null;

    publicstaticvoid main(String[] args) {
        try {
            System.out.println(“[INFORMATION OF CURRENT WINDOW HANDLES]”);
            System.out.println(“”);

            hwndInfoList = new ArrayList<String>();

            BBShowAllHwndInfos instance = new BBShowAllHwndInfos();
            instance.printAllHwndInformations();

            int count = hwndInfoList.size();
            for (int i=0; i<count; i++) {
                System.out.print(“(“ + (i+1) + “/” + count + “) “);
                System.out.println(hwndInfoList.get(i));
            }

            System.out.println(“END”);

        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            // wait for 10 minutes after run
            Thread.sleep(1000 * 60 * 10);
        } catch (Exception e) {
            // ignore
        }
    }

    privatevoid printAllHwndInformations() throws Exception {
        try {
            User32.INSTANCE.EnumWindows(new WNDENUMPROC() {
                publicboolean callback(HWND hwnd, Pointer arg1) {
                    char[] windowText = new char[512];
                    User32.INSTANCE.GetWindowText(hwnd, windowText, 512);
                    String wText = Native.toString(windowText);

RECT rectangle = new RECT();
User32.INSTANCE.GetWindowRect(hwnd, rectangle);

                    // 숨겨져 있는 창은 제외하고 찾기
                    if (wText.isEmpty() || !(User32.INSTANCE.IsWindowVisible(hwnd))) {
                        returntrue;
                    }

                    // 최소화 여부
                    boolean bMinimized = false;
                    if (rectangle.left <= -32000) {
                        bMinimized = true;
                    }

                    // 핸들(hwnd)의 클래스 네임 가져오기
                    char[] c = new char[512];
                    User32.INSTANCE.GetClassName(hwnd, c, 512);
                    String clsName = String.valueOf(c).trim();

                    // 핸들(hwnd)의 pid 가져오기
                    IntByReference pidByRef = new IntByReference(0);
                    User32.INSTANCE.GetWindowThreadProcessId(hwnd, pidByRef);
                    int pid = pidByRef.getValue();

                    StringBuilder buff = new StringBuilder();
                    buff.append(“PID : “).append(pid);
                    buff.append(“\n”).append(“CLASSNAME : “).append(clsName);
                    buff.append(” / “).append(“TEXT : “).append(wText);
                    buff.append(“\n”).append(“MINIMIZED : “).append(bMinimized);
                    buff.append(” / “).append(“POSITION : (“).append(rectangle.left).append(“,”).append(rectangle.top).append(“)”);
                    buff.append(“~(“).append(rectangle.right).append(“,”).append(rectangle.bottom).append(“)”);
                    buff.append(“\n”);

                    hwndInfoList.add(buff.toString());

                    returntrue;
                }
            }, null);

        } catch (Exception e) {
            throw e;
        }
    }
}

결과 예시

[INFORMATION OF CURRENT WINDOW HANDLES]

(1/4) PID : 8164
CLASSNAME : SWT_Window0 / TEXT : BBShowAllWindowInfos – BBShowWindowInfos/src/com/thkmon/bbwin/main/BBShowWindowInfos.java – Eclipse
MINIMIZED : false / POSITION : (-8,-8)~(1928,1054)

(2/4) PID : 10056
CLASSNAME : IEFrame / TEXT : 글쓰기, 흑곰의 유익한 블로그 : 네이버 블로그 – Internet Explorer
MINIMIZED : false / POSITION : (101,442)~(1576,1258)

(3/4) PID : 5496
CLASSNAME : ConsoleWindowClass / TEXT : C:\WINDOWS\system32\cmd.exe
MINIMIZED : false / POSITION : (156,156)~(1149,675)

(4/4) PID : 14240
CLASSNAME : Chrome_WidgetWin_1 / TEXT : Google 번역 – Chrome
MINIMIZED : true / POSITION : (-32000,-32000)~(-31801,-31966)

END

윈도우핸들 클래스네임 얻기(GetClassName)

public static void main(String[] args) {
try{
   Robot robot=new Robot();
   robot.delay(100);

   WinDef.HWND hWnd;//윈도우 핸들

   hWnd=null;

   //핸들을 얻는다
   HWND h=User32.INSTANCE.GetForegroundWindow();
   System.out.println(h);
   char[] c=new char[1000];

   System.out.println(User32.INSTANCE.GetClassName(h, c, 1000));

System.out.println(c);

}catch(Exception ex){System.out.println(ex.getMessage());}
}

///////예를 들면 아래와 같다.
이클립스 “SWT_Window0”
익스플로러 “IEFrame”
파워포인트2007 “PP12FrameClass”

파워포인트2003 “PP11FrameClass”

파워포인트2002 (PPT XP버젼) “PP10FrameClass”

파워포인트2000 “PP9FrameClass”

파워포인트97 “PP97FrameClass”

엑셀 “XLMAIN”

워드 “OpusApp”

메모장 “Notepad”

2015년 8월 12일

자바 클립보드

복사 하는 방법 (자바->클립보드)

Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
String copyString = textArea.getSelectedText();
if(copyString != null)
{
StringSelection contents = new StringSelection(copyString);
clipboard.setContents(contents, null);
}

꺼내오는(붙여넣기) 방법 (클립보드->자바)

Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
Transferable contents = clipboard.getContents(clipboard);

if(contents != null)
{

     try {
           String pasteString = (String)(contents.getTransferData(
DataFlavor.stringFlavor));
           textArea.insert(pasteString, textArea.getCaretPosition());
      } catch (Exception e) {}

}

2015년 8월 12일

jna예제

// jna-4.1.0.jar 와 같이 jna 자르파일이 필요함.

// jna는 자바 네이티브 액서스로 jni(자바 네이티브 인터페이스)보다 좀 더 접근이 용이함

package com;
import com.sun.jna.*;

interface MyUser32 extends Library {
public int MessageBoxA(int handle, String message, String title, int type);

}
public class MainClass {

public static void main(String[] args) {
  // TODO Auto-generated method stub

  String mytext = “Hello World!”;
        String mytitle = “Title bar”;

String libName = “c”;

        if (System.getProperty(“os.name”).contains(“Windows”)) {
            libName = “user32”;
        }

MyUser32 user32 = (MyUser32) Native.loadLibrary(libName, MyUser32.class);
user32.MessageBoxA(0, mytext, mytitle, 0);
}

}

//Dll 함수 API을 보고 파라메터에 해당하는 인자를 인터페이스로 만들어 사용하면 됨

2015년 8월 12일

자바매크로 (키보드후킹)

출처: http://okky.kr/article/270141

okky.kr의 아이디 jeemin2 님이 작성하셨습니다.

————————————————

JAVA Robot – http://docs.oracle.com/javase/7/docs/api/java/awt/Robot.html 

자바 공식지원 매크로 도구.
화면캡쳐, 키보드누르기, 마우스 움직이고 클릭 등등 매크로에 필요한 기능을 전부 제공한다.

Tasklist – http://technet.microsoft.com/en-us/library/bb491010.aspx 

프로세스 정보를 출력하는 콘솔 명령어

XP이후부터 등장한 이녀석을 이용하면 간단한 프로세스 정보를 얻어올 수 있다. 자바의 콘솔실행 기능을 이용하면

new ProcessBuilder(“tasklist”, “/FI”, “\”IMAGENAME eq calc.exe\””).start(); 이런식으로 해서 계산기가 실행중인지 여부를 판단이 가능

NirCmd – http://www.nirsoft.net/utils/nircmd.html 

콘솔명령어 도구.

마우스/키보드누른효과, 모니터 끄기/켜기, Alt-Tab기능, 딴창크기조절, CD-ROM열기 등등등 컴퓨터로 할 수 있는 거의 모든 기능을

콘솔명령어로 실행할 수 있게 해주는 녀석. 그러니까 콘솔창에서 “nircmd sendkeypress Shift+n” 이렇게 쳐주면

진짜로 키보드의 쉬프트+N키를 누른 효과가 나오는 녀석…

한마디로 자바에서 new ProcessBuilder(“nircmd.exe”, “win”, “activate”, “calc.exe”).start(); 이런식으로 계산기 창을 최상위로

올린다던가 하는 상세한 제어를 할 수 있게 된다.

Open CV for JAVA – http://opencv.org/ 

유명한 이미지 처리기.

얼마전부터 정식으로 자바를 지원하기 시작해서 고도의 이미지 처리를 자바에서 자유자재로 할 수 있게 되었다.

덕분에 Imgproc.matchTemplate(img1, img2, img3, Imgproc.TM_CCOEFF_NORMED); 요렇게 한줄만 해줘도

이미지가 엄청난 속도로 패턴검색이 되어 미리 저장해둔 패턴이 현재 화면에 존재하는지, 그리고 위치가 어딘지까지 찾아올 수있다.

즉 특정버튼을 미리 캡쳐해 놨다가 자동으로 클릭하는 기능같은것도 순식간에 만들수 있다는 이야기.

JNativeHook – https://github.com/kwhat/jnativehook 

자바 글로벌 후킹 도구.

시스템 자체를 후킹해서 사용자가 입력하는 모든 키보드, 마우스이동, 클릭좌표 등의 정보를 자바로 가져올 수 있게 해준다.

자바커에게 익숙한 이벤트 방식으로 동작하기에 아주 편하게 쓸 수 있다.

그외 기타 꼼수들

클립보드

Toolkit.getDefaultToolkit().getSystemClipboard();

이런식으로 하면 현재 클립보드에 복사되어 있는 내용을 자바로 가져올 수 있다.

현재 커서 위치의 문자열을 자바로 읽어오기 귀찮을땐, Robot으로 강제로 Ctrl+C를 누른 효과를 줘버리고 클립보드에서 가져오면 편하다.

기본 프로그램 실행

Desktop.getDesktop().open(new File(“abcd.xls”));

이런식으로 해주면 그냥 알아서 엑셀이 실행된다. 설치 여부를 검사하거나 Programs Files뒤질 필요없이 해당 파일에 연결된

시스템 기본 프로그램이 그냥 알아서 실행된다.

기본 브라우져로 URL열기

Desktop.getDesktop().browse(new URI(“http://www.naver.com“));

이런식으로 해주면 시스템 기본 브라우져가 알아서 실행되며 지정한 페이지가 열린다.

매크로상 외부와 통신해야 한다면 귀찮게 소켓통신이나 DB연결 할 필요없이 웹기반으로 통신하면 편하다.

2015년 7월 29일

파싱기본

try{

URL url = new URL(“http://www.naver.com“);

BufferedReader in = new BufferedReader(new InputStreamReader(url.openStream()));

String iline=””;

while ((iline = in.readLine()) != null)

System.out.println(iline);

in.close();

}catch(Exception ex){System.out.println(ex.getMessage());}

XML, Annotation, SPRING, HADOOP, JQuery 총정리

XML

문서 저장 언어(반정형화)

=> 호환성 (모바일, 운영체제)

=> 파싱(DOM, SAX, JAXB(OXM):XML,JSON모두 포함)

Annotation: 구분문자

<구분의 범위>

TYPE : 클래스 구분

METHOD : 메소드 구분

FIELD : 멤버변수 구분

PARAMETER: 매개변수 구분

SPRING: 의존성이 약한 프로그램

=<Container의 종류> : Component 관리자(사용자 정의 클래스)

BeanFactory

ApplicationContext

AnnotationConfigApplicationContext

GenericApplicationContext

WebApplicationContext

= DI, DL

= AOP (Transaction, Security)

= MVC (Tiles)

= DispatcherServlet

= @Controller

@RequestMapping

@ResponseBody

@PathVariable

= ORM (MyBatis)

HADOOP

= 설치 (의사/가상 모드, Full Mode)

= Map/Reduce

= Mongodb

= hive

= hbase

= zookeeper

= spring에서 hadoop연결

= 하둡에서 jar구동

JQuery : 자바스크립트 라이브러리

선택자 $(선택자. css와 유사).이벤트

#으로 id 찾기, .(점)으로 class 찾기

Angular JS

JSP 총정리

1) 지시자

= page : contentType, import

= taglib : prefix, uri

= include : file=”” (정적)

<%@ include %> : JSP+JSP (소스가 묶인다. 같은 변수를 쓰면 에러가 난다)

<jsp:include> : HTML+HTML (결과페이지가 묶인다)

2) JSP 사용법

<% %> : 스크립트릿(자바코딩)

<%= %> : 표현식

<%! %> : 선언식(메소드, 멤버변수)

3) 자바빈즈 :

DTO (데이터빈)

DAO (액션빈)

4) 자바빈 제어 : 액션태그

<jsp:useBean>

<jsp:setProperty>

<jsp:getProperty>

5) 데이터베이스 연결

= DAO
= DBCP(데이터베이스 커넥션풀) : 이름을 갖고 가져오는 JNDI(자바네이밍디렉토리 인터페이스)를 씀 => 스프링에선 DL(디펜젼시 룩업)

6) MVC

프레젠테이션과 비즈니스 로직이 분리됨

오라클 총정리

2. Oracle

DML:

1) SELECT

연산자

= IS NULL, IS NOT NULL (NULL 연산자. null인 값은 인덱스를 만들지 않는게 좋다)

= BETWEEN ~ AND ( >= and <= )

= LIKE (% , _ )

= IN => OR

내장함수

= 문자열, SUBSTR, INSTR, RPAD, LENGTH

= 숫자: MOD, ROUND, TRUNC

= 날짜: SYSDATE, MONTHS_BETWEEN

= 변환: TO_CHAR

= 기타: NVL

= 그룹: COUNT, MAX, MIN, AVG, SUM

JOIN

INNER JOIN

= EQUI JOIN

(NATURAL JOIN, JOIN~USING)

= NON-EQUI JOIN

OUTER JOIN

= LEFT OUTER JOIN

= RIGHT OUTER JOIN

SubQuery

= 단일행 main-query = (subquery)

= 다중행 IN, ANY, ALL => MAX, MIN

2) INSERT

3) UPDATE

4) DELETE

DDL: CREATE, DROP, ALTER(MODIFY, DROP, ADD)

DCL: GRANT, REVOKE

TCL: COMMIT, ROLLBACK

VIEW: 보안, 쿼리문장을 단순화

=> INLINE VIEW

SUBQUERY를 쓰는 위치: SELECT (SELECT ~),

FROM (SELECT)

=> 서브쿼리가 Column이나 Table을 대체할 수 있다.

SEQUENCE => 자동 증가번호

PROCEDURE => SQL 중복, SQL 문장을 감출 경우

TRIGGER

제약조건

= PRIMARY KEY : 중복비허용, NULL비허용 (UNIQUE+NOT NULL)
= FOREIGN KEY

= UNIQUE : 중복비허용, NULL허용

= CHECK

= NOT NULL => DEFAULT

자바 총정리

*   1. 자바 (1.7~1.8)
*   1.8에 증가된 내용
*   1) 람다식 ()->{구현} (파이썬,C#) : 오라클(파이썬, C)
*   2) Nashorn : 자바스크립트 엔진
*   3) NIO (입출력)
*   4) 프로젝트 내에서 중복 제거, 관리 => 직소
*
* 2. 자바
*   변수(데이터형: int, byte, long, double, String, boolean), 상수
*   배열(일차원 배열), 제어문(if,for,while,switch-case,break,continue)
*   클래스: POJO(상속이나 구현이 없다. 사용자 정의때문에 쓴다. 제한 없이 프로그래머 마음대로 사용할 수 있기 때문)
*     => 추상클래스 VS 인터페이스
*        : 사용목적 = 서로 다른 클래스를 모아서 관리
*     *변수를 모아 관리->배열
*     *클래스를 모아 관리->인터페이스
*      extends, implements=>동일한 클래스형으로 변환
*      => instanceof
*     => 익명의 클래스: 람다식
*           => 메소드
*       : 반복수행(재사용) => CallBack(AOP) 자바에서는 메인클래스, 이벤트(액션퍼폼드), 서블릿의 두겟/두포스트
*       : 한 가지 기능만 수행
*              => 변수
*                 1) instance
*                 2) static
*               ==============================
*                method영역, static
*               ==============================
*                stack(지역변수, 매개변수):메모리 관리 영역
*               ==============================
*                heap(new): 프로그래머가 관리 -> GC
*                  new => malloc(sizeof(10))
*                  delete => free()
*               ==============================
*
*  3. 객체 지향의 기능
*   1) 캡슐화: 데이터 보호
*         캡슐화 VS 은닉화
*         (게터세터) (프라이빗)
*     2) 상속(변경해서 쓴다): 재사용 => 포함(있는 그대로 쓸 때)
*        ===            ===
*     3) 오버라이딩 VS 오버로딩 : 다형성
*        ======= ======
*      modify   new
*
*   4. 예외처리
*     : 비정상 종료를 방지하고 현재 실행상태 유지

람다식 기초2

interface My{
  public void a(int a,int b);
}
public static void main(String[] args) throws Exception {
  My m=(x,y)->{System.out.println(x+y);};
  m.a(10,20);
}

—> 30 이 출력됨

——————————————————————————–

public static void main(String[] args) throws Exception {

  System.out.println(“1.익명의 클래스”);
  new Thread(){
   public void run(){
    try{
     Thread.sleep(1000);
     System.out.println(“1시간:”+System.currentTimeMillis());
    }catch(Exception ex){}
   }
  }.start();


  ///////////////////////////////////////////
  System.out.println(“2.람다식 표현”);
  new Thread(()->{
   try{
    System.out.println(“2시간:”+System.currentTimeMillis());
   }catch(Exception ex){}
  }).start();

}

나즈혼(Nashorn)

public static void main(String[] args) throws Exception {
  ScriptEngine se= new ScriptEngineManager().getEngineByName(“nashorn”);
       se.eval(new FileReader(“C:\\Spring\\workspace\\NashornPorject\\src\\myScript.js”));
       // Java + JavaScript Method 통신

       Invocable in = (Invocable)se;
       Object result = in.invokeFunction(“func1”, “Hong Gil Dong”);
       System.out.println(result);
}

myScript.js

var func1=function(name){
print(“Hi!”+name);
return “Test NasHorn”;
}

람다식 기초

interface A{
  public void display();
}
public static void main(String[] args) {
  A a=new A(){
   public void display(){
    System.out.println(“A:Display() Call”);
   }
  };

  a.display();
  ////////////////////////////////////////////////////////
  a=()->{System.out.println(“A:람다식표현”);};
  a.display();
}

https://codility.com/programmers/

프로그래밍 연습사이트

Refactor yourself. Train your programming skills – Codility

codility.com

총요약

SRPING

AOP

Transaction

Security

=> Tiles

=> ORM

=> OXM

=> Hadoop, MongoDB

=> Container

=> MVC

자바

=> 변수, 연산자, 제어문

=> 객체지향 프로그램
1) 메소드

2) 클래스 (종류)

= 일반 클래스

= 추상 클래스

= 익명의 클래스

Oracle

= DML, DDL, DCL, TCL

= JOIN, SUBQUERY

= 제약조건, 테이블명 변경, 수정

= Procedure

= Trigger

= Sequence

= View

= Index

JSP

SPRING

HADOOP

XML

JSON

Annotation

MyBatis

람다식

자바1.7

A a=null;
a=new A(){
public void display(){
System.out.println(“aaa”);
}
}

람다식(1.8)

A a=null;
a+()->{System.out.println(“aaa”);};
a.display();

instanceof

클래스들의 크기를 비교한다.

여기서 할아버지(인터페이스) – 아버지(클래스)- 아들(클래스)가 있다고 가정한다.

다음과 같은 결과가 나온다.

1. 아들은 아버지의 인스턴스이다 (참)

2. 아들은 할아버지의 인스턴스이다 (참)

3. 아버지는 할아버지의 인스턴스이다 (참)

여기까지는 너무나 당연하다.

4. 할아버지에 아버지를 오버라이딩한 클래스는, 할아버지의 인스턴스이다 (참)
5. 할아버지에 아버지를 오버라이딩한 클래스는, 아버지의 인스턴스이다 (참)

6. 할아버지에 아버지를 오버라이딩한 클래스는, 아들의 인스턴스이다 (거짓)

※ 참고) 할아버지에 아버지를 오버라이딩한 클래스 : 할아버지 a=new 아버지();

7. 아버지에 아들을 오버라이딩한 클래스는, 할아버지의 인스턴스이다 (참)
8. 아버지에 아들을 오버라이딩한 클래스는, 아버지의 인스턴스이다 (참)
9. 아버지에 아들을 오버라이딩한 클래스는, 아들의 인스턴스이다 (참)

※ 참고) 아버지에 아들을 오버라이딩한 클래스 : 아버지 a=new 아들();

——————————————————————————————————–

interface GF{};
class F implements GF{};
class S extends F{};

public class MainClass {

public static void main(String[] args) {
  F f=new F();
  S s=new S();

  if(s instanceof F){
   System.out.println(“1. 아들은 아버지의 인스턴스이다”);//TRUE
  }
  if(s instanceof GF){
   System.out.println(“2. 아들은 할아버지의 인스턴스이다”);//TRUE
  }
  if(f instanceof GF){
   System.out.println(“3. 아버지는 할아버지의 인스턴스이다”);//TRUE
  }

  GF a1=new F();
  F a2=new S();

  if(a1 instanceof GF){
   System.out.println(“4. 할아버지에 아버지를 오버라이딩한 클래스는, 할아버지의 인스턴스이다”);//TRUE
  }
  if(a1 instanceof F){
   System.out.println(“5. 할아버지에 아버지를 오버라이딩한 클래스는, 아버지의 인스턴스이다”);//TRUE
  }
  if(a1 instanceof S){
   System.out.println(“6. 할아버지에 아버지를 오버라이딩한 클래스는, 아들의 인스턴스이다(거짓)”);//FALSE
  }

  if(a2 instanceof GF){
   System.out.println(“7. 아버지에 아들을 오버라이딩한 클래스는, 할아버지의 인스턴스이다”);//TRUE
  }
  if(a2 instanceof F){
   System.out.println(“8. 아버지에 아들을 오버라이딩한 클래스는, 아버지의 인스턴스이다”);//TRUE
  }
  if(a2 instanceof S){
   System.out.println(“9. 아버지에 아들을 오버라이딩한 클래스는, 아들의 인스턴스이다”);//TRUE
  }

}

}