블로그 이미지
우디냥
"지금 잠을 자면 꿈을 꾸지만, 지금 공부하면 꿈을 이룰수있다"

calendar

            1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30            

Notice

'─☻раցеº②/└ᘐ java'에 해당되는 글 26

  1. 2007.05.07 자료구조 클래스들
  2. 2007.05.07 SimpleDateFormat 클래스와 Math 클래스
  3. 2007.05.07 String 클래스
  4. 2007.05.07 예외처리(Try)
  5. 2007.05.02 접근제어
  6. 2007.05.02 instanceof 연산자 와 열거타입
  7. 2007.04.24 Package
  8. 2007.04.18 인터페이스
  9. 2007.04.18 계층추적
  10. 2007.04.18 super.과 this( )
└ᘐ 자료구조 클래스들 (데이터를 관리 하는 방식에 따라 구분)
       --------------------------------------------------------
          자료구조    │       클래스 이름
       --------------------------------------------------------
         리스트        │  ArrayList       LinkedList       (Vector)
         스택           │  LinkedList     (Stack)
         큐              │  LinkedList
         해쉬 테이블 │  HashMap      (HashTable)
         집합           │  HashSet
       --------------------------------------------------------
   
   ▶ ArrayList 클래스
       - 데이터를 배열 형태로 관리하는 클래스
       [특징]
            1. 데이터가 입력한 순서대로 기억된다.
            2. 위치값에 의해서 직접 검색이 가능하다.

        <생성방법>
            ArrayList list  = new ArrayList();
            ArrayList list  = new ArrayList(10);  // -> 구버젼
            ArrayList<String> list  = new ArrayList();
            ArrayList<String> list  = new ArrayList(10);  // -> 신버젼
                            └ 데이터의 형태를 미리 결정하고 누적! -> 꺼낼 경우 구분 할 필요 없다.
            * 10 이라는건 처음 시작할때 확보한 메모리의 개수
                  => 데이터가 넘치면 자동적으로 메모리의 개수를 늘려나간다.
                  => 메모리 개수를 지정하는 이유 : 메모리 확보 처리 시간을 단축!
       
        <주요함수>
            add()   데이터를 누적시키는 함수
            get()    특정 위치의 데이터를 꺼내는 함수
            set()    특정 위치의 데이터를 변경하는 함수
            size()  누적된 데이터의 개수를 알아내는 함수


                           
   

     

         
 
posted by 우디냥
TAG ArrayList
└ᘐ SimpleDateFormat 클래스
      -> java.text 패키지 소속
      상속관계
          Format => dateFormat - 실제 사용 함수 (Format)

      <생성방법>
           SimpleDateFormat(String pattern)
     
└ᘐ Math 클래스
           -> 100 % static 함수로 구성 => new 시킬 필요가 없다.

       1. 삼각함수 사용법
          - 삼각함수의 모든 파라메터는 반드시 라디안 값으로 넣어주어야 한다.
          ex)  double result = Math.sin(90.0);  //틀린 경우
                 double result = Math.sin(Math.toRadians(90.0)); // 맞는 경우

        
posted by 우디냥
└ᘐ String 클래스
       -> 문자열을 관리하는 클래스
         단점 : 문자열이 변경되면 새로운 문자열을 만들고, 그 문자열의 주소를 새롭게 기억
     
      *생성방법
            String str  = new String();
            String str = new String("Hong");
           
            Char[] temp  = {'H', 'o', 'n', 'g' };
            String str = new String(temp);
       
    - 자주 사용하는 기능이므로
           String str = "Hong"; (처리가능)
      문제점> 위의 방식으로 처리하면 실제 Hong 은 Heap에 생기는 것이 아니고 ,
                  리터럴 풀에 생겨난다.
                   └ 같은 의미의 값이 오면 다시 저장하지 않고, 존재하는 값을 돌려주는 메모리    

└ᘐ StringBuffer 와 StringBuilder
         ->String 클래스의 단점을 보완하기 위해서 만들어진 클래스
         -> 한번 주소를 받으면 그 주소를 이용해서 문자열을 변경하도록 제작
    
    
