[자바 7일차] 26일차 - 상속, 추상클래스, 추상메서드 , 인터페이스(Do it 공부단 p.234~)

프로그래밍/자바(java) 융합개발자 2차

[자바 7일차] 26일차 - 상속, 추상클래스, 추상메서드 , 인터페이스(Do it 공부단 p.234~)

aSpring 2021. 1. 20. 16:31

728x90

2021/01/20 - [공부/자바(java) 융합개발자 2차] - [자바 6일차] 25일차 - 다차원 배열, 상속(Do it 공부단 p.219~)

지난 시간 과제 p.234~253

Customer.java

package com.day06;

public class Customer {
	private int customerID;
	private String customerName;
	private String customerGrade;
	int bonusPoint;
	double bonusRate;
	
	public Customer() {
		customerGrade = "SILVER";
		bonusRate = 0.01;
	}
	public int calPrice(int price) {
		bonusPoint += price * bonusRate;
		return price;
	}
	public String showCustomerInfo() {
		return customerName + "님의 등급은 " + customerGrade + " 이며, 보너스 포인트는" + bonusPoint + "입니다.";
	}
}

VIPCustomer.java

package com.day06;

//p236
public class VIPCustomer {
	private int customerID;
	private String customerName;
	private String customerGrade;
	int bonusPoint;
	double bonusRate;//여기까지 Customer과 같은 속성

	private int agentID; // 전담직원
	double saleRate = 0.1; // 할인율

	public VIPCustomer() {
		customerGrade = "VIP";
		bonusRate = 0.05;
		saleRate = 0.1;

	}

	public int calPrice(int price) {
		bonusPoint += price * bonusRate;
		return price - (int) (price * saleRate);
	}

	public int getAgentID() {
		return agentID;
	}

	public String showCustomerInfo() {
		return customerName + "님 등급은 " + customerGrade + "이며, 보너스 포인트 " + bonusPoint + " 입니다.";
	}
}

OverridingTest.java

package com.day06;
//p.252, 253 같이 넣을 것
public class OverridingTest {
	
	public static void main(String[] args) {
		Customer customerLee = new Customer(10010, "이순신");
		customerLee.bonusPoint = 1000;
		
		VIPCustomer customerKim = new VIPCustomer(10020, "김유신", 12345);
		customerKim.bonusPoint = 10000;
		
		int price = 10000;
		System.out.println(customerLee.getCustomerName() + "님이 지불해야 하는 금액은" + customerLee.calPrice(price) + "원 입니다.");
		System.out.println(customerKim.getCustomerName() + "님이 지불해야 하는 금액은" + customerKim.calPrice(price) + "원 입니다.");
		
		Customer vc = new VIPCustomer(10030, "나몰라", 2000);
		vc.bonusPoint = 1000;
		System.out.println(vc.customerName + "님이 지불해야 하는 금액은" + vc.calPrice(price) + "원 입니다."); 
	}
}

오류나지 않게 생성자 만들고 상속 관계 만들기

==> 풀이

Customer.java

package com.day06;

public class Customer {
	protected int customerID; // 상속받은 클래스에서 사용 가능하도록 protected
	private String customerName;
	protected String customerGrade;
	protected int bonusPoint;
	protected double bonusRate;
	
	//public Customer() {
	//	customerGrade = "SILVER";
	//	bonusRate=0.01;
	//} -> 이걸 살리려면 16번 적어주고 19~20번 주석처리 하면 됨
	
	public Customer(int customerID, String customerName) { //OverridingTest.java에는 인자를 2개 받으므로 생성자도 그렇게 만들어주기(ID, 이름 받기)
		//this(); //10번 호출
		this.customerID = customerID;
		this.customerName = customerName;
		customerGrade = "SILVER";
		bonusRate = 0.01;
	}
	public int calPrice(int price) {
		bonusPoint += price * bonusRate;
		return price;
	}
	public String showCustomerInfo() {
		return customerName + "님의 등급은 " + customerGrade + " 이며, 보너스 포인트는" + bonusPoint + "입니다.";
	}
	//protected 예약어로 선언한 변수를 외부에서 사용 가능하도록 get(), set() 메서드 추가
	public String getCustomerName() {
		return customerName;
	}
	
}

VIPCustomer.java

package com.day06;

//p236
public class VIPCustomer extends Customer { //Customer 클래스 상속 받음
	//private int customerID;
	//private String customerName;
	//private String customerGrade;
	//int bonusPoint;
	//double bonusRate;//여기까지 Customer과 같은 속성 -> 상속 받아서 필요없음

	private int agentID; // VIP 고객 상담원 아이디
	double saleRate; // 할인율

	//public VIPCustomer() {
	//	customerGrade = "VIP";
	//	bonusRate = 0.05;
	//	saleRatio = 0.1;
	//}
	
	// ID, 이름, 전담 상담원 받을 수 있게 생성자 수정
	public VIPCustomer(int customerID, String customerName, int agentID) {
		super(customerID, customerName); //부모에 있는 거니까
		this.agentID = agentID;
		super.customerGrade = "VIP";
		super.bonusRate = 0.15;
		saleRate = 0.1;
	}

	public int calPrice(int price) {
		bonusPoint += price * bonusRate;
		return price - (int) (price * saleRate); //할인율 적용
	}

	public String showCustomerInfo() {
		return customerGrade + ":" + super.showCustomerInfo();//수정! VIP 고객 등급 외에는 Customer의 showCustoemrInfo 출력하면 되니까
	}
}

OverridingTest.java

package com.day06;
//p.252, 253 같이 넣을 것
public class OverridingTest {
	
	private int custoemrID;
	private String customerName;
	
	public void Customer(int customerID, String customerName) {
		this.custoemrID = customerID;
		this.customerName = customerName;
	}
	
	public static void main(String[] args) {
		Customer customerLee = new Customer(10010, "이순신"); //ID, 이름-> Customer.java에서 인자 2개 갖는 생성자 만들기
		customerLee.bonusPoint = 1000;
		
		VIPCustomer customerKim = new VIPCustomer(10020, "김유신", 12345);// ID, 이름, 전담 상담원 -> VIPCustomer.java 수정 
		customerKim.bonusPoint = 10000;
		
		int price = 10000;
		System.out.println(customerLee.getCustomerName() + "님이 지불해야 하는 금액은" + customerLee.calPrice(price) + "원 입니다.");
		System.out.println(customerKim.getCustomerName() + "님이 지불해야 하는 금액은" + customerKim.calPrice(price) + "원 입니다.");
		
		Customer vc = new VIPCustomer(10030, "나몰라", 2000);
		vc.bonusPoint = 1000;
		System.out.println(vc.getCustomerName() + "님이 지불해야 하는 금액은" + vc.calPrice(price) + "원 입니다.");
		
		Customer gc = new GoldCustomer(10040, "이율곡");
		gc.bonusPoint = 2000;
		
		System.out.println(gc.getCustomerName() + "님이 지불해야 하는 금액은 " + vc.calPrice(price) + "원 입니다.");
	}
}

이순신님이 지불해야 하는 금액은10000원 입니다.
김유신님이 지불해야 하는 금액은9000원 입니다.
나몰라님이 지불해야 하는 금액은9000원 입니다.

GoldCustomer만들기 -> Customer를 상속 받는 클래스 만들기

- 속성 : 고객 아이디, 고객 이름, 고객 등급(Gold), 할인율10%, 보너스 포인트 적립 비율 2%

