Yi

javafx 예제 모음 : https://gist.github.com/james-d

자바 멀티쓰레딩 관련 예제 링크

http://www3.ntu.edu.sg/home/ehchua/programming/java/j5e_multithreading.html

package string;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class PatternTest {
 public static void main(String[] args) {
  
  System.out.println("생성자로 초기화 : " + new Integer("2"));
  System.out.println("Object를 기본 int type으로 변환 : " + Integer.parseInt("20"));
  
  //아래는 java.lang.NumberFormatException 발생
  //System.out.println(new Integer("a1"));
  
  // 예문
  String str = "학0교abc 1종2e이 땡f34땡g땡5!6! hi7어서 8모이9자!@ ";
  String result = "";
  
  // ASCII 값 47~58은 숫자 0~10
  int i = 0;
  while(i<str.length()) {
   if(str.charAt(i)>=47 &&  str.charAt(i)<=58) {
    result += "\t" + str.charAt(i);
   }
   i++;
  }
  System.out.println("ASCII 로 찾은 숫자 : " + result);
  
  
  // reference으로 확인
  int j = 0;
  result = "";
  while(j<str.length()) {
   if(Character.isDigit(str.charAt(j))) {
    result += "\t" + str.charAt(j);
   }
   j++;
  }
  System.out.println("Character의 isDigit(ch)을 이용한 찾기 : " + result);
  
  
  // Pattern을 이용한 숫자 찾기
  result = "";
  String patternStr = "[\\d]";
  Pattern pattern = Pattern.compile(patternStr);
  Matcher matcher = pattern.matcher(str);
  while(matcher.find()) {
   result += "\t" + matcher.group(0);
  }
  System.out.println("Pattern 을 이용한 숫자 찾기 : " + result);
  
  // Pattern을 이용한 a~z 찾기
  result = "";
  patternStr = "[a-z]";
  pattern = Pattern.compile(patternStr);
  matcher = pattern.matcher(str);
  while(matcher.find()) {
   result += "\t" + matcher.group(0);
  }
  System.out.println("Pattern 을 이용한 a~z 찾기 : " + result);
  
 }
}

이번 프로젝트를 진행하면서..

앞전에 들었던 적이 있었는데 막상 써먹지 않으면 내것이 아니란것을 절실히 느끼며..

찾았다-_-

static 한정자의 사용법..

아래 사이트에서 찾았다.. 해석은 간단하니 알아서-_-

//In Java(tm), you can use static initialization blocks in classes to do one-time per-class test for the class:

public class GlobalInstance {

 private static GlobalInstance instance;

 static {
  instance = new GlobalInstance();
 }
 
 private GlobalInstance() {
  
 }
 
 
 
 public static GlobalInstance getInstance() {
  return instance;
 }
}

http://java.sun.com/docs/books/tutorial/java/javaOO/initial.html

원본 - java 로 배우는 디자인 패턴 입문

Singleton 패턴
# 하나의 인스턴스만 생성되어야 하는 클래스 구현 패턴

# 사용 목적
프로그램 실행 시 하나의 클래스에 대한 인스턴스가 보통 여러 개 생성 및 사용 된다.하지만 반드시 하나의 인스턴스만 생성되어야 하는 클래스도 있다.
(예: 컴퓨터 자체를 표현한 클래스, 윈도 시스템을 표현한 클래스 등)

일반적으로 인스턴스 생성시 new MyClass( )를 한번만 실행하면 된다.
그러나, 1개의 인스턴스만 생성되도록 프로그램에 표현하고 싶을 때 Singleton 패턴을 사용한다.

# 규칙
private 맴버 변수
private 생성자
public 호출자

# 간단한 예제

## Main.calss
## Singleton Class 의 인스턴스를 호출하여 동일한 객체인지 유무 확인

package singleton;

public class Main {
 
 /**
  * main method
  * @param args
  */
 public static void main(String[] args) {
  
  Singleton obj1 = Singleton.getInstance();
  Singleton obj2 = Singleton.getInstance();
  
  if(obj1 == obj2) {
   System.out.println("같은 객체");
  } else {
   System.out.println("다른 객체");
  }
 }
}

