23일차 내용 정리

채공부·2025년 6월 25일

Git

🔴폴더 & 파일 생성

playground ⭢ git_test 에서 test12 폴더 생성
VS Code에서 File ➜ Open Folder로 test12만 단독 열기
index.html 파일 생성
h1 요소 추가

🔴 Git 저장소 초기화

Source Control ➜ Initialize Repository click : git init 상태로 변경

🔴 Git 상태 변화

"+" click ➜ git add 와 동일
"index.html added" 라는 commit 메세지 작성 후 ✔Commit click

🔴 GitHub 저장소 생성

GitHub 접속 ➜ test12 저장소 생성
해당 저장소 URL 복사

🔴 GitHub 저장소 연동

VS Code 에서 Push click : 원격 저장소 등록을 안 해서 실패

Remote ➜ Add Remote ➜ 저장소 URL 붙여넣기 ➜ 이름은 origin 입력 후 enter
Push ➜ 알람창 ok click
해당 GitHub 저장소에 해당 파일이 업로된 걸 확인 가능

🔴 다른 컴퓨터 해당 폴더 Clone

다른Com ⭢ git_repos 에서 Git Bash 실행

git clone test12_저장소_URL
      ⤷ 다른 컴퓨터에서 원격 저장소를 로컬로 복사

🔴 다른 컴퓨터 클론한 폴더 VS Code로 열기

VS Code에서 File ➜ New Window : 새 창 생성
Open Folder ➜ clone 받은 test12 폴더 선택

🔴 학원에서 작업 후 집에서 반영

  1. 학원에서 작업
p 요소 추가
"p1 추가함" 이라는 commit 메세지 작성 후 ✔Commit click
Push click : GitHub에 반영 ➜ origin/main 포인터가 올라감
  1. 집에서 반영받기
현재 집의 로컬에서는 p1 커밋이 없는 상태

origin/main : GitHub 원격 저장소를 추적

집에서는 원격 저장소의 변경 내용을 받아야 한다
Fetch click ➜ GitHub에 있던 새로운 커밋 정보를 받아준다
현재 브랜치(main)에는 반영되지 않는다 ➜ merge 필요

Branch ➜ Merge : origin/main을 현재 브랜치에 병합

Terminal ➜ New Terminal click
git merge origin/main ➜ fast-forward 방식으로 병합 완료

➜ 현재 학원, GitHub, 집의 커밋 상태가 동일

🔴 집에서 작업 후 학원에서 반영

집에서 index.html 파일에 p 요소 추가
"p2 추가함" 라는 commit 메세지 작성 후 ✔Commit click

Sync Changes click : push 완료

학원 VS Code 에서 Pull click : fetch와 merge 가 한 번에 진행 완료

Eclipes

Method

static

🟨 static 메소드 기본 사용법

public class MainClass01 {
	// static 영역에 만들어지는 main() 메소드
	public static void main(String[] args) {
		System.out.println("main 메소드 호출됨");
		
		// 클래스명에 . 찍어서 static 메소드 호출하기
		MainClass01.test();
        // 동일한 클래스 안에 있는 static 메소드를 호출할 때 클래스명. 은 생략 가능
		test();
		
		System.out.println("main 메소드 종료됩니다");
		
	}
	
	public static void test() {
		System.out.println("test() 메소드 호출됨");
	}
}

실행 결과

main 메소드 호출됨
test() 메소드 호출됨
test() 메소드 호출됨
main 메소드 종료됩니다

⚠️ static 없는 메소드를 호출한다면?

  • error 발생
// main 클래스

public class MainClass02 {
	public static void main(String[] args) {
		MainClass02.sendMessage();
		sendMessage();
	}
	
	public void sendMessage() {
		
	}
}

➜ static이 없는 메소드는 객체를 생성하지 않고 호출 불가능

🟨 매개변수가 있는 static 메소드

public static void main(String[] args) {
		sendMessage("hello");
	}
	
	public static void sendMessage(String msg) {
		
	}

➜ 전달되는 매개변수 값의 타입과 메소드의 선언과 일치해야 호출 가능

예제

// Post 클래스

