2013년 7월 3일 강의내용(생성자, Wrapper Class, Vector & ArrayList).

생성자!

---

---

public class JavaEx_12 { 

    String name; 
    int age; 
    float money; 

    // 기본 생성자는 원래 묵시적으로 선언 되어 있기때문에 
    // 명시적으로 선언하지 않아도 사용할수 있지만 
    // 오버로딩된(다른) 생성자가 출현하면 
    // "기본 생성자 사용시" 명시적으로 언급 해야한다. 
    JavaEx_12() { 
        // TODO Auto-generated constructor stub 
    } 

    /* 
     * source -> generate toString() : 자동 overriding 
     */ 
    @Override 
    public String toString() { 
        return "JavaEx_12 [name=" + name + ", age=" + age + ", money=" + money 
                + "]"; 
    } 

    /* 
     * usage : source -> generate hashCode()/equals() : 자동 overriding 
     * name.hashCode() : String 소속의 멤버 메소드 -> 재활용(re-use) +a -> 현재의 클래스 소속의 
     * hashCode() : 상속성 
     */ 
    @Override 
    public int hashCode() {
        final int prime = 31;
        int result = 1; 
        result = prime * result + age; 
        result = prime * result + Float.floatToIntBits(money); 
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result; 
    } 

    @Override 
    public boolean equals(Object obj) {
        if (this == obj) 
            return true; 
        if (obj == null) 
            return false;
        if (getClass() != obj.getClass()) 
            return false;
        JavaEx_12 other = (JavaEx_12) obj; 
        if (age != other.age) 
            return false;
        if (Float.floatToIntBits(money) != Float.floatToIntBits(other.money))
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true; 
    } 

    // 단위 테스트용 : main 메소드의 확장(분신, 조각) 
    // main 메소드가 없으면 실행이 안됨. 
    static { 

        System.out.println("test1"); 

        // 재귀 참조/호출(recursive/ reflexive reference /call)
        // 자기(클래스)가 자신을 호출 
        JavaEx_12 javaEx_12 = new JavaEx_12(); 
        System.out.println(javaEx_12); 

        javaEx_12.name = "홀길동"; 
        javaEx_12.age = 20; 
        javaEx_12.money = 100.0f; 

        System.out.println("hashCode : " + javaEx_12.hashCode()); 

        JavaEx_12 obj = new JavaEx_12(); 
        javaEx_12 = obj; 
        // (메모리)주소값을 대입(할당) 
        // true ! ; 가리키(pointing : 참조하는) 주소값이 같기 때문에 ! 

        System.out.println("javaEx_12.equals(obj) : " + javaEx_12.equals(obj)); 
        // javaEx_12 객체와 obj 객체(인스턴스)와 obj 객체(인스턴스)
        // 메모리 "주소값"으로 비교 ! 

        // 아래의 세가지 유형은 
        // 동일한 유형이나 경우에 따라서 달리 사용한다. 

        // 1) 유형 
        // 생성과 동시에 필드 초기화 
        JavaEx_12 newObj = new JavaEx_12("규리", 26, 27000.0f); 

        // 2) 유형 
        // 생성과 필드의 초기화 별도 
        // 필드의 접근 지시자가 대체로 private이 아닌 
        // (은닉되어 있는, 필드에 직접 접근이 안되는) 경우 
        JavaEx_12 newObj2 = new JavaEx_12(); 
        newObj2.name = "규리"; 
        newObj2.age = 26; 
        newObj2.money = 27000.0f; 

        // 3) 유형 
        // 전형적인 Java Beans 패턴에 적합한 객체생성 및 필드 초기화
        // ※ Java Bean(s) "패턴(pattern)" 
        // 멤버 필드 -> private : 데이터의 보호(보안성) 
        // 데이터 접근(입력/출력) : setter/getter 
        // - > 대부분 public ! 
        JavaEx_12 newObj3 = new JavaEx_12(); 
        newObj3.setName("규리"); 
        newObj3.setAge(26); 
        newObj3.setMoney(27000.0f); 

    } 

    // 생성자의 오버로딩(overloading) : 다형성 
    // usage : source - > generate constructor using 
    // 자동 생성자 오버로딩 생성(작성) 
    // 객체 생성과 동시에 멤버변수의 초기값이 할당(setter) 
    public JavaEx_12(String name, int age, float money) {
        // super(); 
        // this(); 
        this.name = name; 
        this.age = age; 
        this.money = money; 
    } 

    public void setName(String name) {
        this.name = name; 
    } 

    public void setAge(int age) {
        this.age = age; 
    } 

    public void setMoney(float money) {
        this.money = money; 
    } 

    public static void main(String[] args) {
        System.out.println("test2"); 

    }// close of main 

}// end of class 

 

 