- 함수 : calPrice(), showCustInfo()

- VIPCustomer와 동일하나 전담 상담원이 없고 적립율이 다름

package com.day06;
//p.267
public class GoldCustomer extends Customer {
	double saleRate;
	
	public GoldCustomer(int customerID, String customerName) {
		super(customerID, customerName);
		super.customerGrade = "Gold";//super. 지워도 됨 -> 부모
		super.bonusRate = 0.02;//super. 지워도 됨 -> 부모의거 것인걸 알려줌
		this.saleRate = 0.1; //this. 지워도 됨 -> 자신의 것인걸 알려줌
	}
	public int calPrice(int price) {
		bonusPoint += price*bonusRate;
		return price-(int)(price*saleRate);
	}
	public String showCustomerInfo() {
		return customerGrade + ":" + super.showCustomerInfo() ;
	}
}

이순신님이 지불해야 하는 금액은10000원 입니다.
김유신님이 지불해야 하는 금액은9000원 입니다.
나몰라님이 지불해야 하는 금액은9000원 입니다.
이율곡님이 지불해야 하는 금액은 9000원 입니다.

PointExam.java

package com.day06;

class Point{
	
}

public class PointExam {

	public static void main(String[] args) {
		point p = new Point(3,4);
		p.showPoint(); //(3,4) 이렇게 출력 되도록
	}

}

오류나지 않게 만들기

package com.day06;

class Point {
	int x, y;
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}
	public void showPoint() {
		System.out.println("(" + x + "," + y + ")");
	}
}

public class PointExam {
	
	public static void main(String[] args) {
		Point p = new Point(3 ,4);
		p.showPoint();
	}

}

(3,4)

오류 수정

==> 전체 코드

package com.day06;

class Point { //생성자
	private int x,y;
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}
	public void showPoint() {
		System.out.println("(" + x + "," + y + ")");
	}
}

class ColorPoint { 
	private int x, y;
	private String color;
	public ColorPoint(int x, int y, String color) {
		this.x = x;
		this.y = y;
		this.color = color;
	}
	public void showPoint() {
		System.out.println("(" + x + "," + y + ")" + color);
	}
}


public class PointExam {

	public static void main(String[] args) {
		Point p = new Point(3,4);
		p.showPoint(); //(3,4)가 나오도록
		ColorPoint cp = new ColorPoint(2,5,"red");
		cp.showPoint(); //(2,5)red 가 나오도록
	}
}

(3,4)
(2,5)red

==>

package com.day06;

class Point { //생성자
	private int x,y;
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}
	public void showPoint() {
		System.out.println("(" + x + "," + y + ")");
	}
}

class ColorPoint { 
	private int x, y;
	private String color;
	public ColorPoint(int x, int y, String color) {
		this.x = x;
		this.y = y;
		this.color = color;
	}
	public void showPoint() {
		System.out.println("(" + x + "," + y + ")" + color);
	}
}


public class PointExam {

	public static void main(String[] args) {
		Point p = new Point(3,4);
		p.showPoint(); //(3,4)가 나오도록
		ColorPoint cp = new ColorPoint(2,5,"red");
		cp.showPoint(); //(2,5)red 가 나오도록
		
		Point p1 = new ColorPoint(7,9,"yellow");
		p1.showPoint();
	}
}

이렇게 만들어주고 싶다면???? 상속관계로 바꾸어 줘야 함

package com.day06;

class Point { //생성자
	private int x,y;
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}
	public void showPoint() {
		System.out.println("(" + x + "," + y + ")");
	}
}

class ColorPoint extends Point {  //상속을 하면 부모한테 감
	//private int x, y; -> 부모에 있으니까 삭제
	private String color;
	public ColorPoint(int x, int y, String color) {
		super(x, y); //-> 부모 것에 받음
		this.color = color;
	}
	//오버라이딩 -> 부모에 있는 showPoint를 들고와서 + color를 더함(부모것 수정해서 사용함)
	public void showPoint() {
		super.showPoint();
		System.out.println(color);
	}
}


public class PointExam {

	public static void main(String[] args) {
		Point p = new Point(3,4);
		p.showPoint(); //(3,4)가 나오도록
		ColorPoint cp = new ColorPoint(2,5,"red");
		cp.showPoint(); //(2,5)red 가 나오도록
		
		Point p1 = new ColorPoint(7,9,"yellow");
		p1.showPoint();
	}
}

(3,4)
(2,5)
red
(7,9)
yellow

여기서 System.out.println(p1); 찍어보면

package com.day06;

class Point { //생성자
	private int x,y;
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}
	public void showPoint() {
		System.out.println("(" + x + "," + y + ")");
	}
}

class ColorPoint extends Point {  //상속을 하면 부모한테 감
	//private int x, y; -> 부모에 있으니까 삭제
	private String color;
	public ColorPoint(int x, int y, String color) {
		super(x, y); //-> 부모 것에 받음
		this.color = color;
	}
	//오버라이딩 -> 부모에 있는 showPoint를 들고와서 + color를 더함(부모것 수정해서 사용함)
	public void showPoint() {
		super.showPoint();
		System.out.println(color);
	}
}


public class PointExam {

	public static void main(String[] args) {
		Point p = new Point(3,4);
		p.showPoint(); //(3,4)가 나오도록
		ColorPoint cp = new ColorPoint(2,5,"red");
		cp.showPoint(); //(2,5)red 가 나오도록
		
		Point p1 = new ColorPoint(7,9,"yellow");
		p1.showPoint();
		System.out.println(p1); //yellow 색깔의 (7,9)
	}
}

(3,4)
(2,5)
red
(7,9)
yellow
com.day06.ColorPoint@6a5fc7f7 <- 이렇게 주소값이 나오는데 주소값이 아닌 yellow 색깔의 (7,9)와 같이 나오도록 해보자.

System.out.println -> toString을 호출 -> 주소값 찍음 -> toString을 오버라이딩 하기

package com.day06;

class Point { //생성자
	private int x,y;
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}
	public void showPoint() {
		System.out.println("(" + x + "," + y + ")");
	}
}

class ColorPoint extends Point {  //상속을 하면 부모한테 감
	//private int x, y; -> 부모에 있으니까 삭제
	private String color;
	public ColorPoint(int x, int y, String color) {
		super(x, y); //-> 부모 것에 받음
		this.color = color;
	}
	//오버라이딩 -> 부모에 있는 showPoint를 들고와서 + color를 더함(부모것 수정해서 사용함)
	public void showPoint() {
		super.showPoint();
		System.out.println(color);
	}
	@Override
		public String toString() {
			//return super.toString();
			return color + " 색깔의 (" + x + "," + y + ")";
		}
}


public class PointExam {

	public static void main(String[] args) {
		Point p = new Point(3,4);
		p.showPoint(); //(3,4)가 나오도록
		ColorPoint cp = new ColorPoint(2,5,"red");
		cp.showPoint(); //(2,5)red 가 나오도록
		
		Point p1 = new ColorPoint(7,9,"yellow");
		p1.showPoint();//yellow 색깔의 (7,9)
		System.out.println(p1);
	}
}

x, y가 private라서 사용하지 못하므로 protected로 바꾸어 주기

package com.day06;

