국비 교육 16일차

인터페이스 - 서로 다른 클래스를 연결해주는 것/ 유지보수가 쉽게 만들어줌 

결합성이 낮은 프로그램-클래스가 여러개 있어도 클라이언트와 연결할때는 인터페이스를 이용함 

 

인스턴스 변수: 클래스 저장시마다 메모리 공간이 따로 생기는 변수

메모리 주소의 데이터형은 int -> 메모리 주소는 int의 범위를 벗어나지 않음 

 

Circle   c1   =   new       Circle();

클래스 객체 = 객체 생성 생성자

 

클래스=데이터형

객체=메모리공간 

 

 

 

클래스의 구성

멤버변수 : 속성

생성자 : 클래스가 객체화될 떄 수행되는 메소드

메소드 : 기능 / 리턴형, 매개변수 잘 생각하기 

 

모든 클래스는 Object로부터 상속받음

 

 

생성자는 초기값을 줄때 사용-필요하지 않을때도 있음 / but 오라클 연동때는 필수적으로 필요함

클래스 영역은 선언만

생성자, 메소드 영역에서 각 기능 구현가능 

 

void가 붙어있으면 일반 메소드, 붙어있지 않으면 생성자

 

클래스 선언

1. 속성만 가지는 클래스 

 

객체의 선언과 생성

클래스명 객체변수 = new 클래스명();

 

멤버변수 - 클래스에서 메소드 외부에 선언된 변수

1. 객채변수

2. 클래스변수

3. 종단변수 (상수, final int a=0; / 값을 항상 줘야함)

 

[ ] 가 나오면 생략이 가능하다는 뜻

 

 

클래스 변수

static을 사용하여 선언

전역변수 (global variable의 개념)

static 변수형 변수명

-> 하나 바뀌면 다 바뀜/동시에 다 바뀌는 것

 

클래스의 일반 구조

- 클래스는 "속성+기능"으로 구성

- 클래스에는 기능을 나타내는 생성자(또는 생성자 메소드)와 메소드가 존재

 

 

자바 클래스 형변환

상속과정이 있을때만 형변환이 가능함

 

class Student /*extends Object (생략되어 있음)*/{
	private int hakbun; // 초기값 0
	private String name; // null
	private String sex; // null
	public Student (int hakbun, String name, String sex)
	{
		// 멤버변수, 지역변수 => 우선 순위 (지역변수 => 멤버변수)
		// 맴버변수 쓰고 싶으면 this. 을써서 꼭 이 클래스의 멤버변수를 사용하는걸 알려줘야함 (지역변수와 멤버변수의 변수명이 동일할때)
		// 모든 멤버메소드(인스턴스메소드에는 this가 사용된다) => 구분이 없는 경우는 this 생략이 가능
		this.hakbun=hakbun;
		this.name=name;
		this.sex=sex;
		
	}
	// 10명이면 10명이 따로 가지고 있는 정보
	
	public void print()
	{
		System.out.println("학번:"+hakbun);
		System.out.println("이름:"+name);
		System.out.println("성별:"+sex);
		System.out.println("this="+this);
		// Student.super -> Object 
		// super. 찍으면 상위클래스인 Object의 메소드를 가져올 수 있음 
		
		
		
		/*
		 * 	인스턴스가 생성시마다 => 각자 this라는 자신의 객체를 가지고 있다
		 * 	this => 컴파일시에 자동 생성 
		 * 	
		 * 	Student s =new Student()
		 * 		   === 주소
		 * 	this=s;
		 * 
		 * 	Student s1=new Studnet()
		 * 	this=s1;
		 * 
		 * 	this=>static으로 설정되어 있음 => 사용시마다 주소값이 변경
		 * 
		 * 
		 * 
		 */
		
		/*
		 *  인스턴스변수 => 초기화 
		 *  ================
		 *  1. 명시적 초기화 ====> int page=1;, totalpage=(여기다가 쓸 수 없음)
		 *  class Recipe
		 *  {
		 *  	int page=1;
		 *  	int totalpage=150000/15;
		 *  	if(1500001%15>0){
		 *  		totalpage++;
		 *  	}
		 *  2. 생성자
		 *  	public Recipe()
		 * 		{
		 * 			totalpage=150001/10;
		 * 			if(150001%15>0)
		 * 			totalpage++;
		 * 		}
		 *  3. 초기화 블럭
		 *  {
		 *  	
		 *  }
		 *  4. setTotalPage():멤버변수를 변경할 경우에 사용
		 *  5. 값 읽기 -> getXXX()
		 *  
		 *  ====변수 (메모리에 저장, 메모리에서 읽기)
		 *  			setter, getter
		 *  
		 */
	}
}
public class MainClass /*extends Object (생략되어 있음)*/{

	public static void main(String[] args) {
		
		Student s1 = new Student(1, "이제노", "남자");
		
		Student s2 = new Student(2, "황인준", "남자");
		System.out.println("s1="+s1);
//		s1.Student(1, "이제노", "남자"); //s1이 가지고 있는 멤버메소드
		s1.print();
		System.out.println("s2="+s2);
		s2.print();
		
	}

}

 

this 생성자가 왜 쓰이는지, 어떻게 쓰이는지 알아 볼 수 있는 예제

이 클래스의 멤버변수를 사용한다는 의미에서 this를 사용한다. 

 

/*
 * 	상속
 * 	상속 내리는(상위 클래스) 클래스는 하위 클래스의 모든 데이터, 메소드를 제어 할 수 없다
 * 	class A
 * 	{
 * 		int a=10;
 * 		public void display(){
 */
