230321 풀스택 14일차 - 자바 기초 복습(생성자~)

온라인 자바 연습장, code.oa.gg/java8 사용법

월화 자바기초 복습 생성자까지
수요일 임베디드
목금 자바기초 복습 생성자 응용 인터페이스와 예외처리
그 다음주 토이프로젝트 자바로(깃허브랑 같이해서 버전관리 하는식으로 포폴형태) => 자바 문법 리마인드
그 다음주 DB, SQL
끝나면 스프링부트(스프링을 더 쉽게 쓰기위한 자유도가 높은 프레임워크)
그다음 게시판 튜토리얼, 프론트엔드과정(HTML, CSS, JS(Jquery))
react
=> 프로젝트 1, 2, 3

230321 오늘은 자바 복습

전사 재공격 문제

public class Main {
    public static void main(String[] args) {
        전사 a전사 = new 전사();

        a전사.공격("브라이언", "칼");
        // 브라이언(이)가 칼(으)로 공격합니다.

        a전사.재공격();
        // 브라이언(이)가 칼(으)로 공격합니다.

        a전사.공격("필립", "창");
        // 필립(이)가 창(으)로 공격합니다.

        a전사.공격("마크", "지팡이");
        // 마크(이)가 지팡이(으)로 공격합니다.

        a전사.재공격();
        // 마크(이)가 지팡이(으)로 공격합니다.

        a전사.재공격();
        // 마크(이)가 지팡이(으)로 공격합니다.
    }
}
class 전사 {
	String 전사이름1; // 매개변수가 없기때문에 전사클래스 안에서 전사 이름과 무기를 새로 선언해줘야 함.
	String 전사무기1; // 매개변수가 없기때문에 전사클래스 안에서 전사 이름과 무기를 새로 선언해줘야 함.
	void 공격 (String 전사이름, String 전사무기) { // 매개변수를 사용해서 출력문 출력
		System.out.println(전사이름 + "(이)가 " + 전사무기 + "(으)로 공격합니다.");
		전사이름1 = 전사이름; // 매개변수로 사용하던 변수들을 매개변수가 없는 메서드에 연결해주는 과정
		전사무기1 = 전사무기; // 매개변수로 사용하던 변수들을 매개변수가 없는 메서드에 연결해주는 과정
	}
	void 재공격 () { // 매개변수 없이 새로 선언된 변수를 이용한 메서드 출력
		System.out.println(전사이름1 + "(이)가 " + 전사무기1 + "(으)로 재공격합니다.");
	}
}

달리기문제(초보문제)

class Main {
	public static void main(String[] args) {
		사람 a사람 = new 사람();
		a사람.달리기_속력 = 20;
		a사람.달리다();
		// 사람이 20km/h로 달립니다.
		
		a사람.달리다();
		// 사람이 20km/h로 달립니다.
		
		a사람.달리기_속력 = 50;
		a사람.달리다();
		// 사람이 50km/h/로 딜립니다.
		
	}
}
class 사람 {
	int 달리기_속력;
	void 달리다 () {
		System.out.println("사람이 " + this.달리기_속력 + "km/h로 달립니다.");
	}
}

a왼팔을 변수에 할당해주세요.

class Main {
	public static void main(String[] args) {
		사람 a사람 = new 사람();
		
		a사람.나이 = 20;
		a사람.a왼팔 = new 팔();
		
	}
}
class 사람 {
	int 나이;
	팔 a왼팔; // 타입이 팔 인 a왼팔 변수 선언.
}
class 팔 {
	
}

칼과 활을 둘 다 사용할 수 있게 해주세요

class Main {
	public static void main(String[] args) {
		전사 a전사 = new 전사();
		a전사.나이 = 20;
		a전사.a무기 = new 활();
		a전사.a무기 = new 칼();
	}
}
class 전사 {
	int 나이;
	무기 a무기; // a무기타입으로 활, 칼객체를 넣어주려고 함. a무기의 자료형 만들어서 선언해주면 됨.
}
class 무기 {
}
class 활 extends 무기{
}
class 칼 extends 무기{
}

아래가 실행되도록 해주세요.

