java 입문반 4주차

카테고리 없음

java 입문반 4주차

수혀이0812 2024. 11. 29. 10:11

728x90

(월요일)

# String 값 변환에 따른 주소 변환

package thisisjava;

public class str03 {

	public static void main(String[] args) {
		String s1 = "KR";
		s1 = null;
		s1 = "EN";
		s1 = "CH";
		
	}
}

# String 메서드

package thisisjava;

public class str04 {

	public static void main(String[] args) {
		String s1 = "Welcome to Korea";
		
		System.out.println(s1.length());
		System.out.println(s1.charAt(0));
		System.out.println(s1.charAt(5));
		System.out.println(s1.charAt(7) + ", ");
//		System.out.println(s1.charAt(-1)); -1은 파이썬에서만!
		
		System.out.println(s1.replace("K", "C"));
		System.out.println(s1.replace("Korea", "한국"));
		System.out.println(s1.replace("e", "2"));
		
		System.out.println(s1.substring(0, 8));
		System.out.println(s1.substring(3, 14));
		
		System.out.println(s1.indexOf("c")); // c의 위치
		System.out.println(
				s1.substring(
						s1.indexOf("c"), s1.indexOf("r") + 1)); // 두가지 메서드를 혼합하여 간단하게 추출가능
		
		String s2 = "사과,배,바나나,수박";
		String[] sArr = s2.split(",");
		for(int i = 0; i < sArr.length; i++) {
			System.out.println(sArr[i]);
		}
		
		System.out.println();
		
	}
}

# 이중 for문

package thisisjava;

public class arr07 {

	public static void main(String[] args) {
		int[][] iArr01 = {{1, 2, 3}, 
						  {4, 5, 6}, 
						  {7, 8, 9}};
		
		System.out.println(iArr01.length); // 3행
		System.out.println(iArr01[0].length); // 1행의 요소의 개수
		
		System.out.println(iArr01[0][0]);
		
		// 3, 4, 8
		System.out.println(iArr01[0][2]);
		System.out.println(iArr01[1][0]);
		System.out.println(iArr01[2][1]);
		
		System.out.println();
		
		// 1 2 3 / 4 5 6 / 7 8 9 출력하기 
		for(int i = 0; i < iArr01.length; i++) {
			for(int j = 0; j < iArr01[i].length; j++) {
				System.out.print(iArr01[i][j] + " ");
			}
			System.out.println();
		}
	}
}

# string 배열의 복사 : 얕은 복사(shallow copy)

package thisisjava;

public class arr11 {

	public static void main(String[] args) {
		int i1 = 11, i2 = 0;
		int[] iArr01 = {10, 20, 30, 40};
		int[] iArr02 = new int[4];
		
		i2 = i1; i2 = 22;
		System.out.println(i1 + ", " + i2);
		iArr02 = iArr01;
		iArr01[3] = 400;
		
		// ---> 10 20 30 40
		for(int i : iArr02) {
			System.out.print(i + " ");
		}
		
	}
}

# class 기초

package thisisjava;

/*
 class
 - 필드(속성), 메서드, 생성자로 이루어져 있다
 - 값과 참조 타입이 혼합되어 있다
 - 값은 0, 참조는 null이 들어있고 나중에 값이 들어가고 참조된다
 - 붕어빵 틀에 붕어를 찍어내듯 같은 형식의 여러 데이터를 담아낼 수 있다
 */

class Book00 {
	String title; 	// 책명
	String author; 	// 저자
	int price; 		// 가격
	
	// 멤버 메소드
	// 반환Type 이름(입력 Type 입력) {처리; return 반환값;}
	// void : 반환값 없음
	void pBook() {
		System.out.println(title + ", " + author + ", " + price);
	}
}

public class Cla00 {
	public static void main(String[] args) {
		Book00 b1 = new Book00();
		b1.title = "자바"; b1.author = "홍길동"; b1.price = 30000;	
		b1.pBook();
//		System.out.println(b1.title + ", " + b1.author + ", " + b1.price);
		
		
		Book00 b2 = new Book00();
		b2.title = "소공"; b2.author = "김은비"; b2.price = 40000;
		b2.pBook();
//		System.out.println(b2.title + ", " + b2.author + ", " + b2.price);
	}
}

