예외처리 / 파일 입출력
JDBC
Properties(설정 파일) , exception_handling log4jdbc 스레드 소켓네트워크
제일 까다로운 것들만 남아서
나원참 ㅡㅅㅡ
| Java 8일차 제네릭, 컬렉션 (1) | 2022.08.30 |
|---|---|
| Java 7일차 다형성 (1) | 2022.08.30 |
| Java 6일차 객체배열, 상속 (0) | 2022.08.30 |
| Java 5일차 객체 (0) | 2022.08.30 |
| Java 4일차 배열 (0) | 2022.08.30 |
Java의 컬렉션 프레임워크의 상속구조 입니다.
컬렉션 : 요소들의 저장소이다. 요소의 개수에 따라 크기가 자동 조절된다. 요소의 삽입, 삭제에 따른 요소의 위치 자동 이동.-> 배열이 가진 고정 크기의 단점을 극복하기 위해 객체들을 쉽게 삽입 삭제 검색 할 수 있는 가변 크기의 컨테이너이다.
가변 크기의 컨테이너 답게 add 함수를 이용해서 초기 값을 넘겨 추가를 해도 계속 삽입 되어진다.
자주쓰는 프레임워크 : LIst , ArrayList
배열과 컬렉션의 차이점 배열은 고정 크기 이상의 객체를 관리할 수 없고, 중간에 객체가 삭제되면 응용프로그램에서 자리를 옮겨야 한다. 하지만 컬렉션은 가변 크기로서 객체의 개수를 염려할 필요가 없고 컬랙션 내의 한 객체가 삭제되면 컬렉션이 자동으로 자리를 옮겨준다.
컬렉션의 특징 : 컬렉션 자체가 제네릭 기법으로 구현되어있고, 컬렉션의 요소는 객체만 가능하다.
ArrayList<E> 에서 E 대신 구체적인 타입을 지정하면 그 값만 저장하는 ArrayList를 사용할 수 있다. 특정 타입만 다루지 않고 여러 종류의 타입으로 변신할 수 있도록 컬렉션을 일반화시키기 위해 <E>를 사용하는 것. <E> 자체를 타입 매개변수라고 부르고 타입 매개변수를 일반화 시킨 타입을 제네릭 타입이라고 부른다.
제네릭 타입 매개변수 컬렉션(ArrayList의 부모) 클래스에서 타입 매개변수로 사용하는 문자는 다른 변수와 혼동을 피하기 위해 일반적으로 하나의 대문자를 사용 ex(E :element T : type V : value K : key)
제네릭 컬렉션 활용
ArrayList**<E>** : 배열을 가변 크기로 다룰 수 있게 하고 객체의 삽입 삭제 이동이 쉽도록 구성한 컬렉션 클래스이다. ArrayList는 삽입되는 요소의 개수에 따라 자동으로 크기를 조절하고, 요소의 삽입과 삭제에 따라 자동으로 요소들의 자리를 이동.
ArrayList<E>
가변 크기의 배열을 구현한 컬렉션 클래스. 경로명은 java.util.ArrayList, Vector 클래스와 거의 동일.차이점은 ArrayList는 스레드 간에 동기화를 지원하지 않기 때문에 다수의 스레드가 동시에 ArrayList에 요소를 삽입하거나 삭제할 때 ArrayList의 데이터가 훼손될 우려가 있다. 하지만 멀티스레드 동기화를 위한 시간 소모가 없기 때문에 ArrayList는 Vector보다 속도가 빨라, 단일 스레드 응용에는 더 효과적이다.
선언 , 생성
ArrayList<String> a = ArrayList<>() ; >> 자료형 선언 후, 생성 시에는 생략 가능.
ArrayList의 크기 알아내기 int len = a.size() //
ArrayList의 값 추가 a.add( (index) , value) >
ArrayList의 요소 전체 삭제 유사. a.clear(); -> 모든 요소를 삭제하는 메소드
ArrayList의 요소 삭제 a.remove(index or value) > 인덱스 또는 값 하나만 삭제
ArrayList의 해당 인덱스의 값 반환 a.get(index)
ArrayList의 해당 인덱스 값 변경 a.set(index, value)
ArrayList의 해당 값의 인덱스 반환하기 a.indexOf(value) >> 해당 인덱스가 없다면 -1 반환
ArrayList의 해당 값 존재 여부 확인 a.contains(value) >> true & false
• 어떤 값이 하나의 참조 자료형이 아닌 여러 참조 자료형을 사용할 수 있도록 프로그래밍 하는 것을 '제네릭(Generic) 프로그래밍' 이라고 한다.
• 여러 참조 자료형이 쓰일 수 있는 곳에 특정한 자료형을 지정하지 않고 클래스나 메서드를 정의한 후 사용하는 시점에 어떤 자료형을 사용할 것인지 지정하는 방식
public class TestGene<T>
{
public T sample;
public void showYourType(){
if(sample instanceof Integer)
System.out.println("Integer 타입 입니다");
else if(sample instanceof String)
System.out.println("String 타입 입니다");
}
}
위의 코드에서 T 는 현재 타입이 정해져 있지 않습니다 (Type 의 약자)
T 는 TestGene의 인스턴스가 생성 될 때 결정이 됩니다.
public class Main{
public static void main(String[] args) {
TestGene<String> stringType = new TestGene<String>();
TestGene<Integer> integerType = new TestGene<Integer>();
stringType.sample = "Hello";
integerType.sample = 1;
stringType.showYourType();
integerType.showYourType();
}
}
<String> , <Integer> 부분이 타입 입니다.
제네릭은 기본 자료형 ( long , int … ) 에 대해서는 지정이 불가능 합니다. 다만 기본 타입을 객체 타입으로 사용하는 Wrapper 클래스 (Integer, Boolean … ) 에는 제네릭 사용이 가능합니다.
public class Data<T>{
public T data;
public Data(T data){
this.data = data;
}
}
public class Main{
public static void main(String[] args) {
Data data = new Data("Hello");
Data<String> data2 = new Data("Hello World");
}
}
Data 클래스의 생성자에 매개변수로 자료형을 T (제네릭)으로 설정하게 된다면
Data 인스턴스 생성 시에
여러 참조 자료형을 사용할 수 있다는 것이 장점이라고 하는데, ArrayList 사용시 한정으로 가급적이면 상속 관계를 가지고 있는 클래스들로 제한해서 사용하는 것이 좋을 듯 하다 (내 생각)
| Java 아직 미작성한 챕터 (1) | 2022.08.30 |
|---|---|
| Java 7일차 다형성 (1) | 2022.08.30 |
| Java 6일차 객체배열, 상속 (0) | 2022.08.30 |
| Java 5일차 객체 (0) | 2022.08.30 |
| Java 4일차 배열 (0) | 2022.08.30 |
클래스 형변환 ( Animal , Rabbit , Tiger ) = 여러 타입의 클래스를 하나의 클래스로 관리가 가능하다
동적 바인딩 = 컴파일 당시에는 해당 타입의 메소드와 연결 되어 있다가 런타임 시에는 실제 객체가 가진 오버라이딩 된 메소드로 바인딩이 바뀌어 동작하는것을 의미한다
( 점심 먹고 졸다가 주석이 휴먼졸림체로 적혀버렸습니다 )
추상클래스와 인터페이스
추상클래스 = 구현부가 없는 클래스
추상클래스를 인스턴스로 만들 수 없음
추상클래스를 사용하려면 다형성을 이용하여 추상클래스를 상속받은 하위클래스를 이용하여 인스턴스 생성.
추상클래스의 추상메소드는 오버라이딩에 의한 강제성이 부여됨.
장점 : 필수 기능을 정의하여 강제성을 부여해 개발 시 일관된 인터페이스를 제공함
abstract class : 추상 클래스
abstract void abstractMethod() : 추상 메소드
extends Product : 추상 클래스(Product) 를 상속 받음
@Override public void abstractMethod() : 구현을 해도되고 안해도 됨.
구현 안함 = 다음 상속 받을 놈 한테 책임 전가
인터페이스 = 모든 메소드가 추상메소드인 클래스
인터페이스를 상속받는 클래스는
인터페이스에 정의된 추상 메소드를 반드시 반드시 절대로 절대로 구현 해야하는 책임이 있다.
API ( Application Programming Interface )
Book 클래스 Object 함수인 toString, equals , hashcode 오버라이딩(재정의)
| Java 아직 미작성한 챕터 (1) | 2022.08.30 |
|---|---|
| Java 8일차 제네릭, 컬렉션 (1) | 2022.08.30 |
| Java 6일차 객체배열, 상속 (0) | 2022.08.30 |
| Java 5일차 객체 (0) | 2022.08.30 |
| Java 4일차 배열 (0) | 2022.08.30 |
int[] intArr = new int[5];
int[] intArr2 = new int[] { 11, 22, 33, 44, 55 }
Car[] carArr = new Car[5]
carArr[0] = new Car("차1",30);
carArr[1] = new Car("차2",60);
carArr[2] = new Car("차3",90);
carArr[3] = new Car("차4",120);
carArr[4] = new Car("차5",150);
배열 : 동일한 자료형의 모음
객체 배열 : 동일한 객체의 모음
객체배열에서 인덱스 하나에 접근하면 객체 이다.
carArr[0].information()
carArr[0].setName() , getName() ... 인덱스 하나를 지정해서 접근가능.
/*상속(inheritance)
* 부모가 가지고 있는 재산(자바에서는 클래스가 가지는 멤버)을 자식이 물려받는 의미
* 자바에서의 상속은 부모클래스의 확장(extend)의 개념
* 물려받아서 자신의 것 처럼 사용하는 것 뿐 아니라 추가적인 멤버도 작성이 가능
* 특히 메소드 재정의(overriding)라는 기술을 이용해서 부모가 가진 메소드를 재정의 하는 것도 가능
*
* 메소드 재정의(overriding)이란 부모가 가지는 메소드 선언부를 그대로 사용하면서
* 자식클래스가 정의한 메소드대로 동작하도록 구현 몸체 부분을 새롭게 다시 작성하는 기술이다.
* 메소드 재정의를 하면 메소드를 호출할 시 재정의한 메소드가 우선적으로 동작하게 된다.
* */
부모 클래스의 성질을 물려받는다. ( 필드, 메소드 )
/* 상속이라는 기술을 사용하게 되면 얻게되는 이점은 크게 두 가지로 볼 수 있다.
* 1. 새로운 클래스를 작성할 시 기존에 작성한 클래스를 재사용할 수 있다.
* 1-1. 재사용 시 생산성을 크게 향상시킬 수 있다. (코드가 줄어듬 ,새롭게 작성하는거보다 빠르다)
* 1-2. 공통적으로 사용하는 코드가 부모클래스에 존재하면 수정사항이 생길 시 부모 클래스만 수정해도
* 전체적으로 적용된다. (유지보수성 증가)
* 2. 클래스간의 계층 관계가 형성되며 다형성의 문법적인 토대가 된다.
*/
Car.java
public class Car{ // 모든 종류의 차는 자동차라고 대분류 할 수 있다. 부모 역할을 하는중
private String brand;
Car(String brand){ // 생성자
this.brand = brand;
}
public void soundHorn(){ // 경적
System.out.println("일반 자동차 경적")
}
}
FireCar.java
public class FireCar extends Car{ // Car의 성질을 물려받아서 쓰겠다 부모를 상속받은 자식클래스
private String color;
FireCar(String brand, String color){ // 부모의 생성자를 이용해서도 초기화가 가능하다
super(brand); // 부모의 생성자(Car ) 를 호출
this.color = color;
}
@Override
public void soundHorn(){
// super.soundHorn(); // 부모의 soundHorn 함수를 실행함
// 부모에도 똑같은 이름의 함수가 있는데, 자식에서 재정의(오버라이딩) 함
System.out.println("소방차의 경적")
}
}
super : 부모클래스의 인스턴스 주소를 보관하는 레퍼런스 변수
super() : 부모클래스의 생성자를 호출하는 함수
| Java 8일차 제네릭, 컬렉션 (1) | 2022.08.30 |
|---|---|
| Java 7일차 다형성 (1) | 2022.08.30 |
| Java 5일차 객체 (0) | 2022.08.30 |
| Java 4일차 배열 (0) | 2022.08.30 |
| Java 3일차 함수 조금, 스캐너, 제어문, 반복문 (1) | 2022.08.30 |
클래스의 구조
필드, 행위
public class 클래스명 {
필드
( 필드부의 접근제한자는 private 로 지정해주는것이 객체지향설계원칙 중의 하나이다. 캡슐화 )
생성자
생성자란, new로 새로운 객체가 생성될때 자동으로 실행되는 함수로써
( 함수의 이름이 클래스 명과 일치해야한다 )
객체를 초기화할 때 편하다.
setter , getter
필드 변수가 private 이기 때문에 getter 와 setter 로 접근해야한다.
사용자 정의 함수
public String information(){
return "객체정보";
}
}
필드 변수만 개발자가 작성해두면 이클립스 단축키 (Alt + Shift + S ) 로 생성자, 매개변수를 필요로 하는 생성자, setter ,getter 를 자동으로 만들어줍니다.
main(){
Car c = new Car() // 바로 여기가 생성자가 호출되는 곳
}
/*
Car() >> 기본생성자 호출
Car(매개변수1, 매개변수2 ... ) >> 매개변수를 필요로 하는 생성자 호출
해당 인스턴스의 필드변수의 값을 매개변수로 저장하게 됨.
*/
/* 생성자를 이용한 초기화와 설정자를 이용한 초기화는 각각의 장단점이 존재한다.
*
* 1. 생성자를 이용한 초기화
* 장점 : setter 메소드를 여러 번 호출해서 사용하지 않고 단 한번의 호출로
인스턴스를 생성 및 초기화 할 수 있다.
* 단점 : 필드를 초기화할 매개변수의 갯수를 경우의 수 별로 모두 만들어둬야 한다.
* 호출 시 인자가 많아지는 경우 어떠한 값이 어떤 필드를 의미하는지 한 눈으로 보기 힘들다.
* 예) 아이디, 비밀번호, 이름이 모두 ohgiraffers인 경우
* new User("ohgiraffers", "ohgiraffers", "ohgiraffers");
몇 번째 인자가 아이디인지 이름인지 알 수 없다.
*
* 2. 설정자를 이용한 초기화
* 장점 : 필드를 초기화하는 각각의 값들이 어떤 필드를 초기화하는지 명확하게 볼 수 있다.
* 예) 아이디, 비밀번호, 이름이 모두 ohgiraffers인 경우
* User user = new User();
* user.setId("ohgiraffers");
* user.setPwd("ohgiraffers");
* user.setName("ohgiraffers");
* 호출하는 코드만 봐도 어떤 값이 어떤 필드를 초기화하는 내용인지 쉽게 알 수 있다.
* 단점 : 하나의 인스턴스를 생성할 때 한 번의 호출로 끝나지 않는다.
* */
생성자나 함수를 선언할 때 (사실 둘 다 함수긴 하지만) 매개변수의 개수, 타입, 순서를 다르게 작성하면 서로 다른 생성자나 함수로 인식하게 된다.
이것을 오버로딩 이라고 한다.
오버로딩의 사용 이유 매개변수의 종류별로 메소드 내용을 다르게 작성해야 하는 경우들이 종종 있다. 이 때, 동일한 기능의 메소드를 매개변수에 따라 다르게 이름을 정의하면 복잡하고 관리하기가 매우 어려울 것이다. 규모가 작은 프로그램의 경우는 정도가 덜 하지만, 규모가 거대해지면 메소드 또한 관리하기가 매우 어려워진다. 따라서 동일한 이름으로 다양한 종류의 매개변수에 따라 처리해야 하는 여러 메소드를 동일한 이름으로 관리하기 위해 사용하는 기술을 오버로딩이라고 한다.
| Java 7일차 다형성 (1) | 2022.08.30 |
|---|---|
| Java 6일차 객체배열, 상속 (0) | 2022.08.30 |
| Java 4일차 배열 (0) | 2022.08.30 |
| Java 3일차 함수 조금, 스캐너, 제어문, 반복문 (1) | 2022.08.30 |
| Java 2일차 연산자, 메소드(함수), 메모리 개념 조금 (2) | 2022.08.30 |
동일한 자료형의 묶음이다.
Heap 메모리에 new 연산자를 이용하여 할당한다.
배열의 인덱스는 0번부터 시작한다 ( 중요 )
자료형 별 배열 선언 형식
// 자료형에 []를 붙이던 변수명에 []를 붙이던 상관없다.
int[] intArr; // 저는 이 형식을 더 선호합니다
int intArr[];
// 선언과 동시에 초기화를 할 수 있다.
int[] intArr = new int[5]; // 크기만 지정 할 경우 초기값으로 5칸이 채워진다.
int intArr[] = new int[5]; // 정수형의 초기값 : 0
// 선언만 하고 나중에 초기화를 할 수도 있다.
int[] intArr;
intArr = new int[5];
// 크기를 지정하지 않고 초기화도 가능하다. 중괄호를 사용한다.
int[] intArr = {11, 22, 33, 44, 55 };
int[] intArr = new int[] {11, 22, 33, 44, 55 };
/* 값의 형태 별 기본값
* int 정수 : 0
* double 실수 : 0.0
* boolean 논리 : false
* char 문자 : \\u0000
* String 참조 : null
* */
// 문자열(String) 을 charAt() 함수를 사용하여 한 글자씩 잘라서 char 배열에 저장할 수 있다.
// char[i] chArr = sc.nextLine().charAt(i) // i 는 반복문 인덱스
// 배열을 초기화하거나 출력하는 등의 작업에는 반복문 사용이 필수적이다.
// 배열명.length = 배열의 길이 값 리턴.
// 1차원 배열이 이렇게 생겼다면,
int[] intArr = new int[5]
[ ][ ][ ][ ][ ]
// 2차원 배열의 형태
int[][] intArr2 = new int[2][3] // [행][열]
[ ][ ][ ]
[ ][ ][ ]
// 각각의 위치 , 배열의 시작 인덱스는 0 번
[ int[0][0] ][ int[0][1] ][ int[0][2] ]
[ int[1][0] ][ int[1][1] ][ int[1][2] ]
for(int i = 0; i < inrArr2.length; i++){ // 조건식 i < 행의 개수
for(int j = 0; j < inrArr2[i].length; j++) { // 조건식 j <열의 개수
System.out.print(inrArr2[i][j] + " "); // 해당 위치 값출력 + 공백
}
}
//수행결과 정수형 배열의 초기값 = 0
0 0 0
0 0 0
정변배열, 가변배열의 선언, 할당
2차원배열 하나씩 접근하기
array_copy app2 얕은복사 다시보기 ㅡㅡ;;
| Java 6일차 객체배열, 상속 (0) | 2022.08.30 |
|---|---|
| Java 5일차 객체 (0) | 2022.08.30 |
| Java 3일차 함수 조금, 스캐너, 제어문, 반복문 (1) | 2022.08.30 |
| Java 2일차 연산자, 메소드(함수), 메모리 개념 조금 (2) | 2022.08.30 |
| Java 1일차 변수,변수 명명 규칙,상수, 형변환 (0) | 2022.08.30 |
Math 클래스는 기본적인 산술연산을 제공해주는 클래스로써 java.lang 패키지에 포함되어있다.
Math 클래스의 함수는 모두 static 으로 정의 되어있어서 인스턴스를 만들지 않아도 사용할 수 있다.
확인하고 싶으면
Ctrl 누르고 Math 부분 클릭
제가 알아볼 수 있는건.... PI가 상수로 정의되어있네요~ 역시 산술연산 클래스 클라쓰 🍷
java.util 패키지에 있는 Scanner 클래스를 import 해야 정상적으로 사용할 수 있다.
예시) int num = sc.nextInt();
해석) int 자료형 변수 num에 사용자로부터 콘솔에서 입력 받은 정수를 저장한다.
예시) String str = sc.next();
해석) String 자료형 변수 str에 사용자로부터 콘솔에서 입력 받은것 중 공백을 만나기 전 까지의 문자열 전부를 저장한다.
예시) String str = sc.nextLine();
해석) String 자료형 변수 str에 사용자로부터 콘솔에서 입력 받은 엔터 치기 전 까지의 문자열 전부를 저장한다.
import java.util.Scanner;
/* 1. Scanner 객체 생성 */
/* 1-1. 원래 이렇게 Scanner 객체를 만들어야 함 */
//java.util.Scanner sc = new java.util.Scanner(java.lang.System.in);
Scanner sc = new Scanner(System.in);
// 2. 자료형 별 값 받기
// 2.1 문자형 /* nextLine() : 입력받은 값을 문자열로 반환해줌 */
// 2.2 정수형
// nextInt() : 입력받은 값을 Int로 변환 한다.
/* nextLong() : 입력받은 값을 long 형으로 반환한다.*/
/* 2-3. 실수형 값 입력 받기 */
/* nextFloat() : 입력받은 값을 float 형으로 반환한다. */
/* nextDouble() : 입력받은 값을 double 형으로 반환한다. */
/* 2-4. 논리형 값 입력받기 */
/* nextBoolean() : 입력받은 값을 boolean형으로 반환한다.
* true or false 외에 다른 값을 입력하게 되면 InputMismatchException 발생함
* */
/* 2-5. 문자형 값 입력받기 */
/* 아쉽게도 문자를 직접 입력 받는 기능을 제공하지는 않는다.
* 따라서 문자열로 입력을 받고, 입력받은 문자에서 원하는 번째 문자를 분리해서 사용해야 한다.
* java.lang.String에 charAt(int index)를 사용한다.
* index를 정수형으로 입력하면 문자열에서 해당 인덱스에 있는 한 문자를 문자 형으로 반환해주는 기능을 한다.
*
* index는 0부터 시작하는 숫자 체계
* 만약 존재하지 않는 인덱스를 입력하게 되면 IndexOutOfBoundsException이 발생한다.
* */
System.out.println("아무문자나 입력해주세요 : ");
char ch = sc.nextLine().charAt(0); // charA(n) n 번째 인덱스 가져오는 함수
System.out.println("입력하신 문자는" + ch + "입니다.");
만약 두 가지 데이터를 받기 위해서 next함수를 연이어서 사용해야 하는 경우.
예시)
int num1 = sc.nextInt();
Sring num2 = sc.nextLine();
두 번째 데이터를 입력받을 때 nextLine() 함수 사용 시,
첫 번째 데이터 입력하고 난 뒤 ‘엔터’ 값이 두 번째 데이터에 바로 입력되는 문제가 발생한다
이를 방지하기 위해서는 nextLine 함수를 한 줄 추가해주면 해결이 된다.
int num1 = sc.nextInt();
sc.nextLine(); // 추가
Sring num2 = sc.nextLine();
// 제어문 형식
if (조건식) {
// 조건식에 맞으면 발동되는 코드
}else {
// 조건식에 맞지 않으면 발동되는 코드
}
if (조건식1){
//조건식1 에 맞을 때 발동되는 코드
} else if(조건식2){
//조건식2 에 맞을 때 발동되는 코드
}else if ... {
//조건식3 에 맞을 때 발동되는 코드
}else{
//아무 조건에도 해당되지 않을 때 발동되는 코드
}
switch(변수)
case (변수값1):
// 행위
break; // 행위를 그만두고 switch 문을 끝내려면 break;
case (변수값2):
// 행위
// 만약 break; 를 사용하지 않았다면, case가 연속되어서 실행된다.
default:
//switch의 인자인 변수가 아무값도 해당 되지 않을 때 발동되는 코드
if(조건식){
if(조건식){
if(조건식){
....
}
}
}
// for 문 표현식
for(초기식; 조건식; 증감값;){
하고싶은 일;
}
// 아래에서 사용되는 int i 는 지역번수이므로 , 반복문 안에서만 사용 할 수 있다.
for(int i = 0; i < 10; i++){
}
// 기존에 있는 변수를 이용 할 수도 있다.
int index = 0;
for(index = 0; index < 10; index++){
}
// 반복문이 끝나면 index는 10 인채로 남아있다.
// while 문 표현식
while(조건식){ // 조건식이 만족되는 동안 반복
하고싶은 일;
한 번의 반복 마다 조건식의 증감에 영향을 주는 코드; // 없으면 무한 반복 하게 된다.
}
while(life != 0){ // life가 0이 아닌 동안 반복 >> life가 점점 줄어들다가 0이되면 종료 됨
야구 게임;
life--; // 한 번 반복할 때 마다 life 가 1씩 감소함.
}
슬슬 내용 정리를 할 여유가 없네요
| Java 6일차 객체배열, 상속 (0) | 2022.08.30 |
|---|---|
| Java 5일차 객체 (0) | 2022.08.30 |
| Java 4일차 배열 (0) | 2022.08.30 |
| Java 2일차 연산자, 메소드(함수), 메모리 개념 조금 (2) | 2022.08.30 |
| Java 1일차 변수,변수 명명 규칙,상수, 형변환 (0) | 2022.08.30 |
산술 연산자
복합 대입 연산자 ( +=, -= , *= … )
a+= >> a = a + 1
a-= >> b = b - 1
개인적으로 오른쪽 식이 저는 더 보기 좋습니다
코드는 자기가 알아보기 좋게 작성하는게 이득
증감 연산자 ( 전위 후위 )
비교 연산자 ( == . != )
논리 연산자 ( && || )
삼항 연산자 조건식 ? ‘true 값’ : ‘false 값’ >> 대입연산자로 바로 변수에 값 초기화도 가능
함수를 설명하기에 가장 친숙한 그림 마법의 함수 상자 입니다.
사과를 한 개 넣으면 막 세 개가 나오고… ㅋㅋ 😆
x 값을 넣으면 y 값으로 나온다 (일반인의 생각)
매개변수 x 를 넣으면 y값이 리턴 된다 (개발자의 생각) 😎
함수를 설명하기 전에 조금 심화 단계 일 수도 있지만
자바 프로그램의 동작 원리를 알아보겠습니다
이걸 설명하기 위해선 ‘메모리’라는 개념이 등장하는데요
컴퓨터 부품 중에 RAM 이라는게 있죠? Random Access Memory 의 약자인데 이것도 메모리입니다
음악 프로그램, 크롬, 게임 등등 무언가 프로그램을 실행하려면 운영체제에게 메모리를 할당 받아서 실행을 하게 되는데 자바 프로그램 또한 똑같습니다.
우리가 Application을 만들어서 ▶️ RUN 버튼을 누르면 프로그램에 메모리가 할당이 되는데 총 3가지 종류의 메모리가 있습니다.
이는 전역 변수와 정적 멤버 변수 static이 붙은 자료형을 저장합니다. 문제는 한 번 선언된 전역 변수는 언제 어디서든 꺼내 쓸 수 있습니다. 덕분에 개발시에 편리하지만 메모리가 계속 상주해 있습니다. 그래서 사이트가 느려지고 서버가 다운되는 경우가 발생하기도 합니다. 그래서 스태틱 메모리 영역은 정말 잘 사용해야 합니다.
기본 자료형을 생성할때 저장되는 공간이 스택 메모리 영역입니다. 데이터 값이 저장되는 공간이라고 보면 됩니다. 메소드가 실행될때 할당 되고 메소드가 종료하면 함께 종료됩니다.
추가) main 메소드도 이 저장공간 가장 첫 스택으로 실행됩니다. main이 스택에서 꺼내질 때,
프로그램이 종료 됩니다.
*생명주기 = 시작부터 종료 까지의 기간
인스턴스 생성할때 생성되는 메모리 형식입니다. new를 사용하여 객체를 생성하면 저장됩니다. 참조형 자료도 힙 메모리 영역으로 저장됩니다. 힙 참조 값은 스택 메모리 영역에서 가지고 있고 해당 객체를 통해서만 힙 메모리에 있는 인스터스들을 핸들링 할 수 있습니다.
▲ 더블 클릭하면 확대 되네요 ( 노션에서는 됐는데 티스토리 이 쓰레기 블로그 ㅠㅠ )
// *접근제한자 : 아직 배우지 않았지만. public , private 등등 이 있음.
// static 함수인 경우
접근제한자 static 반환자료형 함수이름 (매개변수, ...){
작업하고싶은 행위 마음껏 입력
return (반환자료형에 맞는 데이터);
}
// static 함수 아닌경우
접근제한자 반환자료형 함수이름 (매개변수, ...){
작업하고싶은 행위 마음껏 입력
return (반환자료형에 맞는 데이터);
}
// 반환자료형이 void 인 경우 >> return이 없음
접근제한자 void 함수이름 (매개변수, ...){
작업하고싶은 행위 마음껏 입력
}
// *매개변수의 개수는 없어도되고, 여러개여도 됨
예시)
public static void main(String[] args){
}
/*1 */public class Application{
/*2 */ public static void main(String[] args){
/*3 */ Application app = new Application();
/*4 */ System.out.println(app.plusMethod(3,5);
/*5 */ }
/*6 */
/*7 */ public int plusMethod(int a, int b){
/*8 */ return a + b
/*9 */ }
/*0 */}
메소드의 형식을 알았으니 이제 일반적인 사용 방법입니다.
형식에 맞게 자기가 선언하고싶은 클래스에서 메소드를 정의하면 되는데요 !!!
( 위 예시에서 7행 부분 )
정의는 했지만 이 함수에 접근하기 위해서는 (메모리 개념)
객체 인스턴스를 생성(new) 해야 접근할 수 있습니다.
( 위 예시에서 3행 부분 )
Application 객체의 app 인스턴스에 . (점 ) 연산자를 이용하여 접근해서
plusMethod 메소드를 사용할 수 있습니다.
( 위 예시에서 4행 app.plusMethod(3,5) 부분 )
위에 설명 했던 메모리의 개념으로 코드 예제를 한 행 씩 컴파일러에 빙의해서 해석해볼까요 ~~
2행 : main을 찾았으니 Stack 메모리에 넣어둡니다.
3행 : new 를 찾았으니 Heap 메모리에 Application 클래스의 인스턴스 app 을 넣어둡니다.
4행 : 인스턴스 app이 가지고 있는 plusMethod 함수를 출력 하는 문장이구나
app 인스턴스니까 Application클래스에 가보면 정의된 plusMethod 이름의 함수를 찾을수 있겠네
7행에 있구나 7행으로 가자
7행 : 함수 실행과 종료 → 4행으로 복귀
5행 : main 함수의 닫히는 중괄호 } 를 만나서 main 함수 종료. 스택 메모리에서 main 사라짐.
//메소드의 형식 에서 가져옴
// static 함수인 경우
접근제한자 static 반환자료형 함수이름 (매개변수, ...){
작업하고싶은 행위 마음껏 입력
return (반환자료형에 맞는 데이터);
}
// static 함수 아닌경우
접근제한자 반환자료형 함수이름 (매개변수, ...){
작업하고싶은 행위 마음껏 입력
return (반환자료형에 맞는 데이터);
}
같은 패키지 안에 있는 다른 클래스 입니다. ( Application9 , Calculator )
non static 함수 minNumberOf , static 함수 maxNumberOf
min 변수에 값을 담을 때, Calculator 클래스의 calc 인스턴스를 생성해서 Calculator의 함수에 접근함
max 변수에 값을 담을 때, 인스턴스를 만들지 않고 클래스에서 바로 함수에 접근함
굳이 인스턴스를 만들어서 static 함수에 접근하면 컴파일러가 노란줄을 긋고 경고한다.
정처기 실기에도 가끔 출제가 되는 static 개념
아직 정리 못했음 !
package com.uni.section02.method;
public class Application1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
/* 패키지와 임포트 */
/* 패키지 : 서로 관련 있는 클래스 또는 인터페이스 등을 모아 하나의 묶음(그룹)으로 단위를 구성하는 것을 말한다.
* 같은 패키지 내에서는 동일한 이름의 클래스를 만들 수 없지만, 패키지가 다르면 동일한 이름을 가진 클래스를 만들 수 도 있다.
* 클래스명은 원래 패키지명을 포함하고 있기 때문이다. 예)com.uni.section01.method.Calculator (이게 클래스명이다.)
* 지금까지 클래스명에 패키지명을 함께 사용하지 않은 이유는 동일한 패키지 내에서 사용했기 때문이다.
* 그렇기 때문에 서로 다른 패키지에 존재하는 클래스를 사용하는 경우에는 클래스명 앞에 패키지명을 명시해서 풀 클래스 이름으로 사용해야 한다.
* */
// non static 메소드
com.uni.section01.method.Calculator calc = new com.uni.section01.method.Calculator();
int min = calc.minNumberOf(30, 20);
System.out.println(min);
// static 메소드
int max = com.uni.section01.method.Calculator.maxNumberOf(30, 20);
System.out.println(max);
}
}
패키지 경로명을 import 하지 않으면 손으로 일일이 타자로 입력 해야 한다.
package com.uni.section02.method;
import com.uni.section01.method.Calculator; // 추가된 코드
public class Application2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
/* 패키지와 임포트 */
/* 임포트 : 서로 다른 패키지에 존재하는 클래스를 사용하는 경우 패키지명을 포함한 풀 클래스 이름을 사용해야 한다.
* 하지만 매번 다른 클래스의 패키지명까지 기술하기에는 번거롭다.
* 그래서 패키지명을 생략하고 사용할 수 있도록 한 구문이 import 구문이다.
* import는 package 선언문과 class 선언문 사이에 작성하며
* 어떠한 패키지 내에 있는 클래스를 사용할 것인지에 대해 미리 선언하는 효과를 가진다.
* */
Calculator calc = new Calculator();
int min = calc.minNumberOf(30, 20);
System.out.println("두 수중 최소값은 " + min);
int max = Calculator.maxNumberOf(30, 20);
System.out.println("두 수중 최대값은 " + max);
}
}
상단부에 패키지 경로를 import 하게 된다면 편하게 사용할 수 있다 !
복합 대입 연산자 ( +=, -= , *= … )
a+= >> a = a + 1
a-= >> b = b - 1
개인적으로 오른쪽 식이 저는 더 보기 좋습니다
코드는 자기가 알아보기 좋게 작성하는게 이득
증감 연산자 ( 전위 후위 )
비교 연산자 ( == . != )
논리 연산자 ( && || )
삼항 연산자 조건식 ? ‘true 값’ : ‘false 값’ >> 대입연산자로 바로 변수에 값 초기화도 가능
| Java 6일차 객체배열, 상속 (0) | 2022.08.30 |
|---|---|
| Java 5일차 객체 (0) | 2022.08.30 |
| Java 4일차 배열 (0) | 2022.08.30 |
| Java 3일차 함수 조금, 스캐너, 제어문, 반복문 (1) | 2022.08.30 |
| Java 1일차 변수,변수 명명 규칙,상수, 형변환 (0) | 2022.08.30 |
컴파일 : 인간이 작성한 코드를 컴퓨터가 알아듣게 번역하는 작업
컴파일러
자바 언어를 해석하는놈은 자바컴파일러 ( javac )
이놈의 특징 >> 컴파일 하고 나면 class 파일이 생성 된다.
두 가지 파일을 직접 열어보시면 감이 오실거에요.
.java 파일 >> notepad++ 로 실행하면 인간의 언어가 보인다. ( 컴퓨터의 입장에서 이해 불가능)
.class 파일 >> notepad++ 로 실행하면 기계어가 보인다. ( 컴퓨터의 입장에서 이해 가능 )
JDK ( Java Development Kit )
여러가지 종류가 있는데 제일 대표적인 JDK는
OpenJDK , Oracle JDK 1.8 (일점팔) , Oracle JDK 11 (십일)
작업 경로 : C\Workspace
개발 도구 : 이클립스 설치
https://www.eclipse.org/downloads/packages/release/2021-06/r
2021-06 R | Eclipse Packages
517 MB 519,828 DOWNLOADS Tools for developers working with Java and Web applications, including a Java IDE, tools for JavaScript, TypeScript, JavaServer Pages and Faces, Yaml, Markdown, Web Services, JPA and Data Tools, Maven and Gradle, Git, and more. Cli
www.eclipse.org
설치 끝났으면
window - preference
spelling , workspace UTF-8 인코딩 설정 (필 수 )
01_firstproject > 아무것도 건들지 말고 Finish
모듈 Dont Create 클릭
우클릭 - new - class
패키지 : 유사한 클래스를 묶어주는 역할, 항상 맨위에 선언 해주어야 함
main 메소드 ( 메소드 = 함수 같은뜻입니다 )
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("Hi~~~~");
}
함수 이름이 main 인 놈을 말합니다 ( 함수가 무엇이냐… 그것은 다음에 알아봅시다 )
한 프로젝트에 반드시 이 녀석(메인 함수) 한 개 는 있어야 프로젝트가 실행이 됩니다
주석 사용 방법 ( 매우 매우 매우 매우 매우 중요 )
코드가 지저분 하게 보이긴 하지만 거의 매 함수, 매 변수마다 주석을 해주는게
기억하기도 편하고 아무튼 유용합니다 !!!!!!!!!
무조건 주석 많이 하세요
주석 안하는 개발자는 멍청한 개발자 입니다 ~
//한줄 주석하기
/*
통째로
주석
하기
*/
한 줄 주석 단축키
Ctrl + /
여러줄 주석 단축키 (드래그 해서 블록지정 한 코드만)
Ctrl + Shift + /
자료형
논리 boolean
문자 char, String
정수형 int
실수형 double
새 프로젝트 생성
사진은 없는데 프로젝트 이름 02_variable
새 클래스 생성
Application2
package com.uni.section01.literal;
public class Application2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
/* 값을 직접 연산하여 출력할 수 있다.
* 값의 형태에 따라 사용할 수 있는 연산자의 종류와 연산의 결과가 달라진다.
* */
/* 1. 숫자와 숫자의 연산 */
/* 1-1. 정수와 정수의 연산 */
/* 수학적으로 사용하는 사칙연산에 추가로 나머지를 구하는 연산(mod)을 사용할 수 있다. */
System.out.println("================ 정수와 정수의 연산 =================");
System.out.println(123 + 456); // 579
System.out.println(123 - 23); // 100
System.out.println(123 * 10); // 1230
System.out.println(123 / 10); // 12
System.out.println(123 % 10); // 3
/* 1-2. 실수와 실수의 연산 */
/* 실수끼리의 연산도 수학에서 사용하는 사칙연산에 나머지를 구하는 연산(mod)을 사용할 수 있다. */
System.out.println("================ 실수와 실수의 연산 =================");
System.out.println(1.23 + 1.23); // 2.46
System.out.println(1.23 - 0.23); // 1.0
System.out.println(1.23 * 10.0); // 12.3
System.out.println(1.23 / 10.0); // 0.123
System.out.println(1.23 % 1.0); // 0.2299999999
/* 1-3. 정수와 실수의 연산 */
/* 정수와 실수의 연산도 수학에서 사용하는 사칙 연산에 나머지를 구하는 연산(mod)을 사용할 수 있다. */
/* 정수와 실수 연산의 결과는 항상 실수가 나온다. */
System.out.println("================ 정수와 실수의 연산 =================");
System.out.println(123 + 0.5); // 123.5
System.out.println(123 - 0.5); // 122.5
System.out.println(123 * 0.5); // 61.5
System.out.println(123 / 0.5); // 246.0
System.out.println(123 % 0.5); // 0.0
/* 2. 문자의 연산 */
/* 2-1. 문자와 문자의 연산 */
/* 문자끼리의 연산도 사칙연산에 mod 연산까지 가능하다. */
/* 지금은 계산 결과가 왜 이렇게 나왔는지 보다 연산이 사용 가능하다는 것에 집중하자!! */
// ASCII CODE (아스키코드) 라는 2바이트 문자들을 숫자로 표현한 국제적인 표준이 있습니다.
// 있다는것만 알아두세요 !!
System.out.println("================ 문자와 문자의 연산 =================");
System.out.println('a' + 'b'); //195
System.out.println('a' - 'b'); //-1
System.out.println('a' * 'b'); //9506
System.out.println('a' / 'b'); //0
System.out.println('a' % 'b'); //97
/* 2-2. 문자와 정수의 연산 */
/* 문자에 정수를 연산하는 것도 가능하다. */
/* 이 쯤 되면 문자 'a'는 숫자 97과 같다라는 것을 알 수 있다. */
/* 컴퓨터는 문자를 인식하지 못하고 숫자로만 인식할 수 있기 때문에, 모든 문자에 대응되는 숫자들이 매칭이 되어 있다.*/
System.out.println("================ 문자와 정수의 연산 =================");
System.out.println('a' + 1); // 98
System.out.println('a' - 1); // 96
System.out.println('a' * 2); // 194
System.out.println('a' / 2); // 48
System.out.println('a' % 2); // 1
/* 2-3. 문자와 실수의 연산 */
/* 실수도 숫자이기 때문에 정수의 연산처럼 모든 연산이 가능하다. */
/* 단, 결과는 실수 형태로 나오게 된다. (아까 위에서 했던 정수와 실수의 연산 결과를 생각해보자) */
System.out.println("================ 문자와 실수의 연산 =================");
System.out.println('a' + 1.0); // 98.0
System.out.println('a' - 1.0); // 96.0
System.out.println('a' * 2.0); // 194.0
System.out.println('a' / 2.0); // 48.5
System.out.println('a' % 2.0); // 1.0
/* 여기서 결론은 문자는 내부적으로 숫자 취급을 한다는 것이다! */
/* 결국 지금까지 연산은 숫자끼리의 연산을 본 것이고, 숫자(정수 혹은 실수) 형태의 값은
수학의 사칙연산과 mod연산이 전부 가능하다. */
/* 3. 문자열의 연산 */
/* 3-1. 문자열과 문자열의 연산 */
/* 문자열과 문자열의 '+' 연산 결과는 문자열 합치기(이어 붙이기)가 된다. */
/* 문자열은 '+' 연산 외에 다른 연산을 사용하지 못한다. */
System.out.println("================ 문자열과 문자열의 연산 =================");
System.out.println("hello" + "world"); //helloworld
//System.out.println("hello" - "world"); //에러 발생
//System.out.println("hello" * "world"); //에러 발생
//System.out.println("hello" / "world"); //에러 발생
//System.out.println("hello" % "world"); //에러 발생
/* 3-2 문자열과 다른 형태의 값 연산*/
/* 문자열과의 연산은 '+' 연산만 가능하다. */
/* 연산 결과는 다른 형태의 값들도 문자열로 취급하여 문자열 이어붙이기(문자열 합치기) 결과가 나오게 된다. */
// 문자열과 무언가를 더하면 모두 문자열로 취급이 된다 !!!
System.out.println("================ 문자열과 다른 형태의 값 연산 =================");
/* 3-2-1. 문자열과 정수의 연산 */
System.out.println("helloworld" + 123); // helloworld123
/* 3-2-2. 문자열과 실수의 연산 */
System.out.println("helloworld" + 123.456); // helloworld123.456
/* 3-2-3. 문자열과 문자의 연산 */
System.out.println("helloworld" + 'a'); // helloworlda
/* 3-2-4. 문자열과 논리값의 연산 */
System.out.println("helloworld" + true); // helloworldtrue
/* 주의사항 : 숫자로 된 문자열 형태의 값은 '+' 연산의 결과가 문자열 합치기 결과가 되는 것에 주의하자! */
System.out.println("================ 문자열 형태의 숫자 값 '+' 연산 =================");
System.out.println("123" + "456"); // 123456
/* 4. 논리값 연산 */
/* 4-1. 논리값과 논리값 연산 */
/* 논리값 끼리의 연산은 모든 연산자 사용이 불가능하다. */
//System.out.println(true + false); //에러 발생
//System.out.println(true - false); //에러 발생
//System.out.println(true * false); //에러 발생
//System.out.println(true / false); //에러 발생
//System.out.println(true % false); //에러 발생
/* 4-2. 논리값과 정수의 연산 */
/* 논리값과 정수의 연산은 모든 연산자 사용이 불가능하다. */
//System.out.println(true + 1); //에러 발생
//System.out.println(true - 1); //에러 발생
//System.out.println(true * 1); //에러 발생
//System.out.println(true / 2); //에러 발생
//System.out.println(true % 2); //에러 발생
/* 4-3. 논리값과 실수의 연산 */
/* 논리값과 실수의 연산은 모든 연산자 사용이 불가능하다. */
//System.out.println(true + 1.0); //에러 발생
//System.out.println(true - 1.0); //에러 발생
//System.out.println(true * 1.0); //에러 발생
//System.out.println(true / 2.0); //에러 발생
//System.out.println(true % 2.0); //에러 발생
/* 4-4. 논리값과 문자의 연산 */
/* 논리값과 문자의 연산은 모든 연산자 사용이 불가능하다. */
/* 이유는, 문자는 내부적으로 숫자 취급을 하기 때문에 결국 논리값과 숫자의 연산과 동일한 의미이다. */
//System.out.println(true + 'a'); //에러 발생
//System.out.println(true - 'a'); //에러 발생
//System.out.println(true * 'a'); //에러 발생
//System.out.println(true / 'a'); //에러 발생
//System.out.println(true % 'a'); //에러 발생
/* 4-5. 논리값과 문자열의 연산 */
/* 논리값과 문자열의 연산은 '+'연산만 사용 가능하다. */
/* 이유는, 위에서 테스트 해 본 문자열 합치기가 되는 원리와 동일하다. */
System.out.println("================ 논리와 문자열의 연산 =================");
System.out.println(true + "a"); // truea //문자열 합치기 됨
//System.out.println(true - "a"); //에러 발생
//System.out.println(true * "a"); //에러 발생
//System.out.println(true / "a"); //에러 발생
//System.out.println(true % "a"); //에러 발생
}
}
허허
int age; // 선언만 하는 것은 의미 없음
int age;
age = 100; // 무언가 값을 담는 행위를 ‘초기화’라고 한다.
실제로 개발자들에게 가장 어려운 일이 무엇이냐? 라고 물어보는 설문조사가 있었습니다
https://www.cio.com/article/220287/the-9-hardest-things-programmers-have-to-do.html
(영어 주의)
그 중 1위가 바로 ‘변수명 작명 하기’ 였습니다
그 만큼 변수든 뭐든 이름을 처음 지을때 잘 지어놓는게 정말 정말 정말 중요한데요
그래서 개발자들은 이름 짓기에 대한 최소한의 규칙을 만들었습니다.
매 단어 단어 마다 첫 번째 글자를 대문자로 작성하는 방식입니다.
(단, 첫 번째 글자는 소문자 !!!)
예시)
iAmVariable
resultSum
goToCentumStudyCafe
마치 변수의 이름이 낙타 등처럼 꾸불꾸불 하죠?? 그래서 낙타 규칙이라는 이름이 붙었답니다.
모든 글자를 소문자로 작성하는 대신 단어 사이를 ( _ : 언더바 ) 를 붙여서 표기하는 방식입니다.
예시)
i_am_variable
eatting_launch
i_am_very_sleepy
이것도 뱀 처럼 생겻다고 해서 뱀 규칙 ~
가끔 괴짜 개발자들은 자기가 만든 변수에 자기 이름을 넣는 괴상한 행동을 하기도 한다네요
ldy_i_want_to_go_home
그러지 맙시다 !!!!!!!!!
/* 상수란?
상수도 명명규칙이 있습니다
/* 상수의 명명 규칙 / / 상수의 명명 규칙은 변수의 명명규칙과 컴파일 에러를 발생시키는 규칙은 동일하다.
⭐ 1. 모든 문자는 영문자 대문자 혹은 숫자만 사용한다.
⭐ 2. 단어와 단어 연결은 언더스코어(_)를 사용한다.
상수 명명 예시)
FINAL DOUBLE PI = 3.141592 // π (파이 , 원주율)
FINAL INT SECPERHOUR = 3600 // 1시간당 초
형 변환도 꽤나 중요한 개념입니다.
지금은 자료형이라는 좁은 범위에서 고무 찰흙 놀이를 하고 있지만
나중에는 여러가지 자료형(자신이 직접 만드는 경우도 다수 = 클래스)을 관리할 때,
엄청나게 많은 형 변환을 해야 하기 때문에 …
위에 두 문장만 알고 넘어가십쇼 !!!!!!!!
| Java 6일차 객체배열, 상속 (0) | 2022.08.30 |
|---|---|
| Java 5일차 객체 (0) | 2022.08.30 |
| Java 4일차 배열 (0) | 2022.08.30 |
| Java 3일차 함수 조금, 스캐너, 제어문, 반복문 (1) | 2022.08.30 |
| Java 2일차 연산자, 메소드(함수), 메모리 개념 조금 (2) | 2022.08.30 |