class Point { //생성자
	protected int x,y;
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}
	public void showPoint() {
		System.out.println("(" + x + "," + y + ")");
	}
}
class ColorPoint extends Point {  //상속을 하면 부모한테 감
	//private int x, y; -> 부모에 있으니까 삭제
	private String color;
	public ColorPoint(int x, int y, String color) {
		super(x, y); //-> 부모 것에 받음
		this.color = color;
	}
	//오버라이딩 -> 부모에 있는 showPoint를 들고와서 + color를 더함(부모것 수정해서 사용함)
	public void showPoint() {
		super.showPoint();
		System.out.println(color);
	}
	@Override
		public String toString() {
			//return super.toString(); -> 원래 요게 출력되어서 주소값이 나오는데 아래와 같이 나오도록 수정
			return color + " 색깔의 (" + x + "," + y + ")";
		}
}
public class PointExam {

	public static void main(String[] args) {
		Point p = new Point(3,4);
		p.showPoint(); //(3,4)가 나오도록
		ColorPoint cp = new ColorPoint(2,5,"red");
		cp.showPoint(); //(2,5)red 가 나오도록
		
		Point p1 = new ColorPoint(7,9,"yellow");
		p1.showPoint();//yellow 색깔의 (7,9)
		System.out.println(p1);
	}
}

(3,4)
(2,5)
red
(7,9)
yellow
yellow 색깔의 (7,9)

추상클래스 p.281~

com.day07

AbsShape.java -> 도형에 대한 클래스

package com.day07;

public class AbsShape {
	// 도형 그리기
	public void draw() { // 함수

	}

	// 도형 출력하기
	public void print() { //함수
		System.out.println("도형출력하기");
	}

	// 도형 이동하기
	public void move() { //함수
		
	}
}

==> 추상 클래스

package com.day07;

public abstract class AbsShape { //추상 클래스
	// 도형 그리기
	public abstract void draw(); // 함수 { } -> 구현 했지만 속의 내용을 모른다. {}를 지우고 ;  -> 미완성. 구현하지 못하겠다. -> abstract를 써주어야 함

	// 도형 출력하기
	public void print() { //함수 -> 이름 만들고 { } 속에 출력하는 내용까지 구현
		System.out.println("도형출력하기");
	}

	// 도형 이동하기
	public abstract  void move(); //함수 -> daraw, move는 메서드 이름은 정하겠지만 구현 내용은 정하지 못하겠음 : abstract(추상 메서드) 라고 표시해주고 { } 하지 말고 ; 닫기
		
}

==> main 만들어 실행하기

AbsShapeMain.java -> 객체 생성해서 함수 실행하는 부분

package com.day07;

public class AbsShapeMain {

	public static void main(String[] args) {

	}
}

추상 클래스는 객체를 생성할 수 없기 때문에 new를 못함 -> 내용 구현 할 게 없으니까!

-> 이런 클래스는 자식이 가져다가 구현해야 함

-> 이름을 통일해서 표준을 정하는 하나의 방식 : 안에 뭘 쓸지는 못정하겠지만 서로 다른 이름을 만들어 사용하지 않도록

==> 자식 클래스 만들기

AbsCircle.java

package com.day07;

public class AbsCircle extends AbsShape {

}

추상 클래스 상속 받음 -> 에러 : 부모 추상 클래스 속 추상 메서드 2개를 반드시 구현해야 하기 때문에 에러남

package com.day07;

public class AbsCircle extends AbsShape {//추상 클래스 상속 받음 -> 에러 : 부모 추상 클래스 속 추상 메서드 2개를 반드시 구현해야 하기 때문에 에러남
	public void draw() {
		System.out.println("원그리기");
	}
	
	public void move() {
		System.out.println("원이동하기");
	}
}

오류 사라짐

==> AbsShpaeMain.java

package com.day07;

public class AbsShapeMain {

	public static void main(String[] args) {
		// AbsShpae as = new AbsShape();
		// 추상 클래스는 객체를 생성할 수 없기 때문에 new를 못함
		
		AbsCircle ac = new AbsCircle();
		ac.move();
		
		AbsShape as = new AbsCircle();
		as.draw();
	}

}

==> AbsSquare.java 생성하고 상속 받음

Add 누르면 알아서 써줌

package com.day07;

public class AbsSquare extends AbsShape {

	@Override
	public void draw() {
		System.out.println("사각형 그리기");
		
	}

	@Override
	public void move() {
		System.out.println("사각형 그리기");
		
	} //추상 클래스를 상속 받았으니 추상 메서드 두개 반드시 구현 

	public void print() {
		System.out.println("사각형 출력하기");
	}
}

==> AbsShapeMain.java

package com.day07;

public class AbsShapeMain {

	public static void main(String[] args) {
		// AbsShpae as = new AbsShape();
		// 추상 클래스는 객체를 생성할 수 없기 때문에 new를 못함
		
		AbsCircle ac = new AbsCircle();
		ac.move();
		
		AbsShape as = new AbsCircle();
		as.draw();
		
		AbsShape asq = new AbsSquare();
		asq.draw();
		asq.print();
		asq.move();
	}

}

원이동하기
원그리기
사각형 그리기
사각형 출력하기
사각형 그리기

Calc.java

abstract 를 체크하면 자동으로 추상 클래스로 만들어줌

package com.day07;

public abstract class Calc {
	public abstract int add(int a, int b); //뭘 할지는 모르겠지만 함수명은 add로 함
	public abstract int sub(int a, int b); //뭘 할지는 모르겠지만 함수명은 sub로 함
	public abstract double average(int[] a); //뭘 할지는 모르겠지만 함수명은 average로 함
}

CalcMain.java -> Calc 상속 받고 밑줄 뜨는 것 눌러서 add 하면 아래처럼 알아서 작성해 줌

package com.day07;

public class CalcMain extends Calc { //추상 클래스 상속 -> 반드시 구현

	public static void main(String[] args) {
		

	}

	@Override
	public int add(int a, int b) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public int sub(int a, int b) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public double average(int[] a) {
		// TODO Auto-generated method stub
		return 0;
	}

}

==> 내용 채우기

추상 클래스 -> 정상적 메서드도 존재하고 추상 메서드도 존재 -> 그러나 이 경우 모든 메서드가 다 추상

-> 그럼 다른 방식으로 표현해야하지 않나?

Calc2.java

Calc.java 내용 다 복사해옴 -> 에러 : 추상 메서드인데 추상 클래스로 안해놓아서

interface : 클래스도 추상, 그 안에 있는 메서드도 추상 -> 즉 모두 다 추상이라는 뜻

Cal2main.java

Calc2를 상속 받음 -> 원래 extends를 쓰는 상속은 클래스를 상속받는 건데 이 경우는 class를 상속받는 게 아니라 interface를 상속받는 것 -> implements를 쓰기

package com.day07;

public class Cal2main implements Calc2 { //클래스를 상속받는 다는 뜻인 extends가 아닌 interface를 상속받는 것이니까 implements 써주기
	public static void main(String[] args) {
		

	}

	@Override
	public int add(int a, int b) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public int sub(int a, int b) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public double average(int[] a) {
		// TODO Auto-generated method stub
		return 0;
	}

}

interface와 abstract 차이 알기!

Calc2.java

interface는 자식이 가져다 쓰라고 만든건데 private를 쓰면 자식이 못가져다 쓰니 XX

package com.day07;