// 문제 : 아래가 실행되도록 해주세요.
class Main {
	public static void main(String[] args) {
		전사 a전사 = new 전사();
		String 이름 = "칸";
		a전사.이름 = 이름;
		a전사.나이 = 20;
		a전사.자기소개();
		
		a전사.나이++;
		a전사.자기소개();
		
		a전사.나이 = 30;
		a전사.이름 = "카니";
		a전사.자기소개();
		
		a전사.a무기 = new 활();
		a전사.공격();
		// 출력 : 카니가 활로 공격합니다.
		
		a전사.a무기 = new 칼();
		a전사.공격();
		// 출력 : 카니가 칼로 공격합니다.
	}
}
class 전사 {
	// 인스턴스 변수
	String 이름;
	// 인스턴스 변수
	int 나이;
	// 인스턴스 변수
	무기 a무기;
	void 자기소개() {
		System.out.println("안녕하세요. 저는 " + this.나이 + "살 " + this.이름 + " 입니다.");
	}
	void 공격 () {
		this.a무기.작동(이름);
	}
}
abstract class 무기 {
	abstract void 작동 (String 전사이름);
}
class 칼 extends 무기 {
	void 작동 (String 전사이름) {
		System.out.println(전사이름 + "가 칼로 공격합니다.");
	}
}
class 활 extends 무기 {
	void 작동 (String 전사이름) {
		System.out.println(전사이름 + "가 활로 공격합니다.");
	}
}

위 문제를 매개변수 없이 출력하는 법

// 문제 : 아래가 실행되도록 해주세요.
class Main {
	public static void main(String[] args) {
		전사 a전사 = new 전사();
		String 이름 = "칸";
		a전사.이름 = 이름;
		a전사.나이 = 20;
		a전사.자기소개();
		a전사.나이++;
		a전사.자기소개();
		a전사.나이 = 30;
		a전사.이름 = "카니";
		a전사.자기소개();
		a전사.a무기 = new 활();
		a전사.공격();
		// 출력 : 카니가 활로 공격합니다.
		a전사.a무기 = new 칼();
		a전사.공격();
		// 출력 : 카니가 칼로 공격합니다.
	}
}
class 전사 {
	// 인스턴스 변수
	String 이름;
	// 인스턴스 변수
	int 나이;
	// 인스턴스 변수
	무기 a무기;
	void 자기소개() {
		System.out.println("안녕하세요. 저는 " + this.나이 + "살 " + this.이름 + " 입니다.");
	}
	void 공격 () {
		a무기.전사이름 = this.이름; // 작동메서드보다 위에 할당되어야 함.
		a무기.작동();
	}
}
abstract class 무기 {
	String 전사이름; // 전사클래스에서 String 이름; 선언해준 것 처럼 여기서도 선언해줘야 밑에 상속받는 클래스에도 할당값이 전달됨.
	abstract void 작동 ();
}
class 칼 extends 무기 {
	void 작동 () {
		System.out.println(전사이름 + "가 칼로 공격합니다.");
	}
}
class 활 extends 무기 {
	void 작동 () {
		System.out.println(전사이름 + "가 활로 공격합니다.");
	}
}

무기가 없을 때 공격을 못하고 무기를 장착하면 공격할 수 있다는 출력
↓↓
공격메서드를 작동시 무기가 있는지 먼저확인하는 목적으로 if문을 사용해서 조건을 걸어줌(무기가 있냐? 없냐? => (a무기 == null))
위 조건이 참이면 무기가 없는 것이므로 System.out.println("아직 무기가 없습니다."); 를 호출하고
위 조건이 거짓일 경우엔 무기가 있다는 뜻이므로 a무기.작동(); 메서드를 호출함.

// 힌트 : if ( a무기 == null ) { ... }
class Main {
	public static void main(String[] args) {
		전사 a전사 = new 전사();
		a전사.공격(); // 전사 클래스의 void 공격 메서드 호출
		// 출력 => 아직 무기가 없습니다.
		a전사.a무기 = new 칼();
		a전사.공격(); // 전사 클래스의 void 공격 메서드 호출
		// 출력 => 칼로 공격합니다.
	}
}
class 전사 {
	무기 a무기;
	void 공격 () { // a전사.공격(); 가 호출한 메서드
		if (a무기 == null) { // void 공격 메서드 내부에서 if 조건문이 실행되어야 함.
			System.out.println("아직 무기가 없습니다.");
		} else {
			a무기.작동(); // 무기 클래스의 void 작동 메서드 호출
		}
	}
}
abstract class 무기 {
	abstract void 작동 (); // a무기.작동(); 가 호출한 메서드
}
class 칼 extends 무기{
	void 작동 () { // a무기.작동(); 가 호출한 메서드
		System.out.println("칼로 공격합니다.");
	}
}

전사는 무기를 양 손으로 사용할 수 있어야 합니다.
핵심은 a무기1과 a무기2가 선언되었을 때, 값이 없으면 null값이 나온다는 것과
값을 할당해주었을 때 해당 객체가 실행된다는 것.