# 클래스 구성 3가지(필드, 생성자, 메서드)

package thisisjava;

public class Book01 {
	// 멤버 필드
	String title;
	String author;
	int price;
	
	// 멤버 생성자(없더라도 은닉되어 있음)
	Book01(String t, String a, int p){
		this.title = t;
		this.author = a;
		this.price = p;
	}
	
	// 멤버 메서드
	void pBook() {
		System.out.println(title + ", " + author + ", " + price);
	}
	
}

# 생성자 메서드 오버로딩

package thisisjava;

class Book03{
	String title; String author; int price;
	// 강사님은 초기값으로 무제/작자미상/0 넣어주심
	
	// 생성자 오버로딩
	Book03(String title, String author, int price) {
		this.title = title;
		this.author = author;
		this.price = price;
	}
	
	Book03(String title, String author) {
		this(title, author, 0);
//		this.title = title;
//		this.author = author;
//		this.price = 0;
	}
	
	Book03(String title) {
		this(title, "작자미상", 0);
//		this.title = title;
//		this.author = "작자미상";
//		this.price = 0;
	}
	
	Book03() {
		this("무제", "작자미상", 0);
//		this.title = "무제";
//		this.author = "작자미상";
//		this.price = 0;
	}
	
	void pBook() {
		System.out.println(this.title + "," + 
						   this.author + "," + this.price);
	}
}

public class Cla03 {

	public static void main(String[] args) {
		Book03 b1 = new Book03("APT", "로제", 10000);
		b1.pBook(); // APT, 로제, 10000;
		Book03 b2 = new Book03("APT", "Tom");
		b2.pBook(); // 자바, Tom, 0
		Book03 b3 = new Book03("기사");
		b3.pBook(); // 기사, 작자미상, 0
		Book03 b4 = new Book03();
		b4.pBook(); // 무제, 작자미상, 0
	}
}

/*
생성자 체이닝 :
- 현업에서 생성자 체이닝은 중복 코드 제거, 유지 보수성 향상, 코드 일관성 확보 등의 이유로 많이 사용되는 기법
- 객체의 초기화 방식을 단순하고 명확하게 유지하는 데 큰 도움이 되므로 
- 초기화의 일관성을 유지하고 중복을 줄이는 방향으로 설계할 때 유용하게 사용
*/

(화요일)

# 객체(Object)

- 물리적으로 존재하거나 개념적인 것 중에서 다른 것과 식별 가능한 것

- 속성과 동작으로 구성, 자바는 이러한 속성과 동작을 각각 필드와 메소드라고 부름

- 실제 존재하는 데이터 하나하나를 인스턴스!

# 객체 지향 프로그래밍(OOP)

- 객체들을먼저 만들고, 이 객체들을하나씩 조립해서 완성된 프로그램을 만드는 기법

# 메서드 오버로딩

package thisisjava;

class Meth06 {
	int Sum(int x, int y) {
		int res = x + y;
		return res;
	}
	
	String Sum(String x, String y) {
		String res = x + y;
		return res;
	}
	
	String Sum(String x, int y, int z) {
		String res2 = x + "결과 : " + Sum(y, z); 
		return res2;
	}	
}

public class Cla06 {
	public static void main(String[] args) {
		Meth06 m1 = new Meth06();
		System.out.println(m1.Sum(20, 10));	
		System.out.println(m1.Sum("대한", "민국"));
		System.out.println(m1.Sum("덧셈", 30, 4));
	}
}

# 가변길이 매개변수 & 오버로딩

package thisisjava;

import java.util.List;

class Meth07 {
	//  배열 매개변수를사용하면 입력받을 때 배열만 허용하기에 여러가지 데이터 타입을 사용할 수는 없다
	int Sum00(int[] iArray) {
		int ans = 0;
		for(int i : iArray) {
			ans += i;
		}
		return ans;
	}
	
