자료구조 1

레퍼런스 타입

• 오브젝트
  • 메모리에 안 올라옴
• New
  • 메모리에 올라옴
  • 인스턴스화

 

레퍼런스 변수 

• 그냥 이름이 홍길동이라면 진짜 사람 홍길동 대상을 접근하는 것

 

배열

• 동일한 데이터 타입을 순차적으로 확보한 것
• C언어 :
  • 일반적으로 메모리 할당
  • 1차원 배열로 저장됨 
  • 그냥 표현을 2차원, 다 차원으로 할 뿐
  • <그림>
• JAVA 
  • int [ ] [ ] arr = new int [2][3];
  • 레퍼런스와 1:1관계
  • <그림>

 

Class 구성원

• 필드
• 생성자
  1. 객체 생성
     • 객체 등록 new
  2. 필드 초기화
     • 객체가 생성되는 시점에
     • 쓰레기값 방지
     • java는 디폴트 값 0임
• 메소드
  • 쓰는 목적
    • 외부와 내부 연결 시켜줌
    • 데이터를 사용 할 수 있게 해줌
    • 캡슐화 메소드를 통해서 함 
  • 인스턴스
    • 각 하나씩 있음
    • new
    • 데이터를 안정적으로 쓰려고
    • 레퍼런스._____
    • this ( O ) 
      • this : 자기자신을 구별하는 키워드
      • 인스턴스 메소드의 첫번째 메소드
      • 무조건 있음 (선언 안 해도)
        • void setXXX ( A this ,,,,)
      • 객체 구별 할 수 있다.
        • 누구의 Set/Get인지
  • static 
    • 미리 만들어진 메모리
    • 공유하는 목적
    • 안 쓰면 안 사라짐
    • 메모리 절약할 수 있음 (공유하면서)
    • 클래스.______
    • this ( X )
      • 객체 구별 X
        • 필드 값 없음
    • 메모리 접근 X
  • final
    • 절대 안 바뀜

 

this 

• this의 목적
  1. 객체 구별
     1. 지벽변수, 필드 변수
  2. 메소드 내 자신을 리턴
     1. return this 
     2. toString
• this( )
  • 생성자 호출
  • 내 자신의 오버로딩된 함수에 있는 생성자
  • 내 클래스 내에 오버로딩 된거 부를 때
  • 또 다른 생성자 부름 (필드 초기화)

 

 

접근 제어자 

• private
• defalut
• protected
• public

 

 

this( )

• 코드의 가독성이 좋아짐

package pratice;

public class First {
	private int A;
	private int B;
	public First() {
//		A = B = 0;
		this(0,0);
	}
	public First(int a) {
//		this.A = a;
//		B = 0;
		this(a,0);
	}

	public First(int a, int b) {
		this.A = a;
		this.B = b;
	}
	public int getB() {
		return B;
	}

	public int getA() {
		return A;
	}


	public static void main(String[] args) {
		First aa  = new First();
		First bb  = new First(10);
		First cc  = new First(20,3);
		
		System.out.println(aa.getA()+ "\t" + aa.getB());	// 0,0
		System.out.println(bb.getA()+ "\t" + bb.getB());	// 10,0
		System.out.println(cc.getA()+ "\t" + cc.getB());	// 20,3
		
		
	}
}

 

 

static 메소드

• 인스턴스 필드 값
  • 구별 못 함 -> 구별하지 못 해서 ( this )
  • 메모리 접근하지 못 함 : 인스턴스 객체 만들어지지 못 해서 
• 구별을 하지 않아도 되는 거 씀 -> static 필드

인스턴스 메소드

 

 

추상 클래스 

1. 오직 상속을 목적으로 사용
2. 추상 클래스를 상속 받는 sub class는 무조건 추상 메소드를 오버라이드 해야만 한다. 
   • 하지 않은 경우 추상 클래스화 돼서 객체를 생성할 수 없다. 
3. 추상 메소드는 강제성을 발휘하기 때문에 꼭 오버라이드를 해야만 한다. 
4. 추상 클래스 보다 더 추상화 된 것은 interface이다. 
5. 추상 메소드 , 상수를 갖는게 원칙.
6. 인터 페이스는 다중 상속을 허용한다. ( 모호성이 발생하지 않는다. )
   • 기능이 없음 -> 클래스에서 정함
7. 다중 상속을 대체하기 위해 만들어졌다. 
   1. 스레드가 된다. 

 

인터페이스

• 다중 상속 허용
• 여러개 쓸 수 있다. 

interface ss{
	//	상수, 추상 메소드
    /*(final static) 생략*/int num = 100;	//	상수

	void disp();	//	추상 메소드
    abstract vodi disp();
}

두가지 경우가 있다.

1.

class second implements ss{

	@Override
	public void disp() {
		// TODO Auto-generated method stub
		
	}
	
}

2.

abstract class second implements ss{
	
}

 

• 클래스 - 인터페이스 : implement

 

동적 바인딩

• 부모의 레퍼런스로 자식을 접근하는 방식
• 서브 클래스가 생겨도 h.disp( )로 접근
• 접근하기 쉽다. 
• 코드의 가독성 높임

package Cource;
class Halbe{
	public void disp() {
		System.out.println("halbe");
	}
}
class Abe extends Halbe{
	public void disp() {
		System.out.println("abe");
	}
}
class Me extends Abe{
	public void disp() {
		System.out.println("me");
	}
}
class second{
	public static void main(String [] args) {
		Halbe halbe = new Halbe();
		Abe abe = new Abe();
		Me me = new Me();
		
		Halbe h;
		
		
		h = halbe;
		h.disp();
		
		h = abe;	//	원래 안 되야함. 
		h.disp();
		
		h = me;
		h.disp();
		
		halbe.disp();
		me.disp();
		abe.disp();
		
		
	}
}