class Super 
{
	int a=100;
	public void display() {
		System.out.println("Super:display() Call...");
	}
}
class Sub extends Super
{
	//Super s=new Super(); // has-a (포함클래스) => 변경해서 사용할 수 없다 (있는 그대로 사용)
	/*
	 * 	int a=100;
		public void display() {
		System.out.println("Super:display() Call..."); => 여기 있는 내용을 바꿔쓰는 것 = 오버라이딩
	 */
	int a=1000;
	public void display() {
	System.out.println("Super:display() Call...");
	}
	int b=200;
	public void bbb()
	{
		System.out.println("Sub:bbb() Call...");
	}
}
class 동물
{
	public void run()
	{
		System.out.println("걷는다!!");
	}
}
class 소 extends 동물
{
	public void run()
	{
		System.out.println("소가 걷는다!!");
	}
	
}
class 돼지 extends 소
{
	public void run()
	{
		System.out.println("돼지가 걷는다!!");
	}
}
class 말 extends 돼지
{
	public void run()
	{
		System.out.println("말이 걷는다!!");
	}
}

public class MainClass4 {

	public static void main(String[] args) {
		System.out.println("===========Super============");
		Super s=new Super();
		System.out.println(s.a);
		s.display();
		System.out.println("===========Sub============");
		Sub sub=new Sub();
		System.out.println("a="+sub.a+", b="+sub.b);
		sub.bbb();
		sub.display();
		
		System.out.println("===========Super>Sub============");
		Super s1=new Sub(); //s1 => a, display만 제어 가능
		// double d=int
		s1.display();
		System.out.println(s1.a);
		// 클래스가 미완성된 클래스 (추상클래스, 인터페이스) => 메모리에 클래스를 저장 할 수 없다
		// 상위 클래스를 받아서 처리 : 상속받은 클래스가 여러개 있는 경우
		
		/*
		 * 상위 클래스로 하위 클래스를 받는 경우 
		 * class A 
		 * class B extends A
		 * 
		 * 	A a=new B();
		 *  =	=======
		 *  
		 *  1. 멤버변수는 A클래스에 있는 변수를 사용한다
		 *  2. 메소드는 생성자 타입을 따라 간다
		 */
		
		동물 ani = new 소();
		ani.run();
		ani=new 말();
		ani.run();
		ani=new 돼지();
		ani.run();
		
		// 데이터가 여러개 있다 => 배열 (배열명으로 모든 데이터를 제어)
		// 다른 종류의 클래스가 여러개 있다 (상속을 받아서 상위클래스로 제어)
		/*
		 * 	Sub sub=new Sub();
		 * 	Super sup=new Sub();
		 * 	Object obj=new Sub();
		 * 
		 */
		Object obj=new Sub();
		// 상위클래스 제어 => 오버라이딩 메소드 
		
		// Sub bb = new Super(); 사용 금지
		Sub ss=new Sub();
		Super sup=new Super();
		//ss=sup; 불가능
		sup=ss; // 가능
		/*
		 * 	생성자에 따라 호출되는 메소드가 달라진다
		 * 	===========================
		 * 	동적 바인딩
		 *  C언어 : 정적바인딩 => 가상함수 : 실행시마다 메소드의 주소를 변경, 변경된 주소를 저장
		 *  
		 *  
		 */
		
	}

}

 

상속에 대한 내용도 배웠다

상속을 받으면 상위클래스에 있는 기능들을 사용할 수 있고, 하위클래스에서는 다른 기능들을 추가할 수 있다. 

상위클래스의 크기가 더 크기 때문에 하위 클래스에 상위클래스를 대입하는 것은 금지되어 있다. 

 

// method => 한개의 클래스 안에서 같은 이름의 메소드를 사용할 수 있다
// => 중복메소드 정의 => 여러개의 기능을 만든다 (오버로딩)
/*
 * 	조건
 * 	 매개변수의 데이터형, 갯수가 다르다
 * 	 리턴형은 관계없다
 * 	 메소드명이 동일 
 */
public class MainClass2 {
	public void plus(int a, int b)
	{
		System.out.println("정수 계산");
		System.out.println(a+b);
	}
	public double plus(double d1, double d2)
	{
		System.out.println("실수 계산");
		return d1+d2;
	}
	public int plus(char c1, char c2)
	{
		System.out.println("문자 계산");
		return c1+c2;
	}
	public String plus(String s1, String s2)
	{
		System.out.println("문자열 계산");
		return s1+s2;
	}
	
	public static void main(String[] args) {
		
		MainClass2 m=new MainClass2();
		m.plus(10, 20);
		m.plus('A', 66);
		m.plus(10.5F, 'A'); //double 호출
		
	}

}

같은 이름의 메소드이지만 데이터형이나 변수의 갯수가 다르면 계속해서 만들어 낼 수 있다. 

-> 오버로딩이라고 부름 

 

package com.sist.main;
import com.sist.recipe.*; // 폴더 다를때는 import로 가지고 와야함
/*
 * 	자바 소스 구조
 * 	1. package명 ===> 1개만 사용 가능
 * 	2. 필요한 라이브러리 import ==> 여러개 사용이 가능
 * 		패키지에 있는 클래스를 읽어 올때
 * 		import com.sist.main.*;
 * 	3. class className{
 * 		====================
 * 		변수 설정(인스턴스변수, 클래스변수)
 * 		====================
 * 		생성자
 * 		====================
 * 		기능(메소드)
 * 		====================
 * 		main method()
 * 		{
 * 		}
 * 		====================
 * }
 */
public class MainClass {

	public static void main(String[] args) {
	
		RecipeManager rm=new RecipeManager();
		int no=rm.main_menu();
		String data=rm.sub_menu(no);
		System.out.println(data);
	}

}

 

자바소스의 구조