	int Sum01(int ... iArray) {
		int ans = 0;
		for(int i : iArray) {
			ans += i;
		}
		return ans;
	}
	
	String Sum01(String ... sArray) {
		String ans2 = "";
		for(String s : sArray) {
			ans2 += s;
		}
		return ans2;
 	}
	
	String Sum00(List<String> string) {
		StringBuilder ans = new StringBuilder();
		for(String s : string) {
			ans.append(s);
		}
		return ans.toString();
	}
}

public class Cla07 {

	public static void main(String[] args) {
		Meth07 m1 = new Meth07(); int res = 0;
		int[] iArr01 = {20, 10, 40};
		res = m1.Sum00(iArr01);
		System.out.println(res);
		res = m1.Sum00(new int[] {20, 10, 5});
		System.out.println(res);
		res = m1.Sum00(new int[] {20, 10, 5, 3});
		System.out.println(res);
		res = m1.Sum00(new int[] {20, 10, 5, 3, 2});
		System.out.println(res);
		
		res = m1.Sum01(20, 10);
		System.out.println(res);
		res = m1.Sum01(20, 10, 5);
		System.out.println(res);
		res = m1.Sum01(20, 10, 5, 3);
		System.out.println(res);
		res = m1.Sum01(20, 10, 5, 3, 2);
		System.out.println(res);
		
		String s;
		s = m1.Sum01("서초", "여성", "인력");
		System.out.println(s);
		s = m1.Sum01("개발", "센터");
		System.out.println(s);
	}
}

# staic 사용

package thisisjava;

class Meth08 {
	static int iMoney; // static이 붙으면 메소드 영역에 static이 생기고 힙 영역에는 만들어지지 않는다
	void setMoney(int i, int o) {
		iMoney = iMoney + i - o;
	}
	void getMoney() { System.out.println(iMoney); }
}

public class Cla08 {
	public static void main(String[] args) {
		Meth08 m = new Meth08();
		Meth08 w = new Meth08();
		
		m.setMoney(20000, 13000); m.getMoney();
		w.setMoney(30000, 10000); w.getMoney();
		
	}
}

# static 사용 2

package thisisjava;

class Meth09 {
	// instance형 method
	void Sum(int x, int y) {
		System.out.println(x + y);
	}
	
	// static 형 method : 공간을 늘릴 필요가 없어서 메모리 사용량을 아낄 수 있다!
	static void Sub(int x, int y) {
		System.out.println(x - y);
	}
}

public class Cla09 {
	public static void main(String[] args) {
		int a = 20, b = 10;
		// instance 생성 후, instance.멤버를 사용하여야 한다
		Meth09 m1 = new Meth09(); m1.Sum(20, 10);
		Meth09 m2 = new Meth09(); m2.Sum(20, 10);
		
		// class명.멤버로 사용하여야 한다
		Meth09.Sub(20, 10);
	}
}

# static 사용 3

- 사칙연산 메소드를 static으로 사용하면 좋은 이유!!

package thisisjava;

class Meth10 {
	static int Sum(int x, int y) {
		return x + y;
	}
	
	static void Sub(int x, int y) {
		System.out.println(x - y);
	}
	
	static int Mul(int x, int y) {
		return x * y;
	}
	
	static void Div(int x, int y) {
		System.out.println(x / y);
	}
}

public class Cla10 {
	public static void main(String[] args) {
		int a = 20, b = 10;
		System.out.println(Meth10.Sum(a, b));
		Meth10.Sub(a, b);
		System.out.println(Meth10.Mul(a, b));		
		Meth10.Div(a, b);
	}
}

# static 사용 4

package thisisjava;

class Meth13 {

	static int cnt0 = 0;
	int cnt3 = 0;
	void count01(int cnt1) {
		cnt0++; cnt1++; cnt3++;
		System.out.printf("%d, %d, %d\n", cnt0, cnt1, cnt3);
	}
	
	void count02(int cnt2) {
		cnt0++; cnt2++; cnt3++;
		System.out.printf("%d, %d, %d\n", cnt0, cnt2, cnt3);
	}
}

public class Cla13 {

