작성 : 2024. 4. 8.
자바 언어를 배우는 순서 및 목록
- 자바의 특징
- 코드 구조
- 변수와 자료형
- 구문규칙 및 주석
- 자료형 ( 숫자, 불, 문자, 문자열, StringBuffer, 배열, 리스트, 맵, 집합, 상수집합, 형변환과 final)
- 제어문
- 객체지향 - 클래스, 매서드, 호출
- 상속
- 생성자
- 인터페이스
- 다향성
- 추상클래스
- 입출력
- 패키지
- 접근 제어자
- 스태틱
- 예외처리
- 스레드
- 함수형 프로그래밍
지난 주 클래스까지 배움. 자료형을 다 다뤄보진 않아서 알고 넘어가는 게 필요할 것 같다.
미리 책을 살펴봤을 때 ‘다향성’ 부분이 이해가 잘 안되던데 수업에서는 어떻게 다룰지 잘 들어봐야겠다.
- 매개 변수 - call by reference (참조형 (주소값)) : 클래스명, 배열
// 일단 클래스를 하나 만들기, 주소값을 사용하기 위해 참조할 주소가 되는 클래스
public class Data {
// call by reference (참조형 (주소값)) : 클래스명, 배열
// 0408 수업
// 맴버변수 하나 저장
int x;
}
// call by reference (참조형 (주소값)) : 클래스명, 배열
public class Function {
// 클래스명의 변수를 썼다 -> 참조형, 배열 사용, 참조방식
void change2(Data d) {
d.x = 1000;
}
// 배열
void arrChange(int[] arr) {
arr[0] = 10;
}
+ 메서드의 정의 방식 2가지
// 인스턴스 메서드
// 클래스 메서드
void instanceMethod() {
System.out.println("인스터스 메서드 호출");
}
static void staticMethod() {
System.out.println("클래스 메서드 호출");
}
}
// call by reference (참조형 (주소값)) : 클래스명, 배열
import java.util.Arrays;
public class FunctionTest {
// 클래스 메서드는 생성 없이 사용할 수 있다
// 공유의 개념!
Function.staticMethod(); // 클래스 메서드 호출
Function f = new Function();
Data d = new Data();
d.x = 10;
f.change2(d);
System.out.println(d.x); // 1000
int[] arr = {1, 2, 3, 4, 5};
f.arrChange(arr);
System.out.println(Arrays.toString(arr)); // [10, 2, 3, 4, 5]
f.instanceMethod(); // 인스터스 메서드 호출
f.staticMethod(); // 클래스 메서드 호출
}
public class Function2 {
// 맴버변수와 메서드 간의 호출관계에 대해 알아보자
int iv;
static int cv;
void instanceMethod1() {
iv = 10;
cv = 20;
}
void instanceMethod2() {
instanceMethod1();
staticMethod1(); // 호출가능
}
static void staticMethod1() {
// iv = 30; // 생성 전에는 메모리 X, 객체를 생성하는 시점에 만들어짐.
cv = 40; //static 한 메서드는 static 변수를 쓸 수 있다.
}
static void staticMethod2() {
// instanceMethod1(); // 불가능
staticMethod1(); // 가능
// 인스턴스는 인스턴스끼리 할당시점이 같고
// static 은 static 끼리 할당시점이 같다
}
}
public class Function2 {
// 맴버변수와 메서드 간의 호출관계에 대해 알아보자
int iv;
static int cv;
void instanceMethod1() {
iv = 10;
cv = 20;
}
void instanceMethod2() {
instanceMethod1();
staticMethod1(); // 호출가능
}
static void staticMethod1() {
// iv = 30; // 생성 전에는 메모리 X, 객체를 생성하는 시점에 만들어짐.
cv = 40; //static 한 메서드는 static 변수를 쓸 수 있다.
}
static void staticMethod2() {
// instanceMethod1(); // 불가능
staticMethod1(); // 가능
// 인스턴스는 인스턴스끼리 할당시점이 같고
// static 은 static 끼리 할당시점이 같다
}
}
public class Function3Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
Function3 f3 = new Function3();
int x = 10;
int y = 20;
System.out.println(f3.add(x,y));
int[] arr = {1, 2, 3, 4, 5};
//f3.add(arr); // void 함수는 실행할 수 없음.
// return 받기 전까진 알 수 없음
// 실행하면 오류가 남.
System.out.println(f3.add(arr));
}
}
- 가변인자
메서드를 호출하고자 할때 인수의 갯수가 가변적일 때 가변인수를 처리하면 손 쉽게 처리할 수 있다.
참조)
[Java]가변인자(varargs)을 왜 쓰는거지? 쉬운 이해와 활용
가변인자(varargs) ...String 0 .개요 가변인자는 메서드의 매개변수를 동적으로 처리할 수 있도록 해준다. 이를 사용하면 메서드 호출 시 전달되는 인자의 개수를 동적으로 변경할 수 있다. public void
hirodevelodiary.tistory.com
public class Function4 {
// 가변인자를 받는 형태
void varArgs(int... args) { // int ...args -> 배열 형식
for (int num : args) {
System.out.println(num);
}
}
}
// 수업이 끝나고 나면 목차 정리를 하고 구체적으로 정리해보새요.
// 메소드에 대해 배운 것들!
// 1. 기본형식 (4개)
// 2. return 특징
// 3. 오버로딩
// 4. 가변인자
// 5. call by value / call by reference
public class Function4Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
Function4 f4 = new Function4();
f4.varArgs(1, 2, 3, 4, 5);
int[] arr = { 6, 7, 8, 9, 10 };
f4.varArgs(arr);
}
}
- 생성자
기능과 속성
속성과 연결되어져서 값을 다룰 때 사용할 수 있는 개념!
public class Car {
// 속성
// 생성자 : **** 멤버변수의 초기화 ( 대상 : 인스턴스 변수 )
// 클래스 변수는 생성자를 사용하지 않음
// 클래스명과 대소문자 동일하게 작성된다
// 메서드처럼 생겼지만 리턴 타입이 없다
// 직접 호출해서 사용할 수 없다
// 객체를 생성할때 1번만 호출 가능
// 속성 밑에 작성
// 생성자 오버로딩이 가능, 매개변수와 타입값을 다르게
// 기능
// 속성
String color;
String gearType;
int door;
// 생성자
Car() {
color = "red";
gearType = "auto";
door = 4;
}
// 생성자가 없어도 기본값이 설정되어 있어 값이 나옴 (null, 0 과 같은)
// Car() {
//
// } <- 역할이 없는 기본 생성자, 단독인 경우 생략이 가능하다!
// 무조건 생략 가능한 게 아니라 생성자 오버로딩 시 생략은 판단해야 한다.
// 속성과 같게
Car(String color) {
this.color = color; // 이름이 같을 경우, 구분을 위해 this. 붙이기
}
Car(String color, String gearType) {
this.color = color;
this.gearType = gearType;
}
Car(String color, String gearType, int door) {
this.color = color;
this.gearType = gearType;
this.door = door;
}
}public class CarTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 객체 생성 생성자를 호출하는 부분!
Car c = new Car();
System.out.println(c.color);
System.out.println(c.gearType);
System.out.println(c.door);
}
}public class Car {
// 속성
// 생성자 : **** 멤버변수의 초기화 ( 대상 : 인스턴스 변수 )
// 클래스 변수는 생성자를 사용하지 않음
// 클래스명과 대소문자 동일하게 작성된다
// 메서드처럼 생겼지만 리턴 타입이 없다
// 직접 호출해서 사용할 수 없다
// 객체를 생성할때 1번만 호출 가능
// 속성 밑에 작성
// 생성자 오버로딩이 가능, 매개변수와 타입값을 다르게
// 생성자 간 상호 호출 가능
// 기능
// 속성
String color;
String gearType;
int door;
// 생성자
// Car() {
// color = "red";
// gearType = "auto";
// door = 4;
// }
// 생성자가 없어도 기본값이 설정되어 있어 값이 나옴 (null, 0 과 같은)
Car() {
// 생성자 간 상호 호출 가능
// this.color = "pink"; 이렇게 하는 것 X
this("pink", "auto", 2);
} //<- 역할이 없는 기본 생성자, 단독인 경우 생략이 가능하다!
// 무조건 생략 가능한 게 아니라 생성자 오버로딩 시 생략은 판단해야 한다.
// 생성자간 호출 : this()
// this() : 생성자의 가장 위쪽에 작성!
// 속성과 같게
Car(String color) {
// this.color = color; // 이름이 같을 경우, 구분을 위해 this. 붙이기
this(color, "auto", 5); // 생성자 간 상호 호출 가능
}
Car(String color, String gearType) {
this.color = color;
this.gearType = gearType;
}
Car(String color, String gearType, int door) {
this.color = color;
this.gearType = gearType;
this.door = door;
}
}
public class CarTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 객체 생성 생성자를 호출하는 부분!
Car c = new Car();
System.out.println(c.color);
System.out.println(c.gearType);
System.out.println(c.door);
Car c2 = new Car("red");
System.out.println(c2.color);
System.out.println(c2.gearType);
System.out.println(c2.door);
Car c3 = new Car("blue" , "auto");
System.out.println(c3.color);
System.out.println(c3.gearType);
System.out.println(c3.door);
Car c4 = new Car("black" , "auto", 4);
System.out.println(c4.color);
System.out.println(c4.gearType);
System.out.println(c4.door);
}
}
- 초기화 순서 자동초기화 - 명시적 초기화 - 초기화 블럭 - 생성자 - 생성 후 초기화
- 변수 생성자 메서드 - 클래스에서 작성되는 세 가지를 다 배웠습니다.
-개념과 코드를 같이 정리해서 공부하기
-개념을 적어두고 그 아래 코드를 써보며 공부
매개변수를 써라. 하면 못쓰겠다.
public class Student {
// 내 풀이 (답이 정수로만 나왔다..)
// 속성
// 생성자
// 기능
String name;
int ban;
int no;
int kor;
int eng;
int math;
int getTotal(int kor, int eng, int math) {
return ( kor + eng + math );
}
int getAverage(int kor, int eng, int math) {
return ( (kor + eng + math)/3 );
}
// int 가 아니라 float 를 쓰는 것이 조건.
// 그렇게 하지 않았기 때문에 답이 정수로만 나옴
-----------------------------------------------------------------------------
// 강사님 풀이 1)
String name;
int ban;
int no;
int kor;
int eng;
int math;
int getTotal() {
return kor + eng + math;
}
float getAverage() {
return (int) (getTotal() / 3.0f * 10 + 0.5f) / 10f ;
}
}
// 강사님 풀이 2)
String name;
int ban;
int no;
int kor;
int eng;
int math;
Student() {
}
Student(String name, int ban, int no, int kor, int eng, int math ) {
this.name = name;
this.ban = ban;
this.no = no;
this.kor = kor;
this.eng = eng;
this.math = math;
}
// Source에 들어가서 자동 생성 가능
// 보통 위처럼 두 개의 생성자를 만들어 사용함
int getTotal() {
return kor + eng + math;
}
float getAverage() {
return (int) (getTotal() / 3.0f * 10 + 0.5f) / 10f;
}
}public class StudentTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 내 풀이
Student S = new Student();
int kor = 70;
int eng = 12;
int math = 97;
System.out.println("총 점수의 합 : " + S.getTotal(kor, eng, math) + "점");
float f = S.getAverage(kor, eng, math);
System.out.println("평균 점수 : " + f + "점");
-----------------------------------------------------------------------------
// 강사님 풀이
Student s = new Student();
s.name = "yuna";
System.out.println(s.name);
Student s2 = new Student("yuna", 1, 1, 62, 85, 100);
int total = s2.getTotal();
float avg = s2.getAverage();
System.out.printf("총점 : %d\n평균 : %f" , total , avg);
}
}배우는 내용이 너무 많아서 언제 이걸 꺼내 사용해야 하는 건지 감이 안잡힌다..
- 롬북사용
// 자동으로 생성자 만드는 법
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
@NoArgsConstructor
@AllArgsConstructor
이제 여러 개의 클래스를 만들고 그 안에서 관계성을 가지고 작업해 볼 예정.
(부모) class —— 관계 맺음—— (자식) class
변수 3개 — 상속 ———> 변수 원래 2개 + 상속 3개 = 총 5개 사용 가능
생성자 생성자
메서드 3개 — 상속 ———> 메서드 원래 2개 + 상속 3개 = 총 5개 사용 가능최소 2명 이상의 자식이 있을 때 ‘상속’이라는 개념 사용
부모가 변수가 3개 있다고 한 자식한테 3개를 준다고 부모 클래스가 사라지는 것이 아님.
똑같이 여러 자식 클래스에게 상속할 수 있음 (코드의 재사용성)
-공통요소를 부모 클래스에 정의 → 똑같이 자식에게 물려줌
-왜 이렇게 해야하나? → 동일한 코드를 반복적으로 정의하는 것을 막기 위해. 코드를 관리할 때 유리해짐.
부모클래스 - 추상화 클래스 ( 변수와 메서드를 상속하는 클래스)
// 상속하는 법
public class Parent {
// 상속
// 두개 이상의 클래스와 부모와 자식을 개념으로 관계를 맺는 것
// 상속의 대상은 변수와 메서드이다.
// 단일 상속만 가능하다.
// 상속에 상속은 가능하다 (다중 상속)
int age;
void add(int x, int y) {
System.out.println(x + y);
}
}// 상속받는 법
public class Child extends Parent {
}public class InheritanceTest {
public static void main(String[] args) {
Child c = new Child();
c.age = 10;
System.out.println(c.age);
}
}
// 상속
public class Tvs {
String color;
boolean power;
int channel;
public void power() {
power = !power;
}
public void channelUp() {
channel++;
}
public void channelDown() {
channel--;
}
}// 상속
public class TvCaption extends Tvs {
}public class Tv3D extends Tvs {
// 클래스를 만들 때도 Superclass 에서 상속 가능
}여기까지 배운 시점에서 전의 내용을 내가 확실하게 알지 않으면 더 이상 따라가기 힘들 것이라고 판단,
생활 코딩을 보며 부족한 개념을 보충하기로 한다.
부족했던 개념 :
상수의 데이터 타입)
상수의 데이터 타입 - 생활코딩
상수 변수는 변하는 값을 의미한다. 그 대척점에 있는 것이 상수인데, 상수(常數, constant)란 변하지 않는 값을 의미한다. 아래의 코드 중에서 a는 변수이고, 1은 상수이다. int a = 1; 변수 a는 대입
www.opentutorials.org
자바에서 데이터 타입이 정수인 상수는 int, 실수형 상수는 double의 데이터 타입.
float 형 변수를 사용할 때는?
-float 형이라는 것을 명시해주면 됨.
float a = 2.2F;
--- F는 이 기호 앞의 숫자가 float 데이터 타입이라는 것을 명시적으로 표현하는 방법이다.자습 시간 반복문까지 읽고 있었음
→ 반복문부터는 실습하며 다시 읽어볼 것!
'2024_UIUX 국비 TIL' 카테고리의 다른 글
| UIUX _국비과정 0411 (0) | 2024.05.29 |
|---|---|
| UIUX _국비과정 0409 (0) | 2024.05.29 |
| UIUX _국비과정 0405 (0) | 2024.05.29 |
| UIUX _국비과정 0404 (0) | 2024.05.29 |
| UIUX _국비과정 0403 (0) | 2024.05.29 |