1. 오목 초기 설정 : 22.12.12
package ex1.test;
public class OmokTest {
public static void main(String[] args) { // 수정하기 쉬운코드이다.
System.out.printf("%c",'┏');
for(int i=0; i<10; i++) //제어구조를 사용하지 않고도 해보기!
System.out.printf("%c",'┬');
System.out.printf("%c",'┓');
System.out.print("\n");
for(int y = 1; y<=10; y++) { // x, y 위치 생각
System.out.printf("%c", '├');
for(int x = 1; x<=10; x++) { // 한눈에 이해하기 쉽게 하기 위해 '1'부터 시작
if (x % 3 == 0 && y % 3 == 0) // 2 5 8
System.out.printf("%c", '○');
else
System.out.printf("%c", '┼');
}
System.out.printf("%c", '┤');
System.out.print("\n");
}
System.out.printf("%c",'┗');
for(int j=0; j<10; j++)
System.out.printf("%c",'┴');
System.out.printf("%c",'┛');
System.out.print("\n");
// for(int x = 0; x<10; x++) {
// for(int y = 0; y<10; y++) {
//
// if(3*y+2 == 3*x+2) // 대각선에 '○'
// System.out.printf("%c", '○');
//
// else
// System.out.printf("%c", '┼');
// }
// System.out.print("\n");
// }
//-----------------------------------------
// for(int i =0; i<100; i++) {
// if(i==12)
// System.out.printf("%c", '○');
// else
// System.out.printf("%c", '┼');
// if(i % 10 == 9)
// System.out.print("\n");
//
//
// }
// for(int i =0; i<100; i++) {
// System.out.printf("%c", '┼');
//
// for(int j = 0; j<=10; j++) {
// if((i % 10) == (10*j-1))
// System.out.print("\n");
// }
//
// }
}
}
2. 오목 초기 설정 : 22.12.12
package ex1.test;
public class OmokTest2 {
public static void main(String[] args) {
for(int y = 1; y<=10; y++) { // x, y 위치 생각
for(int x = 1; x<=10; x++) // 한눈에 이해하기 쉽게 하기 위해 '1'부터 시작
if (x % 3 == 0 && y % 3 == 0) // 2 5 8
System.out.printf("%c", '○');
else if (y==1) // 코드는 수정하기에 편해야 한다.(유지보수)
System.out.printf("%c", '┬');
else if (y==10)
System.out.printf("%c", '┴'); // 이 코드는 고치기 어렵다.
else if (x==1)
System.out.printf("%c", '├');
else if (x==10)
System.out.printf("%c", '┤');
// else if (x==1 && y==1)
// System.out.printf("%c", '');
else
System.out.printf("%c", '┼');
System.out.print("\n");
}
}
}
3. 오목 게임만들기 (예외처리 추가해야함.) : 22.12.13
- 오목알 겹치는 것에 대한 예외처리
package ex1.array;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.util.Scanner;
public class ExamApp {
//static int kor1, kor2, kor3;
public static void main(String[] args) throws IOException {
//ConsoleOutputStream out = new ConsoleOutputStream(); //
int answer = 1;
//int kor1=0, kor2=0, kor3=0;
int[] kors= new int[3];
NEWLEC:
while(answer == 1) {
int total;
double avg;
int menu;
{
System.out.println("┌──────────────────────┐");
System.out.println("│ 메인 메뉴 │");
System.out.println("└──────────────────────┘");
System.out.println("1. 성적 입력");
System.out.println("2. 파일 입력");
System.out.println("3. 성적 출력");
System.out.println("4. 파일 저장");
System.out.println("5. 종료");
System.out.println("선택 > ");
Scanner scan = new Scanner(System.in);
menu = Integer.parseInt(scan.nextLine());
}
//System.out.println("1번 검사 전");
switch(menu) {
case 1:
{
// 콘솔 - 성적 입력 부분
Scanner scan = new Scanner(System.in);
System.out.println("┌──────────────────────┐");
System.out.println("│ 성적 입력 │");
System.out.println("└──────────────────────┘");
// System.out.print("kor1 : ");
// kor1 = scan.nextInt();
for(int i =0; i<3; i++) { // 원래 코드대로 사용하면 배열 연산이 많아지므로 복잡해진다.
int kor; // 따라서, 배열 연산을 최대한 많이 줄이려고 최대한 배열의 사용을 줄인다.
do {
System.out.printf("kor%d: ", i+1);
kor = scan.nextInt();
if(kor < 0 || kor > 100)
System.out.println("kor1는 0~100 의 값을 입력해주세요.");
} while (kor < 0 || kor > 100);
kors[i]= kor;
}
scan.nextLine(); // 에러발생 줄이려고, 버퍼를 마지막에 다 비워준다.
break;
}
//---------------------------------------------------------------------------
//System.out.println("2번 검사 전");
case 2:
{
// 파일 입력 부분
FileInputStream fis = new FileInputStream("res/data.csv");
Scanner scanner = new Scanner(fis);
String line = scanner.nextLine();
String[] tokens = line.split(","); // 임시 변수를 tokens에 넣어준다.
for(int i=0; i<3; i++)
kors[i] = Integer.parseInt(tokens[i]);
// scan.close();
fis.close();
break;
}
//---------------------------------------------------------------------------
//System.out.println("3번 검사 전");
case 3:
{
// 콘솔 - 성적 출력 부분
System.out.println("┌──────────────────────┐");
System.out.println("│ 성적 출력 │");
System.out.println("└──────────────────────┘");
total = 0;
for(int j=0; j<3; j++) {
for(int i=0; i<3; i++)
total += kors[i];
avg = total / 3.0; // 요즘은 double을 많이 사용하는 추세이다.(용량 증가로)
System.out.printf("───────────<%d>───────────\n", j+1);
for(int i =0; i<3; i++) {
System.out.printf("국어%d : %3d\n", i+1, kors[i]);
}
System.out.printf("총점 : %3d\n", total);
System.out.printf("평균 : %6.2f\n", avg);
}
System.out.println("─────────────────────────");
break;
}
//---------------------------------------------------------------------------
//System.out.println("4번 검사 전");
case 4 :
{
// 파일 출력 부분
FileOutputStream fos = new FileOutputStream("res/data.csv");
PrintStream out = new PrintStream(fos);
for(int i=0; i<3; i++) { // 수평을 수직형태로 변경하면, 반복문 가능
out.printf("%d", kors[i]);
if (i == 2)
out.print("\n");
else
out.print(",");
}
out.println("┌──────────────────────┐");
out.println("│ 성적 출력 │");
out.println("└──────────────────────┘");
for(int i=0; i<3; i++) {
out.printf("국어%d : %3d\n",i+1, kors[i]);
}
out.println("────────────────────────");
fos.close();
System.out.println("작업완료");
break;
}
//fos.close(); // 하부 시스템이 리소스를 차지하고 있어서 사용하고나서 항상 닫아줘야 한다.
// close의 위치도 중요하다. 가장 마지막에 close 해줄 것
//---------------------------------------------------------------------------
//System.out.println("5번 검사 전");
case 5:
{
/*
* System.out.println("계속하시겠습니까?(계속:1/종료:0)\n"); Scanner scan = new
* Scanner(System.in); int answer = Integer.parseInt(scan.nextLine());
*/
System.out.println("계속하시겠습니까?(계속:1/종료:0)\n");
Scanner scan = new Scanner(System.in);
answer = Integer.parseInt(scan.nextLine());
if(answer == 0)
break;
break;
}
default:
{
System.out.println("입력 번호가 잘못되었습니다. 1~5까지만 입력해주세요.");
System.out.println("치명적인 오류로 프로그램을 종료합니다.");
break NEWLEC;
}
}
}
System.out.println("Bye~!"); // 조건식이 많을 수록 좋은 코드가 아니라서 이게 옳다.
}
}
3-1. 오목 : 에러발생 (재수정하기)
package ex1.test;
import java.util.Scanner;
public class OmokTest3 {
public static void main(String[] args) {
// 오목에서 배열 10x10 100개 문자를 담을 수 있는 배열 이름: board
char[] board = new char[100];
char[][] board2 = new char[10][10];
//----------- board1 -------------------
for(int i=0; i<100; i++)
board[i] = '┼';
// board[15] ='○'; // 배열은 기존의 정수값과는 다르다.
// //board[44] ='○';
// board[(5-1)*10+(6-1)] ='○';
// for(int i=0; i<100; i++) {
//
// System.out.print(board[i]);
//
// if(i % 10 ==9)
// System.out.print("\n");
//
// }
//----------- board2 -------------------
for(int y=1; y<=10; y++) {
for(int x =1; x<=10; x++) {
board2[y-1][x-1] = '┼';
}
}
for(int y=1; y<=10; y++) {
for(int x =1; x<=10; x++) {
board2[0][x-1] = '┬';
board2[9][x-1] = '┴';
}
board2[y-1][0] = '├';
board2[y-1][9] = '┤';
board2[0][0] = '┌';
board2[0][9] = '┐';
board2[9][0] = '└';
board2[9][9] = '┘';
}
for(int y=1; y<=10; y++) {
for(int x =1; x<=10; x++) {
System.out.printf("%c", board2[y-1][x-1]);
}
System.out.print("\n");
}
//----------- omok game -------------------
for(int count =100; count>0; count--) {
System.out.println("(x, y) > ");
Scanner scan = new Scanner(System.in);
int ox, oy;
do {
ox = scan.nextInt();
if(ox>10)
System.out.println("x는 1~10의 수만 입력할 수 있습니다. x: ");
} while(ox > 10);
do {
oy = scan.nextInt();
if(oy>10)
System.out.println("y는 1~10의 수만 입력할 수 있습니다. y: ");
} while(oy > 10);
if(count %2 == 0)
board2[ox-1][oy-1] = '○';
else
board2[ox-1][oy-1] = '●';
for(int y=1; y<=10; y++) {
for(int x =1; x<=10; x++) {
System.out.printf("%c", board2[y-1][x-1]);
}
System.out.print("\n");
}
}
}
}
3-2. 오목 게임 완성
package ex1.test;
import java.util.Scanner;
public class OmokTest3 {
public static void main(String[] args) {
// 오목에서 배열 10x10 100개 문자를 담을 수 있는 배열 이름: board
char[] board = new char[100];
char[][] board2 = new char[10][10];
//----------- board1 -------------------
for(int i=0; i<100; i++)
board[i] = '┼';
//----------- board2 -------------------
for(int y=1; y<=10; y++) {
for(int x =1; x<=10; x++) {
board2[y-1][x-1] = '┼';
}
}
for(int y=1; y<=10; y++) {
for(int x =1; x<=10; x++) {
board2[0][x-1] = '┬';
board2[9][x-1] = '┴';
}
board2[y-1][0] = '├';
board2[y-1][9] = '┤';
board2[0][0] = '┌';
board2[0][9] = '┐';
board2[9][0] = '└';
board2[9][9] = '┘';
}
for(int y=1; y<=10; y++) {
for(int x =1; x<=10; x++) {
System.out.printf("%c", board2[y-1][x-1]);
}
System.out.print("\n");
}
//----------- omok game -------------------
Scanner scan = new Scanner(System.in); // while문의 조건 처리는 변수화하여 최대한 적게 해야한다.
int ox, oy;
int count = 100;
while(count > 0) { // 중첩이 최대한 적게 만들어야 한다.
System.out.println("(x, y) > ");
ox = scan.nextInt();
oy = scan.nextInt();
if(ox<1 || ox>10 || oy<1 || oy>10) { // 예외 처리 추가 (같은 위치에 오목돌 겹치지 않게 하기)
System.out.println("x는 1~10의 수만 입력할 수 있습니다. x: ");
System.out.println("y는 1~10의 수만 입력할 수 있습니다. y: ");
continue;
}
if(board2[ox-1][oy-1] == '○' || board2[ox-1][oy-1] == '●') {
System.out.println("돌이 있습니다. ");
continue;
}
if(count % 2 == 0)
board2[ox-1][oy-1] = '○';
else
board2[ox-1][oy-1] = '●';
for(int y=1; y<=10; y++) {
for(int x =1; x<=10; x++) {
System.out.printf("%c", board2[y-1][x-1]);
}
System.out.print("\n");
}
count --;
}
}
}
4. 자리 바꾸기(초기 버전) : 22.12.13
package ex1.test;
import java.util.Random;
public class ArrayTest {
public static void main(String[] args) {
// 배열은 객체다.
int[] ar1 = new int[5];
ar1 = new int[7]; // 가능하다.
int[][] ar2 = new int[3][5];
ar2 = new int[2][6]; // 가능하다. (중대원 개념)
ar2[0] = new int[9]; // 가능하다.(소대원 개념)
int[][] ar3 = new int[3][]; // 자바는 기본으로 톱니형 배열이다.(삐죽 튀어 나옴.)
// *** 자바는 배열을 문법적으로 통으로 생성하지만,
// 실제 모습은 그렇지 않고 유연하게 가변길이 형태로 배열이 생성된다.
// 정리: 2차원 배열 사용하는 이유 , 원하는 것을 찾아서 값을 바꾸는 것
int[] nums = {20,5,7,98,45,7,45,82,12,47};
for(int i =0; i<10; i++) {
System.out.printf("%s", nums[i]); // 초기에 입력값 만드는 게 힘듬.
if(i!=9)
System.out.printf(",");
}
System.out.print("\n");
// 1번째 자리 3번째 자리 바꾸기
{
int temp = nums[1]; // 이건 보지도 않고 바로 칠 수 있어야 한다.(3, 1, 2 화살표)
nums[1] = nums[3];
nums[3] = temp;
for(int i =0; i<10; i++) {
System.out.printf("%s", nums[i]); // 초기에 입력값 만드는 게 힘듬.
if(i!=9)
System.out.printf(",");
}
System.out.println();
}
// 랜덤으로 바꾸기
{
Random rand = new Random();
int s = rand.nextInt(10);
int d = rand.nextInt(10);
int temp = nums[s]; // 이건 보지도 않고 바로 칠 수 있어야 한다.(3, 1, 2 화살표)
nums[s] = nums[d];
nums[d] = temp;
for(int i =0; i<10; i++) {
System.out.printf("%s", nums[i]); // 초기에 입력값 만드는 게 힘듬.
if(i!=9)
System.out.printf(",");
}
System.out.println();
}
}
}
5. 자리 바꾸기(수정 버전), 버블 정렬 : 22.12.14
[정렬 종류]
- 버블 정렬 : 뽀글뽀글 정렬(옆사람과 싸움) - [많이 쓰임]
- 선택 정렬(왕좌가 밖에 존재한다.) : 옆사람과 싸우는게 아니라 밖으로 나와 있는 것과 싸움 - [많이 쓰임]
- 퀵 정렬 : 싸워서 올라가는것
package ex1.test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.util.Random;
import java.util.Scanner;
public class ArrayTest2Sort {
public static void main(String[] args) throws IOException {
// 배열은 객체다.
int[] ar1 = new int[5];
ar1 = new int[7]; // 가능하다.
int[][] ar2 = new int[3][5];
ar2 = new int[2][6]; // 가능하다. (중대원 개념)
ar2[0] = new int[9]; // 가능하다.(소대원 개념)
int[][] ar3 = new int[3][]; // 자바는 기본으로 톱니형 배열이다.(삐죽 튀어 나옴.)
// *** 자바는 배열을 문법적으로 통으로 생성하지만,
// 실제 모습은 그렇지 않고 유연하게 가변길이 형태로 배열이 생성된다.
// 정리: 2차원 배열 사용하는 이유 , 원하는 것을 찾아서 값을 바꾸는 것
int[] nums = {20,5,7,98,45,7,45,82,12,47};
for(int i =0; i<10; i++) {
System.out.printf("%s", nums[i]); // 초기에 입력값 만드는 게 힘듬.
if(i!=9)
System.out.printf(",");
}
System.out.print("\n");
// 1번째 자리 3번째 자리 바꾸기
{
int temp = nums[1]; // 이건 보지도 않고 바로 칠 수 있어야 한다.(3, 1, 2 화살표)
nums[1] = nums[3];
nums[3] = temp;
for(int i =0; i<10; i++) {
System.out.printf("%s", nums[i]); // 초기에 입력값 만드는 게 힘듬.
if(i!=9)
System.out.printf(",");
}
System.out.println();
}
// 랜덤으로 바꾸기
{
Random rand = new Random();
int s = rand.nextInt(10);
int d = rand.nextInt(10);
int temp = nums[s]; // 이건 보지도 않고 바로 칠 수 있어야 한다.(3, 1, 2 화살표)
nums[s] = nums[d];
nums[d] = temp;
for(int i =0; i<10; i++) {
System.out.printf("%s", nums[i]); // 초기에 입력값 만드는 게 힘듬.
if(i!=9)
System.out.printf(",");
}
System.out.println();
}
// <정렬 종류>
//---------- 버블 정렬 : 뽀글뽀글 정렬(옆사람과 싸움) - [많이 쓰임]
// 선택 정렬(왕좌가 밖에 존재한다.) : 옆사람과 싸우는게 아니라 밖으로 나와 있는 것과 싸움 - [많이 쓰임]
// 퀵 정렬 : 싸워서 올라가는것
int[] numss = new int[15];
{
FileInputStream fis = new FileInputStream("res/data.txt"); // (" ")이라는 파일과 연결된 FileInputStream을 "fis"라는 참조변수(연결 통로)로 만들어서 사용할 것이다.
Scanner scan = new Scanner(fis); // Scanner는 문자열을 통으로 받기 위해 사용하며, fis라는 연결통로에 scan이라는 버퍼를 만든다.
for(int i=0; i<15; i++)
numss[i]= scan.nextInt();
System.out.println("로드 완료");
fis.close();
}
{
// Random rand = new Random();
//
// for(int i=0; i<50; i++) { // random 난수의 반복 위치 생각(프로그래밍 동작 이해)
//
// int s = rand.nextInt(15);
// int d = rand.nextInt(15);
//
// int temp = numss[s];
// numss[s] = numss[d];
// numss[d]= temp;
// }
//
//
// System.out.println("번호 섞기 완료");
}
{
FileOutputStream fos = new FileOutputStream("res/data-out.txt"); // (" ")이라는 파일 이름과 연결된 FileOutputStream을 "fos"라는 참조변수로 만들어서 사용할 것이다.
PrintStream out = new PrintStream(fos); // Scanner와 같이 PrintStream도 문자열을 통으로 받기 위해 사용하며, fos라는 연결통로에 out이라는 버퍼를 만든다.
// 스트림은 연결통로이고 버퍼는 임시 저장공간(박스)이다.
// FileOutputStream fos는 문자를, PrintStream out은 문자열을 사용
for(int i=0; i<15; i++) {
out.printf("%d", numss[i]);
if(i!=14)
out.print(",");
}
System.out.println("저장 완료"); // 20,30,29,39,49,38,10,19,87,29,38,27,8,90,87
fos.close(); // 닫아주는 것 주의!
}
// [sort 하기]
{ // 제일 큰 번호를 제일 끝으로 올리기
for(int i=0; i<15-1; i++) {
System.out.printf("%d", numss[i]);
if(i!=13)
System.out.printf(",");
}
System.out.print("\n");
int temp;
for(int j=0; j<15-1; j++) // "15-1-i"으로 생각하고 for문은 항상 시작을 "0"으로 할 것.("5-i" 느낌이다.-> 5, 4, 3, 2, 1)
for(int i=0; i<15-1-j; i++) { // 중간값 찾기, 큰 값 찾기 등등 하나의 문장으로 만들어야한다. 이것을 함수 단위로 만들어 사용!!
if(numss[i]>numss[i+1]) {
temp = numss[i];
numss[i] = numss[i+1];
numss[i+1] = temp;
}
}
// 화면에 출력하기
for(int i=0; i<numss.length; i++) {
System.out.printf("%d", numss[i]);
if(i!=14)
System.out.printf(",");
}
System.out.print("\n");
}
// [문자열]
// 문자열 연산자 : 자바에서는 모든 문자열이 객체이다, String s1= "hello"; String s2 = new String("hello");에서 s1과 s2를 비교
// s1은 담고 있는 그릇인 참조 변수이다. 이름 그 자체...
}
}
6. 문자열 연산자 : 22.12.14
package ex1.test;
public class StringTest {
public static void main(String[] args) {
// 문자열 연산자는 뒤에 것을 문자열로 바꿔준다.
// 자신의 전문적인 알고리즘이나 플랫폼을 키울 것!(사람이 많이 모이는 것으로 플랫폼 만들기)
// 내가 원하는 서비스를 만들면서, 내것을 쓰기 위해서 공부하면서 만들기, 처음엔 만들면서 도구로 가져가다가 사용하고 추가로 확장되어 만들고 싶을때는 추가로 그 기능을 위한 공부하기
//1. 숫자를 문자열로 변환 : String s = String.valueOf(n), String s = Integer.toString(n) (암기)
// 문자열을 숫자로 변환 : int x = Integer.parseInt(s); (암기)
int n = 3;
String s = String.valueOf(n);
//String s = Integer.toString(n);
int x = Integer.parseInt(s);
// 2. "=="는 객체 자체를 비교한다. "equals"는 객체의 값을 비교한다.
// new 연산자를 이용하면 객체 자체를 만든 것이고 new 없이 String을 생성하면, 변수 자체를 만든다.
// (차이점: 기존에 있는 String 이용, 새로운 객체인 String 이용)
String name1 = "아이유";
//String name2 = "아이유";
String name2 = new String("아이유");
System.out.println(name1 == name2);
System.out.println(name1.equals(name2));
}
}
7. 문자열 연산자 : 22.12.15
[함수]
- 모든 언어 java, c++, 에서 함수의 개념이 같다.
- function call : 함수를 불러들임.
- return : 흐름이 반환된다.
-
return value :
- 함수 1개는 40~50 line정도가 적당하다.(IBM)
- 이것을 구조화된 프로그래밍이라고한다.
- Top Down 방식 : 구조를 먼저 생각하고 구현을 나중에 한다.(가장 바람직한 모습)
- BottomUp 방식 : 구현 먼저 하는 것(경험이 없으면 이렇게 진행할 것.)
[함수의 장점]**
-구현코드를 숨길 수 있다.(코드의 직접 사용을 차단 가능)
-코드를 작게 나누어서 만들 수 있다.
-코드를 집중화할 수 있다.
-코드를 재사용할 수 있다.
[함수의 사용법]
- 반환하는 값의 자료형을 함수명 앞에 써주자.
- 일단, static은 무조건 사용!
- call by value : 함수를 call할 때, value를 받아서 call할 수 있다.
[함수의 특징]
- 함수명 앞에는 자료형과 return에 반환 값을 넣어준다.
- 하지만, void는 계산하는 것이 아니라 바로 소비해버린다.
[전역 변수]
- 지역을 벗어난 함수
- 하지만, 무조건 함수는 고립화되어 있어야한다. 그러므로, 다른 영역에서 영향을 받아서 결합되어 있으면 안된다. 왜냐하면, 갑자기 외부의 영향을 받아서 에러가 발생할 수 있다.
- 결론 : 전역적으로 결합되어 있다는 뜻이다.
- 따라서, 함수를 만들면서 전역변수보다 지역변수를 많이 사용해야 한다. ***
[함수명 정의법]
- 행위 + 재료이름
- 카멜 표기 : 소문자로 시작하다가 의미가 바뀌면 대문자를 쓴다.
- 파스칼 표기 : 대문자 + 대문자
- 숫자로 시작하면 안되고 공백이 들어가면 안 된다.(특수문자도 불가능)
[함수 생성시, 주의 사항]
- 전달할 변수가 있을 것 같다면, 함수에 변수를 직접 정의 하지 않기!! 매개변수 이용하자!
- 함수가 전달하는게 객체면 같은 것을 전달한다.
-
단축키 : F3, alt + 왼/오른쪽 방향키
- 문자가 단독으로 공유되는 것을 불가능하다. 대신 묶어줘서 객체화하면 가능하다. ***
- 원시형 primitive 타입은 공유되지 않는다. 참조는 개별적인 사번이라서 값을 무조건 공유 불가능
- 현재 parameter로 전달했을 때, 공유되는 경우는 절대 없다. ***
[#7. 문자열 연산자의 실습 코드]
package ex3.func;
import java.util.Scanner;
public class BasicFunctionTest2 {
public static void main(String[] args) {
// 오목에서 배열 10x10 100개 문자를 담을 수 있는 배열 이름: board
char[][] board = new char[10][10];
initBoard(board); // ** 함수에 직접 정의 하지 않기!!!! 매개변수 이용
initPrintBoard(board);
//----------- omok game ------------------
int count = 100;
while(count > 0) { // 중첩이 최대한 적게 만들어야 한다.
inputOmokOnBoard(count, board);
printBoard(count, board);
}
}
static void printBoard(int count, char[][] board) {
for(int y=1; y<=10; y++) {
for(int x =1; x<=10; x++) {
System.out.printf("%c", board[y-1][x-1]);
}
System.out.print("\n");
}
count --;
}
static void inputOmokOnBoard(int count, char[][] board) {
Scanner scan = new Scanner(System.in);
int ox, oy;
System.out.println("(x, y) > ");
ox = scan.nextInt();
oy = scan.nextInt();
// 예외 처리 추가 (같은 위치에 오목돌 겹치지 않게 하기)
if(ox<1 || ox>10 || oy<1 || oy>10) {
System.out.println("x는 1~10의 수만 입력할 수 있습니다. x: ");
System.out.println("y는 1~10의 수만 입력할 수 있습니다. y: ");
return;
}
if(board[ox-1][oy-1] == '○' || board[ox-1][oy-1] == '●') {
System.out.println("돌이 있습니다. ");
return;
}
if(count % 2 == 0)
board[ox-1][oy-1] = '○';
else
board[ox-1][oy-1] = '●';
}
static void initPrintBoard(char[][] board) {
for(int y=1; y<=10; y++) {
for(int x =1; x<=10; x++) {
System.out.printf("%c", board[y-1][x-1]);
}
System.out.print("\n");
}
}
static void initBoard(char[][] board) { // 매개 변수!!, 반환 타입이 void여도 괜찮네
// 출력부 함수를 따로 만들어주므로
for(int y=1; y<=10; y++) {
for(int x =1; x<=10; x++) {
board[y-1][x-1] = '┼';
}
}
for(int y=1; y<=10; y++) {
for(int x =1; x<=10; x++) {
board[0][x-1] = '┬';
board[9][x-1] = '┴';
}
board[y-1][0] = '├';
board[y-1][9] = '┤';
board[0][0] = '┌';
board[0][9] = '┐';
board[9][0] = '└';
board[9][9] = '┘';
}
}
}
8. Stack의 개념 : 22.12.15
[함수 호출과 스택]
- 우리는 프로그램을 실행하기 위해서 메모리에 올린다.
- 프로세스 : 프로그램이 메모리에 로드되어 실행되며 실체화되었다.
[Stack의 개념]
- 정적인 Stack에는 예약된 변수가 저장된다.
- 정적인 Stack은 실행되기 전에 미리 준비되는 것이다. 예약어라서, 지역블록에서 만들어지고 사라진다.(args, total, kor, kors 4개다.)
- 예약어는 할당만하고 그 자리를 잠궈버린다.
[Heap의 개념]
- heap과 stack은 메모리 상에서 같은 공간에 존재한다. stack은 예약석, heap은 입석이다.
- heap에는 이름에 해당하는 것이 할당된다.
- heap은 버퍼같은 느낌이다. stack은 쌓아서 사용하고나서 사라진다.
- 변수명은 stack에 있고 배열과 배열의 이름은 heap에 존재한다. ***
- 함수가 끝나서 stack이나 배열이 사라지게되는데 garbage(가비지)로 존재하게 된다. 나중에 garbage collector가 수거해간다. ***
9. 재귀함수의 개념 : 22.12.15
[재귀함수]
- 사용하는 방법론임 : 함수가 코드를 잘라서 사용하는 것이 아니라 함수가 반복이 된다.
- 반복횟수가 많이 커질 수록 stack에 계속 쌓인다. 즉, 성능이 안 좋아진다.(실행 속도 등등)
10. 데이터 구조화 : 22.12.16
[데이터 구조화]
- 데이터를 묶어서 한 번에 사용하기 위해서 객체로 만든다.
- 기본형식을 제외하고 모든 것을 생성할 때는 new로 생성한다.
- 현실 세계에 갖고 있는 Type을 객체라고 한다.
- 개체 entity, 객체 object
- java는 무조건 new를 통해서 모든 것이 만들어 진다.
- 속성들에 의해서 정해진다.
[클래스를 사용하는 이유]***
- 사용자 정의 함수 : 데이터를 구조화해서 묶기 위해서 사용
- 묶기 위해서 = 캡슐화
[클래스를 사용하는 이유]***
-
데이터를 묶어주는 것을 “구조체”라고도 부름.
-
선언이라는 것은 새로운 심볼을 들이는 것..
-
각 지역을 같은 이름으로 같은 공간을 사용한다.
ex)
package ex4.classTest;
public class Exam {
int kor;
int eng;
int math;
}
package ex4.classTest;
public class ExamApp {
public static void main(String[] args) {
Exam exam1 = new Exam(); // 선언된 변수만이 Stack으로 간다.
// 이름을 만들어주면 공간을 만들어주므로 사용할 수 있다.(exam1은 stack에 마련!!!!!)
exam1.kor = 10; // 하지만, 이름이 있다고 모두 stack에 있는 것이 아니다. kor은 heap에 있다.(그림의 컨테이너 박스 생각해봐!!!)
// 상태변수와 제어 할 때, 이것을 사용한다.(지역적으로 사용)
// 관리라는 것을 해야할 때, 공유해야 한다.
// ex) member.name 에서 member는 stack, name은 heap(컨테이너 박스 생각해봐!!!)
// 결론 : 구조체를 한 번에 여러개 만들 수 있다.
exam1.eng = 20;
exam1.math = 30;
printExam(exam1);
Exam[] exams = new Exam[3]; // 공간만 만들었지만(배열 선언 부분!!), heap에서 만들어짐
// 아직 할당이 되지 않아서(뭐가 만들어진지 없다. exam 참조형이 없다.) nullPoint error 발생
// 동적 할당 메모리(우리가 직접 동적으로 실행해봐야 아는 것이다!!)라고 한다!!
// *** new Exam[3]는 heap에 생기고 exams은 stack에서 생성된다.
// 결론 : 구조체를 한 번에 여러개 만들 수 있다.
exams[0] = new Exam(); // exams[0]는 이름이고 참조이다.그래서 exams[0]도 heap에 만들어짐. 그냥 바로 할당해버림 Exam exam1 = new Exam(); 이것과 같은 코드이다.
// 배열도 객체이므로... List 인터페이스 중에 하나다.
exams[0].kor = 30;
exams[0].eng = 40;
exams[0].math = 50;
exams[1] = new Exam();
exams[1].kor = 20;
exams[1].eng = 30;
exams[1].math = 70;
exams[2] = new Exam();
exams[2].kor = 40;
exams[2].eng = 50;
exams[2].math = 60;
printExam(exams);
}
// ex) arr 배열 정수 3개 짜리 만들고, 정수 2개 add함수,
// 개발자의 필수 능력 : 통역사 능력, 만들 것을 만들 수 있어야 하는 능력, 에러 해결 능력 순서로 중요!, 문제 해결 능력은 마지막에 천천히 키우기
static void printExam(Exam[] exams) {
for(int i=0; i<3; i++) {
Exam exam = exams[i];
printExam(exam);
// System.out.printf("kors%d : %d\n", i, exam[i].kor);
// System.out.printf("engs%d : %d\n", i, exam.eng);
// System.out.printf("maths%d : %d\n", i, exam.math);
// System.out.printf("-----------------------\n");
}
}
static void printExam(Exam exam1) {
//int kor = exam.kor;
System.out.printf("kor: %d\n", exam1.kor);
System.out.printf("eng: %d\n", exam1.eng);
System.out.printf("math: %d\n", exam1.math);
System.out.printf("-----------------------\n\n");
}
}