	public static void main(String[] args) {
		Meth13 m1 = new Meth13(); m1.count01(10); // 1, 11, 1 
		Meth13 m2 = new Meth13(); m2.count02(20); // 2, 21, 1
	}
}

(수요일)

# static / instance / local 변수 비교하기

package thisisjava;

class Meth14 {
	static int staticCnt = 0;
	int instanceCnt = 0;
	void Count() {
		int localCnt = 0;
		staticCnt++; instanceCnt++; localCnt++;
		System.out.printf("%d, %d, %d\n",staticCnt, instanceCnt, localCnt);
	}
}

public class Cla14 {	
	public static void main(String[] args) {
		Meth14 m1 = new Meth14(); 
		m1.Count(); // 1, 1, 1
		m1.Count(); // 2, 2, 1
		m1.Count(); //a3, 3, 1
		
		Meth14 m2 = new Meth14(); 
		m2.Count(); // 4, 1, 1
		m2.Count(); // 5, 2, 1
		m2.Count(); // 6, 3, 1
	}
}

static : 모두의 공용 공간에 존재!! 항상 값이 바뀐다

instance : 내가 같은 객체를 호출할때마다 값이 바뀐다

local : method가 실행할때마다 값이 생기고 없어진다!!

# private를 사용하여 getter, setter 메서드를 우회적으로 사용했을때..

package thisisjava;

class Book16{
	// 필드명이 그대로 노출되는것이 좋지 않아서 private로 처리를 많이 하는데
	// 그때 getter, setter 메서드를 만듦으로써 우회적으로 메서드를 사용하여 만드는것이 좋다
	private String title = "무제"; 
	private String author = "미상";
	
	public String getTitle() { return this.title; }
	public void setTitle(String title) { this.title = title; }
}

public class Cla16 {
	public static void main(String[] args) {
		Book16 b1 = new Book16();
		b1.setTitle("Java"); 
		System.out.println(b1.getTitle());
		
	}
}

# Class의 활용

package thisisjava;

class Point17 {
    int x, y;
    
    Point17() { }; 
    
    Point17(int i, int j) {
        this.x = i;
        this.y = j;
        System.out.println(this.x + ", " + this.y);
    }
    
    void Sum(Point17 p1, Point17 p2) {
        this.x = p1.x + p2.x;
        this.y = p1.y + p2.y;
        System.out.println(this.x + ", " + this.y);
    }
    
    // 강사님 코드
    static Point17 pSum(Point17 i, Point17 j) {
    	int a = i.x + j.x;
    	int b = i.y + j.y;
    	return new Point17(a, b);
    }
    
    // 직사각형 넓이 구하기
    static int pRect(Point17 i, Point17 j) {
//    	int height;
//    	int width;
//    	if(i.x >= j.x) {
//    		width = i.x - j.x;
//    	} else width = j.x - i.x;
//    	
//    	if(j.y >= i.y) {
//    		height = j.y - i.y;
//    	} else height = j.y - i.y;
    	int height = Math.abs(i.x - j.x);
    	int width = Math.abs(i.y - j.y);
    	int res = height * width;
    	return res;
    	
    }
}

public class Cla17 {
    public static void main(String[] args) {
        Point17 p1 = new Point17(20, 10); 
        Point17 p2 = new Point17(35, 25); 
        Point17 p3 = new Point17();
        p3.Sum(p1, p2);      // 55, 35
        
        // 강사님 코드
//        Point17 p4 = Point17.pSum(p1, p2);
        System.out.println(p3.pRect(p1, p2));
    }
}

# 싱글톤 패턴

생성자를 private 접근 제한해서 외부에서 new 연산자로 생성자를 호출할 수 없도록 막아서 외부에서 마음대로 객체를 생성하지 못하게 함
대신 싱글톤 패턴이 제공하는 정적 메소드를 통해 간접적으로 객체를 얻을 수 있음
싱글톤 : 클래스의 인스턴스를 딱 하나만 생성하도록 보

package thisisjava;

