[STUDY] JAVA 웹 개발 코스 - 개발 언어
함수
package 함수;
public class JavaTest{
static void myFunction(){ // static 으로 선언된 함수는 static으로 선언된 함수에서 선언 가능
System.out.println("return 값을 가져갈 수 없음");
}
static void myAdd(int num){ // 매개변수 int num
System.out.println("매개변수 하나가 있습니다." + num);
}
static void myAdd(String a, String b){
System.out.println(a + b);
}
// 오버로딩: 함수 이름이 같지만 매개변수의 개수나 자료형이 다른 경우 호출 가능
int myAdd(int a, int b){
return a+b;
}
public static void main(String[] args) {
JavaTest.myFunction();
// 함수에 인자값 5를 전달
JavaTest.myAdd(5);
JavaTest.myAdd("지", "연");
// 인스턴스 생성
JavaTest jt = new JavaTest();
int result = jt.myAdd(10, 13);
System.out.println("int myAdd: " + result);
}
}✅ 오버로딩: 함수 이름이 같지만 그 안의 매개변수의 개수나 자료형이 다를 경우
✅ static: 정적 메소드는 클래스가 메모리에 올라갈 때 정적 메소드가 자동적으로 생성된다. 따라서 호출 할 때 인스턴스를 생성해주지 않아도 된다.
✅ 그러나 int myAdd() 함수는 static 메소드가 붙지 않았기 때문에 인스턴스를 생성해서 호출해줘야 한다.
예외 처리
import java.util.Scanner;
public class JavaTest{
public static void main(String[] args) {
try{
// 사용자로부터 입력 받기
System.out.println("값 입력");
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] members = {1, 2, 3, 4, 5};
System.out.println("배열의 값: " + members[n]);
// 무조건 오류 출력
// throw new Exception("사용자오류");
}
catch (ArrayIndexOutOfBoundsException e){ // 배열의 요소를 초과하였을 때
System.out.println(e.getMessage());
}
catch (Exception e){ // 예외가 발생하였을 때
System.out.println(e.getMessage());
}
finally{ // 오류가 발생하더라도, 발생하지 않더라도 문구 출력
System.out.println("오류가 발생하였습니다.");
}
}
}
접근 제어자
접근 권한 범위: public > protected > default > private
private: private로 선언된 함수, 멤버변수, 생성자는 선언된 클래스 내부에서만 접근 가능
default: 접근 제어자를 사용하지 않을 경우 클래스, 함수, 멤버변수, 생성자는 동일한 패키지에서만 접근 가능
protected: 함수, 멤버변수, 생성자는 동일 패키지 혹은 다른 패키지의 하위 클래스에서만 접근 가능
public: public으로 선언된 함수, 멤버변수, 생성자는 모든 다른 클래스에서 접근 가능
- final: 클래스 사용 시 다른 클래스에서 상속 불가능, 매소드, 멤버 변수에 사용 시 오버라이딩 수정 불가
- static: 매소드, 멤버변수에 사용, 클래스에 속하게 되며 객체의 생성 없이 바로 접근 가능
- abstract: 클래스 사용시 객체 생성 불가능, 오직 다른 클래스가 상속 받아 사용해야 함
- 메소드 상속시 오직 abstract 클래스에서만 abstract 메소드 정의 가능, 메소드는 바디(중괄호) 부분이 없음
- 메소드 예: abstract void run(): 바디 부분은 상속받은 곳에서 기능에 맞게 작성
package 접근제어자;
public class JavaTest{
public static void main(String[] args) {
// 접근 권한 범위: public > protected > default > private
JavaTests javaTest = new JavaTests();
System.out.println("값 열기 " + javaTest.var);
System.out.println("문자열 열기 " + javaTest.str);
// 값과 문자열 초기화
int var = 0;
String str = " ";
JavaTests javaTest2 = new JavaTests(5, "100");
System.out.println("값 열기 " + javaTest2.var);
System.out.println("문자열 열기 " + javaTest2.str);
// javaTest2.a = 5 final로 선언한 변수는 값을 변경하는 것이 불가능
System.out.println(javaTest2.a);
// System.out.println(javaTest2.abc); private로 선언한 변수는 외부에서 가져와 사용하는 것이 불가능
javaTest2.setAbc(100);;
System.out.println("private 요소 얻기: " + javaTest2.getAbc());
}
}package 접근제어자;
public class JavaTests {
private int abc; // 외부에서 접근 불가능
final int a = 5; // 값 변경 불가능
public int var;
public String str;
public JavaTests(){
var = 01;
str = "null1";
}
public JavaTests(int a, String s){
var = 02;
str = "null2";
}
public int getAbc() { // 값을 가져오고
return abc;
}
public void setAbc(int abc) { // 값을 할당
this.abc = abc;
}
}
캡슐화
'데이터의 은닉'을 목적으로 함
- 민감한 데이터를 private로 감추어서 public 의 setter 또는 getter 메소드로만
private 으로 감춘 데이터에 접근하거나 변경할 수 있음
- 따라서 이러한 private 변수에 read-only(읽기 전용-getter만 제공) 또는 write-only(변경만 가능-setter만 제공)한 선택적 접근을 제어할 수 있음
- public 보다 보안성이 증가하여 멤버변수와 함수를 더 좋게 제어할 수 있음
데이터의 은닉 이외에도 아래와 같은 목적이 있음
- 유연성: 같은 타입을 이루는 자료형에서 Map, Stack, Queue 와 같은 Collection 변경을 클래스 내부의 일부분만 변경하여 자료형을 변경할 수 있음
- 초기화 작업을 클래스에 모아서 처리함으로써 초기화 중에 데이터의 가공이 일어날 경우 일부분만 변경하면 됨
상속
부모 클래스가 자식 클래스를 상속
- 상속받을 때는 extends 키워드 사용
package 상속;
// 부모, 상위 클래스
public class Vehicle {
protected String model = "홍길동";
public void sound(){
System.out.println("정적이 울렸습니다.");
}
}package 상속;
// 자식, 하위 클래스
public class Car extends Vehicle{
public String handle =" ";
public void run()
{
System.out.println("경적이 울립니다.");
}
public void sound()
{
System.out.println("경적이 울렸습니다.");
}
}package 상속;
public class JavaTest {
public static void main(String[] args) {
Car car = new Car(); // 자식 클래스의 인스턴스
System.out.println("부모 클래스의 요소: " + car.model);
car.sound();
System.out.println("자식 클래스의 요소: " + car.handle);
}
}- 같은 패키지 내 클래스에서 사용 가능함
- 상속은 코드를 재사용하는데 유용
- 이미 존재하고 검증된 클래스의 멤버변수와 메소드를 재사용 하여 새로운 클래스를 만들 때 사용
다형성
- 여러 가지 자료형을 가질 수 있는 것을 의미
- 앞의 상속에서 멤버변수, 메소드를 다른 클래스로부터 물려 받음
- 다형성은 이러한 상속받은 메소드들을 동일하게 호출하여 다른 작업을 수행하는 것을 가능하게 함
package 다형성;
// 부모, 상위 클래스
public class Animal {
public void animalBark(){
System.out.println("동물 소리");
}
}package 다형성;
// 자식, 하위 클래스
public class Bird extends Animal{
public void animalBark(){
System.out.println("짹짹");
}
}package 다형성;
// 자식, 하위 클래스
public class Dog extends Animal{
public void animalBark() {
System.out.println("멍멍");
}
}package 다형성;
// 자식, 하위 클래스
public class Owl extends Animal{
public void animalBark(){
System.out.println("부엉부엉");
}
}package 다형성;
public class JavaTest {
public static void main(String[] args) {
/*
Animal animal = new Animal();
Animal bird = new Bird();
Animal dog = new Dog();
Animal owl = new Owl();
animal.animalBark();
bird.animalBark();
dog.animalBark();
owl.animalBark();
*/
// 쉬운 교체로 기존 코드의 재사용
// 동일한 데이터 타입으로 다양한 작업 수행
Animal animal = new Owl();
animal.animalBark();
// 코드의 확장
if (animal instanceof Owl) {
System.out.println("부엉이 입니다.");
}
}
}
오버라이딩
- 부모 클래스의 메소드를 자식 클래스에서 재정의 하여 사용하는 것
오버로딩
- 같은 이름의 매소드를 여러개 가지면서 매개변수의 개수, 유형이 다른 것
- 실무에서는 기능이 추가되거나 변경될 때 사용
추상화
- 메소드의 세부 사항을 숨기고, 메소드의 필수적인 정보만 보여주는 과정
- 이러한 추상화를 추상 클래스 또는 인터페이스라 함
- Abstract class: 객체 생성이 불가능하며 상속 받아서 해당 기능을 사용해야 함
- Abstract method: Abstract class 에서만 Abstract method 생성이 가능하며, 중괄호가 없는 것이 특징 ({,} 없음)
- 추상 클래스 Car
package 다형성;
abstract class Car {
public abstract void start();
// abstract 클래스는 무조건 abstract 메소드를 재정의 해줘야 함
public void accelerate(){
System.out.println("가속합니다.");
}
}
- Car의 자식 클래스
package 다형성;
public class X500Car extends Car{
// 오버라이딩: 부모 클래스의 메소드를 자식 클래스에서 재정의 하여 사용하느 것
@Override
public void start() {
System.out.println("X500 모델의 시작");
}
}
- main 클래스
package 다형성;
public class JavaTest {
public static void main(String[] args) {
X500Car x500Car = new X500Car();
x500Car.accelerate();
x500Car.start();
}
}
인터페이스
- 인터페이스는 완전한 추상 클래스임
- 인터페이스는 멤버 변수를 가지고 있지 않음
- 메소드의 바디{} 부분이 비어 있으며, 관련된 메소드들을 그룹화하는데 사용함
- 인터페이스는 new를 통한 객체 생성 불가
- 인터페이스는 생성자를 포함할 수 없음
- 인터페이스를 구현한 클래스는 모든 메소드를 오버라이드로 재정의를 해야 함
package 인터페이스;
public interface Menu {
public void coffee();
public void water();
public void drink();
}package 인터페이스;
public interface State {
public void hot();
public void ice();
}- 인터페이스의 핵심은 implements 라는 키워드를 사용
- interface 키워드를 통해 인터페이스 생성
- 인터페이스에는 메소드의 이름, 타입만 적어줌
package 인터페이스;
public class Client implements Menu, State {
@Override
public void coffee() {
System.out.println("아메리카노 나왔습니다.");
}
@Override
public void water() {
System.out.println("물 나왔습니다.");
}
@Override
public void drink() {
System.out.println("음료 나왔습니다.");
}
@Override
public void hot() {
System.out.print("따뜻한 ");
}
@Override
public void ice() {
System.out.print("차가운 ");
}
}- Menu, State 인터페이스를 implements
package 인터페이스;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
Client cnt = new Client();
System.out.println("어서오세요 손님, 어떤 걸로 드릴까요? (아메리카노, 물, 음료)");
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String order = br.readLine();
System.out.println("음료는 hot/ice 중, 어떤 상태로 드릴까요? ");
BufferedReader brState = new BufferedReader(new InputStreamReader(System.in));
String state = brState.readLine();
switch (order){
case "아메리카노":
if(state.equals("hot")){
cnt.hot();
cnt.coffee();
}
else if(state.equals("ice")){
cnt.ice();
cnt.coffee();
}
break;
case "물":
if(state.equals("hot")){
cnt.hot();
cnt.water();
}
else if(state.equals("ice")){
cnt.ice();
cnt.water();
}
break;
case "음료":
if(state.equals("hot")){
cnt.hot();
cnt.drink();
}
else if(state.equals("ice")){
cnt.ice();
cnt.drink();
}
break;
}
}
}
출력 결과
장점
- 다중 인터페이스를 구현함으로써 대체 가능
ex) implements Menu, State
내부 클래스
- 클래스 안에 클래스 선언이 가능함
- 이러한 내부 클래스를 내포하는 클래스와 내부 클래스는 더욱 밀접한 관계를 가지게 되며, 코드를 읽기 쉬워질 뿐만 아니라 서로 연관되어 있기 때문에 관리와 파악이 쉬움
package 내부클래스;
public class StudyJava {
public int a = 5;
// 내부 클래스
// 외부 클래스의 멤버 변수를 사용하고 싶기 때문에 static 메서드 붙이지 않는다.
class InnerTest{
int b = 7;
public int add() {
return a+b;
}
}
}package 내부클래스;
public class JavaTest {
public static void main(String[] args) {
StudyJava studyJava = new StudyJava();
// StudyJava 객체 안에 있는 내부 클래스인 InnerTest 선언
StudyJava.InnerTest innerTest = studyJava.new InnerTest();
System.out.println("더한 값은? " + innerTest.add());
}
}
열거형
- 서로 관련 있는 상수들을 모아둔 클래스와 비슷한 형식
- 제약 사항들
- 다른 클래스를 상속받을 수 없음
- 객체의 생성 불가
- 값의 재할당 불가
- 보통 메소드는 생성하지 않음
package 열거형;
import javax.swing.*;
public class JavaTest {
// 열거형 선언
public enum Season{
// 멤버 변수에 public static final 키워드가 붙은 것과 동일
// 사용할 상수는 대문자로 적는 것이 원칙
// 예) 주로 변하지 않는 것들: 모델 타입, 요일, 계절 등..
Spring, Summer, Autumn, Winter;
}
public static void main(String[] args) {
// 열거형에 선언된 상수들 중 하나로 일단 넣어줌
Season season = Season.Spring;
switch (season){
case Spring:
System.out.println("봄이다!");
break;
case Summer:
System.out.println("여름이다!");
break;
case Autumn:
System.out.println("가을이다!");
break;
case Winter:
System.out.println("겨울이다!");
break;
}
System.out.print("열거형에서 해당 계절이 적힌 순서는 ");
System.out.println(season.ordinal() + " 입니다.");
// season = 0;
}
}
ArrayList
- 배열 대신 자주 사용되며, 배열과 달리 크기를 조절할 수 있음
- 자바의 List 인터페이스를 상속받고 있음
- 배열의 크기는 한 번 정해지면 크기를 변경할 수 없고, 속도가 약간 더 뛰어남
- 그러나 ArrayList와 배열의 사용 방법은 전혀 다름
package ArrayList;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class JavaTest {
public static void main(String[] args) {
// String data
ArrayList<String> arrayList = new ArrayList<String>();
// int data
// ArrayList<Integer> arrayList1 = new ArrayList<Integer>();
arrayList.add("봄"); // 0
arrayList.add("여름"); // 1
arrayList.add("가을"); // 2
arrayList.add("겨울"); // 3
System.out.println("계절 뽑기: " + arrayList.get(0));
System.out.println("ArrayList 크기: " + arrayList.size());
// ArrayList에 저장된 값 변경 .set(인덱스 값, 변경하고자 하는 값)
arrayList.set(0, "벚꽃");
// 변경한 값 출력
System.out.println("봄 -> " + arrayList.get(0));
// arrayList의 상위 클래스 : List
List list;
list = arrayList;
arrayList.set(0, "봄");
System.out.println(list.get(0)); // List 인터페이스에 포함된 모든 list들은 이렇게 사용 가능
System.out.println(arrayList.get(0));
// ArrayList 정렬할 때엔 Collections.sort()
// 지금 ArrayList에는 한글 문자가 들어가 있으므로 ㄱ~ㅎ 순서대로 정렬
// 영어는 A~ 부터 순서대로 정렬
// 숫자는 마이너스 포함해서 가장 작은 값부터 ~ 순서대로 정렬
Collections.sort(arrayList);
// arrayList.size(): arrayList 크기만큼 반복하기
for(int i =0; i<arrayList.size(); i++){
System.out.println("List 정렬 (ㄱ~ ): " + arrayList.get(i));
}
}
}
HashMap
- HashMap은 Map 인터페이스를 구현한 대표적인 Map 컬렉션
- Map 인터페이스의 기능들을 모두 구현할 수 있음
- HashMap을 사용하면 시간 복잡도가 O(1) 로 효율적으로 사용 가능
- 키와 값의 1:1 저장 ex) "101" 혹은 "apple" 이라는 키로 "사과" 값을 저장하거나 얻을 수 있음
- 키와 값의 자료형은 서로 달라도 괜찮음
package HashMap;
import java.util.HashMap;
public class JavaTest {
public static void main(String[] args){
HashMap<String, Object> hashMap = new HashMap<String, Object>();
// HashMap<key, value>
hashMap.put("fruit", "복숭아");
hashMap.put("userVALUE", 23);
hashMap.put("userID", "아이디");
hashMap.put("userNAME", "이름");
// hashMap.put(key) 하면 해당 key에 해당하는 value 출력 됨
System.out.println("hashMap.get(key value)을 통한 값 얻기: " + hashMap.get("fruit"));
// get 함수의 data 자료형이 object이기 때문에 오류가 발생
// int var = hashMap.get("userNAME");
// String 타입의 key: "userVALUE" 의 value: 300 출력 hashMap<String, Object>
// 여기서 Object는 int 타입
int var = Integer.parseInt(hashMap.get("userVALUE").toString());
// String 타입인 key: "101"의 value: "복숭아" 출력 hashMap<String, Object>
// 여기서 Object는 String 타입
String str = hashMap.get("fruit").toString();
// hashMap의 size 찾기
System.out.println("hashMap의 size: " + hashMap.size());
// for( key 값을 가져올 변수 i : key에 해당 되는 값을 가져옴)
for (String i : hashMap.keySet()) {
System.out.println("저장된 key: " + i);
System.out.println(hashMap.get(i));
}
}
}
package HashMap;
import java.util.HashMap;
public class JavaTest {
public static void main(String[] args){
HashMap<Integer, String> hashMap = new HashMap<Integer, String>();
hashMap.put(01, "key(01)- value");
hashMap.put(02, "key(02)- value");
hashMap.put(03, "key(03)- value");
hashMap.put(04, "key(04)- value");
hashMap.put(05, "key(05)- value");
// <Integer, String>
// int value = Integer.parseInt(hashMap.get(01).toString());
// System.out.println(value);
// key: 01
// hashMap.get() 을 통해 key에 저장된 값 얻어오기
String str = hashMap.get(01).toString();
System.out.println(str);
System.out.println("hashMap 크기: " + hashMap.size());
for(Integer i : hashMap.keySet()){
System.out.println("key: " + i);
// key에 저장된 값 얻어오기
System.out.println(hashMap.get(i));
}
}
}
Stack
- LIFO(Last In First Out)
- 맨 나중에 넣은 값이 가장 먼저 나오게 됨
ex) 1,2,3,4,5 순서대로 넣고 -> 5,4,3,2,1 순으로 나옴
- push (값 넣기) pop (값 뽑기)
package Stack;
import java.util.Stack;
public class JavaTest {
public static void main(String[] args){
Stack<Integer> stack = new Stack<Integer>();
stack.push(1);
stack.push(2);
stack.push(3);
stack.push(4);
stack.push(5);
System.out.println("저장된 값을 하나씩 출력(Stack): " + stack.pop());
System.out.println("저장된 값을 하나씩 출력(Stack): " + stack.pop());
System.out.println("저장된 값을 하나씩 출력(Stack): " + stack.pop());
System.out.println("저장된 값을 하나씩 출력(Stack): " + stack.pop());
System.out.println("저장된 값을 하나씩 출력(Stack): " + stack.pop());
}
}
Queue
- FIFO(First In First Out)
- 가장 먼저 넣은 값이 가장 먼저 나옴
- java에서는 Queue를 인터페이스로 지원함
- add (값 넣기) poll (값 뽑기)
package Queue;
import java.util.LinkedList;
import java.util.Queue;
public class JavaTest {
public static void main(String[] args){
Queue<Integer> queue = new LinkedList<Integer>();
queue.add(1);
queue.add(2);
queue.add(3);
queue.add(4);
queue.add(5);
System.out.println("저장된 값을 하나씩 출력(Queue): " + queue.poll());
System.out.println("저장된 값을 하나씩 출력(Queue): " + queue.poll());
System.out.println("저장된 값을 하나씩 출력(Queue): " + queue.poll());
System.out.println("저장된 값을 하나씩 출력(Queue): " + queue.poll());
System.out.println("저장된 값을 하나씩 출력(Queue): " + queue.poll());
}
}
Stream
- 스트림은 단일 방향의 흐름을 의미
- 프로그램이 데이터를 입력 받을 때 사용하는 입력 스트림
- 프로그램이 데이터를 내보낼 때 사용하는 출력 스트림
package Stream;
import java.io.*;
public class JavaTest {
public static void main(String[] args) throws FileNotFoundException {
try {
// 복사 할 파일의 경로와
// 복사 될 파일의 경로를 적음
String testFile = "C:\\Users\\study\\test.txt";
String copyFile = "C:\\Users\\study\\copy.txt";
// 복사할 파일의 내용을 읽을 변수
FileInputStream input = new FileInputStream(testFile);
// 복사 될 파일에 내용을 쓰기 위한 변수
FileOutputStream output = new FileOutputStream(copyFile);
// 문자가 얼마나 읽어졌나에 대한 숫자를 확인하기 위한 변수
int readByteNum;
// 읽어드릴 문자열을 저장하기 위한 byte 배열
byte[] bytes = new byte[100];
// 파일 복사가 이루어지는 동작
while ((readByteNum = input.read(bytes)) != -1){ // testFile에 적힌 내용응 bytes 배열에 저장
// 0부터 시작해서 읽은 byte 단위까지 읽을 것임
output.write(bytes, 0, readByteNum);
}
// 사용한 자원을 닫음
output.flush();
output.close();
input.close();
System.out.println("Copy finished! - - - ");
} catch (IOException e) {
System.out.println("error: " + e.getMessage());
}
}
}
- 복사가 완료된 모습을 확인
스레드
- 비디오 재생 프로그램은 화면 출력과 동시에 오디오 출력도 가능
- 이처럼 한 개의 프로그램에서 여러 작업을 가능하게 해주는 것이 '스레드'
package thread;
public class Sound implements Runnable{
@Override
public void run() {
// thread: start() 호출 시에 동작하는 함수
for (int i = 0; i < 5; i++) {
try {
System.out.println("== == == sound == == == ");
Thread.sleep(300); // 0.3초마다 출력
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}package thread;
public class Main {
public static void main(String[] args) {
Sound sound = new Sound();
Thread thread = new Thread(sound);
thread.start(); // Sound 클래스의 thread 가 동작
for (int i = 0; i < 5; i++) {
try {
System.out.println("-- -- -- Main -- -- --");
Thread.sleep(500); // 0.5초마다 출력
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}+ 비동기: 스레드에서 각자의 작업을 서로 병행하면서 실행
- 다수의 작업에 대해 병렬작업을 진행하는 것을 의미
+ 동기: 하나하나 작업을 처리해가는 방식
- 멀티스레드 환경에서 같은 자원(변수)을 사용하면 그 자원이 다른 스레드가 작업을 끝날 때까지 기다리는 교착상태가 발생할 수 있음
싱글톤 패턴
- 시스템 설계에서 다루는 내용
- 싱글톤 패턴은 클래스의 인스턴스가 하나만 생성되도록 하는 개발 방법임
적용되는 사례)
- 응용프로그램에서 단일 창만 띄우거나 클래스의 객체를 생성할 때 사용
- Spring은 사용자의 요청이 매우 많을 수 있기 때문에 그 때마다 많은 객체를 생성할 수 없음 -> 하나의 객체를 생성하여 스레드로 공유하는 싱글톤 패턴과 비슷한 방식을 사용
package SingleTon;
// 멀티 환경에 취약
// 가장 기본적인 싱글톤 형식으로 개발 상황에 맞게 변경이 필요
public class SingleTon {
// 자기 자신의 객체를 생성
private static SingleTon singleTonObject;
// 다른 객체의 생성을 막음
private SingleTon() {
}
public static SingleTon getSingleTonObject() {
if (singleTonObject == null) {
singleTonObject = new SingleTon();
}
return singleTonObject;
}
}