9:20 경 학원 도착
주말에 복습하던 내용 조금 더 정리하고 수업 들을 준비
 
 
<9:30 1교시>
로컬에서 새로 만든 폴더에 대해 vs code에서 terminal로 새로운 "혈통"의 깃허브 저장소 만들기
git  init
git  add  .
git  commit  -m  "index.html added"
git  remote  add  origin   저장소의위치(깃허브링크)
git  push  origin  master
 
올린 파일 변경하고 다시
 
git  add  .
git  commit  -m  "p1 added"
git  push  origin  master
 
깃허브에서 README.md 작성하고
commit changes 눌러서 README.md를 만든 다음
로컬에서 README.md를 받으려면
 
git  fetch  origin  master
git  checkout  master
 
를 하면 README.md가 보일 것이고,
 
git  merge  origin/master
 
방금 만든 원격 저장소를 MyHome 폴더에서 clone 하려면 새로운 폴더 만들 필요 없이 그냥 바로 git bash를 열고
 
git   clone   저장소위치(깃허브링크)
 
를 입력하면 끝난다.
 
나는 새로운 폴더를 만들어서 시도했는데, 굳이 그럴 필요가 없었던게, git init을 하지 않으면 그 폴더 전체가 git에 의해 관리되겠다는 의미가 아니기 때문에 그냥 git bash를 여는 거 자체는 전혀 문제가 아니어서 걱정할 필요가 없었다.
그냥 git bash 열자마자 clone 하면 바로 복제된 폴더가 나타난다. 
 
local 폴더에 있는 것은 학원에서 만든 것 그리고 이걸 
Remote로 연결한 깃허브저장소의 "혈통의 시작"이자 기원이 된 것이 local의 폴더.
MyHome 폴더에 있는 것은 복제된 것


 
 
로컬(처음 만들어진 곳)에서 변경된 내용이 있다면 add, commit 하고 push 한 다음 깃허브에서 확인해보고
MyHome 폴더에서는 fetch origin master 하고 merge origin/master 하면 된다.(또는 pull로 fetch와 merge를 한번에 할 수 있다)
거꾸로 MyHome 폴더에서 변경된 내용이 있다면 add commit 하고 push 한 다음 깃허브에서 확인해보고
로컬에서 fetch origin master 하고 merge origin/master 하면 된다.(마찬가지로 pull로 한 번에 할 수 있다)
 
 
<10:30 2교시>

package test.main;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import test.dto.MemberDto;
import test.util.DBConnector;

public class MainClass10 {
	public static void main(String[] args) {
		//추가할 회원 정보라고 가정하자
		String name="이름1";
		String addr="노량진";
		
		//추가할 회원정보를 MemberDto 객체에 담고
		MemberDto dto=new MemberDto();
		dto.setName(name);
		dto.setAddr(addr);
		
		//미리 준비된 메소드를 이용해서 DB에 저장하고 성공여부를 리턴받기
		boolean isSuccess=insert(dto);
		if(isSuccess) {
			System.out.println("저장했습니다");
		}else {
			System.out.println("저장하지 못했습니다");
		}
		
	}
	//매개변수에 전달된 MemberDto 객체에 담긴 name과 addr을 DB에 저장하고
	//작업의 성공여부를 리턴하는 메소드
	public static boolean insert(MemberDto dto) { //리턴 값이 boolean이라서 boolean 값이 나오기 전까지는 에러가 난 상태
		//필요한 객체를 담을 지역변수 미리 만들기
		Connection conn=null;
		PreparedStatement pstmt=null;
		//변경된 row 갯수를 저장할 변수를 0을 대입하여 미리 만들어두기
		int rowCount=0;
		try {
			//Connection 객체의 참조값 얻어내기
			conn=new DBConnector().getConn();
			//실행할 미완성의 sql 문
			String sql= """
						Insert into member
						(num, name, addr)
						values(member_seq.Nextval, ?, ?)
					""";
			//미완성의 sql 문을 전달하면서 PreparedStatement객체의 참조값 얻어내기
			pstmt = conn.prepareStatement(sql);
			//?에 값 바인딩하기
			pstmt.setString(1, dto.getName());
			pstmt.setString(2, dto.getAddr());
			//sql문 실행하고 추가(Insert)되거나, 변경(Update)되거나, 삭제(Delete)된 row의 갯수(int 값)를 리턴 받음
			rowCount= pstmt.executeUpdate();
		}catch(SQLException se) {
			se.printStackTrace();
		}finally {
			try {
				if(pstmt!=null)pstmt.close();
				if(conn!=null)conn.close();
			}catch(Exception e) {}
		}
		//rowCount 변수에 들어 있는 값을 확인해서 작업의 성공 여부를 리턴해줌
		if(rowCount>0) {
			return true;
		}else {
			return false;
		}	
		
		
		
	}
}

 
 
 
예제 풀어보기

* 수정할 회원의 정보(번호, 이름, 주소)가 MemberDto 객체에 담겨서 전달되는 메소드

* 성공여부가 리턴되는 메소드

 
 
<11:30 3교시>
2교시 예제 답

package test.main;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import test.dto.MemberDto;
import test.util.DBConnector;

public class MainClass11 {
	public static void main(String[] args) {
		//수정할 회원 정보라고 가정하자
		String name="이름3";
		String addr="다른 주소";
		int num = 1;
		
		//수정할 회원정보를 MemberDto 객체에 담고
		MemberDto dto=new MemberDto();
		dto.setName(name);
		dto.setAddr(addr);
		dto.setNum(num);
		//미리 준비된 메소드를 이용해서 DB에 저장하고 성공여부를 리턴받기
		boolean isSuccess=update(dto);
		if(isSuccess) {
			System.out.println("수정했습니다");
		}else {
			System.out.println("수정하지 못했습니다");
		}
	}
	/*
	 * 수정할 회원의 정보(번호, 이름, 주소)가 MemberDto 객체에 담겨서 전달되는 메소드
	 * 성공여부가 리턴되는 메소드
	 */
	public static boolean update(MemberDto dto) {
		//필요한 객체를 담을 지역변수 미리 만들기
				Connection conn=null;
				PreparedStatement pstmt=null;
				//변경된 row 갯수를 저장할 변수를 0을 대입하여 미리 만들어두기
				int rowCount=0;
				try {
					//Connection 객체의 참조값 얻어내기
					conn=new DBConnector().getConn();
					//실행할 미완성의 sql 문
					String sql= """
								Update member
								set name=?, addr=?
								where num=?
							""";
					//미완성의 sql 문을 전달하면서 PreparedStatement객체의 참조값 얻어내기
					pstmt = conn.prepareStatement(sql);
					//?에 값 바인딩하기
					pstmt.setString(1, dto.getName());
					pstmt.setString(2, dto.getAddr());
					pstmt.setInt(3,	dto.getNum());
					//sql문 실행하고 추가(Insert)되거나, 변경(Update)되거나, 삭제(Delete)된 row의 갯수(int 값)를 리턴 받음
					rowCount= pstmt.executeUpdate();
				}catch(SQLException se) {
					se.printStackTrace();
				}finally {
					try {
						if(pstmt!=null)pstmt.close();
						if(conn!=null)conn.close();
					}catch(Exception e) {}
				}
				//rowCount 변수에 들어 있는 값을 확인해서 작업의 성공 여부를 리턴해줌
				if(rowCount>0) {
					return true;
				}else {
					return false;
				}	
				
				
		
	}
}

 
 
row를 delete 하는 예제
처음에 앞에 두 개 때 복사 붙여넣기 했던 부분 때문에 int num을 바꾼 부분 때문에
pstmt.setInt(1, num);
부분에 num 대신 dto.getNum();을 썻는데 그렇게 할 필요가 없던 거임.

package test.main;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import test.dto.MemberDto;
import test.util.DBConnector;

public class MainClass12 {
	public static void main(String[] args) {
		//삭제할 회원 정보
		int num = 2;
		
	
		//미리 준비된 메소드를 이용해서 DB에 저장하고 성공여부를 리턴받기
		boolean isSuccess=delete(num);
		if(isSuccess) {
			System.out.println("수정했습니다");
		}else {
			System.out.println("수정하지 못했습니다");
		}
	}
	
	//매개변수로 전달되는 회원의 번호를 이용해서 회원 한명의 정보를 삭제하고 성공여부를 리턴하는 메소드
	public static boolean delete(int num) {
		//필요한 객체를 담을 지역변수 미리 만들기
		Connection conn=null;
		PreparedStatement pstmt=null;
	
		//변경된 row 갯수를 저장할 변수를 0을 대입하여 미리 만들어두기
		int rowCount=0;
		try {
			//Connection 객체의 참조값 얻어내기
			conn=new DBConnector().getConn();
			//실행할 미완성의 sql 문
			String sql= """
						delete from member
						where num=?
					""";
			//미완성의 sql 문을 전달하면서 PreparedStatement객체의 참조값 얻어내기
			pstmt = conn.prepareStatement(sql);
			//?에 값 바인딩하기
			pstmt.setInt(1,	num);
			//sql문 실행하고 추가(Insert)되거나, 변경(Update)되거나, 삭제(Delete)된 row의 갯수(int 값)를 리턴 받음
			rowCount= pstmt.executeUpdate();
		}catch(SQLException se) {
			se.printStackTrace();
		}finally {
			try {
				if(pstmt!=null)pstmt.close();
				if(conn!=null)conn.close();
			}catch(Exception e) {}
		}
		//rowCount 변수에 들어 있는 값을 확인해서 작업의 성공 여부를 리턴해줌
		if(rowCount>0) {
			return true;
		}else {
			return false;
		}	
		
		

	}
	
}

 
 
 
회원 한명의 정보만 select 해오기

package test.main;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import test.dto.MemberDto;
import test.util.DBConnector;

public class MainClass13 {
	public static void main(String[] args) {
		//select 할 회원 번호
		int num = 2;
		
		//미리 준비된 메소드를 이용해서 회원번호를 전달하고 해당하는 회원 정보를 DB에서리턴받기
		MemberDto dto=getData(num);
		if(dto!=null) {
			System.out.printf("번호:%d, 이름:%s, 주소:%s" , dto.getNum(),dto.getName(), dto.getAddr());
		}else {
			System.out.printf("요청한 %d 회원의 정보를 찾을 수 없습니다", num);
		}
	}
	//매개변수로 전달되는 번호에 해당하는 회원 정보를 select 해서 MemberDto 객체에 담아서 리턴해주는 메소드
	public static MemberDto getData(int num) {
		//memberdto 객체를 담을 변수를 미리 선언
		MemberDto dto=null;
		
		//필요한 객체를 담을 지역변수 미리 만들기
		Connection conn=null;
		PreparedStatement pstmt=null;
		ResultSet rs=null;
		try {
			//Connection 객체의 참조값 얻어내기
			conn=new DBConnector().getConn();
			//실행할 미완성의 sql 문
			String sql= """
						select name, addr 
						from member
						where num=?
					""";
			//미완성의 sql 문을 전달하면서 PreparedStatement객체의 참조값 얻어내기
			pstmt = conn.prepareStatement(sql);
			pstmt.setInt(1, num);
			rs=pstmt.executeQuery();
			//만일 select 된 row가 있다면 if 안으로 들어가서 실행, 없으면 바깥으로 빠져서 null return
			if(rs.next()) {
				//MemberDto 객체를 생성해서
				dto=new MemberDto();
				//select 된 정보를 담는다
				dto.setNum(num);
				dto.setName(rs.getString("name"));
				dto.setAddr(rs.getString("addr"));
				
			}
		}catch(SQLException se) {
			se.printStackTrace();
		}finally {
			try {
				if(pstmt!=null)pstmt.close();
				if(conn!=null)conn.close();
				if(rs!=null)rs.close();
			}catch(Exception e) {}
		}
		return dto;
	}
	
}

 
 
<12:30 4교시>

 
주말에 java 복습 정리하던 거 이어서 정리할려고 했는데 과제가 주어졌다.
 
 
 
과제

package test.dao;

import test.dto.MemberDto;

/*
 * 회원정보를 insert, update, delete, select(getData, getList)할 수있는 기능을 가진 객체를 생성할 클래스 설계하기 = 편하다
 * -이런 기능을 가진 객체를 Data Access Object 라고 한다 DAO
 */
public class MemberDao {
	//매개 변수에 전달된 MemberDto 객체에 담긴 회원 한명의 정보를 DB에 저장하는 메소드
	public boolean insert(MemberDto dto) {
		
	}
	//매개 변수에 전달된 번호에 해당하는 회원 한명의 정보를 삭제하는 메소드
	public boolean delete(int num) {
		
	}
	//매개 변수에 전달된 MemberDto 객체에 담긴 회원 한명의 정보를 수정하는 메소드
	public boolean update(MemberDto dto) {
		
	}
	// 전체 회원 목록을 리턴하는 메소드
	public List<MemberDto> getList(){
		
	}
	//매개변수에 전달된 번호에 해당하는 회원 한명의 정보를 리턴하는 메소드
	public MemberDto getData(int num) {
		
	}	
}

 
 
주말에 하던거 마저 정리하고 과제 해보러 감.

 
 
과제 시도 (복사 붙여넣기의 향연)

더보기
package test.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import test.dto.MemberDto;
import test.util.DBConnector;

/*
 * 회원정보를 insert, update, delete, select(getData, getList)할 수있는 기능을 가진 객체를 생성할 클래스 설계하기 = 편하다
 * -이런 기능을 가진 객체를 Data Access Object 라고 한다 DAO
 */
public class MemberDao {
	//매개 변수에 전달된 MemberDto 객체에 담긴 회원 한명의 정보를 DB에 저장하는 메소드
	public boolean insert(MemberDto dto) {
		//필요한 객체를 담을 지역변수 미리 만들기
				Connection conn=null;
				PreparedStatement pstmt=null;
				//변경된 row 갯수를 저장할 변수를 0을 대입하여 미리 만들어두기
				int rowCount=0;
				try {
					//Connection 객체의 참조값 얻어내기
					conn=new DBConnector().getConn();
					//실행할 미완성의 sql 문
					String sql= """
								Insert into member
								(num, name, addr)
								values(member_seq.Nextval, ?, ?)
							""";
					//미완성의 sql 문을 전달하면서 PreparedStatement객체의 참조값 얻어내기
					pstmt = conn.prepareStatement(sql);
					//?에 값 바인딩하기
					pstmt.setString(1, dto.getName());
					pstmt.setString(2, dto.getAddr());
					//sql문 실행하고 추가(Insert)되거나, 변경(Update)되거나, 삭제(Delete)된 row의 갯수(int 값)를 리턴 받음
					rowCount= pstmt.executeUpdate();
				}catch(SQLException se) {
					se.printStackTrace();
				}finally {
					try {
						if(pstmt!=null)pstmt.close();
						if(conn!=null)conn.close();
					}catch(Exception e) {}
				}
				//rowCount 변수에 들어 있는 값을 확인해서 작업의 성공 여부를 리턴해줌
				if(rowCount>0) {
					return true;
				}else {
					return false;
				}	
	}
	
	//매개 변수에 전달된 번호에 해당하는 회원 한명의 정보를 삭제하는 메소드
	public boolean delete(int num) {
		//필요한 객체를 담을 지역변수 미리 만들기
				Connection conn=null;
				PreparedStatement pstmt=null;
			
				//변경된 row 갯수를 저장할 변수를 0을 대입하여 미리 만들어두기
				int rowCount=0;
				try {
					//Connection 객체의 참조값 얻어내기
					conn=new DBConnector().getConn();
					//실행할 미완성의 sql 문
					String sql= """
								delete from member
								where num=?
							""";
					//미완성의 sql 문을 전달하면서 PreparedStatement객체의 참조값 얻어내기
					pstmt = conn.prepareStatement(sql);
					//?에 값 바인딩하기
					pstmt.setInt(1,	num);
					//sql문 실행하고 추가(Insert)되거나, 변경(Update)되거나, 삭제(Delete)된 row의 갯수(int 값)를 리턴 받음
					rowCount= pstmt.executeUpdate();
				}catch(SQLException se) {
					se.printStackTrace();
				}finally {
					try {
						if(pstmt!=null)pstmt.close();
						if(conn!=null)conn.close();
					}catch(Exception e) {}
				}
				//rowCount 변수에 들어 있는 값을 확인해서 작업의 성공 여부를 리턴해줌
				if(rowCount>0) {
					return true;
				}else {
					return false;
				}	
				
	}
	
	//매개 변수에 전달된 MemberDto 객체에 담긴 회원 한명의 정보를 수정하는 메소드
	public boolean update(MemberDto dto) {
		//필요한 객체를 담을 지역변수 미리 만들기
		Connection conn=null;
		PreparedStatement pstmt=null;
		//변경된 row 갯수를 저장할 변수를 0을 대입하여 미리 만들어두기
		int rowCount=0;
		try {
			//Connection 객체의 참조값 얻어내기
			conn=new DBConnector().getConn();
			//실행할 미완성의 sql 문
			String sql= """
						Update member
						set name=?, addr=?
						where num=?
					""";
			//미완성의 sql 문을 전달하면서 PreparedStatement객체의 참조값 얻어내기
			pstmt = conn.prepareStatement(sql);
			//?에 값 바인딩하기
			pstmt.setString(1, dto.getName());
			pstmt.setString(2, dto.getAddr());
			pstmt.setInt(3,	dto.getNum());
			//sql문 실행하고 추가(Insert)되거나, 변경(Update)되거나, 삭제(Delete)된 row의 갯수(int 값)를 리턴 받음
			rowCount= pstmt.executeUpdate();
		}catch(SQLException se) {
			se.printStackTrace();
		}finally {
			try {
				if(pstmt!=null)pstmt.close();
				if(conn!=null)conn.close();
			}catch(Exception e) {}
		}
		//rowCount 변수에 들어 있는 값을 확인해서 작업의 성공 여부를 리턴해줌
		if(rowCount>0) {
			return true;
		}else {
			return false;
		}	
			
	}
	
