//설계용 클래스(라이브러리 클래스)에서는 메인메서드를 작성하지 않습니다.
public class a_Pen {
//객체의 속성을 필드(클래스 멤버변수)라고 부릅니다.
String color;
int price;
//객체의 기능들을 메서드라고 부릅니다.
void write() {
System.out.println(color + "색 글을 씁니다.");
}
void priceInfo() {
System.out.println(color + "펜의 가격은" + price + "원 입니다.");
}
}
public class b_PenFactory {
public static void main(String[] args) {
// 펜의 기능과 속성을 사용하려면 설계도(class)를 바탕으로 펜 객체를 생성해야 합니다.
//객체 생성 문법: new 클래스이름();
a_Pen redPen = new a_Pen();
//참조연산자(.)를 통해 객체의 속성과 기능을 사용할 수 있습니다.
redPen.color = "빨강";
redPen.price = 500;
a_Pen bluePen = new a_Pen();
bluePen.color = "파랑";
bluePen.price = 600;
redPen.write();
bluePen.write();
redPen.priceInfo();
bluePen.priceInfo();
System.out.println("----------------------------");
System.out.println(redPen);
System.out.println(bluePen);
}
}
/*
# 멤버 변수(field, class member variable)
1. 클래스 블록에 선언된 변수를 의미합니다.
2. 메모리의 Heap영역에 저장되며 값을 초기화하지 않아도 각 데이터 타입의 기본값으로 자동 초기화됩니다.
3. 객체를 가리키고 있는 레퍼런스변수가 사라지거나 주소값을 잃어버리면 메모리에서 가비지 컬렉터(gc)에 의해 자동 제거됩니다.
# 지역 변수(local variable)
1. 메서드나 생성자 블록 내부에서 선언된 변수를 의미합니다.(지금까지 해왓던 변수 다 메인메서드 안에서 한거잖아)
2. 메모리의 stack 영역에 저장되며,선언된 블록을 벗어나면 메모리에서 자동으로 제거됩니다.
3. 값을 초기화하지 않으면 변수를 사용할 수 없습니다.
*/
public class c_MemberLocalVariable {
int a; // 멤버변수
void printNumber(int c) { // int c : 매개변수
int b = 1; // 지역변수
System.out.println("멤버변수: " + a);
System.out.println("지역변수: " + b);
System.out.println("매개변수: " + c);
}
public static void main(String[] args) {
c_MemberLocalVariable m = new c_MemberLocalVariable();
m.printNumber(4);
//출력시 멤버변수:0, 지역변수:1, 매개변수:4가 나온다.
}
}
public class d_Phone {
String model;
String color;
int price;
/*
# 생성자 (constructor)
1. 생성자는 객체를 생성하는 역할을 하며, 그렇기 때문에 클래스 내부에 반드시 하나 이상 존재해야 합니다.
2. 생성자를 하나도 선언하지 않았을 경우에는 JVM이 자동으로 매개변수가 존재하지 않는 기본 형태의 생성자(default constructor)를 만들어 줍니다.
3. 생성자는 반드시 클래스 이름과 대/소문자까지 동일하게 작성하여 선언하며, 리턴 타입이 존재하지 않습니다.
4. 생성자 내부에는 객체가 생성되자마자 해야 할 로직들을 기술할 수 있습니다.
*/
// 생성자 선언.
d_Phone(){
System.out.println("1번 생성자 호출!");
model = "애니콜";
color = "회색";
price = 20000;
}
/*
# 생성자 오버로등(중복)
1. 생성자는 중복해서 여러개 만들 수 있습니다.
2. 단, 생성자의 매개변수의 타입, 갯수, 순서가 달라야 합니다.
*/
d_Phone(String pModel, String pColor){
System.out.println("3번 생성자 호출!!!");
model = pModel;
color = pColor;
}
d_Phone(String pModel){
System.out.println();
System.out.println("2번 생성자 호출!");;
model = pModel;
color = "블루";
price = 1000000;
}
d_Phone(String pModel, String pColor, int pPrice){
System.out.println("4번 생성자 호출!");
model = pModel;
color = pColor;
price = pPrice;
}
void showSpec() {
System.out.println("*** 핸드폰의 정보 ***");
System.out.println("# 모델명: " + model);
System.out.println("# 색상: " + color);
System.out.println("# 가격: " + price);
}
}
public class e_PhoneFactory {
public static void main(String[] args) {
d_Phone basic = new d_Phone();
basic.showSpec();
d_Phone galaxys10 = new d_Phone("갤럭시s10");
galaxys10.showSpec();
d_Phone iPhoneXs = new d_Phone("아이폰Xs","스페이스그레이");
iPhoneXs.showSpec();
d_Phone xiaomi = new d_Phone("흥미노트","에메랄드", 400000);
xiaomi.showSpec();
}
}
public class f_namewhat {
/*
static String name = "홍길동";
static int age = 30;
static int tall = 175;
static void info() {
System.out.printf("이름: %s\n나이: %d\n키:%dcm\n", name, age, tall);
System.out.println();
}
static String name2 = "김철수";
static int age2 = 25;
static int tall2 = 180;
static void info2() {
System.out.printf("이름: %s\n나이: %d\n키:%dcm\n", name2, age2, tall2);
}
static String name3 = "박영희";
static int age3 = 20;
static int tall3 = 168;
static void info3() {
System.out.printf("이름: %s\n나이: %d\n키:%dcm\n", name3, age3, tall3);
}
*/
/*
- 객체를 생성하지 않았을 때의 예시를 파악하여 Person이라는 클래스를 생성하여 중복되는 속성들과 기능들을 선언하세요.
- main 메서드에 실제 객체를 생성한 후 출력 예시와 똑같이 실행시켜 보세요.
출력예시>
이름: 홍길동
나이: 30
키:175cm
이름: 김철수
나이: 25
키:180cm
이름: 박영희
나이: 20
키:168cm
* */
public static void main(String[] args) {
g_Person kimchi = new g_Person("홍길동",30, 175);
g_Person kimchi2 = new g_Person("김철수",25, 180);
g_Person kimchi3 = new g_Person("박영희",20, 168);
kimchi.info();
kimchi2.info();
kimchi3.info();
}
}
public class g_Person {
String name;
int age;
double key;
g_Person(){} //기본생성자를 사용할 일 있으면 직접 선언해주어야 함
g_Person(String pName, int pAge, double pKey){
System.out.println("1번 생성자 호출!");
name = pName;
age = pAge;
key = pKey;
}
void info() {
System.out.println("*** 사람의 정보 ***");
System.out.println("# 이름: " + name);
System.out.println("# 나이: " + age);
System.out.println("# 키: " + key);
}
}
/*
- 클래스들을 묶음으로 관리하려면 패키지 선언을 해야합니다.
- 패키지 선언은 반드시 코드의 최 상단부에 위치하여야 합니다.
*/
package fruits;
public class h_Apple {
public h_Apple() {
System.out.println("fruits패키지의 Apple 객체 생성!");
}
}
package reference;
public class p_User {
String pw;
p_User(String uPw){
pw = uPw;
}
}
package reference;
import java.util.Scanner;
public class q_CompareStr {
public static void main(String[] args) {
String name = "홍길동";
String name2 = "홍길동";
System.out.println(name == name2);
p_User kim = new p_User("abc1234");
Scanner sc = new Scanner(System.in);
System.out.println("비밀번호를 입력하세요: ");
String password = sc.next();
System.out.println("내가 방금 입력한 비번: " + password);
System.out.println("가입 당시 설정한 비번: " + kim.pw);
System.out.println("kim.pw == password : " + (kim.pw == password)); // == --> false값으로 나옴 연산자로 비교하면 주소값을 비교한다.(당연히 false 나옴)
System.out.println("---------------------");
System.out.println("kim.equals(password):" + (kim.pw.equals(password))); // 따라서, equals메소드를 참고해야함
System.out.println(kim);
System.out.println(password.hashCode());
}
}
package test;
import fruits.*; //객체 한꺼번에 생성하는 것
import juice.*;
import Car.sedan.m_Sonata;
public class test {
public static void main(String[] args) {
fruits.h_Apple a1 = new fruits.h_Apple();
juice.o_Apple a2 = new juice.o_Apple();
fruits.h_Apple a3 = new fruits.h_Apple();
h_Apple a5 = new h_Apple(); // 패키지가 다르고 클래스 이름이 동일할 경우 패키지의 경로를 써넣어주어야 함
i_Banana b1 = new i_Banana();
j_Melon m1 = new j_Melon();
m_Sonata s = new m_Sonata();
java.util.Scanner sc = new java.util.Scanner(System.in);
}
}
package inherit.good;
/*
# 부모 클래스, 상위 클래스(Parent, Super class)
- 데이터를 다른 클래스에게 상속하는 클래스를 부모 클래스라고 부릅니다.
- 상속을 사용하면 데이터를 물려받는 클래스에게 부모클래스의 멤버변수와 메서드가 상속됩니다. 단, 생성자는 상속되지 않습니다.
*/
public class Player {
String name;
int level;
int atk;
int hp;
// 공통되는 부분만 넣도록 한다.
void characterInfo() {
System.out.println("*** 캐릭터 정보 ***");
System.out.println("#아이디: " + name);
System.out.println("#레벨: " + level);
System.out.println("#공격력: " + atk);
System.out.println("#체력: " + hp);
}
}
package inherit.good;
public class MainClass {
public static void main(String[] args) {
Warrior w1 = new Warrior();
w1.name = "전사1";
w1.level = 1;
w1.atk = 3;
w1.hp = 50;
w1.rage = 60;
w1.characterInfo();
Mage m1 = new Mage();
m1.name = "마법사1";
m1.level = 15;
m1.atk = 4;
m1.hp = 45;
m1.skill = "fuck!";
m1.characterInfo();
Hunter h1 = new Hunter();
h1.name = "헌터1";
h1.level = 441;
h1.atk = 23144;
h1.hp = 5335;
h1.characterInfo();
}
}
package inherit.good;
/*
# 자식클래스, 하위클래스(Child, Sub class)
- 부모 클래스로부터 멤버변수와 메서드를 물려받는 클래스를 자식 클래스라고 부릅니다.
- 상속을 적용시키려면 자식 클래스의 선언부의 클래스 이름 뒤에 키워드 extends를 쓰고 물려받을 부모 클래스의 이름을 적어줍니다.
*/
public class Warrior extends Player {
int rage;
void characterInfo() {
System.out.println("*** 캐릭터 정보 ***");
System.out.println("#아이디: " + name);
System.out.println("#레벨: " + level);
System.out.println("#공격력: " + atk);
System.out.println("#체력: " + hp);
System.out.println("#분노: " + rage); // 자식클래스에서 새롭게 정의가 된게 출력이 된다.
}
}
package inherit.good;
public class Mage extends Player {
String skill;
void characterInfo() {
System.out.println("*** 캐릭터 정보 ***");
System.out.println("#아이디: " + name);
System.out.println("#레벨: " + level);
System.out.println("#공격력: " + atk);
System.out.println("#체력: " + hp);
System.out.println("#기술: " + skill); // 자식클래스에서 새롭게 정의가 된게 출력이 된다.
}
}
package inherit.good;
public class Hunter extends Player{
}
package overriding;
public class Calculator {
/*
- Computer 클래스를 Calculator 클래스를 상속받습니다.
- Calculator 클래스에 있는 calcCircle 메서드를 Computer 클래스가 오버라이딩해서 좀더 정확한 원의 넓이를 표현하고 싶습니다.(3.1415926535)
- Computer클래스에 calcCircle을 오버라이딩 한 후 Main Class에서 각각의 원 넓이를 출력해 보세요.
(반지름이 5인 원의 넓이).
*/
double calcCircle(int r) {
return r * r * 3.14;
}
}
package overriding;
public class Computer extends Calculator {
/*
# 메서드 재정의 규칙
1. 반드시 상속이 전제되어야 한다.
2. 반드시 반환 유형이 같아야 한다.
3. 메서드 이름이 같아야 한다.
4. 매개 변수 선언이 일치해야 한다.
5. 접근 제한자는 같거나 더 제한이 없어야 합니다.
*/
double calcCircle(int r) {
return r * r * 3.1415926535; //리턴값 정의 다시하는거임
}
}
package overriding;
public class Main {
public static void main(String[] args) {
Calculator cal = new Calculator();
System.out.println("# 계산기로 계산한 원의 넓이");
System.out.println("->" + cal.calcCircle(5));
System.out.println();
Computer com = new Computer();
System.out.println("# 컴퓨터로 계산한 원의 넓이");
System.out.println("->" + com.calcCircle(5));
}
}
package overloading;
public class Calculator {
/*
# 오버로딩 : 하나의 클래스 내부에서 같은 이름을 가진 메서드나 생성자를 여러 개 선언할 수 있게 해주는 문법.
- 오버로딩의 적용 조건
1. 매개변수의 데이터 타입이 다를 것! or
2. 매개변수의 전달 순서가 다를 것! or
3. 매개 변수의 갯수가 다를 것!
4. 반환유형은 오버로딩에 영향을 주지 않습니다.
void inputData(int a) {
System.out.println("정수 1개가 전달됨!");
}
void inputData(int a, int b) {
System.out.println("정수 2개가 전달됨!"); //된다!
}
void inputData(int a, int b) {
System.out.println("정수 2개가 전달됨!");
}
void inputData(String s) {}
void inputData(int a, double d) {}
void inputData(double d, int a) {}
// void inputData(int number) {} //(X) 불가능 - 이미 매개값 하나받는 애가 있는데 똑같아(a나 number나 똑같잖아)
// int inputData(int number) { (X)
// return 0;
*/
int calcRectArea(int a) {
return a * a;
}
int calcRectArea(int width, int height) {
return width * height;
}
}
package overloading;
public class MainClass {
public static void main(String[] args) {
/*
- Calculator 클래스에 calcRectArea() 메서드를 선언하여
길이를 하나만 전달하면 정사각형의 넓이를 리턴,
길이를 두개 전달(가로, 세로)하면 직사각형 넓이를 리턴하도록 오버로딩을 사용하여 메서드를 선언하세요.
*/
Calculator cal = new Calculator();
System.out.println("정사각형의 넓이: " + cal.calcRectArea(5));
System.out.println("직사각형의 넓이: " + cal.calcRectArea(10, 20));
}
}
댓글 영역