Youth-tory 유스토리

Design Pattern(설계패턴)

Singleton pattern

어플리케이션 전체에서 객체 한개만 생성해서 사용하는 패턴

객체 한개를 공유해서 사용

두개 만들면 데이터의 동기화가 어려운 경우

SingletohObject.java

xxxxxxxxxx
package com.util;
/***
 * Singleton Pattern이 적용된 Class
 * 객체 생성을 한번만 수행하고 그 이후로는 생성된 객체 공유
 * 
 * Singleton Pattern 객체 조건
 * 1. field : private, static 자기자신 객체(instance)
 * 2. 생성자 : private
 * 3. getInstance() : 객체를 생성해서 리턴해주는 static method가 반드시 있어야 한다. 
*/
public class SingletonObject {
    private static SingletonObject instance ;
    
    private SingletonObject() {}
    
    public static SingletonObject getInstance() {
        if(instance == null) {
            instance = new SingletonObject();
        } 
        //한번 생성된 후에는, 만들어진 객체를 계속 리턴한다. 
        return instance;
    }
    
    public void print() {
        System.out.println("hello, print");
    }
}
​

SingletohObjectUser.java

package com.util;
​
public class SingletonObjectUser {
    public static void main(String[] args) {
        SingletonObject o1 = SingletonObject.getInstance();
        SingletonObject o2 = SingletonObject.getInstance();
        SingletonObject o3 = SingletonObject.getInstance();
    
        o1.print();
        o2.print();
        o3.print(); 
    }
}
​

interface

인터페이스는 상수와 구현되지 않은 메소드로만 구성된다.

추상 아닌것도 필요한데요? ---> 추상클래스 이용 !! interface X

인터페이스 상속 implements

다중상속을 지원하기 위함.

인터페이스 안의 필드는 기본으로 static, final

인터페이스 안의 메소드는 public abstract

자식클래스에서는 implements로 상속하고, 부모가 가지고 있던 메소드를 반드시 완성시켜야 한다.

xxxxxxxxxx
package com.inter;
//interface: 내부에 추상메소드만 가지고 있는 객체. 미완성 객체. 객체생성 안됨
public interface MyInterface {
    //인터페이스 안의 필드는 기본으로 static, final이 붙어있다.
    int num=100; //static, final
    
    //인터페이스 안의 메소드는 기본으로 public abstract가 붙어 있다.
    public abstract void go();
    void stop();
}

xxxxxxxxxx
package com.inter;
​
​
class Tom{
    int age = 50;
}
​
//인터페이스 안의 필드는 기본으로 static, final이 붙어있따.
interface Hillary{
    int age = 46; 
}
​
​
​
public class LittleTom extends Tom implements Hillary {
    int age = 20;
    
    private void test() {
        System.out.println(age); //20
        System.out.println(this.age); //20
        System.out.println(super.age); //50 -Tom
        System.out.println(Hillary.age);//46-Hillary
    }
    
    public static void main(String[] args) {
        LittleTom little = new LittleTom();
        little.test();
        
        
        if(little instanceof Tom) //상속관계
            System.out.println("instanceof Tom");
        if(little instanceof Hillary)
            System.out.println("instanceof Hillary");
        if(little instanceof LittleTom)
            System.out.println("instanceof LittleTom");
        if(little instanceof Object)
            System.out.println("instanceof Object");
        
//      if(little instanceof Bill) //상속관계가 없으면 아예 사용 불가능
//          System.out.println("instanceof Bill");
    }
​
}
​
​

java0116

final

• class

  상속을 받을 수 없다.

  상속을 받는 이유 : 물려받아서 수정하고, 오버라이딩하고 ... --> 불가

  final class는 처음에 만들어 놓은 모양 그대로만 사용할 수 있다.

   

• method

  overriding(재정의) 불가

  클래스 상속은 가능, 클래스 안의 다른 메소드는 가능.

  final이 붙은 메소드만 오버라이딩 불가.

클래스가 파이널이면, 클래스 상속 불가. 그안의 메소드도 건들일 수 없다. ==> final method 효과

일반 클래스에서 한 메소드만 final면, 그 메소드만 overriding 불가.

• variable

  상수가 된다. 항상 변하지 않는 값.

   

  ex) math.class

  final class ==> 모든 메소드와 변수는 final. 즉, 고칠 수 없다.

   

   

package com.basic;
​
//1. final calss : 상속이 안됨
final class MyFinal{
    public void test() {
        System.out.println("MyFinal-test()");
    }
}
​
class YourFinal{
    public void test2() {
        //....
    }
    
    //2. final method: overriding이 안됨
    public final void test() {
        System.out.println("YourFinal-test()");
    }
}
​
public class FinalTest extends YourFinal{
    //3. final variable: 값을 수정할 수 없음.
    final int max = 999;
    
    public static void main(String[] args) {
        FinalTest f = new FinalTest();
        //f.max = 10;
    }
}
​

**static

field variable, method, block 에 붙힐 수 있다.

생성이 되는 위치와 시점이 다르다.

소스파일 --컴파일--> 실행파일 ----> ~~~

.src .class

컴파일 하다가 static 을 만나면 인식하고,

실행버튼 누르면. main이 실행되기 전에 (컴파일 시점) static붙은 애들은 컴파일러가 미리 class area에 미리 만들어 놓는다. 1개만.

원래는 main이 실행되어야 객체가 만들어짐

x
package com.basic;
​
public class StaticTest {
    //1. static field. class area에 실행전 한개만 미리 만들어 짐. 객체 생성을 하지 않아도 된다.
    static int scount; //=0. class variable
    int count;//=0. 실행이 되면 객체마나 만들어짐. instance variable
    //필드는 객체를 생성하면 기본값이 있다.
    
    //2. static method
    public static void go() {
        System.out.println("gogogo~~~");
    } 
    
    
    //3. static block : { }, 메인보다 먼저 생성
    static {
        System.out.println("static block-1");
    }
    
    public static void main(String[] args) {
//      System.out.println(++count); // non static field count ERROR
        System.out.println(++scount);
        go();
        
        System.out.println(Math.PI);
        System.out.println(Math.pow(2, 3));
        System.out.println(Math.max(2,3));
        System.out.println(Math.min(2, 3));
        System.out.println(Math.abs(-22));
        
        
//      StaticTest s1 = new StaticTest();
//      StaticTest s2 = new StaticTest();
//      StaticTest s3 = new StaticTest();
//      
//      System.out.println(++s1.count + "--" + ++s2.count + "--" + s3.count);
//      System.out.println(++s1.scount + "--" + ++s2.scount + "--" + s3.scount);
    }
}

count변수는 객체 생성을 해야 만들어진다.

static 변수를 사용할때는 객체 생성을 안해도 된다.

타 클래스에서 static변수를 사용하고 싶을때

==> 클래스이름.변수명

xxxxxxxxxx
package com.basic;
​
public class HelloWorld {
    public static void main(String[] args) {
        
        /* Static 호출 */
        System.out.println(StaticTest.scount);
        StaticTest.go(); 
        
        String name = "tommy";
        String this2 = "hi";
        
        System.out.println(name + this2);
    }
}

static method 안에서는 this, super 사용 불가능

main이 실행되기전에 생성되므로, this나 super가 없어서 error발생