## Singleton.class
## 1. private 맴버변수 선언
## 2. private 생성자 선언
## 3. public get 호출자 선언
## static 으로 선언하여 VM에서 전역 변수로 사용
## private 변수와 생성자를 사용하여 외부에서 변경 못하도록 지정.

package singleton;

public class Singleton {

 private static Singleton instance;

 /*
  * 정적 필드 - 최초 로드 시 한번만 초기화를 한다.
  */
 static {
  instance = new Singleton();
 }
 

 /**
  * 생성자
  */
 private Singleton() {
  
 }
 
 
 /**
  * get property
  */
 public static Singleton getInstance() {
  return instance;
 }
 
}

## 실행 결과 : 같은 객체

# 한정자가 필요한 이유
인스턴스가 하나만 존재한다는 것이 보증되면, 인스턴스 상호 간에 영향을 주어 생각지 못한 버그가 발생할 가능성이 없어진다.

# 유일한 하나의 인스턴스는 언제 생성되는가
프로그램 실행 후, 처음으로 Singleton.getInstance( ) 메소드가 호출되면, Singleton 클래스가 초기화되고, 이 때 static 필드인 singleton 필드가 초기화된다.

* synchronized

프로젝트 수행중 간단하게 workspace 안의 파일 목록이 필요하여 간단하게 파일 검색하는 콜백 함수를 만들어 보았다;; 검색 및 출력은 제대로 되는데 검증은... ?



import java.io.File;

class FileSearch
{
    public static void main(String[] args)
    {
        printFiles(new File("C:/"));
    }

     // 파일을 매개 변수로 받는 메소드
     public static void printFiles(File f) 
    {
        // 매개변수가 디렉토리 일경우
        if(f.isDirectory()) 
        {
            String[] s = f.list();  // 디렉토리 내의 모든 파일의 list를 확인
   
            // 파일 목록에서 디렉토리일 경우
            //printFiles 메소드 호출 그리고 파일일 경우 단순 출력을 수행
            for(int i=0; i<s.length;i++) 
            {
                File f1 = new File(f.getPath() + "/" + s[i]);
    
                if(f1.isDirectory())
                {
                      System.out.println(f1);
                      printFiles(f1);
                 }
                 else
                 {
                       System.out.println("isFile " + f1.getPath() + "\t" + f1.getName());
                 }
            }
       }
      else
      {
           System.out.println("파일이지요~ " + f.getName());
       }
  
    }
}

Annotations

Release 5.0 of the JDK introduced a metadata facility called annotations. Annotations provide data about a program that is not part of the program, such as naming the author of a piece of code or instructing the compiler to suppress specific errors. An annotation has no effect on how the code performs.

Annotations use the form @annotation and may be applied to a program's declarations: its classes, fields, methods, and so on. The annotation appears first and often (by convention) on its own line, and may include optional arguments:

@Author("MyName")
class myClass() { }

or

@SuppressWarnings("unchecked")
void MyMethod() { }

Defining your own annotation is an advanced technique that won't be described here, but there are three built-in annotations that every Java programmer should know: @Deprecated, @Override, and @SuppressWarnings. The following example illustrates all three annotation types, applied to methods:

import java.util.List;

class Food {}
class Hay extends Food {}
class Animal {
    Food getPreferredFood() {
        return null;
    }
    /**
     * @deprecated document why the method was deprecated
     */
    @Deprecated
    static void deprecatedMethod() { }
}
class Horse extends Animal {
    Horse() {
        return;
    }
    @Override 
    Hay getPreferredFood() {
        return new Hay();
    }
    @SuppressWarnings("deprecation")
    void useDeprecatedMethod() {
        Animal.deprecateMethod(); //deprecation warning - suppressed
    }
}

@Deprecated

The @Deprecated annotation indicates that the marked method should no longer be used. The compiler generates a warning whenever a program uses a deprecated method, class, or variable. When an element is deprecated, it should be documented using the corresponding @deprecated tag, as shown in the preceding example. Notice that the tag starts with a lowercase "d" and the annotation starts with an uppercase "D". In general, you should avoid using deprecated methods — consult the documentation to see what to use instead.