public class Post {
	private int id;
	private String title;
	private String author;
	
	public Post() {
		
	}
	
	public Post(int id, String title, String author) {
		this.id = id;
		this.title = title;
		this.author = author;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public String getAuthor() {
		return author;
	}

	public void setAuthor(String author) {
		this.author = author;
	}
}
  • 객체를 메소드에 전달
// main 클래스

import test.mypac.Post;

public class MainClass04 {
	public static void main(String[] args) {
	}
	
	public static void sendPost(Post post) {
		System.out.println("글을 전송했습니다");
	}
}
  • sendPost() 메소드 호출
import test.mypac.Post;

public class MainClass04 {
	public static void main(String[] args) {
		// 다양한 방식으로 sendPost() 호출하기
		sendPost(null);
		
		sendPost(new Post());
		
		sendPost(new Post(1, "제목1", "작성자1"));
		
		Post post = new Post(2, "제목2", "작성자2");
		sendPost(post);
		
		Post p2 = new Post();
		p2.setId(3);
		p2.setTitle("제목3");
		p2.setAuthor("작성자3");
		sendPost(p2);
	}
	
	public static void sendPost(Post post) {
		System.out.println("글을 전송했습니다");
	}
}
  • Messenger type 객체의 sendPost() 메소드를 호출
public class Messenger {
	public void sendPost(Post post) {
		System.out.println(post.getAuthor() + "님이 작성한 글을 전송했습니다");
	}
}
// main 클래스
import test.mypac.Messenger;
import test.mypac.Post;

public class MainClass05 {
	public static void main(String[] args) {
		Messenger msg = new Messenger();
		msg.sendPost(new Post(1, "제목1", "작성자1"));
	}
}

➜ static이 아니기 때문에 객체를 생성해야 호출 가능

  • 배열에 객체를 담고 반복문으로 메소드 호출
// ZzangGu 클래스

public class ZzangGu {
	public void dance() {
		System.out.println("부리 부리~");
	}
}
import test.mypac.ZzangGu;

public class MainClass06 {
	public static void main(String[] args) {
		/*
		 * ZzangGu 객체를 3개 생성해서 배열에 담은 다음
		 * 반복문 돌면서 배열에 담긴 ZzangGu 객체의 dance() 메소드를 모두 호출해 보세요
		 * */
		
		ZzangGu z1 = new ZzangGu();
		ZzangGu z2 = new ZzangGu();
		ZzangGu z3 = new ZzangGu();
		
		ZzangGu[] zs = {z1,z2,z3};
		
		
		for (ZzangGu z : zs) {
			z.dance();
		}
	}
}

abstract (추상 클래스)

public abstract class Weapon {
	// 무기 작동을 준비하는 메소드
	public void prepare() {
		System.out.println("무기 작동을 준비합니다");
	}
	
	// 공격하는 메소드
	public abstract void attack();
}

추상 메소드 : 구현되지 않은 미완성 메소드 (내용 없이 선언만)

추상 클래스 : 일반 메소드 + 추상 메소드를 동시에 가질 수 있는 클래스

  • 객체 생성 불가
  • 데이터 type 으로 사용 가능

➜ 추상 클래스는 자식 클래스가 Override 하지 않으면 사용할 수 없음

  • 추상 클래스 상속
// MyWeapon 클래스

public class MyWeapon extends Weapon{
	@Override
	public void attack() {
		System.out.println("지상 공격을 해요!");
	}
}
  • 추상 클래스를 타입으로 사용
import test.mypac.MyWeapon;
import test.mypac.Weapon;

public class MainClass01 {
	public static void main(String[] args) {
		// 추상 클래스도 data type 의 역할을 할 수 있다
		Weapon w1 = null;
		
		// Weapon w2 = new Weapon(); : 추상 클래스 단독으로 객체 생성 불가
		Weapon w2 = new MyWeapon();
		w2.prepare();
		w2.attack();
	}
}

➜ 추상 클래스는 객체를 만들 수 없지만 부모 타입의 역할은 가능

class

🟨 class 안에서 정의할 수 있는 4가지 구성 요소