class Sing18 {
	// 딱 한번만 실행되어야 하는 애들한테 강제로 하게 한다!! 
    // Sing18 클래스는 자기 자신의 객체를 클래스 내부에서 단 한 번 생성합니다.
	private static Sing18 sing = new Sing18();
    // 생성자를 private으로 선언하여 외부에서 객체를 생성할 수 없도록 제한합니다.
	private Sing18() {}
	
	static Sing18 getInstnace() {
		return sing;
	}
}

public class Cla18 {
	public static void main(String[] args) {
		Sing18 s1 = Sing18.getInstnace();
		Sing18 s2 = Sing18.getInstnace();
		
		System.out.println(s1 == s2);
	}
}

# 상속 (& 메소드 오버라이딩)

package thisisjava;

class Ani20 {
	String name = "이름";
	void cry() { System.out.println("으앙"); }	
}

class Dog20 extends Ani20 {
	String name = "해피";
	@Override
	void cry() { System.out.println("멍멍"); } // Method Overriding
}

class Cat20 extends Ani20 {
	String name = "아치";
	@Override
	void cry() { System.out.println("야옹"); 	}
}

class Duck20 extends Ani20 { 
	String name = "도트";
	@Override
	void cry() { System.out.println("꽤꽥"); 	}
}

public class Cla20 {
	public static void main(String args[]) {
		Dog20 d1 = new Dog20();
		System.out.print(d1.name); d1.cry();
		
		Cat20 c1 = new Cat20();
		System.out.print(c1.name); c1.cry();
		
		Duck20 d2 = new Duck20();
		System.out.print(d2.name); d2.cry();
	}
}

# 상속 ( & final & Override)

package thisisjava;

class Vehicle22{
	static final int a = 1;
	void start() {System.out.println("출발");}
	void move() {System.out.println("이동");}
	void stop()  {System.out.println("멈춤");}
}
class Car22 extends Vehicle22{
	// final이 붙은 경우 오버라이딩 불가능 
//	@Override
//	int a = 2;
	
	// final + 변수 -> 상수같은 느낌
	static final int Normal = 1;
	static final int Accel = 2;
	static final int Slow = 3;
	
	int moveMode = Normal;
	
	void move() {
		if (moveMode == Normal) { super.move(); }
		else if (moveMode == Accel) 
			{System.out.println("빠른 이동");}
		else {System.out.println("천천히 이동");}
	}
}
public class Cla22 {
	public static void main(String[] args) {
		Car22 c1 = new Car22();
		c1.start();
		c1.move();
		c1.moveMode = Car22.Accel;
		c1.move();
		c1.moveMode = Car22.Slow;
		c1.move();
		c1.stop();
	}

}

# 참조형 형변환

- 부모 보다 자식에 더 많은 데이터가 들어있다!!

- 값을 찾을 수 없어서 마지막 4번은 틀린거임

package thisisjava;

class A25 { int a = 200; }
class B25 extends A25{ int b = 100; }


public class Cla25 {
	public static void main(String[] args) {
		// 참조형 형변환
		A25 z1 = new A25();
		B25 z2 = new B25();
		A25 z3 = new B25();
		// B25 z4 = new A25(); 문법적인 에러는 아니지만 메모리적인 에러
		
		short s1 = 10;
		int i1 = s1;
		int i2 = 20;
		short s2 = (short) i2;
	}
}

(목요일)

# 상속

package thisisjava;

class A26 {}
class B26 extends A26 {}
class C26 extends A26 {}
class D26 extends B26 {}
class E26 extends C26 {}

public class Cla26 {

	public static void main(String[] args) {
		B26 b = new B26();
		C26 c = new C26();
		D26 d = new D26();
		E26 e = new E26();
		
		A26 a1 = b; A26 a2 = c;
		A26 a3 = d; A26 a4 = e;
		
		B26 b1 = d; C26 c1 = e;
//		B26 b3 = e; C26 c3 = d;  -> 직계가 아니면 형변환 불가
		
		System.out.println(d instanceof B26);
		System.out.println(d instanceof A26);
		System.out.println(b instanceof D26); // false 
		
		System.out.println(e instanceof C26);
		System.out.println(e instanceof A26);
	}

}