@Override

The @Override annotation informs the compiler that the element is meant to override an element declared in a superclass. In the preceding example, the override annotation is used to indicate that the getPreferredFood method in the Horse class overrides the same method in the Animal class. If a method marked with @Override fails to override a method in one of its superclasses, the compiler generates an error.

While it's not required to use this annotation when overriding a method, it can be useful to call the fact out explicitly, especially when the method returns a subtype of the return type of the overridden method. This practice, called covariant return types, is used in the previous example: Animal.getPreferredFood returns a Food instance. Horse.getPreferredFood (Horse is a subclass of Animal) returns an instance of Hay (a subclass of Food). For more information, see Overriding and Hiding Methods.

@SuppressWarnings

The @SuppressWarnings annotation tells the compiler to suppress specific warnings that it would otherwise generate. In the previous example, the useDeprecatedMethod calls a deprecated method of Animal. Normally, the compiler generates a warning but, in this case, it is suppressed.

Every compiler warning belongs to a category. The Java Language Specification lists two categories: "deprecation" and "unchecked". The "unchecked" warning can occur when interfacing with legacy code written before the advent of generics. To suppress more than one category of warnings, use the following syntax:

@SuppressWarnings({"unchecked", "deprecation"})

Consult your compiler's documentation for a complete list of supported warning categories.

The more advanced uses of annotations includes writing a program that can read a Java program and process its annotations. To facilitate this task, release 5.0 of the JDK includes an annotation processing tool, called apt. In the next release of the JDK (codename Mustang) the functionality of apt will be a standard part of the Java compiler. For more information, see Getting Started with the Annotation Processing Tool. For more information on the work-in-progress for Mustang, see the Language Model API and JSR 269: Pluggable Annotation Processing API.

추상클래스(Abstract Class)
 
-abstract 키워드를 사용

-몸체없는 추상메서드를 하나라도 포함하고 있으면 추상클래스가 된다.

-추상클래스가 되면 반드시 abstract 키워드를 명시해야 한다.

-클래스를 선언할 때  클래스 앞에 abstract 키워드를 사용하면 추상메서드를 포함하고 있지 않아도 추상클래스 된다.

-추상클래스는 객체(인스턴스)를 생성할 수 없다.

-추상메서드는 묵시적으로 가상메서드(Virtual Method)가 된다.

-추상메서드는 virtual 키워드를 사용할 수 없다.
 


인터페이스(Interface)

-클래스의 뼈대만을 가지고 있는 것

-인터페이스 내의 멤버는 모두 몸체가 없다.

-인테페이스의 멤버는 디폴트로 전부 public이다.

-내부에 필드를 가질 수 없다.

-멤버에 어떠한 접근자, 한정자도 붙이지 않는다.

antlr
commons-beanutils  
common-chain
commons-logging
commons-logging-api
commons-validator
freemarker  
ognl   
oro
struts2-core  
struts-core  
xwork

★ ValueStack
☞ Xwork와 Struts2의 동적컨텍스트 구성의 핵심

☞ ActionContext맵의 내장맵으로 request, session, parameters 맵들과 기타 여러 맵들과 함꼐 ActionContext를 구성

☞ Action이 실행되는 동안 액션을 ValueStack에 저장하므로 ValueStack을 통해 Action프라퍼티의 값들에 엑세스가 가능

☞ 요청파라미터와 Action프라퍼티의 매핑에 사용됨


★ ActionContext
☞ Action이 실행되는 실행 환경

☞ 어플리케이션, 세션, 액션인보케이션, 파라미터, 로케일 정보와 같이 미리 정의된 값을
  얻거나 저장하기 위한 Thread Local Map

☞ 각각의 Action객체는 각각의 ActionContext에서 수행 됨

☞ 액션프락시가 액션인보케이션을 호출할때 생성되고 액션인보케이션 수행이 끝나면 제거됨

☞ 액션인보케이션이 수행되는 동안 쓰레드로 구성됨