public interface Calc2 { //Calc.java 내용 다 복사해옴 -> 에러 : 추상 메서드인데 추상 클래스로 안해놓아서
	int value = 5;
	public abstract int add(int a, int b);
	public abstract int sub(int a, int b);
	public abstract double average(int[] a);
}

Calc2Main.java

따라서 interface에 정의되는 변수는 final인 셈! final은 굳이 써주지 않고 생략이 가능

package com.day07;

public class Cal2main implements Calc2 { //클래스를 상속받는 다는 뜻인 extends가 아닌 interface를 상속받는 것이니까 implements 써주기

	public static void main(String[] args) {
		

	}

	@Override
	public int add(int a, int b) {
		System.out.println(value);
		//value = 4; -> final 값인데 변경하려고 해서 에러
		return 0;
	}

	@Override
	public int sub(int a, int b) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public double average(int[] a) {
		// TODO Auto-generated method stub
		return 0;
	}

}

Calc2.java

package com.day07;

public interface Calc2 { //Calc.java 내용 다 복사해옴 -> 에러 : 추상 메서드인데 추상 클래스로 안해놓아서
	//인터페이스 변수는 final, (final 생략 가능)
	//메소드는 추상으로 만들어짐(abstract 생략 가능)
	final int value = 5; //final이나 생략 가능
	public int add(int a, int b); // interface -> 전부 추상이라 메소드는 추상으로 만들어짐(abstract 생략 가능)
	public int sub(int a, int b); 
	public double average(int[] a);
}

interfaceEx.java

package com.day07;

interface PhoneInterface {
	int TIMEOUT = 10000;
	void sendCall(); //누구한테 걸고 받을지 모름 -> interface로 만듬
	void receiveCall();
}

public class interfaceEx {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}
}

==> interface MobileInterface를 만들고 PhoneInterface를 상속받아 사용하기

이 때는 interface를 상속받는 거지만 implements를 안 쓰고 크래스를 상속받을 때처럼 extends를 씀

-> interface에서 interface를 가져다 쓸 때는 implements를 쓰지 않고 그냥 extedns 씀

package com.day07;

interface PhoneInterface { //부모를 이걸로 하겠다
	int TIMEOUT = 10000;
	void sendCall(); //누구한테 걸고 받을지 모름 -> interface로 만듬
	void receiveCall();
}

interface MobileInterface extends PhoneInterface { //interface에서 interface를 가져다 쓸 때는 interface를 쓰지 않고 그냥 extedns 씀
	void sendSMS(); //상속 받아 내용 추가
	void receiveSMS();
}

interface MP3Interface extends PhoneInterface {
	void play(); //상속 받아 내용 추가
	void stop();
}

public class interfaceEx {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}
}

+ 클래스 PDA 만들기

-> 하나의 파일에 인터페이스 여러개와 클래스를 만들었음

package com.day07;

interface PhoneInterface { //부모를 이걸로 하겠다
	int TIMEOUT = 10000;
	void sendCall(); //누구한테 걸고 받을지 모름 -> interface로 만듬
	void receiveCall();
}

interface MobileInterface extends PhoneInterface { //interface에서 interface를 가져다 쓸 때는 interface를 쓰지 않고 그냥 extedns 씀
	void sendSMS(); //상속 받아 내용 추가
	void receiveSMS();
}

interface MP3Interface extends PhoneInterface {
	void play(); //상속 받아 내용 추가
	void stop();
}
//클래스 만들기
class PDA {
	public int calculate(int x, int y) {
		return x+y;
	}
}

public class interfaceEx {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}
}

==> 여기에서

SmartPhone 클래스 작성을 하는데

//단, 이 클래스는 PDA를 상속받고
//MobileInterface, MP3Interface 인터페이스 기능을 다 갖는다

어떻게 만들어야 할까?

package com.day07;

interface PhoneInterface { //부모를 이걸로 하겠다
	int TIMEOUT = 10000;
	void sendCall(); //누구한테 걸고 받을지 모름 -> interface로 만듬
	void receiveCall();
}

interface MobileInterface extends PhoneInterface { //interface에서 interface를 가져다 쓸 때는 interface를 쓰지 않고 그냥 extedns 씀
	void sendSMS(); //상속 받아 내용 추가
	void receiveSMS();
}

interface MP3Interface extends PhoneInterface {
	void play(); //상속 받아 내용 추가
	void stop();
}
//클래스 만들기
class PDA {
	public int calculate(int x, int y) {
		return x+y;
	}
}
//SmartPhone 클래스 작성
//단, 이 클래스는 PDA를 상속받고 
//MobileInterface, MP3Interface 인터페이스 기능을 다 갖는다
class SmartPhone extends PDA implements MobileInterface, MP3Interface { //상속은 다중이 안되지만 인터페이스는 다중 가능
	
}

public class interfaceEx {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}
}

클래스 상속은 다중이 안되지만 인터페이스는 다중 가능

==> 내용 적어주기

package com.day07;

interface PhoneInterface { //부모를 이걸로 하겠다
	int TIMEOUT = 10000;
	void sendCall(); //누구한테 걸고 받을지 모름 -> interface로 만듬
	void receiveCall();
}

interface MobileInterface extends PhoneInterface { //interface에서 interface를 가져다 쓸 때는 interface를 쓰지 않고 그냥 extedns 씀
	void sendSMS(); //상속 받아 내용 추가
	void receiveSMS();
}

interface MP3Interface extends PhoneInterface {
	void play(); //상속 받아 내용 추가
	void stop();
}
//클래스 만들기
class PDA {
	public int calculate(int x, int y) {
		return x+y;
	}
}
//SmartPhone 클래스 작성
//단, 이 클래스는 PDA를 상속받고 
//MobileInterface, MP3Interface 인터페이스 기능을 다 갖는다
class SmartPhone extends PDA implements MobileInterface, MP3Interface {

	@Override
	public void sendCall() {
		System.out.println("sendCall");
		
	}

	@Override
	public void receiveCall() {
		System.out.println("receiveCall");
		
	}

	@Override
	public void play() {
		System.out.println("play");
		
	}

	@Override
	public void stop() {
		System.out.println("stop");
		
	}

	@Override
	public void sendSMS() {
		System.out.println("sendSMS");
		
	}

	@Override
	public void receiveSMS() {
		System.out.println("receiveSMS");
		
	} //상속은 다중이 안되지만 인터페이스는 다중 가능
	
}

public class interfaceEx {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}
}

==> 출력 위해 main 작성하기

package com.day07;

interface PhoneInterface { //부모를 이걸로 하겠다
	int TIMEOUT = 10000;
	void sendCall(); //누구한테 걸고 받을지 모름 -> interface로 만듬
	void receiveCall();
}

interface MobileInterface extends PhoneInterface { //interface에서 interface를 가져다 쓸 때는 interface를 쓰지 않고 그냥 extedns 씀
	void sendSMS(); //상속 받아 내용 추가
	void receiveSMS();
}

interface MP3Interface extends PhoneInterface {
	void play(); //상속 받아 내용 추가
	void stop();
}
//클래스 만들기
class PDA {
	public int calculate(int x, int y) {
		return x+y;
	}
}
//SmartPhone 클래스 작성
//단, 이 클래스는 PDA를 상속받고 
//MobileInterface, MP3Interface 인터페이스 기능을 다 갖는다
class SmartPhone extends PDA implements MobileInterface, MP3Interface {

	@Override
	public void sendCall() {
		System.out.println("sendCall");
		
	}