---

---

 Wrapper Class

Wrapper Class : 프리미티브 타입의 값을 담는 객체를 생성하는 것. 

/* 
 * Wrapper class : casting(형변환) 
 * => 생성자, (일반)메소드 
 */ 
public class JavaEx_13 { 

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

        String str = "123"; 
        // String str = new String("123"); -> 위에랑 같은거. 

        int number = 0; 

        // number=str; // 형변환이 필요! 
        // String(reference type) -> 원시형(primitive type) 

        number = new Integer(str); // 방법 (1) 
        // since JDK 1.5 : auto-unboxing(class -> 원시형) 
        // String -> (생성자) -> Integer(class) -> int(원시형) 

        // number = Integer.parseInt(str); //방법 (2) 
        // all version 

        // number = Integer.valueOf(str); // 방법(3) 
        // since JDK 1.5 : auto-unboxing(class -> 원시형) 

        // Intrger i = new Integer(str); 
        // number = i,intValue(); 
        number = new Integer(str).intValue(); 
        // 무명(익명) 인스턴스 -> 일회용 ! 
        // 방법 (4) 
        // all version ! 

    } 

}

 

---

  

---

 

Vector & ArrayList

import java.util.ArrayList; 
import java.util.List; 
// import java.util.*; 
import java.util.Vector; 

public class JavaEx_14 { 
    /** 
     * @param args 
     */ 
    public static void main(String[] args) {
        // ArrayList list = new ArrayList(); 
        // until JDK 1.4 

        // if) 요소(element) 로써 모든 자료형 허용 
        ArrayList<Object> listObj = new ArrayList<Object>(); 
        // since JDK 1.5 

        // Generics(제너(네)릭스) 
        // why) 형(type)의 안전성(safety)을 
        // 유지하여 제너릭스를 사용하는 
        // 객체(클래스, 인터페이스)의 성능을 
        // 최대화 

        ArrayList<String> listStr = new ArrayList<String>(); 

        Object objElement = new Object(); 
        // objElement = (Object)"샘 해밍턴"; 
        objElement = "샘 해밍턴"; 

        listStr.add("김태희"); 
        listStr.add("박신혜"); 
        listStr.add("김슬기"); 
        listStr.add("배수지"); 
        listStr.add("한지민"); 
        // listStr.add(123); // (X) 
        // listStr.add(objElement); // (X) 
        listStr.add(objElement.toString()); // (O) 
        listStr.add((String) objElement); 
        // (O) => 클래스 : casting 연산자 
        // = 상속관계에만 적용 ! 
        System.out.println("ArrayList의 size : " + listStr.size()); 

        System.out.println("listStr의 첫번째 요소 : " + listStr.get(0)); 

        for (int i = 0; i < listStr.size(); i++)
            // { 
            System.out.println(listStr.get(i)); 
        // } 

        listStr.set(0, "한예슬"); 

        System.out.println("listStr의 첫번째 요소 : " + listStr.get(0)); 

        listStr.remove("샘 해밍턴"); 

        for (int i = 0; i < listStr.size(); i++)
            System.out.println(listStr.get(i)); 

        System.out.println(listStr.indexOf("한예슬")); 

        // //////////////////////////////////// 

        // Vector vector = new Vector(); // until JDK1.4 
        Vector<String> vector = new Vector<String>(); 

        vector.addElement("김태희"); 
        vector.add("박신혜"); 
        vector.add("김슬기"); 
        vector.add("배수지"); 
        vector.add("한지민"); 
        // vector.add(123); // (X) 
        // vector.add(objElement); // (X) 
        vector.add(objElement.toString()); // (O) 
        vector.add((String) objElement); 
        // (O) => 클래스 : casting 연산자 
        // = 상속관계에만 적용 ! 

        /* 
         * for (int i=0; i<vector.size(); i++) 
         * System.out.println(vector.get(i)); 
         */ 

        for (int i = 0; i < vector.size(); i++)
            System.out.println(vector.elementAt(i)); 

        for (String i : listStr) { 
            System.out.println("향상된 for문으로 출력 : " + i);
        } 

        /* 
         * ArrayList<ArrayList<String>> lists = new 
         * ArrayList<ArrayList<String>>(); 
         *  
         * lists.add(listStr); lists.add(vector); // Vector<String> // (X) 
         */ 
        ArrayList<List<String>> lists = new ArrayList<List<String>>(); 

        lists.add(listStr); // (O) 
        lists.add(vector); // (O) 

        // List listNew = new List(); 
        // 인터페이스는 생성자가 없음 => (X) 
        List<String> listNew = new ArrayList<String>(); // (O) 

    } 
}// end of class