☞ 인터셉터, 액션, 리절트가 실행시 사용자의 코드에서 액션컨텍스트를 얻기 위해서
  ActionContext.getContext()를 호출하면 됨
 

★Struts2의 개요
☞ Struts 프레임워크는 http://struts.apache.org에서 배포하는
   MVC기반의 모델2를 이용한 웹어플리케이션 개발을 돕는 프레임워크

☞ 웹어플리케이션에서 MVC패턴의 Controller부분을 담당하며, Controller의 기능을
   계층화하여 제공

☞ XML기반의 환경설정 파일을 이용하여 코드의 직접 수정을 최소화

☞ 다양한 태그라이브러리 지원으로 View에서의 데이터표현 작업을 효율적으로 처리 가능

☞ 리소스번들을 이용한 다양한 언어의 표현으로 웹어플리케이션의 국제화를 지원

☞ 현재 Struts 1 , Struts 2 , Struts 2.1 버전이 공개되어 있음


★Struts1의 단점
☞ 프레임워크의 핵심객체들이 POJO기반이 아님으로 객체들이 프레임워크에 종속적

☞ 객체들의 프레임워크 종속성으로 인해 모듈별 테스트가 힘듦

☞ ActionForm의 사용으로 인한 불필요한 작업과 코드량 증가

☞ 태그라이브러리의 부족으로 다양한 활용이 용이치 않음

☞ 과다한 XML설정으로 설정 작업이 많음