posted by 우디냥

└ᘐ TRY
      -> 실행도중 발생하는 에러를 처리하기 위한 방법
          (주로 데이터가 잘못 처리된 경우, 오브젝트가 실제 주소를 가지지 못하는 경우)
      - 실행도중 에러 발생 -> 인터럽트 처리기에 의해 처리된다.
          (Run Time Error)                 └ 운영체제가 가지고 있는 도구
                                                       └ 근본목적 : 시스템을 정상적으로 동작하도록 하는기능
     
      - 결론 : Run Time Error가 발생하는 경우 이것의 처리를 인터럽트 처리기에게
                 넘기지 않고 프로그램 자체적으로 처리하는 기능
     
   <형식 >  ①
           try {
                ②
           ③ 에러발생 위험이 있는 요소
                ④       
           }
           catch (???) {
           ⑤ 에러가 발생하면 처리할 내용들
           }
                ⑥  

   <순서>
       1 -> 2 -> 3 -> 에러발생 경우 -> 5 -> 6
                      └> 에러발생 안한 경우 -> 4 -> 6

 ▶ try 블럭의 크기
      결론 : 에러가 발생하면 에러 발생 시점에서 나머지 부분이 실행되지 않는다.
               그러므로 try 블럭의 크기는 에러가 발생하면 더이상 처리가 필요없는 부분까지 잡아줌
 
 ▶ finally 블럭
      -> 에러 발생 여부에 관계없이 무조건 실행 해야 하는 부분을 처리하는 블럭
     [형식]
               try {
               } catch (Exception e){
               } finally {
               }
 
 ▶ 예외 전이하기
       -> 특정 함수에서 그 함수를 실행하는 도중 발생하는 에러를 그 함수가 처리 하지 않고,
           그 함수를 호출한 곳에 에러를 대신 처리하라고 알리는 방법
      [형식]
           void abc() throws 에러클래스이름{
           }
       ex)
           void abc() throws lOException {
           }
            =>  abc 실행하는 도중 발생하는 모든  IO 에러에 대해서 이 함수가 처리하지 않고,
                함수를 호출한 곳에서 처리하도록 하는것.
                이 함수에서 IOException 말고는 처리되지 않는다.
   ※ 예외
        -> 던지는 에러가 RuntimeException을 상속하는 에러 라면 그 함수는 try~catch를 안해도
            상관없지만, 상속관계가 없는 에러라면 반드시 try~catch 해주어야 한다.
 
  ▶ 생성자 함수가 던지는 예외
      -> 생성자 함수를 실행하는 도중 발생하는 에러를 그 생성자 함수를 호출한 곳에 넘기는 것
            => new 시키는 곳!
      ex)   
           class Sam {
              public Sam() throws Exception{
              }
           }
           class Test {
               public static void main(String[] args){
                    try {
                          Sam s = new Sam();
                    }catch (Exception e){
                    }
              }
           }

   ▶ 사용자가 예외 클래스 만들기
         방법 1. 반드시  Exception 클래스를 상속 받아서 만든다.
                  ex)  class MyException extends Exception{
                         }
                2. toString()함수를 오버라이딩해서 그 안에 에러의 이유에 대해서 기술
     
       * 사용자 예외 클래스 사용하기
            - jvm은 에러로 인정 하지 않을때 ->강제로 jvm에게 에러라고 알려줘야 한다.
            [형식]
                   throw new 사용자예외클래스();
 

posted by 우디냥
└ᘐ 접근제어
      -> 사용가능여부를 지정하는 방식

      1. public  
          - 어디서든지 사용 가능 -> 다른 패키지에서도 사용가능한 클래스
      2. protected
          - 반드시 상속관계에 있어야 사용 가능
            예외, 상속관계에 없더라도 같은 패키지 소속이면 사용가능
      3. private
         - 오직 자기 자신만 사용가능
      4. 생략
         - 같은 패키지 소속끼리만 사용가능
         - class 선언에서 생략하면 반드시 같은 패키지 안에 있는 클래스만 사용할 수 있다.

    [범위]
         public -> protected -> 생략 -> private

 └ᘐ 오버라이드 할 경우의 접근지정자 지정방법
       -> 오버라이드 하는 하위에서는 상위 함수보다 접근 범위가 더 크거나 같아야 한다.
