2016년 6월 13일 월요일

05day java

자료형
  • 기본자료형
  • 참고(확장)자료형
    • 객체(class)
      • new
      • .
    • OOP
      • 은닉
        • 접근제어자
          • public(일반적으로 메서드) / private(필드)
        • setter / getter
      • 상속
        • 클래스의 재사용

      • 추상
        • 상속과 오버라이디잉 전제가 됨
        • 추상클래스 , 추상 메서드
        • 추상 필드라는 개념은 없음
        • 인터페이스
          • 필드 public static final
          • 메서드 abstract
          • extends 단일 상속
          • implement 다중 구현
      • 다형
객체 구성요소
  • 인스턴스 멤버
  • 스태틱(static) 멤버
  • 멤버
    • 필드
      • 자동초기화 (↔지역변수는 자동초기화 되지 않음)
    • 메서드
      • 사용자 메서드
        • is*** -true/false : 값 검사
        • set/get*** : 값을 입력/출력
      • 특수목적 메서드
        • 생성자
          • 멤버필드 초기화
        • main
          • 프로그램 시작/끝 지점
    • 오버로딩
      • 조건:
      • 일반 메서드/ 생성자 둘다 가능함
    • this
    • this()

패키지 : 폴더단위로 관리

  • 내용
    • 일반클래스
    • 추상클래스
    • 인터페이스
  • 명령어
    • package : 파일로 관리하겠다는 명령어
    • import : 클래스로 읽어드리는 명령어
    • -d : 패키지 컴파일 옵션

1
class ParentEx01{
    String p1;
    void viewParent1(){
        System.out.println("viewParent1() 호출"+this);
    }
}
class ChildEx01 extends ParentEx01{
    String c1;
    void viewChild1(){
    System.out.println("viewChild1() 호출"+this);
    }
}
class ChildEx02 extends ParentEx01{
    String c2;
    void viewChild2(){
    System.out.println("viewChild2() 호출");
    }
}

public class MainEx2{
    public static void main(String[] args){
        ParentEx01 p1 = new ParentEx01();
        p1.viewParent1();

        ChildEx01 c1 = new ChildEx01();
        c1.viewChild1();
        c1.viewParent1();//부모로부터 클래스를 상속받아서 같은 주소에 넣는다
        System.out.println(c1);
        c1.p1="홍길동";
        System.out.println(c1.p1);

        ChildEx02 c2 = new ChildEx02();
        c2.viewChild2();
        c2.viewParent1();
        c2.p1="박문수";
        System.out.println(c2.p1);
    }
}


2
class ParentEx01{
    String p1;
    ParentEx01(){
        System.out.println("ParentEx01() 생성자 호출");
    }
    void viewParent1(){
        System.out.println("viewParent1() 호출"+this);
    }
}
class ChildEx01 extends ParentEx01{
    String c1;
    ChildEx01(){
    System.out.println("ChildEx01() 생성자 호출");
    }
    void viewChild1(){
    System.out.println("viewChild1() 호출"+this);
    }
}

public class MainEx01{
    public static void main(String[] args){
        ChildEx01 c1 = new ChildEx01(); //부모의 생성자가 먼저 호출이 된다
        System.out.println(c1);
    }
}


3
class ParentEx02{
    private String p1 = "홍길동"; //상속 제한
    public String p2= "박문수";
    String p3= "이몽룡";
}
class ChildEx02 extends ParentEx02{

}

public class MainEx02{
    public static void main(String[] args){
        ChildEx02 c1 = new ChildEx02(); 
        //System.out.println(c1.p1);
        //상속제한 에러발생 //MainEx02.java:12: error: p1 has private access in ParentEx02
        System.out.println(c1.p2);
        System.out.println(c1.p3);
    }
}


4
class ParentEx02{
    private void viewParent1(){ //상속제한
        System.out.println("viewParent1() 호출");
    }
    public void viewParent2(){
        System.out.println("viewParent2() 호출");
    }
}
class ChildEx02 extends ParentEx02{

}