# 다중 상속(인터페이스는 가능)

- 불가능한 이유 : 필드랑 메서드를 아무리 안 만든다고 하더라도 근본적으로 object에 상속을 받기 때문에 없다고 느껴도 실질적으로 equals()나 toString()같은 메서드가 포함되어 있기 때문에 다중 상속이 불가하다

- Java는 클래스 간의 다중 상속을 허용하지 않습니다. 그 이유는 다중 상속이 허용될 경우, 두 부모 클래스에서 같은 이름의 메서드나 필드가 정의되었을 때 어떤 것을 사용할지 결정하는 과정에서 혼란스러워질 수 있기 때문입니다(다이아몬드 문제). 또한, Java의 모든 클래스는 기본적으로 Object를 상속받기 때문에, 다중 상속이 허용되면 상속 관계가 지나치게 복잡해지고 충돌 가능성이 높아집니다. 이러한 이유로 Java는 클래스 간의 다중 상속을 금지하고, 대신 인터페이스를 통해 다중 구현을 지원합니다.

- interface는 가능한 이유 : 상태(필드)가 없고 동작(행위)만 정의하기 때문에 다중 구현이 안전합니다.

package thisisjava;


//class A27{}
//class B27{}
//class C27 extends A27,B27 { }

interface A27{ }
interface B27{ }
class C27 implements A27, B27{ }

public class Cla27 {

	public static void main(String[] args) {
		System.out.println("잘 실행됨");
	}
}

본질적으로 같은걸 상속받으면 extends 다르면 implements abstract class -> interface(implements)이다!!

# 접근제한자

(public / protected / (default) / private)

package thisisjava;

class A28 {
	
	int aa1 = 10;				// default (같은 패키지) / 숨겨져 있다 / 공개 범위 3등
	public int aa2 = 100; 		// public (항상 공개) / 공개 범위 1등
	private int aa3 = 1000;		// private(자기 클래스) / 공개 범위 꼴등
	protected int aa4 = 10000;	// protected (상속관계 내 + default) / 공개 범위 2등
}

class B28 extends A28 {
	int bb1 = 20;
}

public class Cla28 {
	public static void main(String[] args) {
		A28 a = new A28(); 
		B28 b = new B28(); 
	}
}

# 상속에서의 접근 범위

- 부모에서 상속받은 멤버는 접근 범위가 작아질 수 없다

- 오버라이딩된 메서드는 부모 클래스의 메서드를 **대체(replace)**하는 역할을 합니다. 따라서 부모 클래스 타입으로 자식 객체를 참조할 때도, 오버라이딩된 메서드에 동일한 접근 수준으로 접근 가능해야 합니다.

package thisisjava;

class A29 {
	void meth01() {}
}

class B29 extends A29 {
	// 부모한테서 상속받은 멤버는 접근범위가 작아질 수 없다
//	@Override
//	private void meth01() {}
}

public class Cla29 {

	public static void main(String[] args) {

	}

}

# 추상 클래스의 활용

- 상속 관계를 유지하면서 다형성을 이용하고자 할때

- 부모는 구현부가 필요하므로

- abstract를 붙여서 추상클래스로 만들면 된다

package ch07.sec08.exam02;

public abstract class Vehicle {
	//메소드 선언
	public abstract void run(); 
}

# main 메서드가 있는 클래스에서 다른 메서드를 static으로 지정하는 것이 권장되는 이유

1. static 메서드와 non-static 메서드 혼용의 문제

main() 메서드는 static 메서드입니다. main() 메서드 내부에서 static 메서드와 non-static 메서드가 혼용되면 가독성이 떨어질 수 있습니다.
예를 들어, test02()를 호출하기 위해 객체를 생성해야 하는 반면, test01()은 객체 없이 호출됩니다.
개발자가 코드를 읽을 때 이러한 혼용은 혼란을 초래할 수 있습니다.

2. 객체 생성 오버헤드