** POJO (wiki
-POJO is an acronym for Plain Old Java Object. The name is used to emphasize that the object in question is an ordinary Java Object, not a special object, and in particular not an Enterprise JavaBean (especially before EJB 3).


★ Struts2의 특징 및 장점
☞ Struts1과는 달리 WebWork2에 기반한 MVC모델 채택
☞ POJO(Plain Old Java Object) 기반의 Action
☞ Zero Configuration 지향
☞ Annotation을 이용한 설정
☞ 변경된 환경설정파일이 웹컨테이너 재시작없이 반영됨으로 개발편이성 증대
☞ 별도의 ActionForm이 필요치 않음
☞ 액션실행 전/후에 실행할 코드를 인터셉터를 이용해 정의
☞ 테마와 템플릿을 포함한 강력한 태그라이브러리 제공
☞ AJAX구현의 편이성 증대 (Dojo프레임워크 포함, ajax테마)
☞ OGNL(Object Graph Navigation Language) 지원
☞ 뷰와 값의 연결을 위해 ValueStack 사용
☞ 다양한 플러그인 적용 가능 (JFreeChart, SiteMesh, JasperReport, Spring …)
☞ 구글쥬스(Google Guice)프레임워크를 채택한 DI(Dependancy Injection) 제공

★Struts2에서 주로 개발해야할 영역
☞ Action
  클라이언트의 요청과 Model, 또는 Model의 응답과 클라이언트 View의 연결 역할

☞ Result
  클라이언트에게 서버의 응답을 보여주기 위한 방법 제공

☞ Configuration
  주요 기본제공 설정 외에는 개발자가 직접 설정


★ Action
☞ 클라이언트의 요청에 대한 비즈니스 로직을 실행하기 위한 창구
☞ Struts2에서 액션은 Singleton이 아님
   - 싱글턴이 아니므로 액션객체에 프라퍼티를 이용해 상태정보를 저장하는 것이 가능
☞ POJO
☞ 기본 엔트리포인트로 execute() 메소드 사용
☞ Struts1이 .do URL을 사용하는데 반해 .action URL을 사용

<action name=“myAction” class=“mypackage.MyActionClass”/>


★ Result
☞ 액션을 통해 수행된 Model의 처리결과를 출력하는데 사용됨

☞ 출력의 형태에 따라 다양한 Result타입 제공

//CastChild.java

class CastChild extends CastParent {
 String name = "CastChild";
 int age = 20;

 CastChild(){
  System.out.println("CastChild타입의 객체 생성됨!");
 }
 CastChild(String name, int age) {
  System.out.println("CastChild타입 객체 생성됨!");
  this.name = name;
  this.age = age;
 }

 void method1(){
  System.out.println("CastChild의 method1()호출됨");
 }
 void method2(){
  System.out.println("CastChild의 method2()호출됨");
 }
 void method3(){
  System.out.println("CastChild의 method3()호출됨");
 }
}

----------------------------------------------------

//CastParent.java
class CastParent {
 String name = "CastParent";
 int age = 50;

 //생성자
 CastParent(){
  System.out.println("CastParent타입의 객체 생성됨!");
 }
 CastParent(String name, int age) {
  System.out.println("CastParent타입의 객체 생성됨!");
  this.name = name;
  this.age = age;
 }

 //메소드 오버라이드
 void method1() {
  System.out.println("CastParent의 method1() 호출됨");
 }

 void method2() {
  System.out.println("CastParent의 method2() 호출됨");
 }
}//class

----------------------------------------------------

//CastMain.java

class CastMain {
 public static void main(String[] args){
  CastParent cp1 = new CastParent(); //부모는 부모 자신을
  System.out.println(cp1.name+":"+cp1.age+"\n");

  CastChild cc1 = new CastChild(); //자식은 자식 자식을
  System.out.println(cc1.name+":"+cc1.age+"\n");

  CastParent cp2 = new CastChild(); //부모(상)는 자식(하)을 묵시적 변환
  System.out.println(cp2.name+":"+cp2.age+"\n");
  
  CastChild cc2 =(CastChild)cp2; //자식타입 cc2에 부모cp를 자식타입으로 변환 후
  System.out.println(cc2.name+":"+cc2.age+"\n");
  
  cp2.method1();
  cp2.method2();
//  cp2.method3();  //CastParent에는 Method3()없음
  
  System.out.println();
  cc2.method1();
  cc2.method2();
  cc2.method3();

  //부모의 method1()과 부모의 method2()호출
  System.out.println();
  CastParent cp3 = new CastParent();
  System.out.println(cp3.name+":"+cp3.age);

  cp3.method1();
  cp3.method2();

  // instanceof
  CastParent cp4 = new CastParent();
  CastChild cc4 = new CastChild();
  CastParent cp5 = cc4;
  if(cp4 instanceof CastParent) {
   System.out.println("41 cp4 is instance of CastParent");
  }
  if(cp4 instanceof CastChild) { //안찍힘.
   System.out.println("44 cp4 is instance of CastChild");
  }
  if(cc4 instanceof CastChild) {
   System.out.println("47 cc4 is instance of CastChild");
  }
  if(cc4 instanceof CastParent) {
   System.out.println("50 cc4 is instance of CastParent");
  }
  if(cp5 instanceof CastParent) {
   System.out.println("53 cp5 is instance of CastParent");
  }
  if(cp5 instanceof CastChild) {
   System.out.println("56 cp5 is instance of CastParent");
  }
  if(cc4 instanceof Object) {
   System.out.println("59 cc4 is instance of Object");
  }
 }
}//class

//A.java
package a;
public class A{
 public A(){
  System.out.println("A const");
 }
}

----------------------

package a.b;

import a.A;

public class B extends A {
 public B() {
  System.out.println("B constr");
 }
}
-----------------------------

package a.b.main;

import a.b.B;

class PackageMain {
 public static void main(String[] args){
  B b=new B();
 }
}

--------------------------------

##실습 5 - 패키지 컴파일
-패키지와 클래스 생성
/src/a/A
/src/a/b/B
/src/a/b/main/PackageMain.java

-클레스 파일구조

PackageMain
p_test/classes/a/A
p_test/classes/a/b/B
p_test/classes/a/b/main/PackageMain.java

디렉토리 : 실습5/src/a
위치 : src
javac -d ../classes a/A.java
javac -d ../classes a/b/B.java
javac -d ../classes a/b/main/PackageMain.java

java -classpath ../classes a.b.main.PackMain

디렉토리 : 실습5/classes
javac -d ./classes src/a/A.java src/a/b/B.java src/a/b/main/PackageMain.java
java -d ./classes a.b.main.PackageMain