public class MainEx03{
    public static void main(String[] args){
        ChildEx02 c1 = new ChildEx02();
        //상속제한 에러발생
        //MainEx03.java:16: error: cannot find symbol c1.viewParent1();
        //c1.viewParent1();
        c1.viewParent2();
    }
}


5
class ParentEx02{
    public String s1="홍길동";
    public void viewParent1(){ 
        System.out.println("parent viewParent1() 호출");
    }
}
class ChildEx02 extends ParentEx02{
    public void viewParent1(){      //override 자식이 재정의 하면 자식것이 우선임
        System.out.println("child viewParent1() 호출");
    }

    //super //부모클래스의 멤버필드, 맴버메서드
    public void showParent1(){
        super.viewParent1();
        
        System.out.println(s1);
        System.out.println(super.s1); //위보다 출처를 더 분명하게 나타냄

        //System.out.println(super); //직접접근을 막아놓음 //참조에서만 쓸수 있음 super.xxx
        System.out.println(this);
    }
}

public class MainEx04{
    public static void main(String[] args){
        ChildEx02 c1 = new ChildEx02();
        c1.viewParent1(); //자식이 정의한 viewParent1()를 보여줌
        c1.showParent1(); //부모가 정의한 viewParent1()를 보여줌
    }
}


6
class ParentEx01{
    // ParentEx01(){
    //     System.out.println("ParentEx01 생성자");
    // }
    // 디폴트가 아니라 생성자에 인자를 넣어서 만들었다면 상속받을 때 인자값을 설정해주지 않으면 에러남
    ParentEx01(String data1){
        System.out.println("ParentEx01 생성자2");
    }
}
class ChildEx01 extends ParentEx01{
    ChildEx01(){
        super("홍길동"); //생성자에 인자가 있도록 만들었으므로 인자를 넣어주어야 함 //생성자super() 첫줄
        System.out.println("ChildEx01 생성자");
    }
}

public class MainEx05{
    public static void main(String[] args){
        ChildEx01 c1 = new ChildEx01();
    }
}


7
class UpperClass{
    int x;
    int y;
    public UpperClass(){
        x= 10;
        y= 20;
    }
    public UpperClass(int x){
        this(); //자신의 클래스UpperClass() 생성자 호출 // 생성자 호출은 첫줄에
        this.x =x;
    }
    public UpperClass(int x, int y){
        this(x); //자신의 클래스UpperClass(int x) 생성자 호출
        this.y =y;
    }
}
class LowerClass extends UpperClass{
    int r;
    public LowerClass(){
        super(); //상위의 클래스UpperClass() 생성자 호출
        r=30;
    }
    public LowerClass(int x){
        super(x); //상위의 클래스UpperClass(int x) 생성자 호출
        r=30;
    }
    public LowerClass(int x, int y){
        super(x,y); //상위의 클래스UpperClass(int x, int y) 생성자 호출
        r=30;
    }
    public LowerClass(int x, int y, int r){
        this(x,y); //자신 클래스LowerClass(int x, int y) 생성자 호출
        this.r=r;
    }
}

public class MainEx06{
    public static void main(String[] args){
        LowerClass lc = new LowerClass(); //x=10, y=20, r=30
        System.out.println("x ="+lc.x+", y ="+lc.y+", r ="+lc.r);
        LowerClass lc1 = new LowerClass(50); //x=50, y=20, r=30
        System.out.println("x ="+lc1.x+", y ="+lc1.y+", r ="+lc1.r);
        LowerClass lc2 = new LowerClass(50,100); //x=50, y=100, r=30
        System.out.println("x ="+lc2.x+", y ="+lc2.y+", r ="+lc2.r);
        LowerClass lc3 = new LowerClass(50,100,150); //x=50, y=100, r=150
        System.out.println("x ="+lc3.x+", y ="+lc3.y+", r ="+lc3.r);
    }
}


8
class ParentEx01{
    void viewParent(){
        System.out.println("viewParent() 호출");
    }
}

//추상클래스
abstract class ParentEx02{
    void viewParent(){
        System.out.println("추상클래스 viewParent() 호출");
    }
}
class ChildEx02 extends ParentEx02{
}