	@Override
	public void receiveCall() {
		System.out.println("receiveCall");
		
	}

	@Override
	public void play() {
		System.out.println("play");
		
	}

	@Override
	public void stop() {
		System.out.println("stop");
		
	}

	@Override
	public void sendSMS() {
		System.out.println("sendSMS");
		
	}

	@Override
	public void receiveSMS() {
		System.out.println("receiveSMS");
		
	} //상속은 다중이 안되지만 인터페이스는 다중 가능
	
}

public class interfaceEx {

	public static void main(String[] args) {
		SmartPhone s = new SmartPhone();
		s.sendCall();
		s.sendSMS();
		s.play();
		System.out.println("3+5 = " + s.calculate(3, 5));
	} // 당연히 다 사용 가능
}

sendCall
sendSMS
play
3+5 = 8

Test.java

AbsShape를 상속 받고 Calc2 기능을 구현한 클래스 작성하기

- AbsShape : 추상 클래스이므로 extedns 사용

- Calc2 : interface이므로 implements 사용

- 적어준 후 Test의 빨간 밑줄 클릭 -> add 해서 아래와 같이 자도으로 구현이 되지 않은 메서드들 작성되도록 함

package com.day07;

//AbsShape를 상속 받고 Calc2 기능을 구현한 클래스 작성하기
public class Test extends AbsShape implements Calc2  {

	@Override
	public int add(int a, int b) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public int sub(int a, int b) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public double average(int[] a) {
		// TODO Auto-generated method stub
		return 0;
	}

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

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

	
}

https://docs.oracle.com/javase/8/docs/api/

Java Platform SE 8

docs.oracle.com

java.util > Classes의 ArrayList

ArrayList도 AbstractList라는 클래스와 List, RandomAccess, Cloneable, Serializble 이런 interface들을 가지고 와서 만들어진다.

PersonNumberStorage.java 인터페이스 만들기

package com.day07;

public interface PersonNumberStorage { //추상 
	public void addPersonalInfo(String name, String perNum); //추상 메서드 -> 메서드 이름 정의, 받아올 인수 지정 But 받아온 인수로 뭘 할지 모르니 구현X
	public String searchName(String pernum); //추상 메서드 -> 구현X
}

PersonNumberStorageImpl.java 클래스 작성

- 이 클래스는 PersonNumberStorage를 받아와서 구현할 것(Impl -> implements)

package com.day07;

public class PersonNumberStorageImpl implements PersonNumberStorage {

	@Override
	public void addPersonalInfo(String name, String perNum) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public String searchName(String perNum) {
		// TODO Auto-generated method stub
		return null;
	}

}

InterfaceTest.java

package com.day07;

interface ShapeArea {
	double area(); //면적 구하기 : 누구의 면적을 구하는지 모르니까 이름만 정해줌
	double circum();
}

public class InterfaceTest {

	public static void main(String[] args) {
		ShapeArea rec = new Rectangle(5, 7); //사각형
		ShapeArea circle = new SCircle(5); //원
		System.out.println("원 넓이 : " + circle.area());
		System.out.println("원 둘레 : " + circle.circum());
		System.out.println("사각형 넓이" : " + rec.area());
		System.out.println("사각형 둘레 : " + rec.circum());
		

	}
}

==> 오류 나지 않도록 만들어 주기

package com.day07;

interface ShapeArea { //아래 두개를 구현해야하지만 추상 이라 구현할 수 없음, 구현할 수 있는 class를 따로 만들어 주어야 함
	double area(); //면적 구하기 : 누구의 면적을 구하는지 모르니까 이름만 정해줌
	double circum();
}

class Rectangle implements ShapeArea {
	private int x, y;
	
	public Rectangle(int x, int y) { //생성자
		this.x = x;
		this.y = y;
	}
	
	@Override
	public double area() {
		return x*y;
	}

	@Override
	public double circum() {
		return 2*(x+y);
	}
}

class SCircle implements ShapeArea {
	int r;
	
	public SCircle(int r) {//생성자
		this.r = r;
	}

	@Override
	public double area() {
		return r*r*3.14;
	}

	@Override
	public double circum() {
		return r*2*3.14;
	}
}

public class InterfaceTest {

	public static void main(String[] args) {
		ShapeArea rec = new Rectangle(5, 7); //사각형 -> 안에 2개 값을 가지는 생성자 필요
		ShapeArea circle = new SCircle(5); //원
		System.out.println("원 넓이 : " + circle.area());
		System.out.println("원 둘레 : " + circle.circum());
		System.out.println("사각형 넓이 : " + rec.area());
		System.out.println("사각형 둘레 : " + rec.circum());
	}
}

원 넓이 : 78.5
원 둘레 : 31.400000000000002
사각형 넓이 : 35.0
사각형 둘레 : 24.0

API 보기

자바는 import를 하지 않으면 기본은 java.lang에 있음

java.lang > Classes Math >

package com.day07;

interface ShapeArea { //아래 두개를 구현해야하지만 추상 이라 구현할 수 없음, 구현할 수 있는 class를 따로 만들어 주어야 함
	double area(); //면적 구하기 : 누구의 면적을 구하는지 모르니까 이름만 정해줌
	double circum();
}

class Rectangle implements ShapeArea {
	private int x, y;
	
	public Rectangle(int x, int y) { //생성자
		this.x = x;
		this.y = y;
	}
	
	@Override
	public double area() {
		return x*y;
	}

	@Override
	public double circum() {
		return 2*(x+y);
	}
}

class SCircle implements ShapeArea {
	int r;
	
	public SCircle(int r) {//생성자
		this.r = r;
	}

	@Override
	public double area() {
		return r*r*Math.PI;//PI를 우리가 만들지 말고 이미 만들어진걸 쓰자
	}

	@Override
	public double circum() {
		return r*2*Math.PI;//static은 클래스 이름을 접근
	}
}

public class InterfaceTest {

	public static void main(String[] args) {
		ShapeArea rec = new Rectangle(5, 7); //사각형 -> 안에 2개 값을 가지는 생성자 필요
		ShapeArea circle = new SCircle(5); //원
		System.out.println("원 넓이 : " + circle.area());
		System.out.println("원 둘레 : " + circle.circum());
		System.out.println("사각형 넓이 : " + rec.area());
		System.out.println("사각형 둘레 : " + rec.circum());
	}
}

원 넓이 : 78.53981633974483
원 둘레 : 31.41592653589793
사각형 넓이 : 35.0
사각형 둘레 : 24.0

이때까지는 3.14를 적어주거나, final double PI = 3.14; 이렇게 만들어줘서 써줬는데

Math라는 수학적 클래스에 static double PI가 있으니 이걸 갖다가 쓰면 된다.

Math.PI

Math는 import를 안해도 사용가능?

- 기본적으로 java.lang이라는 패키지에 들어있는 것은 import를 하지 않아도 쓸 수 있다.

ex) System.out.println();, Object 등을 우리가 이때까지 그냥 써온 것처럼

java.ultil > Classes에 ArrayList, Scanner ..

이전 6일차에 했던 ProductMain2.java를 보기

List로 바꾸면 에러 남 -> java.util의 List를 import 시켜주지 않았기 때문

java.util에 있는 것은 반드시 import해서 써줘야 한다.

이렇게 써주어도 됨

p. 275~276

AnimalTest.java