non-static 메서드를 사용하기 위해 객체를 생성해야 하므로, 불필요한 메모리 사용과 처리 비용이 발생할 수 있습니다.
만약 메서드가 인스턴스 상태를 참조하지 않는다면, static으로 선언하여 객체 생성을 피할 수 있습니다.

3. 코드의 일관성 유지

main() 메서드가 속한 클래스에서 모든 메서드를 static으로 선언하면, 객체 생성 없이 클래스 이름으로 모든 메서드 호출이 가능합니다.
이렇게 하면 일관성 있는 코드 스타일을 유지할 수 있습니다.

4. 유지보수성

정적 메서드는 상태를 공유하기 때문에 코드의 흐름을 예측하기 쉽습니다.
비정적 메서드가 혼재되면 객체 생성과 관리를 따로 추적해야 하므로 유지보수가 어려워질 수 있습니다.

package thisisjava;

class Cla31 {
	public static void main(String[] args) {
		System.out.println("Cla30-main() 실행");		
	}
	
	static void test01() {
		System.out.println("Cla31-test01() 실행");
	}
	
	void test02() {
		System.out.println("Cla31-test02() 실행");
	}
}

public class Cla30 {

	public static void main(String[] args) {
		System.out.println("Cla30-main() 실행");
		Cla31.test01();
		Cla30.test01();
		test01();
		
		Cla31 c31 = new Cla31();
		c31.test02();
		
		// 권장하지 않는 이유 : main 메서드가 있는 곳에서는 main 메서드를 제외하고 다른 메서드 또한 static을 붙여주는것이 좋다고 권장 (안되는건 아님)
		Cla30 c30 = new Cla30();
		c30.test02();
		
	}
	static void test01() { System.out.println("Cla30-test01() 실행"); }
	void test02() {
		System.out.println("Cla31-test02() 실행");
	}
}

# 봉인된 클래스

- sealed ~ permits : 상속을 허락하는 클래스를 제한할 수 있다

- nonsealed : 누가 상속하든 상관 x

- final : 상속하지 x

package ch07.sec11;

// Person 클래스는 Employee와 Manager에게만 상속을 허락한다
public sealed class Person permits Employee, Manager {
	//필드
	public String name;
	
	//메소드
	public void work() {
		System.out.println("하는 일이 결정되지 않았습니다.");
	}
}


// non-sealed는 누가 상속하든지 상관 없다!
public non-sealed class Manager extends Person {
	@Override
	public void work() {
		System.out.println("생산 관리를 합니다.");
	}
}


// final은 Employee이후 클래슨 더 이상 상속 해주지 않음
public final class Employee extends Person {
	@Override
	public void work() {
		System.out.println("제품을 생산합니다.");
	}
}

# interface 사용!!

- 구현은 필요없고 정의만 하는 경우 interface 사용

- class가 interface를 사용하여 구현할 때는 extends -> implements로 변경

- 인터페이스의 모든 메서드는 기본적으로 public abstract이므로 interface에서 상속받아서 사용할 때는 접근제한자를 public 보다 같거나 큰 범위인 public 설정 필수

package thisisjava;

// 굳이 쓰지도 않은 구현체가 있을때 interface를 사용!!
interface TV{
	void PowerOn();
	void PowerOff();
}

class LGTV implements TV{
	// 부모 멤버의 접근 제한자보다 범위가 커야해서 public이 필수임
	public void PowerOn() {
		System.out.println("LGTV 켜짐");
	}
	public void PowerOff() {
		System.out.println("LGTV 꺼짐");
	}
}

class SSTV implements TV{
	public void PowerOn() {
		System.out.println("SSTV 켜짐");
	}
	public void PowerOff() {
		System.out.println("SSTV 꺼짐");
	}
}

class KTTV implements TV{
	public void PowerOn() {
		System.out.println("KTTV 켜짐");
	}
	public void PowerOff() {
		System.out.println("KTTV 꺼짐");
	}
}

public class Cla32 {
	public static void main(String[] args) {
		TV[] tvs = { new LGTV(), new SSTV(), new KTTV() };
		for(TV tv : tvs) {
			tv.PowerOn();
			tv.PowerOff();
		}
	}
}

728x90

저작자표시