posted by 우디냥
└ᘐ instanceof 연산자
      -> 특정 레퍼런스가 특정 클래스의 상속 관계에 있는지를 검사하는 연산자.

    <형식> 주소 instanceof 클래스이름
    <결과> 논리값으로 나온다. 
               주소가 클래스의 상속관계에 있으면 -> 참
               주소가 클래스의 상속관계에 없으면 -> 거짓

└ᘐ 열거타입
     -> 특정내용을 1에서 순서대로 나열한 후 사용하는 기능.
     
     <형식>
           enum 이름 {열거할 내용...}
     <사용>
          이름.내용
       ex)  Seson.SPRING;  -> 1의 의미
              Seson.WINTER;  -> 4의 의미
   
     * 참고
         열거형 변수는 무조건 static 이다.
 
posted by 우디냥
└ᘐ  Package
       -> 물리적으로 같은 디렉토리 안에 포함된 클래스의 집합

     ▶ 특정 클래스를 특정 패키지에 만드는 방법
           1) 패키지명을 결정합니다.
           2) 클래스에 package선언문을 집어 넣습니다.
           3) 디렉토리 구조를 패키지 구조에 맞게 설정합니다.
        [형태]
           Package  ??? ;    //패키지를 선언
           class Sam
           {
           }

    ▶ 패키지 선언이 된 클래스를 컴파일 하는 방법
         ~> javac 파일이름.java  (일반적인 컴파일방법)
             javac -d . 파일이름.java (패키지 선언된 컴파일방법)
       
        * -d란?  
           - 패키지 컴파일을 해달라는 옵션 명령
        * . ?
           - 디렉토리가 존재하는 기본 위치
             (즉. 현재 디렉토리를 기준으로..)

    ▶ 특정 패키지 소속의 클래스를 이용하는 방법(자신과 다른 패키지 소속)
          import 패키지명.클래스명 or * ;    //선언하고, 일반적인 사용법 처럼 사용한다.

    ▶ Package의 중요성
        1. 프로젝트 또는 라이브러리를 더 용이하게 편성할 수 있다.
        2. 이름 영역을 지정(api문서)하여 충돌을 미연에 방지한다.
            => 객체지향의 특징이 재사용이 가능한 구성요소를 만드는 것 이기 때문..
            * 참고
               - 패키지 명을 새로 만들어야 할 경우 패키지 명의 충돌을 막기위해
                 역도메인명을 붙여준다.
        3. 보안기능을 제공한다.

 
    [편법1]
         import 시키지 않고 클래스 사용 시점에 가서 그 클래스의 소속을 일일이
         알려줄 수도 있다.
  
posted by 우디냥
TAG Package

└ᘐ 인터페이스
         => 오직 추상적인 함수(몸체를 가지지 않는 함수)만 가지고 있는 특별한 케이스
      [형식]   interface 이름
                  {
                       public void 함수이름() ;
                  }
       
       ※ 참고
             1. 일반 함수가 포함되어서는 안된다 -> 무조건 추상메소드
             2. 변수는 선언될 수 있다 -> 단! 그 변수는 저절로 static 변수가 된다.
 
      ▶ 사용목적
            -> 추상클래스와 마찬가지로 계층 추적의 상위 클래스의 역할을 하기 위해 존재
 
      ▶ 사용방법
             1. 스스로 new 되지 못한다 -> 즉, instence가 될 수 없다.
             2. 반드시 다른 일반 클래스에 상속해서 사용한다.
                 ※ 인터페이스를 상속 받는 방법
                      [형식] class Sam implements 인터페이스이름
                                {
                                }
             3. 상속받은 클래스는 인터페이스 안에 있는 모든 함수를 반드시 오버라이드한다.
     
      ▶ 인터페이스라는 개념을 왜?
             1. 인터페이스 안에 함수는 존재한다.
             2. 그 함수는 몸체가 없다(->즉, 그 함수가 해야할 일을 지정하지 않았다.)
   
      ※ 인터페이스는 추상적 함수로만 구성되어 있다. => 함수는 이미 만들어져 있다.
          근데 사용하라면 상속 받은 후 반드시 오버라이드 해서 사용해야 한다.
 
      ※ extends 와 implements의 차이점
           => extends는 단일 상속만 가능한데 비해서
                implements는 다중 상속이 가능하다.
            ex) class Father
                 {
                 }
                 interface MyIn
                 {
                 }
                 interface YouIn
                 {
                 }
                 class Sam extends Father implements MyIn, YouIn
                 {
                 }            //이것이 가능하다!          
   
   
                     
                   
         

