반응형
test2.zip
0.01MB
어제의 예제폴더다 풀이존재
2025.02.11 - [AWS활용 자바 부트캠프] - AWS활용 자바 부트캠프자바/스프링 개발 부트캠프 8일차
AWS활용 자바 부트캠프자바/스프링 개발 부트캠프 8일차
어제 상속 , 생성자 부분 문제 하나만 풀고 시작= * 원(Circle) 클래스 구현하기 * 1. 멤버변수 * 반지름(r),x좌표(x),y좌표(y), 원의번호(no) * 원의번호 생성 변수 count
ddkk1120.tistory.com
어제 좀 어려웠다던 Buyer클래스 부분의 답이다
위의 링크를 가서 전체 코드를 보고 뭐가달라졌는지 알아보자
( 난 배열을 이용해 풀었지만 이거는 간단하게 String을 이용함 )
class Buyer1 {
int money=10000,point,cnt;
Food[] cart = new Food[30];
void buy(Food f) {
if(money < f.price) {
System.out.println(f + "구매시 잔액부족");
return;
}
money -= f.price;
point += f.point;
System.out.println(f + "를(을) " + f.price + "가격에 구입");
if(f instanceof Fruit) {
Fruit fr = (Fruit)f; //자식참조변수 <= 부모참조변수 { 형변환연산자 생략불가 }
System.out.println(fr.brix + "당도 상품 구매");
}
if(f instanceof Drink) {
Drink dr = (Drink)f;
System.out.println(dr.ml + "ml 상품 구매");
}
if(f instanceof Snack) {
Snack sn = (Snack)f;
System.out.println(sn.gram + "g 상품 구매");
}
cart[cnt++] = f;
}
void summary() {
int total=0,ftot=0,dtot=0,stot=0;
int fcnt=0,dcnt=0,scnt=0;
String list="",flist="",dlist="",slist="";
for(int i=0;i<cnt;i++) {
total += cart[i].price;
list += cart[i] + ",";
if(cart[i] instanceof Fruit) {
ftot += cart[i].price;
flist += cart[i] + ","; //flist = flist + cart[i]로써 불변인 String에 계속 쌓아둠
fcnt++;
}
if(cart[i] instanceof Drink) {
dtot += cart[i].price;
dlist += cart[i] + ",";
dcnt++;
}
if(cart[i] instanceof Snack) {
stot += cart[i].price;
slist += cart[i] + ",";
scnt++;
}
}
System.out.println("총 구매금액 : " + total);
System.out.println("총 구매목록 : " + list);
System.out.print("과일 구매건수:"+fcnt+", 구매금액 : " + ftot);
System.out.println(", 구매목록 : " + flist);
System.out.print("음료 구매건수:"+dcnt+", 구매금액 : " + dtot);
System.out.println(", 구매목록 : " + dlist);
System.out.print("과자 구매건수:"+scnt+", 구매금액 : " + stot);
System.out.println(", 과자 구매목록 : " + slist);
}
}String a = "";
a+="사과";
System.out.println(a);
a+="배";
System.out.println(a);
사과
사과배
이 방식으로 작동함!!!!
어제 상속을 공부했는데
조금 더 남아서 계속 할 것 같다!!
1) 상속
1-1) 패키지
1-2) 접근제어자
---------------------------------------------------------------
2) 인터페이스
2 - 1) 리턴값 사용하는 인터페이스
2 - 2) 매개변수로 사용하는 인터페이스
2- 3) default , static 메서드
2 - 4) 람다식
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
1-1) 패키지 ( 클래스들의 모임 )
- 클래스의 이름은 패키지명을 포함
- 패키지의 설정은 파일의 처음에 한번만 기술해야 함
=> 같은 파일에 존재하는 모든 클래스는 같은 패키지에 속한 클래스임.
import :
클래스이름의 패키지명을 생략할수있도록 미리선언
*클래스의 패키지명을 생략 할 수 있는경우
*1.같은 패키지에 속한 클래스는 패키지명 생략가능
*2.java.lang 패키지에속한 클래스는 패키지명을 생략가능(String, System)
* 3.import구문으로 선언된 클래스는 패키지명 생략가능
* * 표현방식으로는 해당 패키지의 모든클래스들은 패키지명 생략가능
package ex7_package;
//import java.util.*; //java.util 패키지의 모든클래스는 패키지명을 생략해서 사용하겠단뜻(권장하진않음
import java.util.Date;
import java.util.Scanner;
class Pack1{
void method() {
System.out.println("ex7_package.Pack1 클래스의 method()메서드");
}
}
public class PackageEx1 {
public static void main(String[] args) {
// ex7_package.Pack1 p1 = new ex7_package.Pack1(); //패지지명이 생략
Pack1 p1= new Pack1();
System.out.println("p1.getClass() : "+p1.getClass()); //패키지와클래스출력
p1.method();
Scanner scan = new Scanner(System.in);
System.out.println("scan.getClass : "+scan.getClass());
Date date = new Date();
}
}
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
p1.getClass() : class ex7_package.Pack1
ex7_package.Pack1 클래스의 method()메서드
scan.getClass : class java.util.Scanner1-2) 접근제어자
* 제한자 : 접근제한자 ㅡ 그 외 제한자(static, abstract, final)
* 접근제한자
* private < (defalut) < protected < public
* private : 동일한 클래스내에서만 접근 허용
* (default) : 같은 패키지 내에서만
* protected : 같은 패키지 내에서만 ( 상속관계는 다른패키지도 가능)
* public : all
클래스에는 public , (default) 만 사용이 가능함
객체생성을 막고싶다면 생성자를 private으로 막아놓자
예시코드( 패키지명을 잘 봐라)
package ex8_modifier;
import ex8_modifier.test.Modifier2;
class Modifier1{
private int v1 = 100;
int v2 = 200;
protected int v3 =300;
public int v4 = 400;
public void method() {
System.out.println(getClass()+" 클래스의 method()");
System.out.println("v1 : "+v1);
System.out.println("v2 : "+v2);
System.out.println("v3 : "+v3);
System.out.println("v4 : "+v4);
}
}
//---------------------------------------------------------------------
class Modifier3 extends Modifier2{
void method2() {
System.out.println("ex8_modifier.Modifier3클래스의 method2");
// System.out.println("v1 : "+v1); private이므로 접근X
// System.out.println("v2 : "+v2); default 접근불가
System.out.println("v3 : "+v3); //상속관계이므로 다른패키지여도 접근가능
System.out.println("v4 : "+v4); //public
}
@Override
//부모의 method()가 public이기 때문에
//접근제어자를 맞춰주자 더 좁은범위로설정할순없다
public void method() {
System.out.println("v3 : "+v3); //상속관계이므로 다른패키지여도 접근가능
System.out.println("v4 : "+v4); //public
}
}
//-----------------------------------------------------------------
public class ModifierEx1 {
public static void main(String[] args) {
Modifier1 m1 = new Modifier1();
m1.method();
System.out.println("ModifierEx1 클래스의 main 메서드에서 호출");
// System.out.println("m1.v1 : "+m1.v1); private은 같은 클래스에서만 접근가능
System.out.println("m1.v2 : "+m1.v2);//v2
System.out.println("m1.v3 : "+m1.v3);
System.out.println("m1.v4 : "+m1.v4);
Modifier2 m2 = new Modifier2(); //다른 패키지임
m2.method();
// System.out.println("m2.v1 : "+m2.v1); private
// System.out.println("m2.v2 : "+m2.v2); default(같은패키지만 접근가능)
// System.out.println("m2.v3 : "+m2.v3); protected(같은패키지만접근 가능 + 상속관계는 다 접근가능)
//The field Modifier2.v2 is not visible
System.out.println("m2.v4 : "+m2.v4);
Modifier3 m3 = new Modifier3();
m3.method2();
}
}
package ex8_modifier.test;
public class Modifier2 {
private int v1=10;
int v2=20;
protected int v3=30;
public int v4 = 40;
public void method() {
System.out.println(getClass()+"클래스의 method()");
System.out.println("v1 : "+v1);
System.out.println("v2 : "+v2);
System.out.println("v3 : "+v3);
System.out.println("v4 : "+v4);
}
}
class ex8_modifier.Modifier1 클래스의 method()
v1 : 100
v2 : 200
v3 : 300
v4 : 400
ModifierEx1 클래스의 main 메서드에서 호출
m1.v2 : 200
m1.v3 : 300
m1.v4 : 400
class ex8_modifier.test.Modifier2클래스의 method()
v1 : 10
v2 : 20
v3 : 30
v4 : 40
m2.v4 : 40
ex8_modifier.Modifier3클래스의 method2
v3 : 30
v4 : 40
Singleton ( private 생성자 이용 )
* 생성자의 접근제어자를 private : 객체의 갯수제한
* 객체의 갯수를 한개만 생성
package ex8_modifier;
import java.time.LocalDate;
class SingleObject{
private static SingleObject obj = new SingleObject();
private SingleObject() {};//생성자
//기본생성자 제공 불가 . 생성자에 접근 현재 클래스에서만허용
int value=100;
public static SingleObject getObj() {
return obj;
}
}
public class SingletonEx1 {
public static void main(String[] args) {
// SingleObject o = new SingleObject();
SingleObject o1 = SingleObject.getObj();
SingleObject o2 = SingleObject.getObj();
System.out.println("o1.value : "+o1.value);
System.out.println("o2.value : "+o2.value);
o1.value = 200; //객체는 하나임
//참조변수를 100개를 만들어도 참조하는 객체는 하나뿐
System.out.println("o1.value : "+o1.value);
System.out.println("o2.value : "+o2.value);
// Math m = new Math(); 객체생성불가능
// Math클래스의 모든멤버는 Static
}
}o1.value : 100
o2.value : 100
== o1.value = 200 실행 후 ==
o1.value : 200
o2.value : 200
@@ 2) 인터페이스 @@
인터페이스의 특징
객체화 불가 -> 구현클래스로 객체화 된다.
클래스간은 상속이고, 클래스와 인터페이스의 관계는 구현이다.
implements 예약어로 표현한다. 다중구현이 가능하다.
인터페이스간의 상속도 가능하다. 인터페이스간의 상속은 다중 상속이 가능하다.
인터페이스의 모든 멤버의 접근제어자는 public이다.
인터페이스의 모든 멤버 변수는 final이 붙은 상수다
클래스가 클래스를 상속받으면서 인터페이스까지 구현하려면
class A extends B implements C;
와 같은 방식으로 작성 !
코드예시
package chap8;
/*
* 인터페이스
* 1.인터페이스의 멤버는 상수 추상메서드 defalut메서드 , static메서드만 가능
* 2.인터페이스의 멤버의 접근제어자는 모두 public !!(생략해도 public)
* 상수 :[ public static final ]자료형 상수명
* 추상메서드 : [public abstract ] 리턴타입 메서드명(매개변수목록);
* default 메서드 : [public] 구현부 가능한 메서드 인스턴스메서드
* static 메서드 : [public] 구현부 가능한 메서드 클래스메서드
* 3. 객체화 불가 : 구현클래스의 객체화를 통해서 객체화가능
* 4. 클래스와 인터페이스는 구현(implements)로표현 , 다중구현 가능.
* 5. 인터페이스간의 상속(extends)로 표현함 , 다중상속가능
*/
interface Printerable{
int INK = 100;//상수는 대문자가 관례임
void print();
default void sort() { //default메서드
System.out.println("정렬페이지 출력");
}
static void sort2() {
System.out.println("정렬페이지2");
}
}
//----------------------------------------------------------------------------------
interface Scannerable{
void scan();}
//----------------------------------------------------------------------------------
interface Faxable{
String FAX_NO = "02-1111-2142";
void send(String no);
void receive(String no);
}
//----------------------------------------------------------------------------------
//인터페이스간의 다중상속
interface Complexerable extends Printerable,Scannerable,Faxable{}
//--------------------------------------------------------------------------------------
//구현클래스 : 인터페이스를 구현한 클래스 (다중구현 가능)
//인터페이스의 추상메서드를 무조건 오버라이딩해서 사용해야함
class Complexer implements Printerable,Scannerable,Faxable{
//implements Complexerable
int ink;
public Complexer() {
this.ink = INK;
}
@Override
public void print() {
System.out.println("프린트 합니다 , 남은 잉크량 : "+--ink);
}
@Override
public void scan() {
System.out.println("이미지 스캔");
}
@Override
public void send(String no) {
System.out.println(FAX_NO+"에서 "+no+"로 FAX 전송");
}
@Override
public void receive(String no) {
System.out.println(no+"에서 "+FAX_NO+"에게 FAX를 받았어요");
}
}
//--------------------------------------------------------------------------구동클래스
인터페이스형 <== 구현클래스의 객체(구현체) 형변환은 자동으로 가능
but 구현클래스의 멤버는 사용할수 없음.
public class InterfaceEx1 {
public static void main(String[] args) {
System.out.println("Printerable.INK : "+Printerable.INK);
// Printerable.INK = 150; 인터페이스상수 == final
Complexer c = new Complexer();
System.out.println("Printerable.INK : "+Printerable.INK);
System.out.println("Complexerable.INK : "+Complexerable.INK);
System.out.println("Complexer.INK : "+Complexer.INK);
System.out.println("Faxable.FAX_NO : "+Faxable.FAX_NO);
System.out.println("Complexerable.FAX_NO : "+Complexerable.FAX_NO);
System.out.println("Complexerable.FAX_NO"+Complexer.FAX_NO);
String num = "010-8248-8421";
c.print();
c.scan();
c.send(num);
c.receive(num);
System.out.println("복합기 프린트 남은 잉크량 : "+c.ink);
System.out.println("===");
if(c instanceof Complexerable) {
System.out.println("@@ c가 참조하고 있는 객체 Complexerable객체 @@");
Complexerable co = c;
//인터페이스 <= 구현클래스 형변환 (자동형변환 가능 )
co.print();
co.scan();
co.send(num);
co.receive(num);
//System.out.println("복합기 남은 잉크량 : "+co.ink);구현체의 기능을 사용할순없음
if(c instanceof Printerable) {
System.out.println("@@ c가 참조하고 있는 객체 Printerable객체 @@");
Printerable p = c;
//인터페이스 <= 구현클래스 형변환 (자동형변환 가능 )
p.print();
System.out.println(Printerable.INK);
// p.scan(); 자신의멤버가 아님
// p.send(num);
// p.receive(num);
//System.out.println("복합기 남은 잉크량 : "+co.ink);구현체의 기능을 사용할순없음
}System.out.println("=================");
if(c instanceof Scannerable) {
System.out.println(" @@ c가 참조하고 있는 객체 Scannerable객체 @@");
Scannerable s = c;
// s.print(); //자신의멤버가아님
s.scan();
// s.send(num);
// s.receive(num);
//System.out.println("복합기 남은 잉크량 : "+co.ink);구현체의 기능을 사용할순없음
}System.out.println("=================");
if(c instanceof Faxable) {
System.out.println("@@ c가 참조하고 있는 객체 Faxable객체 @@");
Faxable f = c;
// f.print(); //자신의멤버가아님
// f.scan();
f.send(num);
f.receive(num);
System.out.println(Faxable.FAX_NO);
//System.out.println("복합기 남은 잉크량 : "+co.ink);구현체의 기능을 사용할순없음
}System.out.println("=================");
if(c instanceof Object) {
System.out.println("@@ c가 참조하고 있는 객체 Object객체 @@");
Object o = c;
// o.print(); //자신의멤버가아님
// o.scan();
// o.send(num);
// o.receive(num);
//System.out.println("복합기 남은 잉크량 : "+co.ink);구현체의 기능을 사용할순없음
}System.out.println("=================");
}
}
}
Printerable.INK : 100
Complexerable.INK : 100
Complexer.INK : 100
Faxable.FAX_NO : 02-1111-2142
Complexerable.FAX_NO : 02-1111-2142
Complexerable.FAX_NO02-1111-2142
프린트 합니다 , 남은 잉크량 : 99
이미지 스캔
02-1111-2142에서 010-8248-8421로 FAX 전송
010-8248-8421는 02-1111-2142에게 FAX를 받았어요
복합기 프린트 남은 잉크량 : 99
===
@@ c가 참조하고 있는 객체 Complexerable객체 @@
프린트 합니다 , 남은 잉크량 : 98
이미지 스캔
02-1111-2142에서 010-8248-8421로 FAX 전송
010-8248-8421는 02-1111-2142에게 FAX를 받았어요
@@ c가 참조하고 있는 객체 Printerable객체 @@
프린트 합니다 , 남은 잉크량 : 97
Printerable.INK : 100
=================
@@ c가 참조하고 있는 객체 Scannerable객체 @@
이미지 스캔
=================
@@ c가 참조하고 있는 객체 Faxable객체 @@
02-1111-2142에서 010-8248-8421로 FAX 전송
010-8248-8421는 02-1111-2142에게 FAX를 받았어요
Faxable.FAX_NO02-1111-2142
=================
@@ c가 참조하고 있는 객체 Object객체 @@
=================
UML다이어그램으로 표현
예제
package chap8;
abstract class Animal{
String name;
Animal(String name){
this.name = name;
}
abstract void eat();
}
//----------------------------------------------------------------------------
interface Flyable {
void fly();
}
//--------------------------------------------------------------------
class Dove extends Animal implements Flyable {
Dove() {
super("비둘기");
}
@Override
public void fly() {
System.out.println(name+"는 날아다닌다");
}
@Override
void eat() {
System.out.println(name+"는 벌레를 잡아먹음");
}
}
//----------------------------------------------
class Monkey extends Animal{
Monkey() {
super("원숭이");
}
@Override
void eat() {
System.out.println(name+"은 바나나를 먹는다");
}
}
//-----------------------------------------------------
public class Exam1 {
public static void main(String[] args) {
Animal a = new Dove();
a.eat();
if(a instanceof Flyable) {
Flyable f = (Flyable)a;
f.fly();
}
//Animal a 가아닌 Dove a 로 참조변수를 만들었다면
// [ 인터페이스 <== 구현체 ]가 자동형변환 가능했을거임
a = new Monkey();
a.eat();
if(a instanceof Flyable) {
Flyable f = (Flyable)a;
f.fly();
}
}
}비둘기는 벌레를 잡아먹음
비둘기는 날아다닌다
=========
원숭이는 바나나를 먹는다
2-1) 리턴타입으로 사용되는 인터페이스
package chap8;
/*
* 리턴타입으로 사용되는 인터페이스
*/
class Lazerzet implements Printerable{
String name = "잉크젯";
@Override
public void print() {
System.out.println("레이저프린터로 프린트");
}
}
//--------------------------------------------------------
class Inkzet implements Printerable{
String name = "레이저젯";
@Override
public void print() {
System.out.println("잉크젯 프린터로 프린트");
}
}
//--------------------------------------------------------
class PrinterManager{
public static Printerable getPrint(String type) {
if(type.equals("INK")) {return new Inkzet();} //ink가 입력되면 Inkzet객체반환
else {return new Lazerzet();}//그 외는 Lazerzet으로 반환
}
}
//--------------------------------------------------------
public class InterfaceEx2 {
public static void main(String[] args) {
Printerable p = PrinterManager.getPrint("INK");
p.print();
// System.out.println(p.name);Printerable의 멤버가 아니므로 사용X
PrinterManager.getPrint("LAZER").print();
}
}잉크젯 프린터로 프린트
레이저프린터로 프린트
2-2 ) 예제 (인터페이스를 매개변수로 사용 )
package chap8;
/*
* interface를 매개변수로 사용
*/
class Unit{
int hp;
final int MAX;
public Unit(int hp) {
this.hp = hp;
MAX = hp;
}
}
//-----------------------------------------------------------------
interface Repariable {}
//-----------------------------------------------------------------
class Tank extends Unit implements Repariable{
public Tank() {
super(150);
}
public String toString() {
return "탱크 ";
}
}
//-----------------------------------------------------------------
class Marine extends Unit implements Repariable{
public Marine() {
super(130);
}
public String toString() {
return "마린 ";
}
}
//-----------------------------------------------------------------
class SCV extends Unit implements Repariable{
public SCV() {
super(50);
}
void repair(Repariable r) {
if(r instanceof Unit) {
Unit u = (Unit)r; // 형변환
u.hp = u.MAX;
System.out.println(r+"수리완료");
}
}
public String toString() {
return "SCV";
}
}
//-----------------------------------------------------------------
public class InterfaceEx3 {
public static void main(String[] args) {
Marine m = new Marine();
Tank t = new Tank();
SCV scv = new SCV();
scv.repair(m);
scv.repair(t);
scv.repair(scv);
}
}마린 수리완료
탱크 수리완료
SCV수리완료
* 추상클래스와 인터페이스를 이름없는 내부객체로 생성하기
package chap8;
import java.security.DrbgParameters.NextBytes;
import java.util.Random;
interface Action{
void action();
}
abstract class Abs{
int num=100;
abstract void method();
}
public class InterfaceEx4 {
private static void hello(Action a) {
a.action();
}
public static void main(String[] args) {
//내부객체
Action a = new Action() {
@Override
public void action() {
System.out.println("--Action 인터페이스의 action메서드--");
}
};a.action();
//Abs 클래스의 객체생성 ( 익명클래스 활용)
Abs abs = new Abs() {
@Override
void method() {
System.out.println("--추상클래스Abs의 메서드--");
System.out.println("num : "+num);
}
};abs.method();
//람다식 : 함수객체
a=()->System.out.println("람다방식으로Action인터페이스 구현");
a.action();
hello(()->{ //인터페이스를 하나정하고 그 인터페이스를 매개변수로받는 static형 메서드hello에 넣기
int nextInt = new Random().nextInt(6)+1;
System.out.println("하이");
System.out.println(nextInt);
});
}
}
2-3 )인터페이스의 default , static 메서드
* -java8 이후에 사용가능한 메서드
* 인터페이스에서 구현부가 존재하는 메서드다.
* --default 메서드 : 인스턴스멤버 (객체화가 되어야 사용가능 )
* --static 메서드 : 클래스멤버 ( 인스턴스명.메서드 로 호출가능)
*
* * 다중구현이 가능
추상메서드 중복된 경우 : 하나만 오버라이딩
default 메서드가 중복된 경우 : 오버라이딩필요
default 메서드가 중복되지 않으면 : 오버라이딩 필수X
static메서드는 중복되어도 상관없음. 인터페이스명.메서드로 접근
package chap8;
interface MyInterface1{
void method();
default void method1() {
System.out.println("MyInterface1의 default메서드 : method1");
}
static void method2() {
System.out.println("MyInterface1의 static메서드 : method2");
}
}
//-------------------------------------------------------------------------------
interface MyInterface2{
void method();
default void method1() {
System.out.println("MyInterface2의 default메서드 : method1");
}
static void method2() {
System.out.println("MyInterface2의 static메서드 : method2");
}
}
//-------------------------------------------------------------------
class Parent{
public void pmethod() {
System.out.println("Parent클래스의 멤버 메서드 : pmethod");
}
}
//----------------------------------------------------------------------------
//구현한 두개의 인터페이스의 이름이똑같은 추상메서드가 존재한다면 한개만 오버라이딩됨
//default메서드는 클래스에서 오버라이딩 시 public으로 바뀌게 됨
class Child extends Parent implements MyInterface1,MyInterface2{
public void method() {
System.out.println("Child클래스에서 method() 오버라이딩");
}
@Override
public void method1() {
// MyInterface1.super.method1(); Child는 MyInterface1 , 2의 참조를알기때문에 접근가능
// MyInterface2.super.method1();
System.out.println("Child클래스에서 default메서드를 오버라이딩함 : method1");
}
}
//------------------------------------------------------------------------------------
public class InterfaceEx5 {
public static void main(String[] args) {
Child c = new Child();
c.method();
c.method1();
c.pmethod();//자식객체 생성 시 부모객체를 가지고있음
MyInterface1.method2(); //static
MyInterface2.method2();
}
}Child클래스에서 method() 오버라이딩
Child클래스에서 default메서드를 오버라이딩함 : method1
Parent클래스의 멤버 메서드 : pmethod
MyInterface1의 static메서드 : method2
MyInterface2의 static메서드 : method2
2-4) 람다식
* 함수적 인터페이스(FunctionalInterface) : 인터페이스의 추상메서드가 한개인 인터페이스
@FunctionalInterface
//함수적 인터페이스로 설정하므로 추상메서드가 1개여야함을 표시(2개입력시 컴파일오류)
기본 람다 방식
@FunctionalInterface //함수적 인터페이스로 설정하므로 추상메서드가 1개여야함을 표시
interface LambdaInterface1{
void method();
// void method2();
}
public static void main(String[] args) {
LambdaInterface1 f1;
f1 = ()->{
String str = "기본람다방식 ";
System.out.println(str);
};
f1.method();
}(내부 문장이 한줄 일 때는 {} 생략가능)
매개변수가 있는 람다방식(리턴값은 X)
package chap8;
interface Lambda2{
int x = 4;
void method(int x);
}
public class LambdaEx2 {
public static void main(String[] args) {
Lambda2 l;
l=(x)->{
int sum=0;
for (int i = 0; i <= x; i++) {
sum+= i;
System.out.print(i+"+");
}System.out.println(" : "+sum);
};
l.method(7);
}
}0+1+2+3+4+5+6+7+ : 28
예제로 확인 ( 매개변수 X , 리턴값 X )
package chap8;
/*
* 람다식 예제
* 함수적 인터페이스(FunctionalInterface) : 인터페이스의 추상메서드가 한개인 인터페이스
*/
@FunctionalInterface //함수적 인터페이스로 설정하므로 추상메서드가 1개여야함을 표시
interface LambdaInterface1{
void method();
// void method2();
}
//-------------------------------------------------------------------
public class LambdaEx1 {
public static void main(String[] args) {
LambdaInterface1 f1;
f1=new LambdaInterface1() {
@Override
public void method() {
System.out.println("기존의 내부객체로 생성함");
}
};f1.method();
//------------------------------------------------------------------- -------
//1.람다식으로변경
f1 = ()->{
String str = "람다방식 1 ";
System.out.println(str);
};f1.method();
//------------------------------------------------------------------- -------
//2.람다방식 : 내부 문장이 한개인경우 {} 생략가능
f1 = ()->System.out.println("람다방식 2 ");
f1.method();
//------------------------------------------------------------------- -------
//3. LambdaInterface1 인터페이스를 매개변수로받는 static메서드로 람다방식이용
execute(()->System.out.println("excute메서드에서 호출함"));
//execute 함수 이용해 1~100까지의 합 출력
execute(()->{
System.out.print("1에서100까지의 합 : ");
int num =100;
int sum=0;
for (int i = 1; i <= num; i++) {
sum+=i;
}
System.out.println(sum);
});
//excute 함수를 이용해 1~100까지의 짝수합 출력해보기
execute(()->{
System.out.print("1에서100까지의 짝수 합 : ");
int num =100;
int sum=0;
for (int i = 1; i <= num; i++) {
if(i%2==0) {
sum+=i;
}
}
System.out.println(sum);
});
}
public static void execute(LambdaInterface1 l) {
System.out.println("excute 시작");
l.method();
System.out.println("excute 종료");
}
}기존의 내부객체로 생성함
람다방식 1
람다방식 2
excute 시작
excute메서드에서 호출함
excute 종료
excute 시작
1에서100까지의 합 : 5050
excute 종료
excute 시작
1에서100까지의 짝수 합 : 2550
excute 종료
@@ 오늘의 예제 @@
test.zip
0.00MB
상속과 인터페이스관련이라
그렇게어렵지는 않은 문제다
가장 헷갈리는거 두개정도만 리뷰하겠음..
package test;
//다음 소스는 컴파일 오류가 발생한다. 결과가 "Tested" 가 출력되도록 프로그램을 수정하기
interface Beta {} //멤버가 없다.
class Alpha implements Beta {
String testIt() {
return "Tested";
}
}
class Gamma implements Beta {
String testIt1() {
return "Gamma";
}
}
public class Test2 {
static Beta getIt() {
return new Alpha();
}
public static void main(String[] args) {
Beta b = getIt();
System.out.println(b.testIt());
}
}일단
Beta에 추상메서드를 둬서
Beta를 구현하는 구현체에게
모두 메서드를 줘야 Beta형으로 메서드를 뽑을 수 있지않을까?
일단
바꾼코드 1
package chap8.test;
//다음 소스는 컴파일 오류가 발생한다. 결과가 "Tested" 가 출력되도록 프로그램을 수정하기
interface Beta {
String testIt1();
} //멤버가 없다.
class Alpha implements Beta {
@Override
public String testIt1() {
return "Tested";
}
}
class Gamma implements Beta {
@Override
public String testIt1() {
return "Gamma";
}
}
//-------------------------------------------------------
public class Test2 {
static Beta getIt(String a) {
if(a.equalsIgnoreCase("alpha")) {
return new Alpha();}
else {
return new Gamma();
}
}
public static void main(String[] args) {
Beta it = getIt("alpha");
System.out.println(it.testIt1());
Beta it2 = getIt("a");
System.out.println(it2.testIt1());
}
}내가 푼 방식은 일단
인터페이스에 추상메서드를 하나만들고
구현체들이 그 메서드를 모두구현함!!
그 후
getIt메서드로 문자열하나를 받아
alpha와 같다면 new Alpha();
---> Alpha는 Beta에 구현체이므로 자동형변환!!!!
이런식으로하면
getIt으로 Tested , Gamma 모두 출력이가능함
구현체가 더 생겨도 출력이가능하게됨
바꾼코드 2
package chap8.test;
//다음 소스는 컴파일 오류가 발생한다. 결과가 "Tested" 가 출력되도록 프로그램을 수정하기
interface Beta1 {
} //멤버가 없다
class Alpha12 implements Beta1 {
public String testIt() {
return "Tested";
}
}
class Gamma12 implements Beta1 {
public String testIt() {
return "Gamma";
}
}
public class Test2_2 {
static Beta1 getIt() {
return new Alpha12();
}
public static void main(String[] args) {
Beta1 it = getIt();
System.out.println(((Alpha12)it).testIt());
}
}구동클래스만만 바꿔서 오류를 해결하는법도 있음
다음 문제
상속 + 구현
package chap8.test;
/*
* 구동 클래스를 실행했을때 다음의 결과가 나오도록 프로그램 구현하기
*
* Flyable 인터페이스, Dove,Monkey,Eagle 클래스 구현하기
* [결과]
* 비둘기는 작은 벌레를 잡아 먹는다.
* 비둘기는 날아 다니는 새입니다.
* 원숭이는 나무에서 열매를 따서 먹는다
* 독수리는 작은 새를 잡아 먹는다.
* 독수리는 엄청 높이 날아 다닌다.
*/
abstract class Animal2 {
String name;
Animal2(String name) {
this.name = name;
}
abstract void eat();
}
//---------------------------------------------------------------------------------
interface Flyable{
void fly();
}
//---------------------------------------------------------------------------------
class Monkey extends Animal2{
Monkey() {
super("원숭이");
}
@Override
void eat() {
System.out.println(name+"은 나무에서열매를 따서먹음");
}
}
//---------------------------------------------------------------------------------
class Dove extends Animal2 implements Flyable{
Dove() {
super("비둘기");
}
@Override
public void fly() {
System.out.println(name+"은 날아다니는 새");
}
@Override
void eat() {
System.out.println(name+"은 작은벌레를 잡아먹어");
}
}
class Eagle extends Animal2 implements Flyable{
Eagle() {
super("독수리");
}
@Override
public void fly() {
System.out.println(name+"은 엄청 높이 날아다니는 새");
}
@Override
void eat() {
System.out.println(name+"은 작은 새"
+ "를 잡아먹어");
}
}
public class Test5 {
public static void main(String[] args) {
Animal2[] arr = new Animal2[3];
arr[0] = new Dove();
arr[1] = new Monkey();
arr[2] = new Eagle();
for (Animal2 a : arr) {
a.eat();
if (a instanceof Flyable) {
((Flyable) a).fly();
}
}
}
}Animal은 멤버변수로 name을 가지고
생성자를 통해 this.name = name 실행
모든동물에게 상속하고
Flyable 인터페이스는 void Fly();라는
추상메서드 하나
Dove와 Eagle에게만 상속
(각각
메서드오버라이딩 해 출력문이 다르게 설정)
monkey == Animal2 상속
Dove == Animal2 상속 , Flyable 구현
Eagle == Animal2 상속 , Flyable 구현
다음문제
* 구동클래스를 실행하였을때 다음의 결과가 나오도록
* 관련 클래스를 구현하기
[결과]
DanceRobot은 춤을 춤니다.
SingRobot은 노래를 부릅니다.
DrawRobot은 그림을 그립니다.
public class Test3_2 {
public static void main(String[] args) {
Robot2[] robot = new Robot2[3];
robot[0] = new DanceRobot2();
robot[1] = new SingRobot2();
robot[2] = new DrawRobot2();
for(Robot2 r : robot) {
r.action();
}
}
}
추상클래스 이용
package chap8.test;
abstract class Robot2 {
String name;
abstract void action();
Robot2(String name){
this.name = name;
}
}
class DanceRobot2 extends Robot2{
DanceRobot2() {
super("DanceRobot");
}
@Override
protected void action() {
// 인터페이스는 오버라이딩 시 무조건 public이지만
//abstract은 접근제한자를 넓은범위로 만들 수 있음
//부모클래스의 메서드가 default이므로
//자식 클래스는 (default),protected , public 가능
System.out.println(name+"은 춤 춘다");
}
}
class SingRobot2 extends Robot2{
SingRobot2() {
super("SingRobot");
}
@Override
void action() {
System.out.println(name+"은 노래부른다");
}
}
class DrawRobot2 extends Robot2{
DrawRobot2() {
super("DrawRobot");
// TODO Auto-generated constructor stub
}
@Override
void action() {
System.out.println(name+"은 그림그린다");
}
}
상속관련 문제
1. 5줄에 메서드를 추가했을 때 에러를 발생시키는 메서드를 고르시오.
- class Super {
- public float getNum( ) {return 3.0f;}
- }
- public class Sub extends Super {
- // 여기에 메서드 추가
- }
(1) public float getNum( ) {return 4.0f; }
(2) public void getNum ( ) { } 메서드오버로딩이 아님 (매개변수의 수 동일)
(3) public void getNum (double d) { }
(4) public double getNum (float d) {retrun 4.0f; }
2. 결과를 예측하시오.
class TestA {
public void start(){
System.out.println(”TestA”);
}
}
public class TestB extends TestA {
public void start() {
System.out.println(”TestB”);
}
public static void main(String[] args) {
TestA a = new TestB();
a.start();
}
}
(1) TestA
(2) TestB
(start는 오버라이딩 됐으므로 부모의참조변수가 자식의 객체를 참조한다면
그렇게 될 것이다)
(3) Compilation fails.
(4) An exception is thrown at runtime.
다음 중 오버라이딩의 조건으로 옳지 않은 것은?
(1) 조상의 메서드와 이름이 같아야 한다.
(2) 매개변수의 수와 타입이 모두 같아야 한다.
(3) 리턴타입이 같아야 한다.
(4) 접근 제어자는 조상의 메서드보다 좁은 범위로만 변경할 수 있다
(조상이 public 이면 자식은 default???? )
다음 중 this에 대한 설명으로 맞지 않은 것은?
(1) 객체 자신을 가리키는 참조변수이다.
(2) 클래스 내에서라면 어디서든 사용할 수 있다.
(3) 지역변수와 인스턴스변수를 구별할 때 사용한다.
(4) 클래스 메서드 내에서는 사용할 수 없다.
다음 중 맞는 것을 2개 고르시오.
10. class Foo {
11. static void alpha() { /* more code here */ }
12. void beta() { /* more code here */ }
13. }
(1) Foo.beta() 문장으로 beta() 메서드 호출 가능.
(2) Foo.alpha() 문장으로 alpha() 메서드 호출 가능. (클래스메서드 : 클래스명.메소드명)
(3) beta() 메서드에서 직접 alpha() 메서드 호출 가능. ( 인스턴스멤버->클래스멤버 접근가능)
(4) alpha() 메서드에서 직접 beta() 메서드 호출 가능.
결과를 예측하시오
1. public class Test {
2. int x= 12;
3. public void method(int x) {
4. x+=x;
5. System.out.println(x);
6. }
7. }
8 class Test1 {
9 public static void main(String[] args) {
10. Test t = new Test();
11. t.method(10);
12 }
13 }
(1) 5 (2) 10 (3) 12 (4) 17 (5) 20
(x+= x ----> 10+=10;;;; 20)
this.x +=x; 로 하면 22 가나옴
다음 중 아래의 add메서드를 올바르게 오버로딩 한 것은? (모두 고르시오)
long add(int a, int b) { return a+b;}
- long add(int x, int y) { return x+y;}
- int add(int a, int b) { return a+b;} // 리턴타입과 오버로딩은 상관이없음
- int add(byte a, byte b) { return a+b;} //매개변수 타입이 다르긴하지만 int보다 작은범위이므로 오버로딩성립X
- long add(long a, int b) { return (int)(a+b);}
(매개변수의 타입이 다르므로 오버로딩)
'부트캠프(Java)' 카테고리의 다른 글
| 자바 / 스프링 부트캠프 11일차( 예외처리 , API) (1) | 2025.02.14 |
|---|---|
| 자바 / 스프링 부트캠프 10일차 ( 람다식 , 내부클래스, 예외처리) (0) | 2025.02.13 |
| 자바/스프링 개발 부트캠프 8일차(상속) (0) | 2025.02.11 |
| 자바/스프링 개발 부트캠프 7일차 (생성자 , 상속) (1) | 2025.02.10 |
| 자바/스프링 개발 부트캠프 6일차(클래스) (1) | 2025.02.07 |