  1. 필드
  2. 메소드
  3. 생성자
  4. 클래스 ➜ 내부 클래스

Inner class

  • 클래스 안에 정의한 클래스 = 내부 클래스
// Zoo 클래스

public class Zoo {
	public class Monkey{
		public void say() {
			System.out.println("안녕, 나는 원숭이야 우끼끼!");
		}
	}
	public class Tiger{
		public void roar() {
			System.out.println("어흥");
		}
	}
	
	public Monkey getMonkey() {
		return new Monkey();
	}

	public Tiger getTiger() {
		return new Tiger();
	}
}
  • 내부 클래스 객체를 얻고 사용
// main 클래스

import test.mypac.Zoo;
import test.mypac.Zoo.Monkey;

public class MainClass03 {
	public static void main(String[] args) {
    	// Zoo 객체 생성
		Zoo z1 = new Zoo();
		
        // Monkey 객체 리턴받기
		Monkey m1 = z1.getMonkey();
        // 메소드 호출
		m1.say();
		
		Zoo.Tiger t1 = z1.getTiger();
		t1.roar();
	}
}

Local Inner Class

  • 메소드 안에 정의하는 클래스 = 지역 내부 클래스
  • 해당 메소드 안에서만 사용 가능
// main 클래스

public class MainClass04 {
	public static void main(String[] args) {

		class Cat{
			public void say() {
				System.out.println("냥");
			}
		}
      
		Cat c = new Cat();
		c.say();
	}
}

➜ 파일로 따로 만들지 않고 해당 메소드에서만 사용하는 일회용 클래스

  • 추상 클래스 상속해 지역 내부 클래스 생성
// main 클래스

import test.mypac.Weapon;

public class MainClass05 {
	public static void main(String[] args) {

		class SpaceWeapon extends Weapon{
			@Override
			public void attack() {
            	prepare();
				System.out.println("우주 공격을 해요!");
			}		
		}
		
		Weapon w1 = new SpaceWeapon();
		w1.attack();
	}
}

➜ 지역 내부 클래스를 통해 즉석에서 구현체 작성 가능
   ∴ 매번 쓰지 않을 클래스는 굳이 지역변수로 만들 필요가 없다

  • 지역 내부 클래스를 1회용으로 사용

new 클래스명().메소드();

new SpaceWeapon().attack();
int ranNum = new Random().nextInt();

익명의 Local Inner Class

  • 이름 없는 클래스를 선언과 동시에 객체로 생성
import test.mypac.Weapon;

public class MainClass06 {
	public static void main(String[] args) {
		Weapon w1 = new Weapon() {
			
			@Override
			public void attack() {
				prepare();
				System.out.println("사이버 공격을 해요!");
			}
		};
		w1.attack();
	}
}

익명 클래스 구조 분석

  • 기본 클래스 형태
public class Phone <extends Object 생략>{
	<public Phone(){} 생략>
	public void call(){

	}
	public void test(){
		<this. 생략>call();
	}
  • 익명 클래스 형태
Weapon w1 = new Weapon() {
	@Override
	public void attack() {
		prepare();
		System.out.println("사이버 공격을 해요!");
	}
};

  • new Weapon( )
    추상 클래스 Weapon의 생성자처럼 보이지만 익명의 클래스(이름 없는 클래스)의 정의와 생성을 동시에 하는 표현식

  • 추상 클래스는 단독으로 객체 생성이 불가능하기에 반드시 추상메소드(attack)를 Override해 구현체(자식 클래스)를 만들어야 한다

  • { ... } 안에서 attack() 메소드를 Override 하면서 이름 없는 자식 클래스를 정의하고 동시에 객체 1개를 생성

🟨 익명 클래스를 사용하는 이유

  • MyWeapon, SkyWeapon, SeaWeapon 처럼 매번 새로운 클래스를 만드는 건 너무 번거럽고 코드가 길어진다
  • 해당 클래스는 한 번만 사용하기 때문에
profile
채공부
학원 공부 내용 정리
이전 포스트

22일차 내용 정리

다음 포스트

24일차 내용 정리

0개의 댓글