posted by 우디냥
└ᘐ 계층추적
         => Reference에 시작해서 Instance 까지 계층추적 하면서 마지막 함수가 실행된다.

      ※ 규칙 : 반드시 reference에 함수가 존재해야 한다.

└ᘐ 추상 class
        => class안에 추상 함수가 0개 이상 포함된 것.
         [형식]
             abstract class 이름
             {
             }

     ※ 참고 - 추상 함수가 1개 이상 있으면 그 클래스는 반드시 추상 class이어야 한다.
                   추상 함수가 없더라도 추상 클래스로 만들 수 있다.
     
      ▶ 추상 class 사용방법

          규칙1. 반드시 누구에겐가 상속을 해서 사용한다.
                    => 스스로 new 시키지 못한다 => instance가 안된다.
              ex) abstract class Sam
                   {
                   }
                   Sam s = new Sam();  --> error!
   
          규칙2. 상속 받은 class는 반드시 추상 class가 가진 추상함수를 over_riding 해야함
              ex) abstract class Sam
                   {
                       abstract void abc();  ─────┐
                   }                                               │
                   class Myclass extends Sam         over_riding 
                   {                                               │
                       void abc()    <────────┘
                       {
                           .....
                       }
                   }

          규칙3. 단, reference는 만들 수 있다.
              ex) abstract class Sam
                   {
                        abstract void abc();
                   }
                   Sam s; --->(o)
                   s = new Sam; --->(x)

      ▶ 추상 class의 사용목적
          - 계층 추적을 위한 상위 class의 역할을 담당

└ᘐ 추상함수
        -> 몸체를 가지지 않는 함수
      [형식] public abstract void 이름(...) ;
           ex) abstract class Sam              ─┐  
                {                                           │추상 class
                      public abstract void abc(); │    추상method 
                }                                        ─┘

   ★ 추상클래스와 추상함수의 장점  -> 메모리를 차지하지 않는다(형식적으로만 존재)
posted by 우디냥

└ᘐ Super.
        => 아버지 class의 member를 지칭하는 예약어
      ex) class Father
           {
               void abc()
               {
                   System.out.println("아버지");
               }
           }
           class Sam extends Father
           {
               void abc()
               {
                    System.out.println("아들");
               }
               void xyz()
               {
                    abc(); ->아들 class의 함수
                    super.abc();  -> 아버지 class의 함수
               }
           }

     ※ 주의
           1. 반드시 상송 받은 class에서만 사용가능
           2. 아버지의 아버지는 되지 않는다 -> 즉, 한 단계 위에만 허락!

└ᘐ This();
        => 자기 자신의 또 다른 생성자 함수를 강제로 호출하는 명령
   
        ▶ 규칙
            1. 반드시 생성자 안에서만 사용
            2. 반드시 첫번째 줄에서만 사용
     
     ex) class Sam
          {
                int a,b;
                public Sam()
                {
                      a = 0;  ┬ this(0,0);
                      b = 0;  ┘    │
                }                     │
                public Sam(int a, int b)
                {
                     this.a = a;
                     this.b = b;
                }
           }

└ᘐ 관계
         this[자신의 주소] <-------> super[아버지의 주소]
         this() [자기 자신의 또 다른 생성자] <--------> super() [아버지의 또 다른 생성자]

posted by 우디냥
TAG super., this()
prev 1 2 3 next

티스토리 툴바