class Main {
	public static void main(String[] args) {
		전사 a전사 = new 전사();
		a전사.a무기1 = new 칼();
		a전사.공격();
		// 출력 => 전사가 칼로 공격합니다.
		
		a전사.a무기1 = new 활();
		a전사.공격();
		// 출력 => 전사가 활로 공격합니다.
		
		a전사.a무기2 = new 칼();
		a전사.공격();
		// 출력 => 전사가 활로 공격합니다.
		// 출력 => 전사가 칼로 공격합니다.
	}
}
class 전사 {
	무기 a무기1;
	무기 a무기2;
	void 공격 () {
		if (a무기1 != null){
			a무기1.작동();
		}
		if (a무기2 != null){
			a무기2.작동();
		}
	}
}
abstract class 무기 {
	abstract void 작동 ();
}
class 칼 extends 무기 {
	void 작동 () {
		System.out.println("전사가 칼로 공격합니다.");
	}
}
class 활 extends 무기 {
	void 작동 () {
		System.out.println("전사가 활로 공격합니다.");
	}
}

전사가 무기를 여러 개 사용할 수 있어야 합니다 ver2

class Main {
	public static void main(String[] args) {
		전사 a전사1 = new 전사();
		a전사1.이름1 = "카니";
		a전사1.a왼손무기 = new 칼();
		a전사1.공격();
		// 출력 => 전사가 왼손으로 칼(을)를 사용합니다.
		전사 a전사2 = new 전사();
		a전사2.이름2 = "프로도";
		a전사2.a왼손무기 = new 창();
		a전사2.a오른손무기 = new 도끼();
		a전사2.공격();
		// 출력 => 전사가 왼손으로 창(을)를 사용합니다.
		// 출력 => 전사가 오른손으로 도끼(을)를 사용합니다.
	}
}
class 전사 {
	String 이름1;
	String 이름2;
	무기 a왼손무기;
	무기 a오른손무기;
	
	void 공격 () {
		if (a왼손무기 != null) {
			a왼손무기.작동("마법사", "왼손");
		} 
		if (a오른손무기 != null) {
			a오른손무기.작동("전사", "오른손");
		}
	}
}
abstract class 무기 {
	abstract void 작동(String 직업이름, String 장착부위);
}
class 칼 extends 무기{
	void 작동 (String 직업이름, String 장착부위) {
		System.out.println(직업이름 + "가 "+장착부위+"으로 칼을 사용합니다.");
	}
}
class 창 extends 무기{
	void 작동 (String 직업이름, String 장착부위) {
		System.out.println(직업이름 + "가 "+장착부위+"으로 창을 사용합니다.");
	}
}
class 도끼 extends 무기{
	void 작동 (String 직업이름, String 장착부위) {
		System.out.println(직업이름 + "가 "+장착부위+"으로 도끼을 사용합니다.");
	}
}

생성자 개념

class Main {
	public static void main(String[] args) {
		전사 a전사 = new 전사("하하");
//		a전사.이름 = "카니"; // 자동으로 NoName
//		a전사.나이 = 22; // 자동으로 20살
		System.out.println(a전사.이름); // 출력 : 카니
		System.out.println(a전사.나이); // 출력 : 22
	}
}
class 전사 {
	String 이름;
	int 나이;
	전사 (String 인사) { // 생성자함수 : 객체가 생성될때 실행되는 함수.
		System.out.println(인사); // new 전사("하하"); "하하"
		this.이름 = "noname";
		this.나이 = 20;
	}
	/*
	원래는 생성자함수는 class가 생성될때 같이 빈 값으로 실행된다.
	'전사 () {} <- 이 값으로'
	근데 위 생성자처럼 생성자함수를 명시 해주면 그 값에 따라 움직이게 된다.
	생성자함수를 명시하면 위 클래스에서 변수에 값을 할당하지 않아도 된다.
	*/
}

생성자는 기본 구조만 파악하면 됨(나중에 구글링)

생성자 응용문제(생성자 겹겹이 중첩 -> 타고 타고 타고 타고 들어가는 문제)

class Main {
	public static void main(String[] args) {
		int 엄지손가락_길이 = new 사람().a왼팔.a손.a엄지손가락.길이;
		System.out.println(엄지손가락_길이 + "cm");
		// 출력 : 5cm
	}
}
class 사람 {
	팔 a왼팔;
	사람() { // 해당 클래스의 생성자를 만들고 그 안에서 a왼팔에 대한 인스턴스화(값을 할당)를 해준다.
		a왼팔 = new 팔();
	}
}
class 팔 {
	손 a손;
	팔 () {
		a손 = new 손();
	}
}
class 손 {
	손가락 a엄지손가락;
	손 () {
		a엄지손가락 = new 손가락();
	}
}
class 손가락 {
	int 길이;
	손가락 () {
		길이 = 5; // 엄지손가락_길이
	}
}

위 코드를 이렇게 '결합도가 높게' 짜줄 수도 있지만 좋은 코드가 아님