Animal 클래스에는 자식 Human, Tiger, Eagle이 있으며,

- Animal은 공통적으로 move할 수 있다.

- 사람은 readBook, 호랑이는 hunting, 독수리는 flying 할 수 있다.

객체 생성은 new 로 할 수 있음 그런데 좌측에서는 내가 객체 생성을 하면서 hu, ti, ea 라는 이름을 지어줬는데

한 번만 쓸거면 굳이 이렇게 이름써주고 하면서 할 필요 없이 우측처럼 해주면 된다.

package com.day07;
//p275~276

import java.util.ArrayList;

class Animal {
	public void move() {
		System.out.println("동물이 움직입니다.");
	}
}

class Human extends Animal { // Animal을 상속 받음
	@Override
	public void move() {
		System.out.println("사람이 두 발로 걷습니다.");
	}

	public void readBook() {
		System.out.println("사람이 책을 읽습니다.");
	}
}

class Tiger extends Animal {
	@Override
	public void move() {
		System.out.println("호랑이가 네 발로 뜁니다.");
	}

	public void hunting() {
		System.out.println("호랑이가 사냥을 합니다.");
	}
}

class Eagle extends Animal {
	public void move() {
		System.out.println("독수리가 하늘을 납니다.");
	}

	public void flying() {
		System.out.println("독수리가 날개를 쭉 펴고 멀리 날아갑니다.");
	}
}

public class AnimalTest {
	ArrayList<Animal> aniList = new ArrayList<>();

	public void addAnimal() { // 추가해야 하니 ArrayList 사용
		aniList.add(new Human()); // Animal hu = new Human(); 에서 hu라는 객체 이름만 없을 뿐! -> 일회성(이름만 없다 뿐이지 객체가 만들어짐)
		aniList.add(new Tiger());
		aniList.add(new Eagle());
	}

	public void testCasting() {
		for (int i = 0; i < aniList.size(); i++) {
			Animal ani = aniList.get(i);
			if (ani instanceof Human) {// 객체가 어디에 해당되는지 물어봄. ani라고 하는 애가 Human형인지 물어보는 것 -> 객체 instanceof 클래스명
				Human h = (Human)ani;//큰 형(ani)을 작은 데(Human)에 담을 때는 반드시 캐스팅? 해줘야 함
				h.readBook();
			} else if(ani instanceof Tiger) {
				Tiger t = (Tiger) ani;
				t.hunting();
			} else if(ani instanceof Eagle) {
				Eagle e = (Eagle) ani;
				e.flying();
			} else {
				System.out.println("지원되지 않는 형입니다.");
			}
		}
	}

	public static void main(String[] args) {
		AnimalTest atest = new AnimalTest();
		atest.addAnimal();
		System.out.println("원래 형으로 다운 캐스팅");
		atest.testCasting();
	}
}

원래 형으로 다운 캐스팅
사람이 책을 읽습니다.
호랑이가 사냥을 합니다.
독수리가 날개를 쭉 펴고 멀리 날아갑니다.

당연히 다 됨 -> 모두 ani를 상속받았기 때문에

package com.day07;
//p275~276 -> instance로 원래 인스턴스형 확인 후 다운 캐스팅하기

import java.util.ArrayList;

class Animal {
	public void move() {
		System.out.println("동물이 움직입니다.");
	}
}

class Human extends Animal { // Animal을 상속 받음
	@Override
	public void move() {
		System.out.println("사람이 두 발로 걷습니다.");
	}

	public void readBook() {
		System.out.println("사람이 책을 읽습니다.");
	}
}

class Tiger extends Animal {
	@Override
	public void move() {
		System.out.println("호랑이가 네 발로 뜁니다.");
	}

	public void hunting() {
		System.out.println("호랑이가 사냥을 합니다.");
	}
}

class Eagle extends Animal {
	public void move() {
		System.out.println("독수리가 하늘을 납니다.");
	}

	public void flying() {
		System.out.println("독수리가 날개를 쭉 펴고 멀리 날아갑니다.");
	}
}

public class AnimalTest {
	ArrayList<Animal> aniList = new ArrayList<>();

	public void addAnimal() { // 추가해야 하니 ArrayList 사용
		aniList.add(new Human()); // Animal hu = new Human(); 에서 hu라는 객체 이름만 없을 뿐! -> 일회성(이름만 없다 뿐이지 객체가 만들어짐)
		aniList.add(new Tiger());
		aniList.add(new Eagle());
	}

	public void testCasting() {
		for (int i = 0; i < aniList.size(); i++) {
			Animal ani = aniList.get(i);
			if (ani instanceof Human) {// 객체가 어디에 해당되는지 물어봄. ani라고 하는 애가 Human형인지 물어보는 것 -> 객체 instanceof 클래스명
				ani = h;
				Human h = (Human)ani;//큰 형(ani)을 작은 데(Human)에 담을 때는 반드시 캐스팅? 해줘야 함
				h.readBook();
			} else if(ani instanceof Tiger) {
				Tiger t = (Tiger) ani; //하위 캐스팅 = 상위(X)
				t.hunting();
			} else if(ani instanceof Eagle) {
				Eagle e = (Eagle) ani;
				e.flying();
			} else {
				System.out.println("지원되지 않는 형입니다.");
			}
		}
	}

	public static void main(String[] args) {
		AnimalTest atest = new AnimalTest();
		atest.addAnimal();
		System.out.println("원래 형으로 다운 캐스팅");
		atest.testCasting();
	}
}

p.278 Q4

Engineer.java

package com.day07;
//p.278 4번 문제
//오류가 발생함 ==> 오류 수정하기
class Employee {
	public String name;
	public String grade;
	public Employee(String name) {
	this.name = name;
	}
}
public class Engineer extends Employee {
	private String skillset;
	public String getSkillSet() {
		return skillset;
	}
	public void setSkillSet(String skillset) {
	this.skillset = skillset;
	}
}

오류 고치기

===>

- 방법 1

package com.day07;
//p.278 4번 문제
//오류가 발생함 ==> 오류 수정하기
class Employee {
	public String name;
	public String grade;
	public Employee() { // 방법1
	
	}

	public Employee(String name) {
	this.name = name;
	}
}

public class Engineer extends Employee {
	private String skillset;
	
	public String getSkillSet() {
		return skillset;
	}
	public void setSkillSet(String skillset) {
	this.skillset = skillset;
	}
}

- 방법2

package com.day07;
//p.278 4번 문제
//오류가 발생함 ==> 오류 수정하기
class Employee {
	public String name;
	public String grade;

	public Employee(String name) {
	this.name = name;
	}
}

public class Engineer extends Employee {
	private String skillset;
	public Engineer() { //방법2
	super("홍길동");
	}
	
	public String getSkillSet() {
		return skillset;
	}
	public void setSkillSet(String skillset) {
	this.skillset = skillset;
	}
}

p.279 Q5

ShapeTest.java -> 이미 같은 패키지 안에 Shape, Circle, Triangle 클래스가 존재하므로

책과 다르게 2를 붙여줌

결과가 다음과 같이 나오도록! 에러 없애주기

Circle2

Triangle2

Shape2

==> 수정

list라는 자료구조 정의가 안되어 있고 이것이 Circle2, Triangle2, Shape2를 모두 아우르는 Shape2형이어야 함

package com.day07;

import java.util.ArrayList;

