1. ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ
์๋ฐ๋ ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ ์ค ํ๋์ด๋ค. ๊ทธ๋ ๋ค๋ฉด ๊ฐ์ฒด๋ ๋ฌด์์ผ๊น?
๊ฐ์ฒด๋ ๋ฌผ๋ฆฌ์ ์ผ๋ก ์กด์ฌํ๊ฑฐ๋ ์ถ์์ ์ผ๋ก ์๊ฐํ ์ ์๋ ๊ฒ๋ค ์ค์์ ์์ฑ์ ๋ํ๋ด๊ณ , ์๋ณ์ด ๊ฐ๋ฅํ ๊ฒ์ ์๋ฏธํ๋ค. ์ด๋, ๊ฐ์ฒด๊ฐ ๊ฐ์ง ์์ฑ์ Field, attribute๋ผ๊ณ ํ๊ณ , ๊ฐ์ฒด๊ฐ ํํ๋ ๋์์ Method๋ผ๊ณ ํ๋ค.
๊ฐ์ฒด๋ค์ ๋ ๋ฆฝ์ ์ผ๋ก ์กด์ฌํ๋ฉฐ, ์๋ก Method๋ฅผ ํตํด ์ํธ์์ฉ์ ํ๊ฒ ๋๋ค. ๋ฉ์๋ ํธ์ถ์ ํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ๋ค.
University university = new University(); // University ํด๋์ค์ constructor ํธ์ถ ๋ฐ ๋ฉ๋ชจ๋ฆฌ ์์ฑ
int courseNum= university.course();// University์ method์ธ course ๋ถ๋ฌ์ค๊ธฐ + return ๊ฐ courseNum
return_variable = ClassName.methodName(Parameter_variable);
/*
return variable: ๋ฆฌํด ํ๋ ๊ฐ์ ์ง์
ClassName: ์ ์์์์ university์ ํด๋น, Class๋ฅผ ์ง์ ํ๋ ์ด๋ฆ์ ์ค์ ํ์ฌ ํ ํด๋์ค์์ ์ฌ์ฉ
parameter variable: method ๋ด์์ ์ฌ์ฉํ ๊ฐ์ method ๋ฐ์์ ๊ฐ์ ธ์ค๋ ๊ฒ
*/
2. ํด๋์ค, ์ธ์คํด์ค, NEW ์ฐ์ฐ์
- ํด๋์ค(Class): ํ๋, ๋ฉ์๋ ์ ์
[ํด๋์ค์ ์ฉ๋]
1. ๋ผ์ด๋ธ๋ฌ๋ฆฌ(API: Application Program Interface) ์ฉ๋ : ๋ค๋ฅธ ํด๋์ค์์ ์ด์ฉํ ๋ชฉ์ ์ผ๋ก ์ค๊ณ
2. ์คํ์ฉ๋ : ex) main()
-> ๋๋ถ๋ถ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ฉ๋์ด๊ณ , ์คํ์ฉ์ ํ๋์ธ ๊ฒฝ์ฐ๊ฐ ๋๋ถ๋ถ์ด๋ค.
[๊ตฌ์ฑ]
1. Field(Attribute) : ๊ฐ์ฒด์ ๊ณ ์ ์ ํน์ง์ ๋ํ๋ด๋ ๊ฐ
2. Constructor : new ์ฐ์ฐ์๋ก ํธ์ถ ๋๋ ๋ธ๋ก, ๊ฐ์ฒด๋ฅผ ์ด๊ธฐํ
3. Method : ๊ฐ์ฒด์ ๋์์ ๋ํ๋ด๋ ๋ธ๋ก
4. Association : ๋ค๋ฅธ ๊ฐ์ฒด์ ์ฃผ์๋ฅผ ๊ฐ๊ณ ์๋ ๊ฒ[์ถ์ฒ: ํ๊ต ๊ฐ์]
5. Component( = aggregation ) : ์์ํ๋ ์์๋ค[์ถ์ฒ: ํ๊ต ๊ฐ์]
- ์ธ์คํด์ค(Instance): ํด๋์ค๋ก๋ถํฐ ๋ง๋ค์ด์ง ๊ฐ์ฒด
ํด๋์ค๊ฐ ์ค๊ณ๋๋ผ๊ณ ํ๋ค๋ฉด, ์ธ์คํด์ค๋ ์ค๊ณ๋๋ฅผ ๋ฐํ์ผ๋ก ๋ง๋ค์ด์ง ๋ฌผ๊ฑด์ด๋ผ๊ณ ํ ์ ์๋ค.
4์ผ์ฐจ ์ฐธ์กฐ ํ์ ๊ธ์์๋ ์ค๋ช ์ ํ์ง๋ง, new ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํด์ ํด๋์ค๋ก๋ถํฐ ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ค.
- new ์ฐ์ฐ์
: constructor ์ฐ๊ฒฐ(class ๋ผ๋ฆฌ ์ฐ๊ฒฐํ์ฌ ๊ฐ์ฒด ์์ฑ), ๋ฉ๋ชจ๋ฆฌ ํ ๋น, ์์(return)์ฃผ์ ๋ฐํ ์ญํ ์ ์ํํ๋ค.
new ์ฐ์ฐ์๊ฐ ๊ฐ์ฒด๋ผ๋ฆฌ ์ฐ๊ฒฐํ์ฌ ์ฐ๊ฒฐ๋ ๊ฐ์ฒด์ ๋ฒ์ง๋ฅผ ๋ฆฌํดํ๊ณ , ์ด๋ฅผ ์ ์ฅํ๋ฉด ํ์ ๊ทธ ๋ฒ์ง๋ก ์ด๋ํ์ฌ ๊ฐ์ฒด๋ฅผ ์์ ๋กญ๊ฒ ์ฌ์ฉ์ด ๊ฐ๋ฅํ ๊ฒ์ด๋ค.
- ๊ฐ์ ํด๋์ค๋ฅผ ์ฐธ์กฐํ๋๋ผ๋, new ์ฐ์ฐ์๋ฅผ ์ด์ฉํ์ฌ ๊ฐ๊ฐ ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ค๋ฉด ์ด๋ ์๋ก ๋ค๋ฅธ ๊ฐ์ฒด๋ฅผ ๊ฐ๊ณ ์๋ ๊ฒ๊ณผ ๊ฐ๋ค. ๋ค์ ์์ ๋ฅผ ํตํด ํ์ธํด๋ณด์. ( ์๋ ์์ ๋ 4์ผ์ฐจ ๊ณต๋ถ์๋ ๊ฒน์น๋ค. )
public static void main(String[] args) {
University university0 = new University();// ๊ฐ๊ฐ ๊ฐ์ ํด๋์ค๋ฅผ ์ฐธ์กฐํ์ง๋ง
University university1 = new University();// ์๋ก ๋ค๋ฅธ ์ธ์คํด์ค๋ฅผ ์์ฑํ ๊ฒ์ด๋ค.
}
3. Field(Attribute)
์์ฑ์, ๋ฉ์๋ ์ค๊ดํธ({}) ๋ธ๋ก ๋ด๋ถ์๋ ์ ์ธ์ด ๋ ์ ์๋ค. ์์ฑ์์ ๋ฉ์๋ ์ค๊ดํธ ๋ด๋ถ๋ field๊ฐ ์๋ local variable์ด ๋๋ ๊ฒ์ด๋ค.
variable(๋ณ์)์ ์ข ๋ฅ: local, parameter, return
4. ์์ฑ์(Constructor)
์์ฑ์๋ new ์ฐ์ฐ์๋ก ํด๋์ค๋ก๋ถํฐ ๊ฐ์ฒด๋ฅผ ์์ฑํ์ฌ ๊ฐ์ฒด ์ด๊ธฐํ๋ฅผ ํ ์ ์๋๋ก ๋ด๋นํ๋ค.
๊ฐ์ฒด ์ด๊ธฐํ: ํ๋๋ฅผ ์ด๊ธฐํํ๊ฑฐ๋ ๋ฉ์๋๋ฅผ ํธ์ถํด์ ๊ฐ์ฒด ์ฌ์ฉํ ์ค๋น๋ฅผ ํ๋ ๊ฒ์ ์๋ฏธ
- Defalut Constructor(๊ธฐ๋ณธ ์์ฑ์) : ํด๋์ค ์์ฑ ์ ๊ธฐ๋ณธ์ ์ผ๋ก ์์ฑ๋๋ constructor
Class_Name(parameter variable){
}
private int a;
private int b;
private int c;
// ์์ฑ์ ์ค๋ฒ๋ก๋ฉ(overLoading): ํ Class ์ ๋งค๊ฐ๋ณ์๋ฅผ ๋ค๋ฅด๊ฒ ํ๋Constructor๊ฐ ์ฌ๋ฌ๊ฐ
public University(int a, int b) {
this.a = a;
this.b = b;
}
public University(int a, int b, int c) {
this.a = a;
this.b = b;
this.c = c;
}
public static void main(String[] args) {
University university0 = new University(1, 2);// ๊ฐ๊ฐ ๊ฐ์ ํด๋์ค๋ฅผ ์ฐธ์กฐํ์ง๋ง
University university1 = new University(3, 4);// ์๋ก ๋ค๋ฅธ ์ธ์คํด์ค๋ฅผ ์์ฑํ ๊ฒ์ด๋ค.
}
- this(): ํ ํด๋์ค ๋ด์์ ๋ค๋ฅธ ์์ฑ์ ํธ์ถ
์์ฑ์ ์ค๋ฒ๋ก๋ฉ์ด ๋ง๊ณ ์ค๋ณต๋ ์ฝ๋ฉ์ด ๋ง๋ค๋ฉด this()๋ฅผ ํตํด์ ๋ฆฌํํ ๋ง์ ์๋ํ ์ ์๋ค.
private int a;
private int b;
private int c;
// ์์ฑ์ ์ค๋ฒ๋ก๋ฉ(overLoading): ํ Class ์ ๋งค๊ฐ๋ณ์๋ฅผ ๋ค๋ฅด๊ฒ ํ๋Constructor๊ฐ ์ฌ๋ฌ๊ฐ
public University(int a, int b) {
this.a = a;
this.b = b;
}
public University(int a, int b, int c) {
this(a, b); //this(); ํจ์ ์ฌ์ฉ, a,b ๊ฐ ์ค๋ณต๋๊ธฐ ๋๋ฌธ
this.c = c;
}
5. Method
์ ์ธ๋ถ(Head)์ ์คํ๋ธ๋ก(Body)์ผ๋ก ๊ตฌ์ฑ
- Head(์ ์ธ๋ถ): ๋ฆฌํดํ์ , ๋ฉ์๋ ์ด๋ฆ, ๋งค๊ฐ ๋ณ์ ์ ์ธ
- Body
๋งค๊ฐ๋ณ์ ์ ์ธ์ ์์๋ ๋ค์๊ณผ ๊ฐ๋ค.
public static void main(String[] args) {
Calculator calculator = new _250Calculator();
int sum = calculator.plus(2, 3);
System.out.println(sum); // 5
}
public class Calculator {
public Calculator() {
}
public int plus(int i, int j) {
int sum = i + j;
return sum;
}
}
๊ทธ๋ ๋ค๋ฉด, ๋งค๊ฐ๋ณ์์ ๊ฐ์๋ฅผ ๋ชจ๋ฅผ๊ฒฝ์ฐ๋ ์ด๋ป๊ฒ ํด์ผํ ๊น? ๋งค๊ฐ๋ณ์๋ฅผ ๋ฐฐ์ด ํ์ ์ผ๋ก ์ ์ธ์ ํด์ผํ๋ค.
public static void main(String[] args) {
Child child = new Child();
int sum = child.plus(new int[] {1, 3, 5, 7, 9});
System.out.println(sum);
}
public class Child {
public Child() {
}
public int plus(int[] array) {
int sum = 0;
for(int i = 0; i<array.length; i++) {
sum+=array[i];
}
return sum;
}
}
๋ฉ์๋๋ ์์ฑ์์ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ฉ์๋ ์ค๋ฒ๋ก๋ฉ์ด ๊ฐ๋ฅํ๋ค.(method ๋ค๋ผ๋ฆฌ ์ด๋ฆ์ ๊ฐ์ง๋ง, ๋งค๊ฐ๋ณ์์ ํ์ , ์์ ์ค ํ๋๊ฐ ๋ฌ๋ผ์ผ ํ๋ค.-> constructor overloading ๊ณผ ๊ฐ์ ์กฐ๊ฑด)
[์ถ์ฒ]
ํผ๊ณต์๋ฐ P 212~269
'Programming Language > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Java 6์ผ์ฐจ ๊ณต๋ถ(์์, Method ์ฌ์ ์) (0) | 2022.02.21 |
---|---|
Java 6์ผ์ฐจ ๊ณต๋ถ(Instance, static, singleton, ์ ๊ทผ ์ ํ์, Getter & Setter) (0) | 2022.02.21 |
Java 5์ผ์ฐจ ๊ณต๋ถ(์ฐธ์กฐ ํ์ : ์ด๊ฑฐํ์ ) (0) | 2022.01.31 |
Java 4์ผ์ฐจ ๊ณต๋ถ(์ฐธ์กฐ ํ์ ) (0) | 2022.01.30 |
Java 3์ผ์ฐจ ๊ณต๋ถ(์กฐ๊ฑด๋ฌธ, ๋ฐ๋ณต๋ฌธ) (0) | 2022.01.29 |