class Main {
    public static void main(String[] args) {
        int 엄지손가락_길이 = new 사람().a왼팔.a손.a엄지손가락.길이;

        System.out.println(엄지손가락_길이 + "cm");
        // 출력 : 5cm
    }
}

class 사람 {
    팔 a왼팔;

    사람() {
        a왼팔 = new 팔();
        a왼팔.a손 = new 손();
        a왼팔.a손.a엄지손가락 = new 손가락();
        a왼팔.a손.a엄지손가락.길이 = 5;
    }
}

class 팔 {
    손 a손;
}

class 손 {
    손가락 a엄지손가락;
}

class 손가락 {
    int 길이;
}

복습문제

// 문제 : 아래와 같이 출력 되도록 해주세요.
class Main {
  public static void main(String[] args) {
    캐릭터 a플레이어_캐릭터;
    
    a플레이어_캐릭터 = new 전사();
    a플레이어_캐릭터.공격();
    // 출력 : 전사가 대검으로 공격합니다.
    
    a플레이어_캐릭터 = new 마법사();
    a플레이어_캐릭터.공격();
    // 출력 : 마법사가 파이어볼로 공격합니다.
  }
}
abstract class 캐릭터 {
	abstract void 공격 ();
}
class 전사 extends 캐릭터{
	void 공격() {
		System.out.println("전사가 대검으로 공격합니다.");
	}
}
class 마법사 extends 캐릭터{
	void 공격() {
		System.out.println("마법사가 파이어볼으로 공격합니다.");
	}
}

전사1~전사5까지 이름을 noname으로 설정하기

// 문제 : 아래와 같이 출력되게 해주세요.
class Main {
	public static void main(String[] args) {
		전사 a전사0 = new 전사();
		a전사0.나이 = 20;
		a전사0.이름 = "칸";
		a전사0.성격 = "차가움";
		a전사0.a무기 = new 활();
		전사 a전사1 = new 전사();
		전사 a전사2 = new 전사();
		전사 a전사3 = new 전사();
		전사 a전사4 = new 전사();
		전사 a전사5 = new 전사();
		System.out.println(a전사0.이름);
		// 출력 : 칸
		System.out.println(a전사1.이름);
		// 출력 : No Name
		System.out.println(a전사2.이름);
		// 출력 : No Name
		System.out.println(a전사3.이름);
		// 출력 : No Name
		System.out.println(a전사4.이름);
		// 출력 : No Name
		System.out.println(a전사5.이름);
		// 출력 : No Name
	}
}
class 전사 {
	int 나이;
	String 이름;
	String 성격;
	무기 a무기;
	// `전사()` 는 생성자 메서드 이다.
	// 클래스 명과 같은 이름의 메서드를 생성자 메서드 라고 한다.
	// 생성자 메서드는 자동으로 호출됩니다.
	// 생성자 메서드는 new 할때(객체 생성할 때) 자동으로 호출됩니다.
	// 생성자 메서드는 다른 모든 메서드 보다 가장 먼저 딱 1번 실행됩니다.
	// 생성자 메서드는 리턴타입이 없습니다.
	// 당연하지만 생성자 메서드는 리턴값도 없습니다.
	전사() {
		// 수정가능지역 시작
		this.나이 = 20;
		this.이름 = "noname";
		this.성격 = "온순함";
		this.a무기 = new 칼();
		// 수정가능지역 끝
	}
}
abstract class 무기 {
}
class 칼 extends 무기 {
}
class 활 extends 무기 {
}

팔을 생성할 때 팔길이가 자동으로 세팅되도록 해주세요(잘 이해안됨.)

// 출력 : 아래와 같이 출력되게 해주세요.
class Main {
	public static void main(String[] args) {
		사람 a사람 = new 사람();
		a사람.나이 = 10;
		a사람.a왼팔 = new 팔();
		System.out.println(a사람.a왼팔.길이 + "cm");
		// 출력 : 100cm
	}
}
class 사람 {
	int 나이;
	팔 a왼팔;
}
class 팔 {
	int 길이;
	팔 () {
		this.길이 = 100;
	}
}

사람이 생성할 때 자동으로 a왼팔 변수에 팔 객체가 연결되게 해주세요.(잘 이해안됨.)

// 출력 : 아래와 같이 출력되게 해주세요.
class Main {
	public static void main(String[] args) {
		사람 a사람 = new 사람();
		new 사람().걷다();
		System.out.println(new 사람().a왼팔.길이 + "cm");
		// 출력 : 100cm
	}
}
class 사람 {
	팔 a왼팔;
	
	void 걷다() {
		System.out.println("사람 걷는다.");
	}
	사람 () {
		a왼팔 = new 팔();
	}
}
class 팔 {
	int 길이;
	팔 () {
		this.길이 = 100;
	}
}