//p.269 Q5번
class Shape2 {
	public void draw() {
		System.out.println("Shape2");
	}
}

class Circle2 extends Shape2 {
	public void draw() {
		System.out.println("Circle2");
	}
}

class Triangle2 extends Shape2 {
	public void draw() {
		System.out.println("Triangle2");
	}
}

public class ShapeTest {
	public static void main(String[] args) {
		ArrayList<Shape2> list = new ArrayList<>(); //
		list.add(new Circle2());
		list.add(new Triangle2());
		list.add(new Shape2());
		
		for(Shape2 s : list) {
			s.draw(); //
		}
	}
}

여기까지가 상속

static에 대한 질문 -static은 어느 범위에서 접근 할 수 있습니까?

static 접근 범위가 패키지단위인가요? 아니면 프로젝트 단위인가요?
static 생성 시기는 jvm 실행 될 때 클래스안에 있는 모든 static들을 뛰우고 시작하나요?
- 먼저 실행합니다
접근 가능한 범위는 패키지에 속해있을 때만 접근가능한가요?

프로그램을 시작하면 static이 가장 먼저 실행된다고 함

보통 객체 생성하거나 사용하거나 함수 사용할 떄 메모리상에 올라가서 실 사용을 하게 되는데 static은 프로그램 실행(자바가상머신) 될 때부터 메모리상에 올라가 있다는 의미

PersonNumberStorageImpl에서 선언한 static String value = "yes"; 이걸 사용할 수 있는 범위는

static의 문제가 아니라 앞에 아무것도 안 붙이느냐 아니면 private가 붙느냐 public이 붙느냐의 문제

private으로 선언하면 사용 불가

public 으로 선언하면 다른 패키지 내에서도 사용 가능?

다시 말해서

그냥 써주면 동일 패키지 내에서는 사용 가능, 다른 패키지에서는 사용 불가능

private를 붙여버리면 같은 패키지에 있더라도 클래스가 다르므로 사용 불가능

public으로 써주면 다른 패키지에서도 사용 가능

-> import되어있어서 그런건가?!

결론 : 모르겠따!

p.298-303

PlayerLevel.java

package com.day07;
//p.299
public abstract class PlayerLevel {
	public abstract void run();
	public abstract void jump();
	public abstract void turn();
	public abstract void showLevelMessage(); // 정의할 수 없어서 함수처럼 취급? 
	
	final public void go(int count) { //final을 써줌으로써 갖다 쓴 곳에서 바꾸지 못하도록 함
		run();
		for(int i=0; i < count; i++) {
			jump();
		}
		run();
	}
}

Player.java

package com.day07;

public class Player {
	private PlayerLevel level;
	
	public Player() {
		level = new BeginnerLevel(); //초급자
		level.showLevelMessage();
	}
	public PlayerLevel getLevel() {
		return level;
	}
	public void upgradeLevel(PlayerLevel level) {
		this.level = level;
		level.showLevelMessage();
	}
	public void player(int count) {
		level.go(count);
	}
}

BeginerLevel 만들어줘야 함

package com.day07;

//p300
public class BeginnerLevel extends PlayerLevel {

	@Override
	public void run() {
		System.out.println("천천히 달립니다.");
	}

	@Override
	public void jump() {
		System.out.println("Jump할 줄 모름.");
	}

	@Override
	public void turn() {
		System.out.println("Turn할 줄 모름");
	}

	@Override
	public void showLevelMessage() {
		System.out.println("**** 초보자 레벨입니다. ****");
		
	}

}

AdvancedLevel도 만들어주기

package com.day07;
//p301
public class AdvancedLevel extends PlayerLevel {

	@Override
	public void run() {
		System.out.println("빨리 달립니다.");
		
	}

	@Override
	public void jump() {
		System.out.println("높이 jmp합니다.");
		
	}

	@Override
	public void turn() {
		System.out.println("Turn할 줄 모름");
		
	}

	@Override
	public void showLevelMessage() {
		System.out.println("**** 중급자 레벨입니다. ****");
		
	}

}

SuperLevel.java

package com.day07;

public class SuperLevel extends PlayerLevel {

	@Override
	public void run() {
		System.out.println("엄청 빨리 달립니다.");
	}

	@Override
	public void jump() {
		System.out.println("아주 높이 Jump합니다.");
	}

	@Override
	public void turn() {
		System.out.println("한 바퀴 돕니다.");
	}

	@Override
	public void showLevelMessage() {
		System.out.println("**** 고급자 레벨입니다. ****");
	}
}

MainBoard

package com.day07;

public class MainBoard {

	public static void main(String[] args) {
		Player player = new Player();
		player.player(1);
		
		AdvancedLevel aLevel = new AdvancedLevel();
		player.upgradeLevel(aLevel);;
		player.player(2);
		
		SuperLevel slevel = new SuperLevel();
		player.upgradeLevel(slevel);
		player.player(3);
	}
}

**** 초보자 레벨입니다. ****
천천히 달립니다.
Jump할 줄 모름.
천천히 달립니다.
**** 중급자 레벨입니다. ****
빨리 달립니다.
높이 jmp합니다.
높이 jmp합니다.
빨리 달립니다.
**** 고급자 레벨입니다. ****
엄청 빨리 달립니다.
아주 높이 Jump합니다.
아주 높이 Jump합니다.
아주 높이 Jump합니다.
엄청 빨리 달립니다.

자바에서는 다중 상속X

그러나 인터페이스에서는 여러개 쓸 수 있다. -> 이런 것들을 이용해서 마치 다중상속 된 것처럼 쓸 수 있다.

String

java.lnag > String >

Object을 상속받음

StringTest01.java

String은 조금 다르다.

보통 객체를 생성할 때 new 라는 키워드를 이용해 만드는데

그냥도 가능! 차이가 있는지 살펴보자

package com.day07;

public class StringTest01 {

	public static void main(String[] args) {
		String str ="안녕"; //new를 사용하지 않고 객체 생성
		String str1 = "안녕";
		String tmp = new String("안녕"); //new를 사용해서 객체 생성
		
		if(str==tmp) {
			System.out.println("str==tmp 같다");
		} else {
			System.out.println("str==tmp 다르다");
		}
		
		if(str==str1) {
			System.out.println("str==str1 같다");
		} else {
			System.out.println("str==str1 다르다");
		}
	}
}

==> 결과 예측 해보자

String -> 정적 클래스 : 변할 수 없다.

우리가 + 기호를 이용해 연결을 시키지만 사실 연결시키면 그 객체가 변하는 것이 아니라

없어졌다 만들어졌다 하는 것

==> 결과 예측

package com.day07;

public class StringTest01 {

	public static void main(String[] args) {
		String str ="안녕"; //new를 사용하지 않고 객체 생성
		String str1 = "안녕";
		String tmp = new String("안녕"); //new를 사용해서 객체 생성
		
		if(str==tmp) { //주소 물어볼 때
			System.out.println("str==tmp 주소 같다");
		} else {
			System.out.println("str==tmp 주소 다르다");
		}
		
		if(str==str1) {
			System.out.println("str==str1 같다");
		} else {
			System.out.println("str==str1 다르다");
		}
		
		if(str.equals(tmp)) { //내용을 물어볼 때
			System.out.println("str equals tmp 내용 같다");
		} else {
			System.out.println("str equals tmp 내용 다르다");
		}
		
		if(str.equals(str1)) {
			System.out.println("str equals str1 내용 같다");
		} else {
			System.out.println("str equals str1 내용 다르다");
		}
	}
}