//추상메서드
abstract class ParentEx03{  //추상메서드가 있는 클래스는 반드시 abstract 를 붙여주어야 함
    abstract void viewParent(); //메서드 뒤에 내용{}을 구현하지 않음
}
abstract class ChildEx03 extends ParentEx03{
    // void viewParent(){
    //     System.out.println("추상메서드 viewParent() 호출");
    // }
}
class ChildSonEx03 extends ChildEx03{ //자식메서드가 부모의 추상메서드를 구현하지 못했을 때 손자 메서드에서 정의 가능
    void viewParent(){                //대신 자식매서드는 구현하지 못했기때문에 abstract를 붙여야 한다
        System.out.println("추상메서드 viewParent() 손자 상속 호출");
    }  
}

public class MainEx07{
    public static void main(String[] args){
        ParentEx01 p1 = new ParentEx01();
        p1.viewParent();
        // ParentEx02 p2 = new ParentEx02();  //error: ParentEx02 is abstract; cannot be instantiated ParentEx02
        // p2.viewParent();
        // ParentEx01 p3 = new ParentEx03();
        // p3.viewParent();

        ChildEx02 c1 = new ChildEx02();
        c1.viewParent();
        // ChildEx03 c2 = new ChildEx03();
        // c2.viewParent();
        ChildSonEx03 c3 = new ChildSonEx03();
        c3.viewParent();
    }
}


9
//인터페이스 //최고로 추상화된 클래스
interface interA{
    public static final String str1="홍길동";
    //String str1="홍길동"; //인터페이스 에서 생략가능 
    public abstract void methodA();
    //void methodA();  //인터페이스 에서 생략가능 

interface interB{
    public static final String str2="박문수";
    public abstract void methodB();
}
class ClassA implements interA, interB{ //다중상속
    public void methodA(){
        System.out.println("methodA 호출");
    }
    // void methodA(){            //컴파일 에러 public 붙여주어야 함
    //     System.out.println("methodA 호출");
    // }
    public void methodB(){
        System.out.println("methodB 호출");
    }
}

public class MainEx08{
    public static void main(String[] args){
        ClassA a = new ClassA();
        a.methodA();
        a.methodB();
    }
}


10
//인터페이스
interface interA{
    public static final String str1="홍길동";
    public abstract void methodA();
}
interface interB extends interA{  //인터페이스 간에 상속 가능함
    public static final String str2="홍길동";
    public abstract void methodB();
}
class ClassA implements interB{ //상속된 인터페이스B를 구현함으로 A,B를 둘다 구현함
    public void methodA(){
        System.out.println("methodA 호출");
    }
    public void methodB(){
        System.out.println("methodB 호출");
    }
}

public class MainEx09{
    public static void main(String[] args){
        ClassA a = new ClassA();
        a.methodA();
        a.methodB();
    }
}


11
package com;
class StudentB {
    private String name;
    public StudentB(){
        this.name = name;
    }
}





12
import com.StudentB; //패키지를 불러오려면 public 이어야 한다
public class MainEx01{
    public static void main(String[] args){
        StudentB s = new StudentB();
        s.name = "홍길동";
        System.out.println(s.name);
    }
}


13
package com;
public class StudentB {
    public String name;
    public StudentB(){
        this.name = name;
    }
}

package com;
//import com.StudentB; //여러번 사용시
public class MainEx01{
    public static void main(String[] args){
        //StudentB s = new StudentB();
        com.StudentB s = new com.StudentB(); //한번 사용시
        s.name = "홍길동";
        System.out.println(s.name);
    }
}





14
package util;
public class MainEx01{
    public MainEx01(){ }
    public void disp(){
        System.out.println("Package로 만든 클래스");
    }
}
//import util.*; //TestEx01 클래스가 MainEx01과 같은 패키지에 있을경우에만 import됨
import util.MainEx01;
public class TestEx01{
    public static void main(String[] ar){
        MainEx01 ts = new MainEx01();
        util.MainEx01 ts1 = new util.MainEx01(); //절대 경로
        ts.disp();
        ts1.disp();
    }
}


작성자: 시간:

댓글 없음:

댓글 쓰기

피드 구독하기: 댓글 (Atom)