	// 전체 회원 목록을 리턴하는 메소드
	public List<MemberDto> getList(){
		//리턴해줄 객체를 미리 생성하기
		List<MemberDto> list=new ArrayList<>();
		//필요한 객체를 담을 지역변수 미리 준비
		Connection conn=null;
		PreparedStatement pstmt=null;
		ResultSet rs=null;
		
		try {
			//우리가 설계한 클래스로 객체생성후 Connection 객체 얻어내기
			conn=new DBConnector().getConn();
			String sql="""
				SELECT num, name, addr
				from member
			""";
			pstmt=conn.prepareStatement(sql);
			rs=pstmt.executeQuery();
			while(rs.next()) {
				int num=rs.getInt("num");
				String name=rs.getString("name");
				String addr=rs.getString("addr");
				//select 된 row 하나의 정보를 MemberDto 객체에 담는다.
				MemberDto dto=new MemberDto();
				dto.setNum(num);
				dto.setName(name);
				dto.setAddr(addr);
			
				//부서의 정보가 담긴 DeptDto 객체를 ArrayList 객체에 누적 시킨다.
				list.add(dto);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}
		
		return list;
	}
	
	
	//매개변수에 전달된 번호에 해당하는 회원 한명의 정보를 리턴하는 메소드
	public MemberDto getData(int num) {
		//memberdto 객체를 담을 변수를 미리 선언
			MemberDto dto=null;
			
			//필요한 객체를 담을 지역변수 미리 만들기
			Connection conn=null;
			PreparedStatement pstmt=null;
			ResultSet rs=null;
			try {
				//Connection 객체의 참조값 얻어내기
				conn=new DBConnector().getConn();
				//실행할 미완성의 sql 문
				String sql= """
							select name, addr 
							from member
							where num=?
						""";
				//미완성의 sql 문을 전달하면서 PreparedStatement객체의 참조값 얻어내기
				pstmt = conn.prepareStatement(sql);
				pstmt.setInt(1, num);
				rs=pstmt.executeQuery();
				//만일 select 된 row가 있다면 if 안으로 들어가서 실행, 없으면 바깥으로 빠져서 null return
				if(rs.next()) {
					//MemberDto 객체를 생성해서
					dto=new MemberDto();
					//select 된 정보를 담는다
					dto.setNum(num);
					dto.setName(rs.getString("name"));
					dto.setAddr(rs.getString("addr"));
					
				}
			}catch(SQLException se) {
				se.printStackTrace();
			}finally {
				try {
					if(pstmt!=null)pstmt.close();
					if(conn!=null)conn.close();
					if(rs!=null)rs.close();
				}catch(Exception e) {}
			}
			return dto;			
	}
	
}

 

<14:30 5교시>

package test.main;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;

public class MainClass02 {
	public static void main(String[] args) {
		//member 테이블에 추가할 회원의 정보라고 가정하기
		int num=1;
		String name="김구라";
		String addr="노량진";
		
		Connection conn=null;
		try {
			//오라클 드라이버 로딩
			Class.forName("oracle.jdbc.driver.OracleDriver");
			//접속할 DB 의 정보 @아이피주소:port번호:db이름
			String url="jdbc:oracle:thin:@localhost:1521:xe";
			//계정 비밀번호를 이용해서 Connection 객체의 참조값 얻어오기
			conn=DriverManager.getConnection(url, "scott", "TIGER");
			//예외가 발생하지 않고 여기까지 실행순서가 내려오면 접속 성공이다.
			System.out.println("Oracle DB 접속 성공");
		} catch (Exception e) {
			e.printStackTrace();
		}
		PreparedStatement pstmt=null;
		try {
			//실행할 미완성의 sql문
			String sql="""
					Insert into member
					(num, name,addr)
					Values(?,?,?)
					""";
			//미완성의 sql문을 전달하면서 PreparedStatement 객체의 참조값 얻어내기
			pstmt=conn.prepareStatement(sql);
			//미완성인 sql 문 완성 시키기(?에순서대로 값 바인딩하기)
			pstmt.setInt(1, num);
			pstmt.setString(2, name);
			pstmt.setString(3, addr);
			//sql문 실행하기
			pstmt.executeUpdate();//insert,update,delete는 모두 exectueUpdate()를 호출하면 됨
			System.out.println("회원정보를 저장했습니다");
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}

 

위에 코드에서 지역변수 num, name, addr에 대입하는 값을 다르게 하면 다른 값들도 입력이 되는데, 아무래도 이 부분을 inputstream과 outputstream 류 객체들을 이용하면 인터넷에서 입력된 정보를 데이터베이스에 입력하는 형태의 웹서버 앱을 만드는 것이 관건인듯.

 

 

예제)

//수정할 회원의 정보라고 가정하자
int num=1;//primary key
String name="에이콘";
String addr ="강남";

//위 정보대로 1번 회원의 이름을 에이콘, 주소를 강남으로 수정하는 프로그래밍 해보기

 

UPDATE 문 까먹고 있었음.... 휴....ㅠㅠ

더보기
package test.main;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;

public class MainClass03 {
	public static void main(String[] args) {
		//수정할 회원의 정보라고 가정하자
		int num=1;//primary key
		String name="에이콘";
		String addr ="강남";
		
		//위 정보대로 1번 회원의 이름을 에이콘, 주소를 강남으로 수정하는 프로그래밍 해보기
		Connection conn=null;
		try {
			//오라클 드라이버 로딩
			Class.forName("oracle.jdbc.driver.OracleDriver");
			//접속할 DB 의 정보 @아이피주소:port번호:db이름
			String url="jdbc:oracle:thin:@localhost:1521:xe";
			//계정 비밀번호를 이용해서 Connection 객체의 참조값 얻어오기
			conn=DriverManager.getConnection(url, "scott", "TIGER");
			//예외가 발생하지 않고 여기까지 실행순서가 내려오면 접속 성공이다.
			System.out.println("Oracle DB 접속 성공");
		} catch (Exception e) {
			e.printStackTrace();
		}
		PreparedStatement pstmt=null;
		try {
			//실행할 미완성의 sql문
			String sql="""
					update member
					set name=?, addr=?
					where num=?
					""";
			//미완성의 sql문을 전달하면서 PreparedStatement 객체의 참조값 얻어내기
			pstmt=conn.prepareStatement(sql);
			//미완성인 sql 문 완성 시키기(?에순서대로 값 바인딩하기)
			pstmt.setInt(3, num);
			pstmt.setString(1, name);
			pstmt.setString(2, addr);
			//sql문 실행하기
			pstmt.executeUpdate();//insert,update,delete는 모두 exectueUpdate()를 호출하면 됨
			System.out.println("회원정보를 업데이트했습니다");
		}catch(Exception e){
			e.printStackTrace();
		}
		
		
	}
}

DELETE 문도 까먹고 있었음...

 

더보기
package test.main;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;

public class MainClass04 {
	public static void main(String[] args) {
		//삭제할 회원의 PK라고 가정
		int num=1;
		//실제로 삭제하는 프로그래밍 해보기
		Connection conn=null;
		try {
			//오라클 드라이버 로딩
			Class.forName("oracle.jdbc.driver.OracleDriver");
			//접속할 DB 의 정보 @아이피주소:port번호:db이름
			String url="jdbc:oracle:thin:@localhost:1521:xe";
			//계정 비밀번호를 이용해서 Connection 객체의 참조값 얻어오기
			conn=DriverManager.getConnection(url, "scott", "TIGER");
			//예외가 발생하지 않고 여기까지 실행순서가 내려오면 접속 성공이다.
			System.out.println("Oracle DB 접속 성공");
		} catch (Exception e) {
			e.printStackTrace();
		}
		PreparedStatement pstmt=null;
		try {
			//실행할 미완성의 sql문
			String sql="""
					delete from member
					where num=?
					""";
			//미완성의 sql문을 전달하면서 PreparedStatement 객체의 참조값 얻어내기
			pstmt=conn.prepareStatement(sql);
			//미완성인 sql 문 완성 시키기(?에순서대로 값 바인딩하기)
			pstmt.setInt(1, num);
		
			//sql문 실행하기
			pstmt.executeUpdate();//insert,update,delete는 모두 exectueUpdate()를 호출하면 됨
			System.out.println("회원정보를 삭제했습니다");
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}

 

DBConnector 객체로 편하게 오라클 연결하기

package test.util;

import java.sql.Connection;
import java.sql.DriverManager;

public class DBConnector {
	//Connection 객체를 리턴해주는 매소드
	//앞으로 Connection 객체 얻기 Connection conn=new DBConnector().getConn();
	public Connection getConn() {
		Connection conn =null;//DB 연결객체를 담을 지역 변수 만들기
		try {
			//오라클 드라이버 로딩
			Class.forName("oracle.jdbc.driver.OracleDriver");
			//접속할 DB 의 정보 @아이피주소:port번호:db이름
			String url="jdbc:oracle:thin:@localhost:1521:xe";
			//계정 비밀번호를 이용해서 Connection 객체의 참조값 얻어오기
			conn=DriverManager.getConnection(url, "scott", "TIGER");
			//예외가 발생하지 않고 여기까지 실행순서가 내려오면 접속 성공이다.
			System.out.println("Oracle DB 접속 성공");
		} catch (Exception e) {
			e.printStackTrace();
		}
		return conn;
		
		
	}
}

 

package test.main;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

import test.util.DBConnector;

public class MainClass05 {
	public static void main(String[] args) {
		//회원 목록을 불러와서 콘솔에 출력하기
		
		//필요한 객체를 담을 지역변수 미리 준비
		Connection conn=null;
		PreparedStatement pstmt=null;
		ResultSet rs=null;
		
		try {
			//우리가 설계한 클래스로 객체 생성후 Connection 객체 얻어내기
			conn=new DBConnector().getConn();
			String sql="""
					SELECT num, name, addr
					from Member
					order by num asc
			""";
			pstmt=conn.prepareStatement(sql);
			rs=pstmt.executeQuery();
			while(rs.next()) {
				int num=rs.getInt("num");
				String name=rs.getString("name");
				String addr=rs.getString("addr");
				System.out.printf("번호 :%d, 이름 :%s, 주소 :%s", num, name, addr);
				System.out.println();
			}
		}catch(Exception e) {
			e.printStackTrace();
		}
		
	}
}

 

 

 

 

 

<15:30 6교시>

MemberDto 클래스를 만들었음

package test.dto;

public class MemberDto {
	//필드 선언
	private int num;
	private String name;
	private String addr;
	//디폴트 생성자
	public MemberDto() {}
	
	public MemberDto(int num, String name, String addr) {
		super();
		this.num = num;
		this.name = name;
		this.addr = addr;
	}

	public int getNum() {
		return num;
	}
	public void setNum(int num) {
		this.num = num;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAddr() {
		return addr;
	}
	public void setAddr(String addr) {
		this.addr = addr;
	}
	
	
}

우리가 하려는 것

SELECT 된 ROW 하나의 정보를 MemberDto 객체에 담고 있고,

row가 여러개니까 MemberDto 객체 여러개가 있고,

이걸 다 List<MemberDto>객체에 순서대로 담는 연습을 하려는 것

 

 

package test.main;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

import test.dto.MemberDto;
import test.util.DBConnector;

public class MainClass06 {
	public static void main(String[] args) {
		//회원 목록을 아주 쉽게 얻어낼 수 있다(날로 먹을 수 있다)
		List<MemberDto> list =getList();
		for(MemberDto tmp:list) {
			System.out.printf("번호:%d, 이름:%s, 주소:%s \r\n",tmp.getNum(), tmp.getName(),tmp.getAddr());
		}
	}
	//미리 준비된 메소드가 있다고 가정하면
	public static List<MemberDto> getList(){
		//여기에 어떻게 코딩하면 회원 목록(List<MemberDto>)를 리턴해줄 수 있을까? 코딩해보세요
		//리턴해줄 객체를 담을 지역변수 미리 준비
		List<MemberDto> list =new ArrayList<>();
		//필요한 객체를 담을 지역변수 미리 준비
		Connection conn=null;
		PreparedStatement pstmt=null;
		ResultSet rs=null;
		for(MemberDto tmp:list) {
			try {
				conn=new DBConnector().getConn();
				String sql="""
						SELECT num, name, addr
						from Member
						order by num asc
				""";
				pstmt=conn.prepareStatement(sql);
				rs=pstmt.executeQuery();
				while(rs.next()) {
					int num=rs.getInt("num");
					String name=rs.getString("name");
					String addr=rs.getString("addr");
				
					//select 된 row 하나의 정보를 memberdto 객체에 담는다.
					MemberDto dto=new MemberDto();
					dto.setNum(num);
					dto.setName(name);
					dto.setAddr(addr);
					//회원 한명의 정보가 담긴 MemberDto 객체를 ArrayList객체에 누적시킴
					list.add(dto);
				}
			}catch(Exception e) {
				e.printStackTrace();
			}	
			}
			return list;
	}
}

 

<16:30 7교시>

방금전 시간에 했던 걸 emp 테이블에 대해서 EmpDto를 만들고 진행

package test.dto;

public class EmpDto {
	private int empno;
	private String ename;
	private String job;
	private double sal;
	
	public EmpDto() {}

	public int getEmpno() {
		return empno;
	}

	public void setEmpno(int empno) {
		this.empno = empno;
	}

	public String getEname() {
		return ename;
	}

	public void setEname(String ename) {
		this.ename = ename;
	}

	public String getJob() {
		return job;
	}

	public void setJob(String job) {
		this.job = job;
	}

	public double getSal() {
		return sal;
	}

	public void setSal(double sal) {
		this.sal = sal;
	}
	
	
}

 

package test.main;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

import test.dto.EmpDto;
import test.dto.MemberDto;
import test.util.DBConnector;

public class MainClass07 {
	public static void main(String[] args) {
		//사원 목록을 아주 쉽게 얻어낼수 있다 (날로 먹을수 있다)
		List<EmpDto> list=getList();
		for(EmpDto tmp:list) {
			System.out.printf("이름:%s, 번호:%d, 직무:%s, 급여:%f \r\n", 
					tmp.getEname(), tmp.getEmpno(), tmp.getJob(), tmp.getSal());
		}
	}
	
	//미리 준비된 메소드가 있다고 가정하면 
	public static List<EmpDto> getList(){
		
		//리턴해줄 객체를 미리 생성하기
		List<EmpDto> list=new ArrayList<>();
		
		//여기에 어떻게 코딩하면 회원 목록(List<MemberDto>) 를 리턴해줄수 있을까? 코딩해 보세요.
		//필요한 객체를 담을 지역변수 미리 준비
		Connection conn=null;
		PreparedStatement pstmt=null;
		ResultSet rs=null;
		
		try {
			//우리가 설계한 클래스로 객체생성후 Connection 객체 얻어내기
			conn=new DBConnector().getConn();
			String sql="""
				SELECT ename, empno, job, sal
				from emp
			""";
			pstmt=conn.prepareStatement(sql);
			rs=pstmt.executeQuery();
			while(rs.next()) {
				String ename=rs.getString("ename");
				int empno=rs.getInt("empno");
				String job=rs.getString("job");
				double sal=rs.getDouble("sal");
				//select 된 row 하나의 정보를 MemberDto 객체에 담는다.
				EmpDto dto=new EmpDto();
				dto.setEname(ename);
				dto.setEmpno(empno);
				dto.setJob(job);
				dto.setSal(sal);
				//사원 한명의 정보가 담긴 MemberDto 객체를 ArrayList 객체에 누적 시킨다.
				list.add(dto);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}
		
		return list;
	}
}

package test.main;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

import test.dto.DeptDto;
import test.dto.EmpDto;
import test.util.DBConnector;

public class MainClass08 {
	public static void main(String[] args) {
		//부서 목록을 아주 쉽게 얻어낼수 있다 (날로 먹을수 있다)
		List<DeptDto> list=getList();
		for(DeptDto tmp:list) {
			System.out.printf("부서번호:%d, 부서이름:%s, 지역:%s \r\n", 
					tmp.getDeptno(), tmp.getDname(), tmp.getLoc());
		}
	}
	
	//미리 준비된 메소드가 있다고 가정하면 
	public static List<DeptDto> getList(){
		
		//리턴해줄 객체를 미리 생성하기
		List<DeptDto> list=new ArrayList<>();
		
		//여기에 어떻게 코딩하면 회원 목록(List<DeptDto>) 를 리턴해줄수 있을까? 코딩해 보세요.
		//필요한 객체를 담을 지역변수 미리 준비
		Connection conn=null;
		PreparedStatement pstmt=null;
		ResultSet rs=null;
		
		try {
			//우리가 설계한 클래스로 객체생성후 Connection 객체 얻어내기
			conn=new DBConnector().getConn();
			String sql="""
				SELECT deptno, dname, loc
				from dept
			""";
			pstmt=conn.prepareStatement(sql);
			rs=pstmt.executeQuery();
			while(rs.next()) {
				int deptno=rs.getInt("deptno");
				String dname=rs.getString("dname");
				String loc=rs.getString("loc");
				//select 된 row 하나의 정보를 DeptDto 객체에 담는다.
				DeptDto dto=new DeptDto();
				dto.setDeptno(deptno);
				dto.setDname(dname);
				dto.setLoc(loc);
			
				//부서의 정보가 담긴 DeptDto 객체를 ArrayList 객체에 누적 시킨다.
				list.add(dto);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}
		
		return list;
	}
}

 

package test.main;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

import test.dto.EmpDeptDto;
import test.util.DBConnector;

public class MainClass09 {
	public static void main(String[] args) {
		//부서 목록을 아주 쉽게 얻어낼수 있다 (날로 먹을수 있다)
		List<EmpDeptDto> list=getList();
		for(EmpDeptDto tmp:list) {
			System.out.printf("사원번호:%d, 사원이름:%s, 부서번호:%d, 부서 이름:%s \r\n", 
					tmp.getEmpno(), tmp.getEname(), tmp.getDeptno(), tmp.getDname());
		}
	}
	
	//미리 준비된 메소드가 있다고 가정하면 
	public static List<EmpDeptDto> getList(){
		
		//리턴해줄 객체를 미리 생성하기
		List<EmpDeptDto> list=new ArrayList<>();
		
		//여기에 어떻게 코딩하면 회원 목록(List<DeptDto>) 를 리턴해줄수 있을까? 코딩해 보세요.
		//필요한 객체를 담을 지역변수 미리 준비
		Connection conn=null;
		PreparedStatement pstmt=null;
		ResultSet rs=null;
		
		try {
			//우리가 설계한 클래스로 객체생성후 Connection 객체 얻어내기
			conn=new DBConnector().getConn();
			String sql="""
				SELECT empno, ename, deptno, dname
				from emp
				join dept using (deptno)
			""";
			pstmt=conn.prepareStatement(sql);
			rs=pstmt.executeQuery();
			while(rs.next()) {
				int empno=rs.getInt("empno");
				String ename=rs.getString("ename");
				int deptno=rs.getInt("deptno");
				String dname=rs.getString("dname");//dname 대신 별칭을 줬다면 여기도 별칭으로 바뀌어야 함
				//select 된 row 하나의 정보를 DeptDto 객체에 담는다.
				EmpDeptDto dto=new EmpDeptDto();
				dto.setEmpno(empno);
				dto.setEname(ename);
				dto.setDeptno(deptno);
				dto.setDname(dname);
			
				//부서의 정보가 담긴 DeptDto 객체를 ArrayList 객체에 누적 시킨다.
				list.add(dto);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}
		
		return list;
	}
}

 

 

<17:30 8교시> 

지금까지 한거 일단 깃허브에 새로운 허브로 올려보려고 함.

그리고 어제 실패했던거 최대한 다시 해보려고 함..

아래는 삽질 하던데까지 백업..

더보기
package test.frame01;

import java.awt.BorderLayout;
import java.awt.event.ActionListener;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class MemoFrame2 extends JFrame{
	//생성자
	public MemoFrame2(String title) {
		super(title);
		
		var topPanel=new JPanel();
		var loadBtn=new JButton("load");
		
		//페널에 UI 두개 추가

		topPanel.add(loadBtn);
		//프레임의 레이아웃 설정
		setLayout(new BorderLayout());
		//프레임의 북쪽에 페널 배치
		add(topPanel, BorderLayout.NORTH);
		//저장 버튼에 리스너 함수 등록 
		loadBtn.addActionListener((event)->{
			//입력한 문자열 읽어오기
			//String msg=inputMsg.getText();
			File f = new File("C:/Users/acorn/Desktop/playground/myFolder/memo.txt");
			
			try {
				//만일 해당 파일이 존재하지 않으면
				if(!f.exists()) {
					//새로 만들어라 
					f.createNewFile();
					System.out.println("memo.txt 파일을 만들었습니다.");
				}
				// new FileWriter(File 객체, append mode 여부 ) 
				var fr=new FileReader(f);	
			
				fr.close(); //마무리
				System.out.println("memo.txt 파일에 문자열을 기록 했습니다");		
			} catch (IOException e) {
				
				e.printStackTrace();
			}
		});
	}
	
	public static void main(String[] args) {
		var f=new MemoFrame2("메모 프레임");
		f.setBounds(100, 100, 500, 500);
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.setVisible(true);
	}
}

9:25경 학원 도착. 엄청 꿀잠 잤고 컨디션 좋다.

초심 되찾고 열심히 하자!

 

 

<9:30 1교시>지난 시간 복습

바이트 알갱이를 읽어들일 때 쓰는 객체
InputStream
바이트 알갱이를 출력할 때 쓰는 객체
OutputStream
문자열을 읽어들일 때 쓰는 객체
InputStreamReader, BufferedReader, Scanner
문자열을 출력할 때 쓰는 객체
OutputStreamWriter, BufferedWriter, PrintWriter(println 쓸 때 사용했음)
파일에서 문자열을 읽어들일 때 사용
FileReader
파일에 문자열을 출력할 때 사용
FileWriter

 

이를 테면, 주로 BufferedReader를 통해 네트워크에 연결해서 읽어들인 내용을 JTextArea 에 도착한 것이 채팅으로 온다.

네트워크에 연결하는 객체가 따로 존재한다.

 

이미지 파일을 읽어들이고 그대로 복사하는 예제

 

package test.main;

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class MainClass11 {
	public static void main(String[] args) {
		try {
			//파일로부터 byte 알갱이를 읽어들일 객체 생성
			var fis= new FileInputStream("C:\\Users\\acorn\\Desktop\\playground\\MyFolder\\0.png");
			
			//byte 알갱이를 파일에 출력할 객체 생성
			var fos= new FileOutputStream("C:\\Users\\acorn\\Desktop\\playground\\MyFolder\\copied.png");
			
			//반복문 돌면서
			while(true) {
				//1 바이트(숫자)를 읽어들여서 10진수로 반환함
				int readedByte= fis.read();//byte 타입으로 표현하게 되면 -128부터 127까지 표현할 수 있음. 이게 바이트 알갱이를 표현하기 딱 좋은 데이터 타입임.
				System.out.println(readedByte);
				if(readedByte==-1)break;//if 문 다음에 실행할 코드가 오직 한줄이면 중괄호 안에 코드할 필요 없음
				//읽어들인 1바이트 출력
				fos.write(readedByte);
				fos.flush();
			}
			System.out.println("파일을 카피했습니다");
			//마무리 작업 : 파일을 연 다음에는 닫아줘야 메모리 누수가 일어나지 않는다
			
			fos.close();
			fis.close();
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
}

 

byte 타입으로 표현하게 되면 -128부터 127까지 표현할 수 있음. 이게 바이트 알갱이를 표현하기 딱 좋은 데이터 타입임.

 

 

 

<10:30 2교시>

package test.main;

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class MainClass12 {
	public static void main(String[] args) {
		try {
			//파일로부터 byte 알갱이를 읽어들일 객체 생성
			var fis= new FileInputStream("C:\\Users\\acorn\\Desktop\\playground\\MyFolder\\0.png");
			
			//byte 알갱이를 파일에 출력할 객체 생성
			var fos= new FileOutputStream("C:\\Users\\acorn\\Desktop\\playground\\MyFolder\\copied.png");
			//byte 알갱이 여러개를 한번에 담을 배열 미리 준비하기
			byte[] buffer=new byte[1024]; // 한번에 1kilobyte를 읽을 수 있는 배열
			
			//반복문 돌면서
			while(true) {
				//byte[] 배열을 전달해서 byte 알갱이를 한번에 1024개씩 읽어들인다.
				int readedCount=fis.read(buffer);//읽어들인 개수가 리턴됨
				System.out.println(readedCount+"바이트를 읽었습니다");
				if(readedCount==-1)break;//더이상 읽을 데이터가 없으면 반복문 탈출
				//byte[]배열에 저장된 byte 알갱이를 0번 인덱스로부터 읽은 개수 만큼만 출력하기
				fos.write(buffer, 0, readedCount);//배열, 시작인덱스, 읽은 숫자를 전달하는 write 메소드를 사용한다.
				//write(byte[] b)를 사용하면 나머지 null값이 들어있는 배열까지 읽어버려서 앞에서 잘 읽어들인 파일이 깨질 수가 있다.
				
			}
			System.out.println("파일을 카피했습니다");
			//마무리 작업 : 파일을 연 다음에는 닫아줘야 메모리 누수가 일어나지 않는다
			
			fos.close();
			fis.close();
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
}

 

 

 

 

 

MainClass12를 다시 작업한 내용

메모리 누수가 발생하지 않게 확실하게 finally에서의 작업으로 파일을 close()해주기 위해서

파일을 읽어들이고 출력하는 지역 변수를 메인 메소드 안에 선언하고

try 블록 안에서 참조값을 대입하여 해결한다.

package test.main;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class MainClass12 {
	public static void main(String[] args) {
		FileInputStream fis= null;//선언
		FileOutputStream fos=null;//선언
		try {
			//파일로부터 byte 알갱이를 읽어들일 객체 생성
			fis= new FileInputStream("C:\\Users\\acorn\\Desktop\\playground\\MyFolder\\0.png");//대입
			//byte 알갱이를 파일에 출력할 객체 생성
			fos= new FileOutputStream("C:\\Users\\acorn\\Desktop\\playground\\MyFolder\\copied.png");//대입
			
			//byte 알갱이 여러개를 한번에 담을 배열 미리 준비하기
			byte[] buffer=new byte[1024]; // 한번에 1kilobyte를 읽을 수 있는 배열
			
			//반복문 돌면서
			while(true) {
				//byte[] 배열을 전달해서 byte 알갱이를 한번에 1024개씩 읽어들인다.
				int readedCount=fis.read(buffer);//읽어들인 개수가 리턴됨
				System.out.println(readedCount+"바이트를 읽었습니다");
				if(readedCount==-1)break;//더이상 읽을 데이터가 없으면 반복문 탈출
				//byte[]배열에 저장된 byte 알갱이를 0번 인덱스로부터 읽은 개수 만큼만 출력하기
				fos.write(buffer, 0, readedCount);//배열, 시작인덱스, 읽은 숫자를 전달하는 write 메소드를 사용한다.
				//write(byte[] b)를 사용하면 나머지 null값이 들어있는 배열까지 읽어버려서 앞에서 잘 읽어들인 파일이 깨질 수가 있다.
				
			}
			System.out.println("파일을 카피했습니다");
			//마무리 작업 : 파일을 연 다음에는 닫아줘야 메모리 누수가 일어나지 않는다
			//만약에 위에서 작업이 진행되다 exception이 진행되는지 아닌지 여부에 관계 없이 마무리 작업을 finally에 보내주는 것이 좋다
			
			//fos.close();
			//fis.close();
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			//마무리 작업을 그대로 가져오면 지역변수를 사용할 수 없기 때문에 오류가 나는데, 그렇기 때문에 try 내부의 지역변수들을 밖으로 옮기자니 트라이캐치로 묶어주라고 그러고...
			//해결책 : 변수 자체는 try 블럭 밖에서 만들어주고 참조값을 트라이 블럭 안에서 넣어주면 됨(선언과 참조값의 대입 분리)
			try {
				
				//마무리 작업
				if(fos!=null)fos.close();//null 체크하고 이상 없으면 메모리 누수 방지하기
				if(fis!=null)fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			
		}
	}
}

 

 

 

자동화된 널체크하기 방법도 편한데 위에꺼랑 같이 알아둬야 함.

package test.main;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class MainClass13 {
	public static void main(String[] args) {
		//try-with-resources 문법
		/* try (){} 형태로 만들어서 소괄호 안에 널체크하고 닫아야 하는 애들을 모두 넣어주면 자동으로 됨
		 * null 체크와 close()호출이 자동화됨
		 */
		try(
			//파일로부터 byte 알갱이를 읽어들일 객체 생성
			var fis= new FileInputStream("C:\\Users\\acorn\\Desktop\\playground\\MyFolder\\0.png");//대입
			//byte 알갱이를 파일에 출력할 객체 생성
			var fos= new FileOutputStream("C:\\Users\\acorn\\Desktop\\playground\\MyFolder\\copied.png");//대입
		){
		
			//byte 알갱이 여러개를 한번에 담을 배열 미리 준비하기
			byte[] buffer=new byte[1024]; // 한번에 1kilobyte를 읽을 수 있는 배열
			
			//반복문 돌면서
			while(true) {
				//byte[] 배열을 전달해서 byte 알갱이를 한번에 1024개씩 읽어들인다.
				int readedCount=fis.read(buffer);//읽어들인 개수가 리턴됨
				System.out.println(readedCount+"바이트를 읽었습니다");
				if(readedCount==-1)break;//더이상 읽을 데이터가 없으면 반복문 탈출
				//byte[]배열에 저장된 byte 알갱이를 0번 인덱스로부터 읽은 개수 만큼만 출력하기
				fos.write(buffer, 0, readedCount);//배열, 시작인덱스, 읽은 숫자를 전달하는 write 메소드를 사용한다.
				//write(byte[] b)를 사용하면 나머지 null값이 들어있는 배열까지 읽어버려서 앞에서 잘 읽어들인 파일이 깨질 수가 있다.
				
			}
			System.out.println("파일을 카피했습니다");
			//위에서 마무리 작업을 자동화 해서 안 해도 됨
            //마무리 작업 : 파일을 연 다음에는 닫아줘야 메모리 누수가 일어나지 않는다
			//만약에 위에서 작업이 진행되다 exception이 진행되는지 아닌지 여부에 관계 없이 마무리 작업을 finally에 보내주는 것이 좋다
			
			//fos.close();
			//fis.close();
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
}

 

 

챗 지피티한테 물어본 널체크 해야하는 이유

더보기

close() 메소드에 대한 널 체크가 필요한 이유는, fis(FileInputStream)와 fos(FileOutputStream) 객체가 제대로 생성되지 않은 경우에 close()를 호출하면 **NullPointerException**이 발생할 수 있기 때문입니다.

일반적으로 close() 메소드는 파일 입출력 스트림을 닫기 위해 호출되는데, 객체가 정상적으로 생성되지 않았을 경우(즉, null일 경우) close()를 호출하면 예외가 발생합니다. 예를 들어, 파일 경로가 잘못되었거나, 파일을 여는 중에 문제가 발생한 경우 fis와 fos가 null일 수 있습니다.

따라서, fis와 fos가 정상적으로 생성되었는지 확인한 후에 close()를 호출해야 안전합니다.

 

 

<11:30 3교시>

 

xxx.jar 파일은 class 파일 여러개가 압축되어 있는 파일이다.

우리는 아래 링크에서 ojdbc11.jar를 다운받아서 필요한 객체(class)들의 라이브러리를 받아올 것이다.

JDBC and UCP Downloads page | Oracle 대한민국

 

JDBC and UCP Downloads page | Oracle 대한민국

Oracle JDBC Driver Implements JDBC 4.2 spec and certified with JDK8, JDK11, JDK17, and JDK19 Oracle JDBC driver except classes for NLS support in Oracle Object and Collection types. (4,535,290 bytes) - (SHA1: d82419ba52c6064a40e211cce991e6e778249912)

www.oracle.com

 

(이럴거면 왜 개발 읍읍)

프로젝트 이름 우클릭 > build path > configure build path > libraries->classpath->add external Jars 선택

 


ctrl + shift +o 를 누르면 긁어온 내용에서 임포트 할거를 일괄 임포트시켜줌

 

오라클에 연결할 Connection 객체를 받아오기 위해 jar 어쩌구를 받아온거구.

Connection 객체에서 필요한 객체를 파생시킬 수 있다.

package test.main;

import java.sql.Connection;
import java.sql.DriverManager;

public class MainClass01 {
	public static void main(String[] args) {
		/*
		 * 자바로 오라클에 scott/TIGER 계정으로 접속해서 
		 * 모든 사원의 사원 번호, 사원이름, 직업, 급여를 사원이름의 내림차순 정렬로 Select 한 후
		 * 콘솔창에 출력하기 
		 */
		//이걸 하려면 오라클 DB에 접속할 수 있는 jar 파일이 필요함
		//DB 연결객체를 담을 지역 변수 만들기
		Connection conn=null;
		try {
			//오라클 드라이버 로딩
			Class.forName("oracle.jdbc.driver.OracleDriver");
			//접속할 DB 의 정보 @아이피주소:port번호:db이름
			String url="jdbc:oracle:thin:@localhost:1521:xe";
			//계정 비밀번호를 이용해서 Connection 객체의 참조값 얻어오기
			conn=DriverManager.getConnection(url, "scott", "TIGER");
			//예외가 발생하지 않고 여기까지 실행순서가 내려오면 접속 성공이다.
			System.out.println("Oracle DB 접속 성공");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

 

 

자바에서 오라클 디비에 접속해서 오라클의 내용을 가져와서 자바에서 볼 수 있는 과정을 해봄.

Java Data Base Connectivity 기능

package test.main;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class MainClass01 {
	public static void main(String[] args) {
		/*
		 * 자바로 오라클에 scott/TIGER 계정으로 접속해서 
		 * 모든 사원의 사원 번호, 사원이름, 직업, 급여를 사원이름의 내림차순 정렬로 Select 한 후
		 * 콘솔창에 출력하기 
		 */
		//이걸 하려면 오라클 DB에 접속할 수 있는 jar 파일이 필요함
		//DB 연결객체를 담을 지역 변수 만들기
		Connection conn=null;
		try {
			//오라클 드라이버 로딩
			Class.forName("oracle.jdbc.driver.OracleDriver");
			//접속할 DB 의 정보 @아이피주소:port번호:db이름
			String url="jdbc:oracle:thin:@localhost:1521:xe";
			//계정 비밀번호를 이용해서 Connection 객체의 참조값 얻어오기
			conn=DriverManager.getConnection(url, "scott", "TIGER");
			//예외가 발생하지 않고 여기까지 실행순서가 내려오면 접속 성공이다.
			System.out.println("Oracle DB 접속 성공");
		} catch (Exception e) {
			e.printStackTrace();
		}
		//SELECT 작업을 위해서 필요한 객체의 참조값을 담을 지역 변수 미리 만들기
		PreparedStatement pstmt=null;
		ResultSet rs= null; // 이건 우리가 오라클에서 SELECT로 가져온 테이블을 담아 놓는 변수라고 생각하면 됨, SELECT 문으로 할 수 있는걸 다 해놓고 가져오는게 좋다
		try {
			//실행할 sql 문을 미리 준비하기//따옴표 세개는 백틱과 동일한 기능이라고 생각하면 됨//단 여기서 셀렉트 문 마지막에 세미콜론 붙이면 안됨//옛날 버전에서는 ""엔터 +""엔터+""로 작성했음
			String sql="""
					Select empno, ename, job, sal
					from emp
					order by empno ASC
					""";
			//PreparedStatement 객체의 참조값 얻어오기
			pstmt= conn.prepareStatement(sql);
			//Select 문 실행하고 결과값을 resultset으로 얻어내기//Select가 아니면 ResultSet을 만들 필요가 없다.
			rs=pstmt.executeQuery();
			//반복문 돌면서
			while(rs.next()) {//rs.next()의 의미는 true를 12번 반환해서 실행했다, 즉 로우가 있으면 true를 반환한다.
            	//칼럼명을 가져오고, 그 칼럼의 값을 가져옴
				int empno =rs.getInt("empno");
				String ename=rs.getString("ename");
				String job= rs.getString("job");
				double sal = rs.getDouble("sal");
				System.out.println(empno+"|"+ename+"|"+job+"|"+sal);
				
			}
		}catch(Exception e) {
			e.printStackTrace();
		}
		
	}
}

 

ResultSet rs= null; 

이건 우리가 오라클에서 SELECT로 가져온 테이블을 담아 놓는 변수라고 생각하면 되는데,

SELECT 문으로 할 수 있는걸 다 해놓고 그 테이블을 가져오는게 좋다. (안그러면 자바에서 노가다)

 

 

<12:30 4교시>

예제 풀이 했다. 정말로 개발자는.... Ctrl +C&V의 향연이구나

더보기
package test.main;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class MainClassTest {
	public static void main(String[] args) {
		
		Connection conn=null;
		try {
			Class.forName("oracle.jdbc.driver.OracleDriver");
			String url="jdbc:oracle:thin:@localhost:1521:xe";
			conn=DriverManager.getConnection(url, "scott", "TIGER");
			System.out.println("Oracle DB 접속 성공");
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		PreparedStatement pstmt=null;
		ResultSet rs= null;
		try{
			
			String sql="""
					Select deptno, dname, loc
					from dept
					""";
			pstmt= conn.prepareStatement(sql);
			rs=pstmt.executeQuery();
			while(rs.next()) {
				int deptno =rs.getInt("deptno");
				String dname=rs.getString("dname");
				String loc= rs.getString("loc");
				System.out.println(deptno+"|"+dname+"|"+loc);
				
			}
		}catch(Exception e) {
			e.printStackTrace();
		}
		
		System.out.println("-------------------------------------");
		//2. 사원번호, 사원이름, 부서번호, 부서명을 사원번호에 대해 내림차순 정렬하기
		try {
				String sql="""
						Select empno,ename, deptno, dname
						from emp
						join dept using (deptno)
						order by empno DESC
						""";
				pstmt=conn.prepareStatement(sql);
				rs=pstmt.executeQuery();
				while(rs.next()){
					int empno=rs.getInt("empno");
					String ename= rs.getString("ename");
					int deptno=rs.getInt("deptno");
					String dname=rs.getString("dname");
					System.out.println(deptno+"|"+ename+"|"+deptno+"|"+dname);
				}
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
}

초심 찾고 열심히 하기로 한지 몇시간 되지도 않아서 딴짓하다 놓칠뻔했다...ㅋㅋㅋㅋ

따라갈만 하다고 자만하는거 하면 안되는데 ㅠ 나는 참 까불거리는 녀석인듯 ㅋㅋㅋㅋㅋ

<14:30 5교시>

바이트 알갱이는 문자를 나타낼 수도, 문서를 나타낼 수도, 사진을 나타낼 수도, 영상을 나타낼 수도 있다.

 

InputStream에 대하여

기본적으로 인풋스트림은 1바이트 처리로, 문자열을 다루긴 어렵다.

문자를 읽어들일때 InputStream, InputStreamReader, BufferedReader 를 사용한다

package test.main;

import java.io.IOException;
import java.io.InputStream;

/*
 * 입력,출력(input, output)
 * -어떤 대상으로부터 데이터를 메모리로 읽어들이는 것을 입력
 * -프로그래밍 언어의 관점에서 메모리라는 것은 변수나 필드나 객체로 생각하면 편함
 * -데이터는 2진수로 이루어졌지만 2진수 8개의 묶음인 1바이트 단위로 생각하면 편함
 * -1바이트는 총 256가지의 값을 표현 가능
 * -1바이트를 10진수로 환산하면 0~255 사이의 숫자 중 하나
 * - 입력과 출력을 통해서 이동하는 데이터는 byte(byte 알갱이) 하나하나가 이동한다고 생각하면 됨
 */
public class MainClass01 {
	public static void main(String[] args) {
		System.out.println("메인 메소드 시작합니다");
		//키보드와 연결된 InputStream 타입의 참조값을 kbd라는 지역변수에 담고
		//InputStream 객체는 1바이트 단위 처리 스트림이다.
		//영문자, 대소문자, 숫자, 특수문자만 처리할 수 있고
		//한글은 처리가 불가능하다.		
		InputStream kbd = System.in;
		
		try {
			//입력한 키의 코드 값 읽어오기
			int code=kbd.read();
			System.out.println("code:"+code);
			//code 값으 대응되는 문자 얻어내기
			char ch=(char)code;
			System.out.println("ch"+ch);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

 

package test.main;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class MainClass02 {
	public static void main(String[] args) {
		System.out.println("메인 메소드 시작");
		//1byte 처리 스트림
		InputStream kbd=System.in;
		
		//2byte 처리 스트림(65536가지를 표현 가능) 한글 처리 가능한 객체
		InputStreamReader isr = new InputStreamReader(kbd);
		//위에거를 var isr=InputStreamReader(kbd);라고 해도 됨
		System.out.println("입력: ");
		try {
			//InputStreamReader 객체로 입력한 문자의 코드 값 읽어내기
			int code=isr.read();
			System.out.println("code:"+code);
			char ch=(char)code;
			System.out.println("ch"+ch);
		} catch (IOException e) {
			
			e.printStackTrace();
		}
	}
}
package test.main;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class MainClass03 {
	public static void main(String[] args) {
		System.out.println("메인 메소드 시작");
		//1byte 처리 스트림
		InputStream kbd=System.in;
		//2byte 처리 스트림
		var isr=new InputStreamReader(kbd);
		//bufferedreader의 생성자로 inputstreamreader 객체를 전달해서 객체 생성
		var br =new BufferedReader(isr);
		System.out.println("입력:");
		try {
			String line=br.readLine();
			System.out.println("line:"+line);
		} catch (IOException ie) {
			ie.printStackTrace();
		}
	}
}

 

 

 

<15:30 6교시>

 

package test.main;

import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;

public class MainClass05 {
	public static void main(String[] args) {
		//콘솔창에 출력할 수 있는 객체의 참조값 얻어내기
		PrintStream ps=System.out;
		//PrintStream 객체의 참조값을 부모 type 변수에 담기
		//OutputStream 도 1바이트 처리 스트림(한글 처리 불가)
		OutputStream os=ps;
		var osw=new OutputStreamWriter(os);
		try {
			osw.write(97);
			osw.write(98);
			osw.write(44032);//한글처리 가능
			osw.write("분수");
			osw.write("\r\n");
			osw.write("piano");
			osw.flush();//방출
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		
	}
}

 

package test.main;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;

public class MainClass06 {
	public static void main(String[] args) {
		//콘솔창에 출력할 수 있는 객체의 참조값 얻어내기
		PrintStream ps=System.out;
		//PrintStream 객체의 참조값을 부모 type 변수에 담기
		//OutputStream 도 1바이트 처리 스트림(한글 처리 불가)
		OutputStream os=ps;
		var osw=new OutputStreamWriter(os);
		//OutputStreamWriter를 BufferedWriter의 생성자에 전달해서 객체 생성
		var bw=new BufferedWriter(osw);
		/*
		 * window의 개행기호:\r\n
		 * 리눅스, 맥의 개행기호 : \n
		 */
		try {
			bw.write("하나");
			bw.newLine();//운영체제에 맞는 개행 기호를 자동으로 출력해주는 메소드
			bw.write("두울");
			bw.newLine();
			bw.write("세엣");
			bw.flush();//방출
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		
	}
}

 

 

 

 

Input - InputStream / InputStreamReader/ BufferedReader

Output- OutputStream/OutputStreamWriter/BufferedWriter

각각 맨 앞에 애들은 한글자밖에 못 읽어들이고 /나머지 두번째, 세번째 네개는 문자열 처리하기도 좋음

 

 

따옴표와 역슬래시를 문자열에 출력하기 위한 방법 역슬래시 뒤에 놓는다.

 

java로 파일 만들기

 

 

package test.main;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class MainClass07 {
	public static void main(String[] args) {
		System.out.println("main() 메소드가 \"시작\"되었습니다");
		System.out.println("main() 메소드가 \\시작\\되었습니다");
		
		//MyFolder/memo.txt 파일에 저장할 문자열을 출력하기
		String msg="난 자바의 신이 될 것이다";
		//1. 메모 파일을 만들기
		//File f= new File("C:\\Users\\acorn\\Desktop\\playground\\MyFolder\\memo.txt");
		File f=new File("C:/Users/acorn/Desktop/playground/MyFolder/memo.txt");
		try {
			if(!f.exists()) {//만일 해당 파일이 존재하지 않으면
				f.createNewFile();//새로 만들어라
				System.out.println("memo.txt 파일을 만들었습니다");
			}
			//2. 문자열을 파일에 저장하기
			//new FileWriter(File 객체, append mode 여부)
			
			var fw= new FileWriter(f, true);
			fw.append(msg);
			fw.append("\r\n");//개행기호
			fw.flush();//실제출력
			fw.close();//마무리
			System.out.println("메모장 파일에 문자열을 기록했습니다.");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		
	}
}

 

 

<16:30 7교시>

더보기

1단계 프레임 만들기

package test.frame01;

import javax.swing.JFrame;

public class MemoFrame extends JFrame{
	//생성자
	public MemoFrame(String title) {
		super(title);
		
		
		
	}

	public static void main(String[] args) {
		var f=new MemoFrame("메모 프레임");
		f.setBounds(100,100,500,500);
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.setVisible(true);
	}
}

 

2단계 텍스트 입력 상자 만들기

package test.frame01;

import java.awt.BorderLayout;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class MemoFrame extends JFrame{
	//생성자
	public MemoFrame(String title) {
		super(title);
		
		var topPanel=new JPanel();
		var inputMsg=new JTextField(30);
		var saveBtn=new JButton("Save");
		// 패널에 UI 두개 추가
		topPanel.add(inputMsg);
		topPanel.add(saveBtn);
		//프레임의 레이아웃 설정
		setLayout(new BorderLayout());
		//프레임의 북쪽에 패널 배치
		add(topPanel, BorderLayout.NORTH);
		
	}

	public static void main(String[] args) {
		var f=new MemoFrame("메모 프레임");
		f.setBounds(100,100,500,500);
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.setVisible(true);
	}
}

 

 

3단계 액션리스너를 프레임 자체가 구현하도록 implement 하고 메모장에 저장하기

package test.frame01;

import java.awt.BorderLayout;
import java.awt.event.ActionListener;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class MemoFrame extends JFrame{
	//생성자
	public MemoFrame(String title) {
		super(title);
		
		var topPanel=new JPanel();
		var inputMsg=new JTextField(30);
		var saveBtn=new JButton("Save");
		
		//페널에 UI 두개 추가
		topPanel.add(inputMsg);
		topPanel.add(saveBtn);
		//프레임의 레이아웃 설정
		setLayout(new BorderLayout());
		//프레임의 북쪽에 페널 배치
		add(topPanel, BorderLayout.NORTH);
		//저장 버튼에 리스너 함수 등록 
		saveBtn.addActionListener((event)->{
			//입력한 문자열 읽어오기
			String msg=inputMsg.getText();
			File f = new File("C:/Users/acorn/Desktop/playground/myFolder/memo.txt");
			
			try {
				//만일 해당 파일이 존재하지 않으면
				if(!f.exists()) {
					//새로 만들어라 
					f.createNewFile();
					System.out.println("memo.txt 파일을 만들었습니다.");
				}
				// new FileWriter(File 객체, append mode 여부 ) 
				var fw=new FileWriter(f, true);
				fw.append(msg);
				fw.append("\r\n"); //개행기호
				fw.flush(); //실제 출력
				fw.close(); //마무리
				System.out.println("memo.txt 파일에 문자열을 기록 했습니다");		
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		});
	}
	
	public static void main(String[] args) {
		var f=new MemoFrame("메모 프레임");
		f.setBounds(100, 100, 500, 500);
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.setVisible(true);
	}
}

 

 

 

package test.main;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

/*
 * C:Users/acorn/Desktop/playground/MyFolder/memo.txt 파일에 저장된 문자열을 읽어와서
 * 콘솔창에 출력하는 예제
 */
public class MainClass08 {
	public static void main(String[] args) {
		File f=new File("C:/Users/acorn/Desktop/playground/MyFolder/memo.txt");
		
		try {
			//파일로부터 문자열을 읽어들일 수 있는 객체 생성
			var fr=new FileReader(f);
			//무한루프 돌면서
			while(true) {
				//문자의 코드값을 읽어들인다.
				int code= fr.read();
				//만일 더이상 읽을 게 없다면
				if(code==-1) {
					break;//반복문 탈출
				}
				//코드를 문자로 변환
				char ch=(char)code;
				//출력
				System.out.println(ch);
			}
		}catch(IOException ie){
			ie.printStackTrace()
		;}
			
		}
		
		
}
package test.main;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

/*
 * C:Users/acorn/Desktop/playground/MyFolder/memo.txt 파일에 저장된 문자열을 읽어와서
 * 콘솔창에 출력하는 예제
 */
public class MainClass09 {
	public static void main(String[] args) {
		File f=new File("C:/Users/acorn/Desktop/playground/MyFolder/memo.txt");
		
		try {
			//파일로부터 문자열을 읽어들일 수 있는 객체 생성
			var fr=new FileReader(f);
			//문자열을 바로 읽어들일 수 있는
			var br= new BufferedReader(fr);
			//무한루프 돌면서
			while(true) {
				String line=br.readLine();
				//더이상 읽어올 문자열이 없으면 반복문 탈출
				//만일 더이상 읽을 게 없다면
				if(line==null) {
					break;
				}
				//읽어낸 문자열을 한줄씩 콘솔창에 출력
				System.out.println(line);
			}
		}catch(IOException ie){
			ie.printStackTrace()
		;}
			
		}
		
		
}

 

package test.main;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

/*
 * C:Users/acorn/Desktop/playground/MyFolder/memo.txt 파일에 저장된 문자열을 읽어와서
 * 콘솔창에 출력하는 예제
 */
public class MainClass10 {
	public static void main(String[] args) {
		
		//문자열을 누적 시킨다음 한번에 누적된 문자열을 얻어낼 수 있는 객체 생성
		var sb= new StringBuilder();
		File f=new File("C:/Users/acorn/Desktop/playground/MyFolder/memo.txt");
		
		try {
			//파일로부터 문자열을 읽어들일 수 있는 객체 생성
			var fr=new FileReader(f);
			//무한루프 돌면서
			var br= new BufferedReader(fr);
			//무한루프 돌면서
			while(true) {
				String line=br.readLine();
				//더이상 읽어올 문자열이 없으면 반복문 탈출
				//만일 더이상 읽을 게 없다면
				if(line==null) {
					break;
				}
				//읽어낸 문자열을 Stringbuilder 객체에 누적시키
				sb.append(line);
				sb.append("\r\n");//개행기호
			}
		}catch(IOException ie){
			ie.printStackTrace()
		;}
		//StringBuilder 객체에 누적된 문자열을 한번에 출력하기
		String result=sb.toString();
		System.out.println(result);
		}
		
		
}

 

 

<17:30 8교시> 

혼자 삽질한거(로드를 눌러서 메모장에 저장된 것을 불러오기)

더보기
package test.frame01;

import java.awt.BorderLayout;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextArea;


public class MemoFrame2 extends JFrame{
	//생성자
	
	
	public MemoFrame2(String title) {
		super(title);
		var topPanel=new JPanel();
		var loadBtn=new JButton("load");
		var ta= new JTextArea();
		
		topPanel.add(loadBtn);
		setLayout(new BorderLayout());
		add(topPanel, BorderLayout.NORTH);
	
	}
	
	public static void main(String[] args) {
		var frame=new MemoFrame2("메모 프레임2");
		frame.setBounds(100, 100, 500, 500);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setVisible(true);
		File f = new File("C:/Users/acorn/Desktop/playground/myFolder/memo.txt");
		var sb=new StringBuilder();
		
		try {
			var fr=new FileReader(f);
			var br=new BufferedReader(fr);
			while(true) {
				String line=br.readLine();
				if(line==null) {
					break;
				}
				sb.append(line);
				sb.append("\r\n");
				
			}
			ta.setText(sb.toString());
		} catch (IOException ie) {
			ie.printStackTrace();
		}
		
		});
	}
	
		
}

 

 

 

 

 

 

9:15경 학원 도착

엊그제 하다가 간거 다시 시도해보려고 함... 실패 ㅎ

 

<9:30 1교시>

엊그제 작업하던 깃허브 공동작업 공간에 리셋된 것에 다시 만들어서 추가하는데 2빠로 성공 ㅎㅎ

vs code로 git 작업하면 생각보다 자동화 되어 있는게 편리하긴 한데, 따로 작업할 때는 아무래도 각자 올리게 되니까 시간에 쫓겨서 할 필요 없고, 이제 2빠는 했으니까 나머지 시간에는 공부한다 생각하고 천천히 올려봐야겠다.

 

이번에는 git bash 이용해서 올려봐야지.는 그냥 또 vs code로 해버렸는데 너무 편하네;;;

 

머릿속에 이미지를 그려보자.

 

맨 처음 공동 작업 장의 사진을 내려 받을 때에는 내 컴퓨터에 새로 추가되거나 변경되어서 지저분한 가지 상태가 아니어야 함.

그래서 혹시라도 변경된 사항이 있다면 commit을 해 놓은 상태에서 공동작업장의 사진들을 내려 받아야 함.

pull로 작업장 내용을 전부 내려 받았다면 merge를 시도하는데, 이때 merge하느라 발생한 충돌을 해결할 필요가 있을 수 있다.

충돌을 해결하고 내가 올리고 싶은 사진을 만든 상태라면 다시 stage에 올려서 commit을 진행하고 push로 공동작업장에 올리는데, 이때 내가 위의 작업을 하는 동안 다른 누군가가 자신의 작업을 push 한 상태라면 위의 내용을 다시 반복해서 진행하면 된다.

 

아무튼 1교시는 또 이렇게 git 관련한 내용을 해보았...

쉬는 시간에다른 수강생이 터미널로 git 하는거 옆에서 거들었는데 위에 내용이 어쨋든 핵심인듯...

 

 

<10:30 2교시>

어제 오후에 못 했던거 답 알려주심... 아쉽다 ㅠㅠ 접근 방법은 맞았는데 아직 식을 쓰거나 대입하는게 서툰 부분이 있다.

더보기
package test.frame05;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Font;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

public class MyFrame extends JFrame {
	JTextArea ta=new JTextArea();
	//생성자
	public MyFrame() {
		//프레임 제목
		this.setTitle("나의 프레임");
		//프레임 위치와 크기 설정 setBounds(x, y, width, height)
		setBounds(100,100,500,500);
		//종료 버튼을 눌렀을 때 프로세스 전체가 종료되도록 하기
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		//레이아웃 메니저 객체 생성
		BorderLayout layout =new BorderLayout();
		//프레임의 레이아웃 메니저 설정
		setLayout(layout);
		
		//TextField 와 Button을 배치할 패널객체
		JPanel topPanel=new JPanel();
		topPanel.setBackground(Color.red);
		//TextField와 Button을 생성해서
		JTextField inputMsg= new JTextField(30);
		JButton sendBtn=new JButton("전송");
		//Panel에 추가
		topPanel.add(inputMsg);
		topPanel.add(sendBtn);
		//프레임의 위쪽에 패널 추가
		add(topPanel, BorderLayout.NORTH);
		
		
		ta=new JTextArea();
		//textarea를 스크롤 패널에 감싼다
		JScrollPane scroll = new JScrollPane(ta);
		//프레임의 가운데에 TextArea 추가
		Font font=new Font("Times New Roman", Font.BOLD, 20);
		ta.setFont(font);
		add(scroll, BorderLayout.CENTER);
		sendBtn.addActionListener((event)->{
			//TextField 에 입력한 문자열을 읽어온다.
			String msg=inputMsg.getText();
			//미리 준비된 메소드를 호출하면서 입력한 문자열을 등록함
			request(msg);			
		});
		
		//화면상에 실제 보이도록 하기
		setVisible(true);
		
	}
	//매개변수에 전달되는 주소로 요청하는 메소드
	public void request(String requesturl) {
        try {
            // 요청 보낼 URL 설정
            URL url = new URL("https://acornacademy.co.kr"); // 예제 URL
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();

            // HTTP 요청 메서드 설정
            connection.setRequestMethod("GET");

            // 헤더 설정 (필요에 따라 추가)
            connection.setRequestProperty("Accept", "application/json");

            // 응답 코드 확인
            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);
            //응답한 문자열을 누적시킬 객체 
            StringBuilder response = new StringBuilder();
            //만일 정상적인 응답이라면 
            if (responseCode == HttpURLConnection.HTTP_OK) {
            	//응답하는 내용을 읽어들일 객체 
            	BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()));           
                //반복문 돌면서
            	while (true) {
                	//한줄씩 읽어들이고 
                	String line=br.readLine();
                	//만일 다 읽었다면 
                	if(line==null) {
                		break; //반복문 탈출
                	}
                	//읽은 문자열 한줄을 누적시킨다.
                    response.append(line+"\r\n");
                }
               
            } else {
                System.out.println("Request failed. Response Code: " + responseCode);
            }
            //누적된 문자열을 출력하기 
           // System.out.println(response.toString());
            //누적된 문자열을 TextArea에 출력하기
            ta.setText(response.toString());
            // 연결 해제
            connection.disconnect();

        } catch (Exception e) {
            e.printStackTrace();
        }
	}
	//main 메소드
	public static void main(String[] args) {
		new MyFrame();
	}
}

 

스레드의 개념

스레드는 실행의 흐름을 말하며, 작업단위가 된다.

run 했을  때 실행되는 흐름은 메인 스레드라고 한다.

아래 코드는 5초간 스레드가 진행되지 않고 sleep(잠을 자며), test()메소드를 호출하게 되면 test 메소드를 호출하고, test()메소드가 실행된 후 리턴(종료)되며, 다음 라인이 실행된 다음 메인 스레드가 종료된다.

 

package test.main;

public class MainClass01 {
	public static void main(String[] args) { //실행의 흐름을 스레드라고 하고, run 했을 때 실행되는 흐름은 main 스레드라고 함.
		System.out.println("메인 메소드가 시작되었습니다");
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		test();
		System.out.println("메인 메소드가 종료됩니다");
	}
	
	public static void test() {
		System.out.println("test() 메소드 호출됨");
	}
}

 

Thread.sleep(1000*10);을 하면 에러가 나는데 마우스를 올려서 surround try/catch를 누르면 해결된다.

package test.frame01;

import java.awt.FlowLayout;

import javax.swing.JButton;
import javax.swing.JFrame;

public class MyFrame extends JFrame {
	//생성자
	public MyFrame(String title) {
		super(title);
		setLayout(new FlowLayout());
		/*
		 * type 추론이 가능하다면 지역 변수의 type 선언 대신에 var로 변수를 선언할 수 있다.
		 * java 10에서 추가된 문법이고, 진부한 코딩을 줄이기 위한 문법이라고 함.
		 * 다만, 아직도 실무에서는 1.8버전을 쓰는 곳이 많으니까 주의하기.
		 * 지역변수에만 사용가능하고 필드에는 사용 불가, 인터페이스는 type 추론이 불가함.
		 * null로 초기화가 불가능함.
		 */
		
		var num=10;
		var name="kim";
		var isRun=true;
		
		
		var startBtn=new JButton("작업시작");
		add(startBtn);
		var startBtn2=new JButton("작업시작2");
		add(startBtn);
		startBtn.addActionListener((e)->{
			System.out.println("10 소요 작업");
			try {
				Thread.sleep(1000*10);
			} catch (InterruptedException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
			System.out.println("작업 종료됨");
		});
	}
}

 

 

<11:30 3교시>

메인스레드가 run하면 실행되는데, 그러면 새로운 작업단위(스레드)에서 작업시키고 버튼을 누를 때마다 실행이되는건 메인 스레드.

메인스레드는 시간이 오래 걸리거나 대기하는 작업을 하면 안되기 때문에 새로운 작업 단위 만들어서 실행시키는 방법을 배우는 것.

 

 

빈 클래스에서 컨트롤 스페이스를 누르면 override 할 수 있는 애들 목록이 보인다.

 

package test.frame01;
/*
 * 새로운 스레드를 만드는 방법
 * 1. Thread 클래스를 상속 받은 클래스를 정의함 extends Thread
 * 2. run()메소드를 오버라이드
 * 3. run()메소드 안에서 새로운 스레드에서 작업할 내용을 코딩
 * 4. 만든 클래스로 객체를 생성하고 해당 객체의 start()메소드를 호출하면 새로운 스레드가 시작됨
 * 		new WorkThread().start();
 */
public class WorkThread extends Thread {//1.
	@Override
	public void run() {
		//새로운 스레드에서 해야할 작업을 run() 메소드 안에서 시작한다.
		System.out.println("10초 소요 작업의 시작");
		try {
			Thread.sleep(1000*10);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("작업 종료");
	}
}

위의 코드와 아래 코드를 적용하면, 작업시작 버튼은 한번 누르면 아무것도 못하는 바보 버튼이 되는데,

작업시작2버튼은 새로운 독립적인 작업스레드가 생겨서 여러번 작업을 할 수도 있고 작업창을 움직일 수 있다.

작업 단위가 여러개가 필요할 때 이 방법을 통해 새로운 독립적인 1회용 작업스레드를 생성할 수 있도록 해준다.

시간이 걸리거나 대기해야 할 것 같은 작업은 이런식으로 새로운 작업단위로 넘겨서 진행해준다.

package test.frame01;

import java.awt.FlowLayout;

import javax.swing.JButton;
import javax.swing.JFrame;

public class MyFrame extends JFrame {
	//생성자
	public MyFrame(String title) {
		super(title);
		setLayout(new FlowLayout());
		//this.setBounds(100,100,300,300); //얘 대신에 맨 아래처럼 쓸 수 있다.
		//this.setDefaultCloseOperation(EXIT_ON_CLOSE);//얘도 맨 아래처럼 쓸 수 있음
		/*
		 * type 추론이 가능하다면 지역 변수의 type 선언 대신에 var로 변수를 선언할 수 있다.
		 * java 10에서 추가된 문법이고, 진부한 코딩을 줄이기 위한 문법이라고 함.
		 * 다만, 아직도 실무에서는 1.8버전을 쓰는 곳이 많으니까 주의하기.
		 * 지역변수에만 사용가능하고 필드에는 사용 불가, 인터페이스는 type 추론이 불가함.
		 * null로 초기화가 불가능함.
		 */
		
		var num=10;
		var name="kim";
		var isRun=true;
		
		
		var startBtn=new JButton("작업시작");
		add(startBtn);
		var startBtn2=new JButton("작업시작2");
		add(startBtn2);
		startBtn.addActionListener((e)->{
			System.out.println("10 소요 작업");
			try {
				Thread.sleep(1000*10);
			} catch (InterruptedException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
			System.out.println("작업 종료됨");
		});
		startBtn2.addActionListener((e)->{
			//WorkThread 클래스로 객체를 생성해서 참조값을 얻어낸 다음
			WorkThread t=new WorkThread();
			//start() 메소드를 호출해서 새로운 스레드가 시작되도록 한다.
			//그럼 start() 메소드를 통해 run()메소드가 호출되면서 자연스럽게 실행된다.
			t.start();
		});
	}
	//run 했을 때 실행의 흐림이 시작되는 메인 메소드
	public static void main(String[] args) {
		var frame=new MyFrame("나의 프레임");
		//MyFrame 객체 안에서 this.으로 호출했던 메소드를
		//객체 외부에서는 참조값에 .을 찍어서 호출할 수 있다.
		frame.setBounds(100,100, 300,300);
		frame.setDefaultCloseOperation(EXIT_ON_CLOSE);
		frame.setVisible(true);
	}
	
}

 

스레드(작업단위) 생성하는 또 다른 방법 : 아래 두개 클래스 코드로 활용 가능(Btn2 부분 참고)

이렇게 생성한 스레드는 3,4번을 통해서 시작시킴

Thread t=new Thread(new WorkRunnable());

t.start();

package test.frame02;
/*
 * 새로운 스레드 만드는 방법2
 * 1. Runnable 인터페이스를 구현한 클래스를 정의하기
 * 2. run()메소드를 강제 오버라이드하기
 * 3. Thread 클래스로 객체를 생성하면서 해당 클래스로 만든 객체를 생성자의 인자로 전달하기
 * 4. Thread 클래스로 만든 객체의 start() 메소드를 호출해서 스레드를 시작시키기 * 
 */
public class WorkRunnable implements Runnable{//1.

	@Override
	public void run() {
		System.out.println("10초 소요 작업의 시작");
		try {
			Thread.sleep(1000*10);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("작업 종료");
	}

}

 

package test.frame02;

import java.awt.FlowLayout;

import javax.swing.JButton;
import javax.swing.JFrame;

public class MyFrame extends JFrame {
	//생성자
	public MyFrame(String title) {
		super(title);
		setLayout(new FlowLayout());
		//this.setBounds(100,100,300,300); //얘 대신에 맨 아래처럼 쓸 수 있다.
		//this.setDefaultCloseOperation(EXIT_ON_CLOSE);//얘도 맨 아래처럼 쓸 수 있음
		/*
		 * type 추론이 가능하다면 지역 변수의 type 선언 대신에 var로 변수를 선언할 수 있다.
		 * java 10에서 추가된 문법이고, 진부한 코딩을 줄이기 위한 문법이라고 함.
		 * 다만, 아직도 실무에서는 1.8버전을 쓰는 곳이 많으니까 주의하기.
		 * 지역변수에만 사용가능하고 필드에는 사용 불가, 인터페이스는 type 추론이 불가함.
		 * null로 초기화가 불가능함.
		 */
		
		var num=10;
		var name="kim";
		var isRun=true;
		
		
		var startBtn=new JButton("작업시작");
		add(startBtn);
		var startBtn2=new JButton("작업시작2");
		add(startBtn2);
		startBtn.addActionListener((e)->{
			System.out.println("10 소요 작업");
			try {
				Thread.sleep(1000*10);
			} catch (InterruptedException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
			System.out.println("작업 종료됨");
		});
		startBtn2.addActionListener((e)->{
			Thread t=new Thread(new WorkRunnable());
			t.start();
		});
	}
	//run 했을 때 실행의 흐림이 시작되는 메인 메소드
	public static void main(String[] args) {
		var frame=new MyFrame("나의 프레임");
		//MyFrame 객체 안에서 this.으로 호출했던 메소드를
		//객체 외부에서는 참조값에 .을 찍어서 호출할 수 있다.
		frame.setBounds(100,100, 300,300);
		frame.setDefaultCloseOperation(EXIT_ON_CLOSE);
		frame.setVisible(true);
	}
	
}

 

 

 

3번째 방법 : interface의 익명 객체 생성 방법을 활용해서 만들기

new Runnable(){}   이상태에서 빨간 밑줄 생기는거에 마우스 가져다 대고 unimplemented element 생성하기 넣고

{} 안에 오버라이드 된 run() 안에다가 Thread.sleep에 의한 실행 집어 넣기

package test.frame03;

import java.awt.FlowLayout;

import javax.swing.JButton;
import javax.swing.JFrame;

public class MyFrame extends JFrame {
	//생성자
	public MyFrame(String title) {
		super(title);
		setLayout(new FlowLayout());
		//this.setBounds(100,100,300,300); //얘 대신에 맨 아래처럼 쓸 수 있다.
		//this.setDefaultCloseOperation(EXIT_ON_CLOSE);//얘도 맨 아래처럼 쓸 수 있음
		/*
		 * type 추론이 가능하다면 지역 변수의 type 선언 대신에 var로 변수를 선언할 수 있다.
		 * java 10에서 추가된 문법이고, 진부한 코딩을 줄이기 위한 문법이라고 함.
		 * 다만, 아직도 실무에서는 1.8버전을 쓰는 곳이 많으니까 주의하기.
		 * 지역변수에만 사용가능하고 필드에는 사용 불가, 인터페이스는 type 추론이 불가함.
		 * null로 초기화가 불가능함.
		 */
		
		var num=10;
		var name="kim";
		var isRun=true;
		
		
		var startBtn=new JButton("작업시작");
		add(startBtn);
		var startBtn2=new JButton("작업시작2");
		add(startBtn2);
		startBtn.addActionListener((e)->{
			System.out.println("10 소요 작업");
			try {
				Thread.sleep(1000*10);
			} catch (InterruptedException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
			System.out.println("작업 종료됨");
		});
		startBtn2.addActionListener((e)->{
			Thread t=new Thread(new Runnable() {

				@Override
				public void run() {
					System.out.println("10 소요 작업");
					try {
						Thread.sleep(1000*10);
					} catch (InterruptedException e1) {
						// TODO Auto-generated catch block
						e1.printStackTrace();
					}
					System.out.println("작업 종료됨");
				}
			});
			t.start();
		});
	}
	//run 했을 때 실행의 흐림이 시작되는 메인 메소드
	public static void main(String[] args) {
		var frame=new MyFrame("나의 프레임");
		//MyFrame 객체 안에서 this.으로 호출했던 메소드를
		//객체 외부에서는 참조값에 .을 찍어서 호출할 수 있다.
		frame.setBounds(100,100, 300,300);
		frame.setDefaultCloseOperation(EXIT_ON_CLOSE);
		frame.setVisible(true);
	}
	
}

 

 

 

더 간단한 방법

new Thread(()->{}).start(); 형태로, Thread 안의 함수 형태의 {} 안쪽에 run 메소드에서 작업할 코딩을 추가한다.

		startBtn2.addActionListener((e)->{
			new Thread(()->{//여기가 run 메소드 안에서 할 작업을 코딩하면 되는 곳
				System.out.println("10 소요 작업");
				try {
					Thread.sleep(1000*10);
				} catch (InterruptedException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
				System.out.println("작업 종료됨");
			}).start();
		});

 

 

 

입력과 출력 공부를 하기 전 바이트의 개념을 알아봤다.

2진수 8자리를 한 묶음으로 바이트라고 말한다.

바이트의 개념은 알갱이라고 생각하면 편하다.

1바이트는 총 256(=2^8)가지의 경우를 표현할 수 있다. 

화소는 보통 점 1개당 3byte가 필요하다고 함.

 

 

<12:30 4교시>

오늘 아침에 답 온거 실행의 request 흐름을 새로운 스레드에서 작업할 수 있게 바꿔보기

일단 제일 마지막에 한 더 간단한 방법을 활용해서 해보긴 했는데 맞는거 같긴한데 한 80%의 확신만 하고 있음.

package test.main;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Font;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

public class MainClass02 extends JFrame {
	JTextArea ta=new JTextArea();
	//생성자
	public MainClass02() {
		//프레임 제목
		this.setTitle("나의 프레임");
		//프레임 위치와 크기 설정 setBounds(x, y, width, height)
		setBounds(100,100,500,500);
		//종료 버튼을 눌렀을 때 프로세스 전체가 종료되도록 하기
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		//레이아웃 메니저 객체 생성
		BorderLayout layout =new BorderLayout();
		//프레임의 레이아웃 메니저 설정
		setLayout(layout);
		
		//TextField 와 Button을 배치할 패널객체
		JPanel topPanel=new JPanel();
		topPanel.setBackground(Color.red);
		//TextField와 Button을 생성해서
		JTextField inputMsg= new JTextField(30);
		JButton sendBtn=new JButton("전송");
		//Panel에 추가
		topPanel.add(inputMsg);
		topPanel.add(sendBtn);
		//프레임의 위쪽에 패널 추가
		add(topPanel, BorderLayout.NORTH);
		
		
		ta=new JTextArea();
		//textarea를 스크롤 패널에 감싼다
		JScrollPane scroll = new JScrollPane(ta);
		//프레임의 가운데에 TextArea 추가
		Font font=new Font("Times New Roman", Font.BOLD, 20);
		ta.setFont(font);
		add(scroll, BorderLayout.CENTER);
		sendBtn.addActionListener((event)->{
			new Thread(()->{
			//TextField 에 입력한 문자열을 읽어온다.
			String msg=inputMsg.getText();
			//미리 준비된 메소드를 호출하면서 입력한 문자열을 등록함
			request(msg);	
			}).start();
		});
		
		//화면상에 실제 보이도록 하기
		setVisible(true);
		
	}
	//매개변수에 전달되는 주소로 요청하는 메소드
	public void request(String requesturl) {
        try {
            // 요청 보낼 URL 설정
            URL url = new URL("https://acornacademy.co.kr"); // 예제 URL
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();

            // HTTP 요청 메서드 설정
            connection.setRequestMethod("GET");

            // 헤더 설정 (필요에 따라 추가)
            connection.setRequestProperty("Accept", "application/json");

            // 응답 코드 확인
            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);
            //응답한 문자열을 누적시킬 객체 
            StringBuilder response = new StringBuilder();
            //만일 정상적인 응답이라면 
            if (responseCode == HttpURLConnection.HTTP_OK) {
            	//응답하는 내용을 읽어들일 객체 
            	BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()));           
                //반복문 돌면서
            	while (true) {
                	//한줄씩 읽어들이고 
                	String line=br.readLine();
                	//만일 다 읽었다면 
                	if(line==null) {
                		break; //반복문 탈출
                	}
                	//읽은 문자열 한줄을 누적시킨다.
                    response.append(line+"\r\n");
                }
               
            } else {
                System.out.println("Request failed. Response Code: " + responseCode);
            }
            //누적된 문자열을 출력하기 
           // System.out.println(response.toString());
            //누적된 문자열을 TextArea에 출력하기
            ta.setText(response.toString());
            // 연결 해제
            connection.disconnect();

        } catch (Exception e) {
            e.printStackTrace();
        }
	}
	//main 메소드
	public static void main(String[] args) {
		new MainClass02();
	}
}

 

 

<14:30 5교시>

4교시때 받은 문제 풀이

Run 했을 때의 실행의 흐름을 Thread라고 한다.

package test.main;

public class QuizMain {
	
/*
 * run 했을 때 콘솔창에 1,2,3... 경과시간을 출력하다가 종료되는 코드
 * hint = >Thread.sleep(1000);
 */
	public static void main(String[] args) throws InterruptedException {
		for(int i=0; i<10; i++) {
			int second = i+1;
			Thread.sleep(1000);
			System.out.println(second+"초");
		}
		Thread.sleep(1000);
		System.out.println("10초가 지났습니다. 종료되었습니다");
	}
}

으악 미쳤다 너무 졸리네

 

package test.mypac;

public class WowException extends RuntimeException{//RuntimeException클래스를 상속 받아서 만든다
	//생성자의 매개 변수로 예외 메세지를 전달받아서
	public WowException(String msg) {
		//부모 생성자에 전달해준다
		super(msg);
	}
	
}

 

 

package test.main;

import java.util.Random;

import test.mypac.WowException;

public class MainClass07 {
	public static void main(String[] args) {
		Random ran=new Random();
		//0~9 사이의 랜덤한 숫자를 얻어냄
		int ranNum=ran.nextInt(10);
		
		if(ranNum==7) {
			//여기서 발생하는 Exception은 JVM이 직접 처리함
			throw new WowException("lucky 7");			
		}
		System.out.println(ranNum+"번 숫자입니다.");
	}
}

 

GUI, 프레임 만들기 JFrame을 상속 받아 프레임을 만들면 적절한 UI가 나온다.

 

package test.frame02;

import java.awt.FlowLayout;

import javax.swing.JButton;
import javax.swing.JFrame;

public class MyFrame extends JFrame {
	//생성자
	public MyFrame() {
		//프레임 제목
		this.setTitle("나의 프레임");
		//프레임 위치와 크기 설정 setBounds(x, y, width, height)
		setBounds(100,100,500,500);
		//종료 버튼을 눌렀을 때 프로세스 전체가 종료되도록 하기
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		//레이아웃 메니저 객체 생성
		FlowLayout layout =new FlowLayout(FlowLayout.LEFT);
		//프레임의 레이아웃 메니저 설정
		setLayout(layout);
		//JButton 객체 생성
		JButton btn1=new JButton("버튼1"); 
		//프레임의 add()메소드를 호출하면서 JButton 객체의 참조값을 전달하면 프레임에 버튼이 배치됨
		add(btn1);
		//화면상에 실제 보이도록 하기
		setVisible(true);
	}
	//main 메소드
	public static void main(String[] args) {
		new MyFrame();
	}
}

 

 

 

<15:30 6교시>

 

 

클래스 안에 정의된 건 필드, 생성자 안에 선언하는 건 지역변수

 

 

버튼을 눌렀을 때 버튼의 숫자가 증가하게 만들기

package test.frame03;

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.ParsePosition;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.text.html.parser.Parser;

public class MyFrame extends JFrame {
	//myframe의 필드에 선언하면 어디서든 가져다 쓸 수 있다
	int count=0;
	//생성자
	public MyFrame() {
		//프레임 제목
		this.setTitle("나의 프레임");
		//프레임 위치와 크기 설정 setBounds(x, y, width, height)
		setBounds(100,100,500,500);
		//종료 버튼을 눌렀을 때 프로세스 전체가 종료되도록 하기
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		//레이아웃 메니저 객체 생성
		FlowLayout layout =new FlowLayout(FlowLayout.LEFT);
		//프레임의 레이아웃 메니저 설정
		setLayout(layout);
		//JButton 객체 생성
		JButton countBtn=new JButton("0"); 
		//프레임의 add()메소드를 호출하면서 JButton 객체의 참조값을 전달하면 프레임에 버튼이 배치됨
		add(countBtn);
		//버튼에 전달할 addActionListener라는 인터페이스 타입 
		//어떤클래스에 implements 하기/
		
		
		//final int count=0; 여기 선언하면 지역 변수 생성자가 생성되면 사라짐
		
		ActionListener listener=new ActionListener() {
			//필드 : 이 객체 안에서만 사용할 수 있다.
			int count=0;
			@Override
			public void actionPerformed(ActionEvent e) {
				// button에 어떤 액션이 일어나면 이 메소드가 자동으로 호출된다는 의미
				//이 안에다가 코딩하면 버튼을 누를때마다 호출되는 동작을 작성할 수 있다.
				System.out.println("버튼을 눌렀습니다");
				//카운트를 1증가 시키고
				count++;
				//정수를 문자열로 변경한 다음 setText()메소드에 전달함
				countBtn.setText(Integer.toString(count));
			}
			
		};
		countBtn.addActionListener(listener);
		
		//화면상에 실제 보이도록 하기
		setVisible(true);
	}
	//main 메소드
	public static void main(String[] args) {
		new MyFrame();
	}
}

 

방금 한거에서 메소드가 하나 있는 클래스 만드는 것은 ()->{}형태로도 가능하다. 익명클래스가 인터페이스를 구현함.

package test.frame03;

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.ParsePosition;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.text.html.parser.Parser;

public class MyFrame2 extends JFrame {
	//myframe의 필드에 선언하면 어디서든 가져다 쓸 수 있다
	int count=0;
	//생성자
	public MyFrame2() {
		//프레임 제목
		this.setTitle("나의 프레임");
		//프레임 위치와 크기 설정 setBounds(x, y, width, height)
		setBounds(100,100,500,500);
		//종료 버튼을 눌렀을 때 프로세스 전체가 종료되도록 하기
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		//레이아웃 메니저 객체 생성
		FlowLayout layout =new FlowLayout(FlowLayout.LEFT);
		//프레임의 레이아웃 메니저 설정
		setLayout(layout);
		//JButton 객체 생성
		JButton countBtn=new JButton("0"); 
		//프레임의 add()메소드를 호출하면서 JButton 객체의 참조값을 전달하면 프레임에 버튼이 배치됨
		add(countBtn);
		//버튼에 전달할 addActionListener라는 인터페이스 타입 
		//어떤클래스에 implements 하기/
		
		
		//final int count=0; 여기 선언하면 지역 변수 생성자가 생성되면 사라짐

		countBtn.addActionListener((event)->{
			System.out.println("버튼을 눌렀네?");
			count++;
			countBtn.setText(Integer.toString(count));
		});
		
		//화면상에 실제 보이도록 하기
		setVisible(true);
	}
	//main 메소드
	public static void main(String[] args) {
		new MyFrame2();
	}
}

 

클래스에 인터페이스를 구현하고 필드에 변수를 선언해서 메소드를 실행할 수 있음.

package test.frame03;

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.ParsePosition;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.text.html.parser.Parser;

public class MyFrame3 extends JFrame implements ActionListener {
	//myframe의 필드에 선언하면 어디서든 가져다 쓸 수 있다, 객체내에서 공유할 자원들을 담아 두는 곳
	int count=0;
	JButton countBtn;
	//생성자
	public MyFrame3() {
		//프레임 제목
		this.setTitle("나의 프레임");
		//프레임 위치와 크기 설정 setBounds(x, y, width, height)
		setBounds(100,100,500,500);
		//종료 버튼을 눌렀을 때 프로세스 전체가 종료되도록 하기
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		//레이아웃 메니저 객체 생성
		FlowLayout layout =new FlowLayout(FlowLayout.LEFT);
		//프레임의 레이아웃 메니저 설정
		setLayout(layout);
		//JButton 객체 생성
		this.countBtn=new JButton("0"); 
		//프레임의 add()메소드를 호출하면서 JButton 객체의 참조값을 전달하면 프레임에 버튼이 배치됨
		add(countBtn);
		//버튼에 전달할 addActionListener라는 인터페이스 타입 
		//어떤클래스에 implements 하기/
		
		//final int count=0; 여기 선언하면 지역 변수 생성자가 생성되면 사라짐

		//countBtn.addActionListener(this); this를 쓰면 ActionListener 타입이 아니기 때문에 에러가 난다. 
		//this가 가리키는 것은 MyFrame3 클래스 또는 JFrame 클래스 또는 Object이기도 하다.
		//this를 써서 구현해보기(JFrame에서 implement 하고 MyFrame에 오류난거 해결)
		countBtn.addActionListener(this);
		//이제 하단에서 override 된 내용이 버튼을 누를 때마다 실행된다는 의미
		
		//화면상에 실제 보이도록 하기
		setVisible(true);
	}
	//main 메소드
	public static void main(String[] args) {
		new MyFrame3();
	}
	@Override
	public void actionPerformed(ActionEvent e) {
		System.out.println("버튼을 눌렀네?");
		count++;
		countBtn.setText(Integer.toString(count));
		
	}
}

 

 

<16:30 7교시>

 

 

 

package test.main;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class MainClass01 {
	public static void main(String[] args) {
        try {
            // 요청 보낼 URL 설정
            URL url = new URL("https://acornacademy.co.kr"); // 예제 URL
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();

            // HTTP 요청 메서드 설정
            connection.setRequestMethod("GET");

            // 헤더 설정 (필요에 따라 추가)
            connection.setRequestProperty("Accept", "application/json");

            // 응답 코드 확인
            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);
            //응답한 문자열을 누적시킬 객체 
            StringBuilder response = new StringBuilder();
            //만일 정상적인 응답이라면 
            if (responseCode == HttpURLConnection.HTTP_OK) {
            	//응답하는 내용을 읽어들일 객체 
            	BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()));           
                //반복문 돌면서
            	while (true) {
                	//한줄씩 읽어들이고 
                	String line=br.readLine();
                	//만일 다 읽었다면 
                	if(line==null) {
                		break; //반복문 탈출
                	}
                	//읽은 문자열 한줄을 누적시킨다.
                    response.append(line+"\r\n");
                }
               
            } else {
                System.out.println("Request failed. Response Code: " + responseCode);
            }
            //누적된 문자열을 출력하기 
            System.out.println(response.toString());
            
            // 연결 해제
            connection.disconnect();

        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("종료 합니다");
	}
}

 

 

네트워크로 응답되는 페이지의 문자열을 얻어낼 수 있음

 

package test.main;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class MainClass01 {
	public static void main(String[] args) {
        try {
            // 요청 보낼 URL 설정
            URL url = new URL("https://acornacademy.co.kr"); // 예제 URL
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();

            // HTTP 요청 메서드 설정
            connection.setRequestMethod("GET");

            // 헤더 설정 (필요에 따라 추가)
            connection.setRequestProperty("Accept", "application/json");

            // 응답 코드 확인
            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);

            // 응답 데이터 읽기
            if (responseCode == HttpURLConnection.HTTP_OK) {
                try (BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
                    StringBuilder response = new StringBuilder();
                    String line;
                    while ((line = in.readLine()) != null) {
                        response.append(line+"\r\n");
                    }
                    System.out.println("Response: " + response.toString());
                }
            } else {
                System.out.println("Request failed. Response Code: " + responseCode);
            }

            // 연결 해제
            connection.disconnect();

        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("종료 합니다");
	}
}

 

 

 

 

<17:30 8교시> 

한 거 합쳐보기(삽질)

더보기
package test.main;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Font;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Scanner;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.JTextField;



public class Quest extends JFrame{
	String msg;
	
	public Quest() {
		this.setTitle("내 프레임");
		setBounds(100,100,500,500);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		BorderLayout layout = new BorderLayout();
		setLayout(layout);
		JPanel topPanel=new JPanel();
		topPanel.setBackground(Color.orange);
		JButton sendBtn=new JButton("전송");
		JTextField tf=new JTextField(20);
		topPanel.add(tf);
		topPanel.add(sendBtn);
		add(topPanel, BorderLayout.NORTH);
		JTextArea ta=new JTextArea();
		Font font=new Font("Times New Roman", Font.BOLD, 20);
		ta.setFont(font);
		add(ta, BorderLayout.CENTER);
		sendBtn.addActionListener((event)->{
			String msg=tf.getText();
			ta.append(msg);
		});
		setVisible(true);
		
	}
	
	public void Form() {
		try {
            // 요청 보낼 URL 설정
            URL url = new URL(tf.getText()); // 예제 URL
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();

            // HTTP 요청 메서드 설정
            connection.setRequestMethod("GET");

            // 헤더 설정 (필요에 따라 추가)
            connection.setRequestProperty("Accept", "application/json");

            // 응답 코드 확인
            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);
            //응답한 문자열을 누적시킬 객체 
            StringBuilder response = new StringBuilder();
            //만일 정상적인 응답이라면 
            if (responseCode == HttpURLConnection.HTTP_OK) {
            	//응답하는 내용을 읽어들일 객체 
            	BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()));           
                //반복문 돌면서
            	while (true) {
                	//한줄씩 읽어들이고 
                	String line=br.readLine();
                	//만일 다 읽었다면 
                	if(line==null) {
                		break; //반복문 탈출
                	}
                	//읽은 문자열 한줄을 누적시킨다.
                    response.append(line+"\r\n");
                }
               
            } else {
                System.out.println("Request failed. Response Code: " + responseCode);
            }
            //누적된 문자열을 출력하기 
            System.out.println(response.toString());
            
            // 연결 해제
            connection.disconnect();

        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("종료 합니다");
	}
	
	
	
	public static void main(String[] args) {
		new Quest();
	}
	
	
}

9:10 경 학원 도착.

도착해서 같이 듣는 수강생들하고 깃 배쉬로 리포지토리 만드는거 헤매봄.

 

<9:30 1교시>

선생님이 만든 깃허브의 공동 작업자로 들어가보기

우리 컴퓨터에서 클론하면 선생님 깃허브 작업이 origin으로 우리에게 등록될 것...이라고 한 것 같음

로컬에서 처음 저장소에 올릴 때, 로컬에서 먼저 커밋을 한 상태라면 저장소는 무조건 비어있어야 한다.

만약 저장소에서 readme 같은 것을 만든 상태라면 그게 커밋으로 적용되기 때문에 로컬에 readme를 추가한 다음 진행해야 하는 상황이다

 

는 메모할 새도 없이 열심히 한 결과 어째어째 했다.

remotes/origin/master origin이라는 원격 저장소의 master 브랜치의 이력.

 

 

<10:30 2교시>



git merge origin/master

fork

 

pull request와 social coding

협업자로 등록해주세요 -> 보통 협업 요청 허락 안해줌 -> fork로 가져와서 바꾸고 보내주면 기여 가능 (한명이 검토하고 merge가 가능해짐)

 

일단 어케어케 했는데 모르겠다, 나중에 다시 또 기회가 있겠지

 

 

어제 하던거 코드 완성

package test.main;

import java.util.ArrayList;
import java.util.List;

import test.mypac.PostDto;

public class MainClass14 {
	public static void main(String[] args) {
		/*  
		 * 1. test.mypac.PostDto 클래스를 만들어 보세요
		 *    PostDto 에는 글번호, 작성자, 제목을 담을수 있어야 합니다.
		 *    즉 3개의 필드를 만드세요
		 *    필드명은 마음데로, 필드의 data type 은 잘 생각해서 결정
		 *    dto 작성 규약에 맞게 만들어 주세요( eclipse generate 기능 활용)
		 *    test.mypac 페키지에 만들기 
		 * 
		 * 2. PostDto 객체에 임의의 글 3개의 정보를 담아 보세요. 
		 *    총 3개의 PostDto 객체가 생성이 되어야 합니다.
		 * 
		 * 3. PostDto 객체를 담을수 있는 ArrayList 객체를 생성해서 위에서 생성한 PostDto 
		 *    객체를 ArrayList 에 담아 보세요.
		 *    
		 * 4. 반복문 돌면서 ArrayList 에 담긴 글 목록을 콘솔창에 이쁘게 출력해 보세요.
		 *  
		 */
		PostDto post1 = new PostDto();
		post1.setNum(1);
		post1.setTitle("제목1");
		post1.setWriter("작가1");
		PostDto post2 = new PostDto(2, "제목2", "작가2");
		PostDto post3 = new PostDto(3, "제목3", "작가3");
		
		List<PostDto> dtos = new ArrayList<>();
		dtos.add(post1);
		dtos.add(post2);
		dtos.add(post3);
		
		for(PostDto tmp : dtos) {
			String info = String.format("글번호:%d, 작성자:%s, 제목:%s", tmp.getNum(), tmp.getWriter(), tmp.getTitle());
			System.out.println(info);
		}
	
	}
}

 

 

 

Exception의 처리 : 코드 실행하다가 발생하는 예외를 처리할 방법들을 3교시부터 배움

현금인출기에서 돈을 인출하는데 갑자기 정전이라는 예외가 일어났을 때, 돈은 인출됐는데 계좌 잔액이 그대로면 매우 좋겠지만 안되잖아

 

 

예외가 발생했음에도 그 밑에 부분을 실행할 수 있게 해주는 방법 try ~ catch

<11:30 3교시>

try 블럭에서 NumberFormatException 타입의 예외가 발생하면 catch 안의 내용으로 건너뛰어 실행한다.

 

자바에서 발생하는 모든 예외는 Exception을 상속받고, RuntimeException은 그 중 하나일 뿐 다른 Exception도 있음.

RuntimeException은 실행 시에 발생하는 예외에 대한 처리를 함.

Compile 시에 발생하는 Exception은 RuntimeException을 상속받지 않음

 

예외가 발생하면 보통 처리 할지말지를 컴퓨터가 알아서 해주는데,  반드시 try catch로 Exception 처리 해야 하는 경우가 있고, 이들은 RuntimeException을 상속받지 않는다.

 

 

 

package test.main;

import java.util.Scanner;

public class MainClass02 {
	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		System.out.println("나눌 수 입력:");
		String inputNum1=scan.nextLine();
		
		System.out.println("나누어지는 수 입력");
		String inputNum2=scan.nextLine();
		try {
			//문자열 형태의 숫자를 실제 정수로 변경하기
			int num1=Integer.parseInt(inputNum1);
			int num2=Integer.parseInt(inputNum2);
			//계산하기
			int result = num2/num1;//몫
			int result2= num2%num1;//나머지
			System.out.println(num2+"를 "+num1+"으로 나눈 몫 : "+result);
			System.out.println(num2+"를 "+num1+"으로 나눈 나머지 : "+result2);
		}catch(NumberFormatException nfe) {
			//예외 객체에 담긴 메세지
			System.out.println(nfe.getMessage());
			System.out.println("숫자를 눌러주세요");
		}catch(ArithmeticException ae) {
			System.out.println(ae.getMessage());
			System.out.println("나눌 수는 0이어선 안됩니다");
		}
		System.out.println("main 메소드가 정상 종료됩니다");
	}
}

 

 

 

package test.main;

import java.util.Scanner;

public class MainClass03 {
	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		System.out.println("나눌 수 입력:");
		String inputNum1=scan.nextLine();
		
		System.out.println("나누어지는 수 입력");
		String inputNum2=scan.nextLine();
		try {
			//문자열 형태의 숫자를 실제 정수로 변경하기
			int num1=Integer.parseInt(inputNum1);
			int num2=Integer.parseInt(inputNum2);
			//계산하기
			int result = num2/num1;//몫
			int result2= num2%num1;//나머지
			System.out.println(num2+"를 "+num1+"으로 나눈 몫 : "+result);
			System.out.println(num2+"를 "+num1+"으로 나눈 나머지 : "+result2);
		}catch(Exception e) {
			//Exception은 모든 예외의 부모 type이기 때문에 어떤 예외가 발생해도 이부분이 실행된다
			System.out.println("예외가 발생했습니다.");
			System.out.println("예외 메세지: "+e.getMessage());
		}finally {
			//예외 발생 유무와 관계 없이 무조건 실행되는 부부분
			//이곳은 예외가 발생하건 안하건 반드시 실행이 보장되는 부분으로, 중요한 마무리 작업을 주로 여기서 수행한다.
			System.out.println("중요한 마무리 작업을 하는 중입니다.");
		}
		System.out.println("main 메소드가 정상 종료됩니다");
	}
}

 

 

 

 

부모 클래스에 RuntimeException이 없는 Exception은 반드시 예외 처리를 해줘야 한다.

package test.main;

public class MainClass04 {
	public static void main(String[] args) throws InterruptedException {
		System.out.println("메인메소드가 시작되었습니다");
		

			Thread.sleep(1000*5);//스레드(실행의 흐름)를 일정시간 지연 시키기(mili second 단위로 숫자를 전달하면 됨)
		
		System.out.println("메인메소드가 종료되었습니다.");
		
	}
}

 

 

package test.main;

public class MainClass05 {
	public static void main(String[] args) {
		System.out.println("메인메소드가 시작되었습니다");
		
		try {
			Thread.sleep(1000*5);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}//스레드(실행의 흐름)를 일정시간 지연 시키기(mili second 단위로 숫자를 전달하면 됨)
		
		System.out.println("메인메소드가 종료되었습니다.");
		
	}
}
package test.mypac;

public class MyUtil {
	//5초가 걸리는 가상의 그림을 그리는 메소드
	public static void draw() {
		try {
			Thread.sleep(5000);
		}catch(InterruptedException e){
			e.printStackTrace();
		}
		System.out.println("그림 완성");
	}
	//5초가 걸리는 가상의 전송을 하는 메소드
	public static void send() throws InterruptedException {
		System.out.println("5초 동안 전송해요..");
		Thread.sleep(5000);
		System.out.println("전송완료");
	}
		
}

 

package test.main;

import test.mypac.MyUtil;

public class MainClass06 {
	public static void main(String[] args) {
		MyUtil.draw();
		
		try{MyUtil.send();}
		catch(InterruptedException e) {e.printStackTrace();}
	}
}

 

 

 

 

 

<12:30 4교시>

와....3교시 막판에 겁나 졸렸다... 배고파서 그랬나 흑 ㅠ

 

4교시 예제 풀어봄

처음에 삽질한거 Thread.sleep(1000*i)라고 했다던가 Thread.sleep(10000)이라고 하고 출력했다든가.

그래서 출력이 되는데 1초의 1초 뒤에 2초, 2초의 2초 뒤에 3초, 3초의 3초 뒤에 4초... 이런 식으로 계속 지연되면서 출력됐었음.

package test.main;

public class QuizMain {
	
/*
 * run 했을 때 콘솔창에 1,2,3... 경과시간을 출력하다가 종료되는 코드
 * hint = >Thread.sleep(1000);
 */
	public static void main(String[] args) throws InterruptedException {
		for(int i=0; i<10; i++) {
			int second = i+1;
			Thread.sleep(1000);
			System.out.println(second+"초");
		}
		Thread.sleep(1000);
		System.out.println("10초가 지났습니다. 종료되었습니다");
	}
}

<14:30 5교시>

package test.main;

import java.util.HashMap;

public class MainClass07 {
	public static void main(String[] args) {
		/*
		 * HashMap<key type, value type>
		 * 
		 * key type은 일반적으로 String type을 가장 많이 사용함
		 * value type은 담고 싶은 데이터의 type을 고려해서 저장하면 됨
		 * value type을 object로 지정하면 어떤 데이타타입이던지 다 담을 수 있음
		 * 순서가 없는 데이터를 다룰 때 사용하면 됨
		 * dto클래스 대신에 사용하기도 함
		 */
		HashMap<String, Object> map=new HashMap<>();
		map.put("num",1);
		map.put("name", "김구라");
		map.put("isMan", true);

		//value의 generic 클래스가 Object 이기 때문에 object 타입이 리턴된다.
		int num=(int)map.get("num");//원래 타입으로 캐스팅이 필요
		String name =(String)map.get("name");
		boolean isMan = (boolean)map.get("isMan");

		//동일한 key 값으로 다시 담으면 수정
		map.put("name", "이정호" );
		//특정 key 값으로 담긴 내용 삭제
		map.remove("isMan");
		//모두 삭제
		map.clear();
	}
}

 

 

package test.main;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class MainClass08 {
	public static void main(String[] args) {
		//hashmap 객체를 생성해서 map 인터페이스 타입 변수에 담기
		Map<String, String> dic = new HashMap<>();
		//key:value의 쌍을 사전형태(dictionary)라고도 함
		dic.put("house", "집");
		dic.put("phone", "전화기");
		dic.put("watch", "시계");
		
		Scanner scan = new Scanner(System.in);
		System.out.println("단어입력:");
		String word=scan.nextLine();
		
		//단어에 해당하는 뜻 얻어내기
		String mean=dic.get(word);
		if (mean==null) {
			System.out.println("찾는 단어가 없습니다.");
		}else {
		//출력하기
		System.out.println(word+"의 뜻은 " +mean+"입니다.");
		}
		
		
	}
}

 

 

예제

//1. 세명의 회원정보(번호,이름,주소)를 해쉬맵 객체를 생성해서 담아보세요

//HashMap 객체 하나당 한명의 회원정보를 담으니깐 총 3개의 Hashmap 객체가 생성돼야 함.

//2. 위에서 생성한 HashMap 객체를 담을 ArrayList 객체를 생성해보세요

//3. ArryList 객체에 Hashmap 객체 3개를 담아보세요

//4. 반복문 돌면서 ArrayList에 담긴 회원정보를 콘솔창에 보기 좋게 출력해보세요.

 

 

<15:30 6교시>

으어억 졸려 살려줘

간신히 잠깨서 예제 답 따라 했다... 휴.. 오늘은 집가면서 다시보고 공부해야겠다..

package test.main;

import java.util.HashSet;
import java.util.Set;

/*
 * HashSet은 Set 인터페이스를 구현한 클래스이다
 * -순서가 없다
 * -key값도 없다
 * -중복을 허용하지 않는다
 * -어떤 data를 묶음(집합)으로 관리하고자 할 때 사용한다
 */
public class MainClass10 {
	public static void main(String[] args) {
		//정수를 저장할 수 있는 hashset 객체를 생성해서 참조값을 set 인터페이스 type 지역변수에 담기
		Set<Integer> set1=new HashSet<>();
		set1.add(10);
		set1.add(20);
		set1.add(20);
		set1.add(30);
		set1.add(30);
		
		//문자열을 저장할 수 있는 HashSet 객체
		Set<String> set2=new HashSet<>();
		set2.add("kim");
		set2.add("lee");
		set2.add("park");
		set2.add("lee");
		set2.add("park");
		
		//set 객체에 저장된 모든 아이템을 순서를 보장할 수는 없지만 모두 참조해서 사용해보기
		set1.forEach((item)->{System.out.println(item);});
		
		System.out.println("------1번구간-----");
		set2.forEach((item)->{System.out.println(item);});
		
		//특정 item(데이터, 참조값) 존재 여부 알아내기
		boolean isContain=set2.contains("lee");
		//저장된 item의 갯수
		int size = set2.size();
		//특정 item의 삭제
		set2.remove("park");
		//모든 item 삭제
		set2.clear();
		
		
		
	}
}

 

 

package test.main;

import java.util.ArrayList;
import java.util.List;

public class MainClass11 {
	public static void main(String[] args) {
		List<Integer> nums=new ArrayList<>();
		nums.add(10);
		nums.add(20);
		nums.add(30);
		
		//readonly로 사용할거라면 위의 세줄을 아래와 같이 사용할 수도 있다.
		
		List<Integer> nums2=List.of(10,20,30);
		//nums2.add(40); //아이템 추가 불가
		//nums2.remove(0);//삭제 불가
		//nums2.set(0,999);//수정 불가
	}
}

 

package test.main;

import java.util.HashMap;
import java.util.Map;

public class MainClass12 {
	public static void main(String[] args) {
		Map<String, String> map1 = new HashMap<>();
		map1.put("house", "집");
		map1.put("phone", "전화기");
		map1.put("watch", "시계");
		
		Map<String, String> map2= Map.of("house", "집", "phone", "전화기", "watch", "시계");
		
		// map2.put("mouse", "쥐");//추가 불가
		// map2.remove("watch"); // 삭제 불가
	}
}

 

 

package test.main;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class MainClass13 {
	public static void main(String[] args) {
		Set<Integer> set= new HashSet<>();
		set.add(10);
		set.add(10);
		set.add(20);
		set.add(20);
		set.add(30);
		set.add(20);
		set.add(40);
		
		//중복이 제거된 Set를 ArrayList 객체의 생성자에 전달해서 객체 생성하기
		List<Integer> list=new ArrayList<>(set);
		//저장된 숫자를 오름차순으로 정렬
		Collections.sort(list);
		//내림 차순 정렬
		//Collections.sort(list, Collections.reverseOrder());
		
		list.forEach((item)->{System.out.println(item);});
	}
}

 

<16:30 7교시>

그동안 배운거 활용해서 퀴즈 풀어보기

는 1번 빼고 하나도 못했다...

Random 객체 생성하기 까먹고 나니까 오늘 간신히 따라한거 적용하기도 어렵더라.

내가 

package test.main;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;

public class QuizMain {
	public static void main(String[] args) {
		//1. 정수를 담을 수 있는 어레이 리스트 객체를 생성해서 nums 라는 지역변수에 담기
			ArrayList<Integer> nums = new ArrayList<>();
		//2. 반복문 10번 돌면서 1~100 사이의 랜덤한 정수를 각각 얻어내서 1에서 생성한 nums 객체에 순서대로 담기
			//랜덤한 정수를 얻어낼 객체
			Random ran = new Random();
			//반복문을 10번돌도록 구성
			for (int i=0; i<10;i++) {
				//1~100 사이의 랜덤한 정수 얻기
				int ranNum= ran.nextInt(100)+1;
				nums.add(ranNum);
			}
		
		//3. nums에 저장된 숫자에서 중복된 숫자가 제거된 새로운 ArrayList 객체를 얻어내 보기
			/*Set<Integer> set= new HashSet<>();
			//set 객체에 숫자를 넣으면 중복이 제거된다
			nums.forEach((item)->{set.add(item);});
			//중복이 제거된 Set를 이용해서 다시 arraylist 객체 생성
			List<Integer> result=new ArrayList<>(set);*/
			Set<Integer> set= new HashSet<>(nums);
			List<Integer> result=new ArrayList<>(set);
		//4. 새로운 배열에 숫자를 오름차순으로 정렬해보기
			Collections.sort(result);
		//5. 새로운 배열에 저장된 숫자를 순서대로 콘솔창에 출력해보기
			result.forEach((item)->{System.out.println(item);});
	}
}

 

로또 번호 생성기 ㅋㅋ

package test.main;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;

public class QuizMain2 {
	public static void main(String[] args) {
		//1. 로또 번호 담을 HashSet 객체 생성해서 set1이라는 지역 변수에 담기
		Set<Integer> set1 = new HashSet<>();
		//2. while 문을 이용해서 랜덤한 로또 번호를 set1에 반복적으로 담아 보세요.
		//while문 탈출 조건은 set1.size()가 6이 되면 탈출되도록 해보기
		Random ranlot = new Random();
		while (true) {
			for(int i=0; i<set1.size(); i++) {
				//1~45 사이의 랜덤한 숫자를 얻어서
				int nums =ranlot.nextInt(45)+1;
				//Set 객체에 담는다
				set1.add(nums);	
			}
			//만일 Set의 크기가 6이면 
			if (set1.size()==6) {
				break;//반복문 탈출
				
			}
		}
		
		//3. set1에 담긴 번호를 오름 차순으로 정렬해서 콘솔창에 모두 출력해보세요
		List<Integer> number = new ArrayList<>(set1);
		Collections.sort(number);
		for(Integer tmp:number) {
			System.out.println(tmp);
		}
		
		
	}
}

 

<17:30 8교시> 

예제 풀기

* 1. test.mypac.PostDto 클래스를 만들어 보세요

* PostDto 에는 글번호, 작성자, 제목을 담을수 있어야 합니다.

* 즉 3개의 필드를 만드세요

* 필드명은 마음데로, 필드의 data type 은 잘 생각해서 결정

* dto 작성 규약에 맞게 만들어 주세요( eclipse generate 기능 활용)

* test.mypac 페키지에 만들기

*

* 2. PostDto 객체에 임의의 글 3개의 정보를 담아 보세요.

* 총 3개의 PostDto 객체가 생성이 되어야 합니다.

*

* 3. PostDto 객체를 담을수 있는 ArrayList 객체를 생성해서 위에서 생성한 PostDto

* 객체를 ArrayList 에 담아 보세요.

*

* 4. 반복문 돌면서 ArrayList 에 담긴 글 목록을 콘솔창에 이쁘게 출력해 보세요.

*

 

일단 맨땅에 헤딩해보기

package test.mypac;

public class PostDto {
	
	private int num;
	private String writer;
	private String title;
	
	public PostDto() {}
	
	public PostDto(int num, String writer, String title) {
		this.num=num;
		this.writer=writer;
		this.title=title;
	}

	public int getNum() {
		return num;
	}

	public void setNum(int num) {
		this.num = num;
	}

	public String getWriter() {
		return writer;
	}

	public void setWriter(String writer) {
		this.writer = writer;
	}

	public String getTitle() {
		return title;
	}

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

9:15경 학원 도착
 
 
 
 
<9:30 1교시>
git restore .   
변경 사항이 저절로 사라짐 ->대신 이건 복구가 안됨,
단, 추적된 파일에 대한 변경 사항만 가능 untracked file에 대한 변경 사항은 변경하지 못한다.

untracked file 까지 지워주려면 
git clean -fd
명령어를 사용해야 한다. untracked 상태인 file 과 directory까지 다 지워버리겠다는 얘기

 
git reset의 강도 (git reset --어쩌구 HEAD~)
1. soft : commit 내용만을 취소하고 add . 된 상태로 복귀. commit message 수정이나 add . 이 아닌 다른 add로 commit 한 경우

2. mixed : commit 과 add가 취소되고, 변경 상황 자체는 남아있음. 디폴트 값이어서 --mixed 만 빼도 됨.

 
3. hard : commit, add, 변경 내용이 모두 취소되어 이전 커밋 상태로 워킹 트리가 클린한 상태로 리셋됨.
 
 
git reflog를 사용한다면 HEAD의 이동 이력을 볼 수 있다.

 
 
origi_HEAD : 원래 head가 있던 곳으로 되돌리겠다.
 
git reset --hard HEAD@{1}          바로 이전 커밋으로 되돌리기
git reflog                                       HEAD의 이동 이력을 볼 수 있다.
git reset --hard HEAD~                HEAD가 한칸 더 이전 걸로 감
git reset --hard ORIG_HEAD      바로 이전 HEAD가 있던 곳으로 감
 

initialize repository : git init 의 역할을 해줌

 

+기호 눌러서 add, 제목 붙이고 commit. master 브랜치 아니고 main 브랜치라고 이름이 붙여짐.
 
terminal 이용해서도 git 을 활용할 수 있음

 
 

git stash -u   :untracked file까지 임시저장하겠다
 
 
<10:30 2교시>
임시저장한 stash 파일을 불러오는 과정들 보기

 

 
 
ArrayList<데이터 타입의 generic 지정>
데이터 타입의 generic을 Object라고 지정하면 아무거나 다 담길 수 있다.
그리고 ArrayList의 특성 상 입력한 순서대로 알아서 들어간다.
Consumer는 메소드 1개 짜리 인터페이스인데, ArrayList의 데이터 타입을 따라
이것을 구현하여 매개변수에 저장된 arraylist의 아이템을 자동으로 호출하는 방법.

foreach라는 메소드를 호출하면서 동작(메소드)하나를 객체에 포장해서 전달하는 것
 
메소드 하나짜리 인터페이스는 함수 형태로 쓸 수 있다. 그래서
Consumer<String> con = (t)->{};
greets.forEach(con);
또는 
greets.forEach((t)->{System.out.println(t);});
라고 함수를 변수에 담은 모양으로 쓸수도 있는 것이다.

package test.main;

import java.util.ArrayList;
import java.util.function.Consumer;

public class MainClass03 {
	public static void main(String[] args) {
		//인사말을 담을 ArrayList 객체를 생성해서 참조값을  greets 라는 지역변수에 대입하기 
		ArrayList<String> greets = new ArrayList<>();
		//greets 에 들어 있는 참조값을 이용해서 인사말 3개를 임의로 담아보세요
		greets.add("hello");
		greets.add("hi");
		greets.add("good night");
		
		//확장 for 문을 이용해서 모든 인사말을 콘솔창에 순서대로 출력해 보세요.
		for(String tmp : greets) {
			System.out.println(tmp);
		}
		
		System.out.println("--- ---");
		
		//아래의 동작을 분석해 보세요
		Consumer<String> con = new Consumer<String>() {
			@Override
			public void accept(String t) {
				// 매개 변수에 전달되는 item 을 가지고 어떤 작업을 할지 여기에 coding 을 하면 된다. 
				System.out.println(t);
			}
		};
		/*
		 *  ArrayList 객체의 forEach() 메소드를 호출하면서 Consumer type 객체를 전달하면
		 *  전달된 객체의 accept() 메소드를 호출하면서 
		 *  ArrayList 객체에 저장된 item 을 순서대로 매개 변수에 전달해 준다. 
		 */
		greets.forEach(con);
		
		System.out.println("-----");
		
		Consumer<String> con2 = (t)->{
			System.out.println(t);
		};
		
		greets.forEach(con2);
		
		System.out.println("-----");
		
		greets.forEach((t)->{
			System.out.println(t);
		});
		
	}
}

 
 
예제
2번까지도 헤매느라 간신히 했고 나머지 다 못풀었뜨아아아ㅏㅏㅏㅏㅏㅏㅏㅏ아앍!!!
정신차리고 공부해!!!

//1. Car type을 저장할 수 있는 ArrayList 객체를 생성해서 참조값을 arrayList 인터페이스 type 지역 변수 cars에 담기

//2. Car 객체(3개)를 생성해서 ArrayList 객체에 저장하기

//3. 일반 for 문을 이용해서 array List 객체에 저장된 모든 Car 객체의 drive()메소드를 순서대로 호출하기

//4. 확장 for 문을 이용해서 array list 객체에 저장된 모든 car 객체의 drive 메소드를 순서대로 호출하기
//5. arraylist 객체의 forEach()메소드를 이용해서 arraylist 객체에 저장된 모든 car 객체의 drive()메소드를 순서대로 호출하기
 
예제 답

더보기
package test.main;

import java.util.ArrayList;

import test.mypac.Car;

public class MainClass04 {
	public static void main(String[] args) {
		//1. Car type을 저장할 수 있는 ArrayList 객체를 생성해서
		//참조값을 arrayList 인터페이스 type 지역 변수 cars에 담기
		ArrayList<Car> cars = new ArrayList<>(); 
		
		
		//2. Car 객체(3개)를 생성해서 ArrayList 객체에 저장하기
		
		Car car1 = new Car("기아");
		Car car2 = new Car("벤츠");
		cars.add(car1);
		cars.add(car2);
		cars.add(new Car("현대"));
		
		
		//3. 일반 for 문을 이용해서 array List 객체에 저장된 모든 Car 객체의 drive()메소드를 순서대로 호출하기
		for (int i=0; i<cars.size(); i++) {
			Car tmp= cars.get(i);
			tmp.drive();
		}
		
		//4. 확장 for 문을 이용해서 array list 객체에 저장된 모든 car 객체의 drive 메소드를 순서대로 호출하기
		for(Car tmp:cars) {
			tmp.drive();
		}
			
		//5. arraylist 객체의 forEach()메소드를 이용해서 arraylist 객체에 저장된 모든 car 객체의 drive()메소드를 순서대로 호출하기
		cars.forEach((tmp->{tmp.drive();}));
		
	}
	

	
}

 
 
<11:30 3교시>


 
 
2교시 때 예제 처참하게 못하고 3교시때는 따라해서 어찌어찌 했는데
혼자 어케하냐 ㅋㅋㅋㅋ ㅠ 공부해!

 

package test.main;


import java.util.ArrayList;
import java.util.List;

import test.mypac.Member;//패키지명 잘 보고 import 하기

public class MainClass05 {
	public static void main(String[] args) {
		//1. member 객체를 담을수있는 어레이리스트 객체를 생성해서 참조값을 members 라는 List type 지역변수에 담아 보세요.
		List<Member> members = new ArrayList<Member>();
		//2.3명의 회원정보를 멤버 객체에 각각 담으세요(멤버 객체 3개가 생성)
		Member mem1 = new Member(1, "하나", "서울");
		Member mem2 = new Member(2, "두리", "경기");
		Member mem3 = new Member(3, "사미", "부산");
			
		//3. 위 멤버 객체의 참조값을 List 객체에 모두 담기
		members.add(mem1);
		members.add(mem2);
		members.add(mem3);
		/*
		 * 4. members 리스트 객체에 담긴 애용을 이용해서 회원 목록을 아래와 같은 형식으로 반복문을 돌면서 출력하기
		 * 번호: 1, 이름: 김구라, 주소: 노량진
		 * 번호: 2, 이름:해골, 주소 : 행신동
		 *  
		 */
		members.forEach((tmp)->{System.out.println("번호: "+tmp.num + ",  이름:" + tmp.name + ",  주소: "+ tmp.addr);});
		
		/*
		 * for (Member tmp:members){
		 *	//String 클래스의 format()이라는 static 메소드를 이용해서 원하는 문자열 형식을 만든 다음
		 * 	String info = String.format("번호:%d, 이름:%s, 주소: %s", tmp.num, tmp.name,tmp.addr);
		 *	//콘솔창에 출력하기
		 *  System.out.println(info);
		 * }
		 */
			
			
			
	}
}

 
 
 
 
또다른 예제 

package test.main;

import java.util.ArrayList;

import test.mypac.MemberDto;

public class MainClass06 {
	public static void main(String[] args) {
		//1. MemberDto 객체를 담을 수 있는 어레이리스트 객체를 생성해서 참조값을 members라는 지역변수에 담기
			ArrayList<MemberDto> members = new ArrayList<>();
		
		//2. 3명의 회원정보를 memberDto 객체에 각각 담기(memberdto 객체가 3개 필요)
			MemberDto m1 = new MemberDto(1, "하나", "서울");
			MemberDto m2 = new MemberDto(2, "두리", "경기");
			MemberDto m3 = new MemberDto(3, "사미", "부산");
			
			
		//3. 위에서 생성된 memberDto 객체의 참조값을 arraylist객체에 모두 담기
			members.add(m1);
			members.add(m2);
			members.add(m3);
			
			
		//4. 반복문을 이용해서 members에 들어있는 회원정보 출력하기
		
			for (MemberDto tmp: members) {
				String info = String.format("번호:%d, 이름:%s, 주소:%s", tmp.getNum(), tmp.getName(), tmp.getAddr());
				System.out.println(info);
			}
			
	}
}

 
 
 
<12:30 4교시>
 
3교시 마지막에 한 예제 답 + Object...이나 String...의 의미(전달할 매개변수 개수를 유동적으로 하겠다는 의미)

package test.main;

import java.util.ArrayList;

import test.mypac.MemberDto;

public class MainClass06 {
	public static void main(String[] args) {
		//1. MemberDto 객체를 담을 수 있는 어레이리스트 객체를 생성해서 참조값을 members라는 지역변수에 담기
			ArrayList<MemberDto> members = new ArrayList<>();
		
		//2. 3명의 회원정보를 memberDto 객체에 각각 담기(memberdto 객체가 3개 필요)
			MemberDto m1 = new MemberDto(1, "하나", "서울");
			MemberDto m2 = new MemberDto(2, "두리", "경기");
			MemberDto m3 = new MemberDto(3, "사미", "부산");
			
			
		//3. 위에서 생성된 memberDto 객체의 참조값을 arraylist객체에 모두 담기
			members.add(m1);
			members.add(m2);
			members.add(m3);
			
			
		//4. 반복문을 이용해서 members에 들어있는 회원정보 출력하기
		
			for (MemberDto tmp: members) {
				String info = String.format("번호:%d, 이름:%s, 주소:%s", tmp.getNum(), tmp.getName(), tmp.getAddr());
				System.out.println(info);
			}
			
		//테스트 메소드 호출 : 매개변수에 전달할 스트링 타입의 개수가 유동적이다.
			test();
			test("kim");
			test("kim", "lee", "park")
			
	}
	//테스트
	public static void test(String... msgs) {
		//String...은 String[]type이다
		String[] a=msgs; 
	}
	
}

 

<14:30 5교시>

package test.main;

import test.mypac.Apple;
import test.mypac.FruitBox;
import test.mypac.Melon;
import test.mypac.Orange;

public class MainClass01 {
	public static void main(String[] args) {
		
		//Generic 클래스를 Apple 로 지정해서 객체 사용하기
		FruitBox<Apple> box1 =new FruitBox<Apple>();
		box1.pack(new Apple());
		Apple a1=box1.unPack();
		
		//Generic 클래스를 Orange로 지정해서 객체 사용하기
		FruitBox<Orange> box2 =new FruitBox<Orange>();
		box2.pack(new Orange());
		Orange o1=box2.unPack();
		
		//Generic 클래스를 Melon으로 지정해서 객체 사용하기
		//객체 생성시에 Generic은 생략 가능하다
		FruitBox<Melon> box3=new FruitBox<>();
		box3.pack(new Melon());
		Melon m1=box3.unPack();		
	}
}

 

 

<15:30 6교시>

package test.main;

import test.mypac.Apple;
import test.mypac.Pear;

public class MainClass02 {
	public static void main(String[] args) {
		
		
		/*
		 * key 값을 어떤 타입으로 설정할지?
		 * value값을 어떤 타입으로 설정할지?
		 * 위 두개를 결정해서 2가지 generic 클래스를 지정해야 함.
		 */
		//우리가 직접 generic 클래스를 쓸 일은 없지만 이미 만들어진걸 적절하게 사용할줄 알아야 한다.
		//Integer라는 포장을 씌워줘야지 int를 쓰면 int가 기본 데이터 타입이라서 에러가 난다.
		Pear<String, Integer> p1= new Pear<>("one", 100);
		String k1=p1.getKey();
		Integer v1=p1.getValue();
		
		Pear<String, Apple> p2= new Pear<>("two", new Apple());
		String k2=p2.getKey();
		Apple v2= p2.getValue();
		
	}
}

 

학원에서 작업한 내용은 바로 github에 등록되는데, 집에서 작업한 내용은 집 환경에도 있지만 깃허브에는 반영되도록 관리되지 않을 수 있는 것은 우클릭에서 Team 메뉴에서 Apply Fetch랑 Share Project 기능 밖에 없는데 Share Project를 눌러서 저장소를 새로 만들거나 해서 git hub에서도 관리될 수 있도록 할 수 있다. 학원에서도 이 폴더를 관리되게 하고 싶다면 폴더를 선택하고 finish 하면 git 저장소로 그 프로젝트가 납치(?)되어 옮겨 간다. 그 폴더는 집에서 만들어졌지만 학원에서 만든것처럼 실행가능하게 되는 것이다.

학원에 있는 git 저장소에서 pull 하면 내가 집에서 작업해서 옮겨간 폴더도 Working Tree로 들어와 있다. 내용을 볼려면 import projects를 진행해야 한다.

 

 

예제 풀어보기

package test.main;

import java.util.ArrayList;

public class MainClass01 {
	public static void main(String[] args) {
		//java에서 배열은 용도가 한정되어 있다. item을 담을 수 있는 공간을 늘리거나 줄일 수 없다.
		
		//문자열(String) type을 담을 수 있는 방 5개 짜리 배열 객체 생성
		String[] names =new String[5];
		names[0]= "name1";
		names[1]= "name2";
		names[2]="name3";
		
		ArrayList<String> friends = new ArrayList<>();
		//이름 3개를 순서대로 담아 보기
		friends.add(0, "name1");
		friends.add(1, "name2");
		friends.add(2, "name3");
		
		//0번방의 아이템을 불러와서 item이라는 변수에 담기
		String item = friends.get(0);
		
		//1번 방의 아이템을 삭제
		friends.remove(1);
		
		//0번 방에 "acorn" 끼워넣기
		friends.add(0, "acorn");
		
		//저장된 아이템의 갯수(size)를 size라는 지역 변수에 담기
		int size = friends.size();
		
		//저장된 모든 아이템 전체 삭제
		friends.removeAll(friends);
		
	}
}

 

 

<16:30 7교시>

객체는 필드와 메소드로 이루어져 있다. 객체를 생성한 이유는?

객체의 기능을 이용해 목적을 달성하기 위해서 객체를 생성한다.

어레이리스트라는 객체를 생성하면 재너릭을 지정하고 객체를 만들어서 배열 리스트를 활용할 수 있다.

 

전시간에 풀은 거거 답 풀이 중인데, 일단 거의 다 맞은거 같은데 흠.

 

아 마지막 하나 틀렸네.

//저장된 모든 아이템 전체 삭제

//friends.removeAll(friends);

friends.clear();

 

이거래.

 

 

 

다음 예제 혼자 풀어본거 : 일단 다 맞았음. 근데 확장  for문의 존재를 잊고 있었음.

package test.main;

import java.util.ArrayList;

public class MainClass02 {
	public static void main(String[] args) {
		//정수를 저장할 수 있는 ArrayList<Integer> 객체를 생성해서 참조값을 지역변수 nums에 담기
		ArrayList<Integer> nums = new ArrayList();
		
		//ArrayList 객체에 10, 20, 30 숫자 3개를 담기
		nums.add(0, 10);
		nums.add(1, 20);
		nums.add(2, 30);
				
		//ArrayList 객체에 저장된 숫자를 for 문을 이용해서 순서대로 콘솔창에 출력하기
		for (int i=0; i<nums.size(); i++) {
			System.out.println(nums.get(i));
		}
		
	}
}

 

 

선생님이랑 한거

저런거 보면 for문 마려워야함 + 확장 for 문 잊지 말기

package test.main;

import java.util.ArrayList;

public class MainClass02 {
	public static void main(String[] args) {
		//정수를 저장할 수 있는 ArrayList<Integer> 객체를 생성해서 참조값을 지역변수 nums에 담기
		ArrayList<Integer> nums = new ArrayList();
		
		//ArrayList 객체에 10, 20, 30 숫자 3개를 담기
		nums.add(10);
		nums.add(20);
		nums.add(30);
				
		//ArrayList 객체에 저장된 숫자를 for 문을 이용해서 순서대로 콘솔창에 출력하기
		for (int i=0; i<nums.size(); i++) { // 자바 스크립트에서 nums.length
			System.out.println(nums.get(i));
		}
		System.out.println("----확장 for 문을 이용하면 ----");
		for (int tmp: nums) {
			System.out.println(tmp);
		}
	}
}

 

 

예제 풀어보기 - 틀림 ㅎ 

for 확장문 안에 int  타입만 써야하는 줄 알고 헛짓거리 하고 있었음..ㅎㅎ

package test.main;

import java.util.ArrayList;

public class MainClass03 {
	public static void main(String[] args) {
		//인삿말을 담을 ArrayList 객체를 생성해서 참조값을 greets라는 지역변수에 대입하기
		ArrayList<String> greets = new ArrayList();
		
		//greets에 들어 있는 참조값을 이용해서 인사말 3개를 임의로 담기
		greets.add(0, "안녕");
		greets.add(1, "반가워");
		greets.add("Hello");
		//확장 for 문을 이용해서 모든 인사말을 콘솔창에 순서대로 출력해보세요
		for (int tmp: greets.get(tmp)) {
			;
			System.out.println(tmp);
		}
		
	}
}

 

 

<17:30 8교시>

예제 답

package test.main;

import java.util.ArrayList;

public class MainClass03 {
	public static void main(String[] args) {
		//인삿말을 담을 ArrayList 객체를 생성해서 참조값을 greets라는 지역변수에 대입하기
		ArrayList<String> greets = new ArrayList<>();
		
		//greets에 들어 있는 참조값을 이용해서 인사말 3개를 임의로 담기
		greets.add(0, "안녕");
		greets.add(1, "반가워");
		greets.add("Hello");
		//확장 for 문을 이용해서 모든 인사말을 콘솔창에 순서대로 출력해보세요
		for (String tmp: greets) {
			System.out.println(tmp);
		}
		
		
	}
}

 

 

 

방금 확장형  for 문으로 호출한 내용과 동일한 결과를 얻을 수 있는 새로운 형태

관련해서 염두에 둘 내용 : 오호라,  Consumer 라는 인터페이스로 객체를 생성해서 보니까 accept 라는 메소드를 하나만 갖고 있네? 그러니까 객체를 생성하는 방법으로 Consumer<String> con = ()->{};  방식으로 생성해도 되겠네? 를 염두에 두고 가자 다음에 계속해주신댔으니. 

package test.main;

import java.util.ArrayList;
import java.util.function.Consumer;

public class MainClass03 {
	public static void main(String[] args) {
		//인삿말을 담을 ArrayList 객체를 생성해서 참조값을 greets라는 지역변수에 대입하기
		ArrayList<String> greets = new ArrayList<>();
		
		//greets에 들어 있는 참조값을 이용해서 인사말 3개를 임의로 담기
		greets.add(0, "안녕");
		greets.add(1, "반가워");
		greets.add("Hello");
		//확장 for 문을 이용해서 모든 인사말을 콘솔창에 순서대로 출력해보세요
		for (String tmp: greets) {
			System.out.println(tmp);
		}
	
		System.out.println("------------");
		
		Consumer<String> con = new Consumer<String>() {
			
			@Override
			public void accept(String t) {
				// TODO Auto-generated method stub
				System.out.println(t);
			}
		};
		greets.forEach(con);
	
	}
}

 

+ Recent posts