equals를 쓸 수 있었던 이유는 equals는 Object가 가지는 메소드이기 때문

==> str = str + str1 해준 뒤 다시 비교해보자.

처음에는 str과 str1이 주소가 같았다. 그러나 str의 내용을 바꿔주자 str의 주소가 변해서 str1과 주소가 다르다고 한다.

정적 클래스는 한번 만든 내용을 바꿀 수 없다 -> str 100번지에 "안녕"이 저장 되어있었는데

str = str+str인 "안녕안녕"을 하면 str은 100번지 "안녕"을 버리고 다른 번지 ex)50 번지에 "안녕안녕"을 새로 만든다.

String 클래스는 정적클래스이므로 내용을 바꾸지 못한다 -> 바뀐것처럼 보이지만 새로 만든 것

StringTest02.java

package com.day07;

public class StringTest02 {

	public static void main(String[] args) {
		String str = "안녕하세요 Hello 지금은 자바공부!!!";
		System.out.println("str 길이 : " + str.length());
		System.out.println("H의 위치 : " + str.indexOf("H")); //위치도 0부터 시작
		System.out.println("Hello의 위치 : " + str.indexOf("Hello"));//Hello가 시작된 위치 알려줌
		System.out.println("4번째 문자는 뭘까 ?" + str.charAt(4)); //int형을 괄호 안에 써주면 char(하나의 문자)를 반환해 줌
	}
}

concat()의 괄호 안에는 String형만 와야 하는데 value는 int형이므로 에러

보통은 객체로 접근

package com.day07;

public class StringTest02 {

	public static void main(String[] args) {
		String str = "안녕하세요 Hello 지금은 자바공부!!!";
		System.out.println("str 길이 : " + str.length());
		System.out.println("H의 위치 : " + str.indexOf("H")); //위치도 0부터 시작
		System.out.println("Hello의 위치 : " + str.indexOf("Hello"));//Hello가 시작된 위치 알려줌
		System.out.println("4번째 문자는 뭘까 ?" + str.charAt(4)); //int형을 괄호 안에 써주면 char(하나의 문자)를 반환해 줌
		System.out.println();
		
		String tmp = "열심히 합시다";
		System.out.println("str과 tmp 연결 : " + str+tmp ); //내용이 바뀌었으므로 메모리에 두개가 합쳐진 것이 새로 만들어졌을 것
		System.out.println("str과 tmp 연결 : " + str.concat(tmp));//두개를 연결시켜주는 함수 -> 위와 결과는 같다
		System.out.println();
		
		int value = 7;
		//str과 value를 연결해보라
		System.out.println("str과 value 연결 : " + str+value );
		//System.out.println("str과 value 연결 : " + str.concat(value)); -> 에러 contcat(문자만가능)
		System.out.println("str과 value 연결 : " + str.concat(value+""));//+""해줘서 value를 문자형으로 바꿔줘도 되고
		//int ==> String 변환
		String s = String.valueOf(value);
		System.out.println("str과 value 연결 : " + str.concat(s));//문자형 변수 s에 담아서 출력해도 되고
		System.out.println("str과 value 연결 : " + str.concat(String.valueOf(value)));//변수에 담지 않고 직접 넣어도 됨
	}
}

str 길이 : 23
H의 위치 : 6
Hello의 위치 : 6
4번째 문자는 뭘까 ?요

str과 tmp 연결 : 안녕하세요 Hello 지금은 자바공부!!!열심히 합시다
str과 tmp 연결 : 안녕하세요 Hello 지금은 자바공부!!!열심히 합시다

str과 value 연결 : 안녕하세요 Hello 지금은 자바공부!!!7
str과 tmp 연결 : 안녕하세요 Hello 지금은 자바공부!!!7
str과 tmp 연결 : 안녕하세요 Hello 지금은 자바공부!!!7
str과 tmp 연결 : 안녕하세요 Hello 지금은 자바공부!!!7

tmp2의 문자를 바꿔보자

자동으로 마지막 문자 찾음!

package com.day07;

public class StringTest02 {

	public static void main(String[] args) {
		String str = "안녕하세요 Hello 지금은 자바공부!!!";
		System.out.println("str 길이 : " + str.length());
		System.out.println("H의 위치 : " + str.indexOf("H")); //위치도 0부터 시작
		System.out.println("Hello의 위치 : " + str.indexOf("Hello"));//Hello가 시작된 위치 알려줌
		System.out.println("4번째 문자는 뭘까 ?" + str.charAt(4)); //int형을 괄호 안에 써주면 char(하나의 문자)를 반환해 줌
		System.out.println();
		
		String tmp = "열심히 합시다";
		System.out.println("str과 tmp 연결 : " + str+tmp ); //내용이 바뀌었으므로 메모리에 두개가 합쳐진 것이 새로 만들어졌을 것
		System.out.println("str과 tmp 연결 : " + str.concat(tmp));//두개를 연결시켜주는 함수 -> 위와 결과는 같다
		System.out.println();
		
		int value = 7;
		//str과 value를 연결해보라
		System.out.println("str과 value 연결 : " + str+value );
		//System.out.println("str과 tmp 연결 : " + str.concat(value)); -> 에러 contcat(문자만가능)
		System.out.println("str과 tmp 연결 : " + str.concat(value+""));//+""해줘서 value를 문자형으로 바꿔줘도 되고
		//int ==> String 변환
		String s = String.valueOf(value);
		System.out.println("str과 tmp 연결 : " + str.concat(s));//문자형 변수 s에 담아서 출력해도 되고
		System.out.println("str과 tmp 연결 : " + str.concat(String.valueOf(value)));//변수에 담지 않고 직접 넣어도 됨
		System.out.println();
		
		String tmp2 = "asdskfdsj fkwehofwe fsdkfjslfdsfkwhelfepjreppp";
		System.out.println("1. tmp2 : " + tmp2);
		System.out.println("2. tmp2 대문자 : " + tmp2.toUpperCase());//대문자로 바꿔줌
		System.out.println("3. tmp2 다시 소문자로 : " + tmp2.toUpperCase().toLowerCase());//대문자로 바꾼 것을 다시 소문자로 변경
		//tmp2 문자열의 길이?
		System.out.println("tmp2의 문자열의 길이 : " + tmp2.length());
		//tmp2 문자열의 마지막 문자는?
		System.out.println("tmp2의 문자열의 마지막 문자 : " + tmp2.charAt(tmp2.length()-1));//이렇게 써주면 마지막 문자가 바뀌어도 자동적으로 마지막 문자 나옴
	}
}

728x90

저작자표시

'프로그래밍 > 자바(java) 융합개발자 2차' 카테고리의 다른 글

[자바 9일차] 28일차 - 컬렉션 프레임워크 (p.404~447) (0)	2021.01.22
[자바 8일차] 27일차 - String 클래스(p.369~) (0)	2021.01.21
[자바 6일차] 25일차 - 다차원 배열, 상속(Do it 공부단 p.219~) (0)	2021.01.20
[자바 5일차] 24일 - ArrayList (0)	2021.01.18
[자바 4일차] 23일차 - 클래스 (0)	2021.01.15

현재글[자바 7일차] 26일차 - 상속, 추상클래스, 추상메서드 , 인터페이스(Do it 공부단 p.234~)

HelloSpring