메인 클래스

Person p = new Person("cha", 20);

• Person class 객체

Student s1 = new Student("kim",30,1);
s1.eat();
s1.sleep();
s1.study();
s1.exam();
s1.showInfo();
System.out.println(s1);

• Student class 객체

Student pts = new PartTimeStudent("choi", 22, 5, 9620, 20);
// Student 눈에는 Student의 멤버만 보인다.
pts.showInfo();
pts.sleep();
pts.eat();
pts.study();
pts.exam();
//pts.work();

• Student 타입의 PartTimeStudent class 객체
• Student class를 참조변수로 PartTimeStudent class를 자료형 변수로 사용한 경우.
• Student class나 Student의 상위 클래스의 메소드만 사용할 수 있다. (오버라이딩 가능/PartTimeStudent class 메소드 사용 불가능)
• PartTimeStudent class에는 work 메소드가 있지만 Student class에 work 메소드가 없기 때문에 사용 시 에러가 난다.

fct(new Person("사람",10));
fct(new Student("학생",20,1));
fct(new PartTimeStudent("근로학생",30,2,9000,10));

• fct 메소드 사용

private static void fct(Person person) {
person.showInfo();
System.out.println("-----------");
}

• 다형성
• fct 메소드에 매개변수로 Person 객체를 생성한다.
• 자식(하위) 객체를 생성할 때, 변수 타입을 부모(상위) 클래스로 사용할 수 있다.
• 단, 부모(상위) 객체를 생성할 때, 자식(하위) 클래스를 타입으로 사용할 수는 없다.

부모(조상, 상위) 클래스

// 필드(특성)
private String name;
private int age;

• 자식 클래스가 공유하는 필드

// 생성자
public Person() {
	System.out.println("Person() call");
	this.name = "noName";
	this.age = 1;
}
public Person(String name, int age) {
	this.name = name;
	this.age = age;
}

• 기본 생성자로 객체를 생성하면 자동으로 name은 noName, age는 1로 값이 들어간다.
• 자식 클래스에서 생성할 때, 호출하여 사용할 수 있다.

// 메소드(행위)
public void sleep() {
	System.out.println("사람은 8시간 잔다.");
}
public void eat() {
	System.out.println("사람은 세끼를 먹는다.");
}
public void showInfo() {
	System.out.println("name: "+name);
	System.out.println("age : "+age);
}

• 해당 메소드를 자식 클래스에서 호출하여 사용할 수 있다.

@Override
public String toString() {
	String str = ("name: "+name+"\nage : "+age);
	return str;
}

• 기본적으로 toString 메소드가 숨겨진 상태로 존재하는데 불러서 고쳐서 사용하는 것을 오버라이딩이라고 한다.

자식(후손, 하위) 클래스

// 필드
// name, age, sleep(), eat()
private int sNo;

• 두번째 줄의 주석처리 부분은 부모 클래스에서 상속한 필드 및 메소드

// 생성자
public Student(String name, int age, int sNo) {
	super(name,age);	// 부모 클래스 호출
	this.sNo = sNo;
}

• super(); 은 부모 클래스를 호출하는 코드.
• 자식 생성자를 먼저 호출하고 자식 생성자에서 부모 생성자를 호출하지만 실행되는 순서는 부모>자식 순으로 한다.
  1. 자식생성자 호출
  2. 부모생성자 호출>실행
  3. 자식생성자 실행
  4. 자식 객체 생성
• ex) super(); == Person(); / super(name, age); == Person(name, age);
• super로 부모 클래스를 호출했기 때문에 this.sNo만 저장하면 된다.

// 메소드
public void study() {
	System.out.println("학생은 공부를 한다.");
}
public void exam() {
	System.out.println("학생은 시험을 본다.");
}

/* 빈 칸에 두고 ctrl+spece bar 누르면 Override(재정의) 할 메소드가 뜸! */

// 메소드 재정의(오버라이딩)
@Override
public void sleep() {
	super.sleep();	//Person의 sleep();
	System.out.println("GAME, TV를 줄인다.");
}
@Override
public void eat() {
	System.out.println("학생은 두끼를 먹는다.");
}
@Override
public void showInfo() {
	super.showInfo();	// Person.showInfo();
	System.out.println("sNo : "+sNo);
}
@Override
public String toString() {
	String str = "\nsNo : "+sNo;
	return super.toString()+str;
	/* super.toString(); == 부모의 toString을 호출
	 * toString(); == 본인의 toString을 호출
	 * toString에서 return toString을 하면 에러가 남 */
}

• 메소드 위에 @Override가 있으면 메소드에 오류가 있을때 걸러준다.
• 부모 클래스에 있는 메소드를 해당 클래스에 맞춰 재정의하는 것이 오버라이딩이다.
• toString에서 return toString을 하면 본인의 메소드를 계속 재실행하기 때문에 에러가 난다.

자식(후손, 하위)의 자식 클래스

// 필드
private int pay;
private int workTime;

// 생성자
public PartTimeStudent(String name, int age, int sNo, int pay, int workTime) {
	super(name, age, sNo);
	this.pay = pay;
	this.workTime = workTime;
}

• super();을 통해 부모 생성자를 호출하여 저장하고, 본인 필드에 값을 저장한다.

// 메소드
public void work() {
	System.out.println("근로학생은 일을 한다.");
	workTime++;
}

// 오버라이딩(메소드 재정의)
@Override
public void showInfo() {
	super.showInfo();	// Student.showInfo();
	System.out.println("주급 : "+(pay*workTime));
}
@Override
public void sleep() {
	System.out.println("근로학생은 4시간 잔다.");
}
@Override
public String toString() {
	String str = "\n주급 : "+(pay*workTime);
	return super.toString()+str;
}

• 맨 위의 메소드는 부모메소드를 호출하고, 추가적으로 출력할 내용을 추가했다.

Scanner sc = new Scanner(System.in);
int sum = 0;

while(true) {
	System.out.print("숫자입력> ");
	int num = sc.nextInt();
	
	if(num == 0 || num == -1) {
		System.out.println("최종 누적합계: "+sum);
		break;
	}else {
		sum+=num;
	}
}

• for문으로 돌리려고 했는데 선생님이 while문이 보기에도 좋고 적합하다고 해서 while문으로 바꿔서 코드를 짰다. 이 이야길 안 듣고 코드를 먼저 짰다면 for문으로 했을 것 같다.
• for문: 반복횟수가 정해져 있을 경우 적합
• while문: 반복횟수가 정해져 있지 않을 경우 적합

1.

while(true) {
	System.out.print("정수입력(종료는 0 or -1): ");
	int num = sc.nextInt();
	
	if(num == 0 || num == -1) {
		break;
	}
	sum+=num;
}
System.out.println("최종 누적합계는 "+sum+"입니다.");

2. 반복횟수를 정하고, 상황에 따라 누적 합계 출력

int cnt = 0;
boolean flag = false;
while(cnt<5) {
	System.out.print("정수입력(종료는 0 or -1): ");
	int num = sc.nextInt();
	
	if(num == 0 || num == -1) {
		flag = true;
		break;
	}
	sum+=num;
	cnt++;
}
if(flag) {
	System.out.println("break 후 최종 누적합계는 "+sum+"입니다.");
}else {
	System.out.println("5번 누적 후 최종 누적합계는 "+sum+"입니다.");

 3. do-while문 이용하여 2번 출력

cnt = 0;
flag = false;
do {
	System.out.print("정수입력(종료는 0 or -1): ");
	int num = sc.nextInt();
	
	if(num == 0 || num == -1) {
		flag = true;
		break;
	}
	sum+=num;
	cnt++;
}while(cnt<5);
if(flag) {
	System.out.println("break 후 최종 누적합계는 "+sum+"입니다.");
}else {
	System.out.println("5번 누적 후 최종 누적합계는 "+sum+"입니다.");
}

String str1 = new String("hello");
String str2 = new String("hello");
String str3 = "hello";

• str1, str2, str3 전부 참조값이 다르다.
• new를 붙이면 새로 만드는 것이기 때문에 같은 문자열이더라도 참조값이 달라진다.

1. == 비교: 참조값을 비교

if(str1 == str2) {
	System.out.println("참조값이 같다.");
}else {
	System.out.println("참조값이 다르다.");
}

2. .equals 비교: 문자열을 비교

if(str1.equals(str2)) {
	System.out.println("문자열이 같다.");
}else {
	System.out.println("문자열이 다르다.");
}

3. .equals 비교를 안 쓰고 문자열을 비교하는 케이스

switch(str1) {
case "hello": case "Hello":
	System.out.println("안녕하세요");
	break;
case "bye": case "Bye":
	System.out.println("잘가요");
	break;
default:
	System.out.println("몰라요");
}

4. toUpperCase / toLowerCase

switch(str1.toUpperCase()) {
case "HELLO":
	System.out.println("안녕하세요");
	break;
case "BYE":
	System.out.println("잘가요");
	break;
default:
	System.out.println("몰라요");
}

• toUpperCase는 문자열을 대문자로 바꿔준다.
• toLowerCase는 문자열을 소문자로 바꿔준다.

int len = "안녕하세요".length();
System.out.println("문자열의 길이: "+len);

• .length는 문자열의 길이를 세준다.

String str = "    Good-Morning    ";
System.out.println(str.trim());

• .trim은 문자열의 공백을 지워준다.

String str2 = str.concat(" everyone");
System.out.println("str2: "+str2);

• str+" evryone" 과 동일

String str5 = String.valueOf(1000)+String.valueOf(2000);
//		str5 = 1000+""+2000+"";	//위와 같음
str5+=1;	//100020001
int num = Integer.parseInt(str5)+1;	//100020002
System.out.println(num);

String str = """
		강아지가 "멍멍" 짖는다.
		C:\\work\\a.txt 열기""";

• 큰 따옴표(")를 세개 쓰고 엔터 친 이후 word를 사용하듯이 글을 적으면 그대로 출력된다.
• 역슬래시(\)의 경우, 한번 더 역슬래시를 적으면 오류없이 제대로 출력 가능

출력 ㄱ

public static void main(String[] arg) {
	int[] arr = new int[10000000];
	new Student();
	Student.scName = "인천대";
	Student.showTitle();
	
	Student kim = new Student("kim",1);
	kim.showStuInfo();
	Student lee = new Student("lee");
	lee.showStuInfo();
		
	Student cha = new Student(10);
	cha.showStuInfo();
	
	Student noname = new Student();		
}

// 클래스 메소드
public static void main(String[] arg){

}

•  main도 클래스 메소드로 한 클래스에 하나만 존재할 수 있는 메소드다.

int[] arr = new int[10000000];
new Student();
Student.scName = "인천대";
Student.showTitle();

• 배열과 class 객체를 생성해봤다.
• 배열: int[] arr = new int[];
• 객체: new Student();
• 객체 값 지정: Student.scName = "인천대";
• 객체 메소드: Student.showTitle();

//Student kim = new Student();
//kim = null;
//kim.setName("Kim");
//kim.setsNo(1);
Student kim = new Student("kim",1);
kim.showStuInfo();
Student lee = new Student("lee");
lee.showStuInfo();
	
Student cha = new Student(10);
cha.showStuInfo();

Student noname = new Student();

• 객체의 값을 지정하고, showStuInfo 메소드를 통해 출력도 진행했다.
• null: 아무 값도 가지고 있지 않다.

// 인스턴스 변수
static String scName = "인하공전";

// 인스턴스 변수_정보은닉
private int sNo;	//이 클래스 밖에서는 접근할 수 없게 하기 위해
//public int sNo;		//이 클래스 밖 어디서도 접근할 수 있도록 하기 위해
private String name;

• 클래스의 인스턴스 변수는 정보은닉을 하는 것이 좋다.
• private int sNo: 같은 클래스 내에서만 접근 가능 (클래스에는 private를 붙일 수 없음)
• public int sNo: 접근 제한 없음

// 클래스 변수 / 인스턴스에 할당되는 변수가 아니라 클래스에 할당되는 변수)
/*
 final변수는 이름이 무조건 대문자. 값을 바꾸려고 하면 에러.
 클래스 변수이기 때문에 final static은 new SCNAME()이 아닌 SCNAME으로만 사용
 */

//생성자
public Student() {
	name = "noname";
	sNo = -1;
}
public Student(String name) {
	this.name = name;
}
public Student(int sNo) {
	this.sNo = sNo;
}
public Student(String name, int sNo) {
	this.name = name;
	this.sNo = sNo;
}

• 매개변수를 아무것도 받지 않으면, 없다는 것을 알리기 위해 name을 noname으로 설정하고, sNo는 -1로 설정한다.
• this: 현재 실행중인 인스턴스의 참조변수

public int getsNo() {
	return sNo;
}
public void setsNo(int sNo) {
	if(sNo<0) return;	//경계검사
	this.sNo = sNo;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public String getScName() {
	return scName;
}
public void setScName(String scName) {
	this.scName = scName;
}

• set/get 메소드
• set 메소드에 if문으로 경계검사를 할 수 있다. 위의 상황에서는 sNo가 0보다 작을 경우에는 리턴한다.
• 마지막의 setScName은 this.scName에서 노란색 밑줄이 쳐지는데, 이거는 클래스변수를 set메소드에 넣어서 나는 경고다. 무시하고 실행해도 정삭작동 된다. (클래스변수는 보통 임의로 변경하지 않으므로 set메소드가 필요없음)

public void showStuInfo() {
	if(sNo==0) {
		System.out.println("\t"+name+"\t"+scName);
	}else if(name == null){
		System.out.println(sNo+"\t\t"+scName);
	}else {
		System.out.println(sNo+"\t"+name+"\t"+scName);
	}
}

•  print를 할 때 조건문을 넣어서 해당하는 상황에 따라 다르게 출력되도록 했다.
• 만약 sNo가 0이라면 즉, sNo를 입력하지 않거나 0을 입력했다면 sNo를 출력하지 않도록 했다.
• 만약 name이 null이라면 즉, name을 입력하지 않았다면 name을 출력하지 않도록 했다.
• 만약 그렇지 않다면 즉, sNo도 name도 값이 있다면 전부 출력하도록 했다.

public static void showTitle() {
	System.out.println("=====================");
	System.out.println("\t"+scName+" 학생명단");
	System.out.println("=====================");
}

• 클래스 메소드
• 인스턴스와 상관없는 일을 하는 메소드
• 이 메소드 안에 System.out.println(name); 라는 코드를 넣게 된다면 인스턴스와 관련이 있기 때문에 에러가 난다.

public static void main(String[] args) {
	SimpleAdder sa = new SimpleAdder();
	sa.adder(10);
	sa.adder(20);
	sa.adder(30);
	System.out.println(sa.getTotalNum());
}

// 체이닝
public static void main(String[] args) {
	SimpleAdder sa = new SimpleAdder()
	sa.adder(10).adder(20).adder(30);
	System.out.println(sa.getTotalNum());
}

• 위의 코드와 아래의 코드는 동일하게 돌아가서 최종 60을 출력하게 된다.
• 아래의 코드처럼 메소드를 연이어서 쓰는 것을 체이닝이라고 한다.

public class SimpleAdder {
	private int totalNum;
	
	public SimpleAdder adder(int num) {
		this.totalNum += num;
		return this;
	}
	
	public int getTotalNum() {
		return totalNum;
	}
}

•  return this;는 자신(원본)을 반환한다.

public class Ex03 {
	public static void main(String[] args) {
		int boxVolume = boxVolume(3,3,3);	//가로,세로,높이
		System.out.println("박스 부피: "+boxVolume);	//27
		boxVolume = boxVolume(5,5);	//높이생략 / 생략하면 무조건 1
		System.out.println("박스 부피: "+boxVolume);	//25
		boxVolume = boxVolume(7);	//세로, 높이 생략
		System.out.println("박스 부피: "+boxVolume);	//7
	}
	

	private static int boxVolume(int i) {
		int volume = i;
		return volume;
	}
	private static int boxVolume(int i, int j) {
		int volume = i*j;
		return volume;
	}
	private static int boxVolume(int i, int j, int k) {
		int volume = i*j*k;
		return volume;
	}
}

//쌤이 하신것
private static int boxVolume(int width, int length, int height) {
	return width*length*height;
}
private static int boxVolume(int width, int length) {
	return boxVolume(width,length,1);	//앞의 메소드를 호출
}
private static int boxVolume(int width) {
	return boxVolume(width,1,1);
}

• main메소드 아래에서 메소드를 만들어서 클래스를 만드는 대신 사용할 수 있다.
• return에서 바로 계산하여 보내도 된다.

// a팀 패키지
package aTeam;
public class Circle {
	public Circle() {
		System.out.println("A팀의 Circle");
	}
	public void showCircleInfo() {
		System.out.println("A팀의 showCircleInfo");
	}
}

// b팀 패키지
package bTeam;
public class Circle {
	public Circle() {
		System.out.println("B팀의 Circle");
	}
	public void showInfo() {
		System.out.println("B팀의 showInfo");
	}
}

• 자바의 클래스는 무조건 패키지에 들어있어야 한다.
• 패키지를 선택하지 않고 클래스를 만들면 default 패키지에 들어가게 된다. (default를 권장하지 않음)

import aTeam.Circle;

public class ShapeMain {
	public static void main(String[] args) {
		Circle cir = new Circle();
		cir.showCircleInfo();
		System.out.println("-------------------");
		bTeam.Circle cir2 = new bTeam.Circle();
		cir2.showInfo();
	}
}

• 같은 프로젝트 내에서라면 a팀의 패키지의 Circle만 import해왔지만 b팀의 패키지의 Circle도 사용할 수 있다.

String name = "kim";
String name2 = "kim";
//name == name2: 참조값이 같다.
//name.equals(name2): 문자열이 같다.

name = "kim"
name2 = new String("kim");
//name == name2: 참조값이 다르다.
//name.equals(name2): 문자열이 같다.

name = new String("kim");
name2 = new String("kim");
//name == name2: 참조값이 다르다.
//name.equals(name2): 문자열이 같다.

name = "kim";
name2 = "cha";
//name == name2: 참조값이 같다.
//name.equals(name2): 문자열이 다르다.

name = "kim"
name2 = new String("cha");
//name == name2: 참조값이 다르다.
//name.equals(name2): 문자열이 다르다.

name = new String("kim");
name2 = new String("cha");
//name == name2: 참조값이 다르다.
//name.equals(name2): 문자열이 다르다.

• ==: 참조값을 비교
• .equals: 문자열을 비교

Point p = new Point(4,4);
Circle cir = new Circle(p, 5.5);
cir.showCircleInfo();
//중심좌표
//x: 4 / y: 5
//반지름: 5.5

Circle cir2 = new Circle(4,4, 5.5);
//중심좌표
//x: 4 / y: 5
//반지름: 5.5
cir2.showCircleInfo();

• import는 패키지가 다를 때에만 사용한다.

public class Point {
	private int x, y;	// 0~100 음수나 100 초과의 숫자는 안 받음
	
	public Point(int x, int y) {
		setX(x);	// 밑의 메소드 호출
		setY(y);
	}

	public int getX() {
		return x;
	}
	public void setX(int x) {
		if(x<0 || x>100) return;
		this.x = x;
	}
	public int getY() {
		return y;
	}
	public void setY(int y) {
		if(y<0 || y>100) return;
		this.y = y;
	}
	
	//좌표 정보 출력
	public void showPointInpo() {
		System.out.println("======중심좌표======");
		System.out.println("x: "+x+"\ty: "+y);
	}
}

• 좌표 정보를 출력하는 showPointInpo 메소드는 인스턴스 메소드.

public class Circle {
	private Point p;	//new Point(1,1);	//중심좌표
	private double radius;	//반지름

	public Circle(Point p, double rad) {
		this.p = p;
		radius = rad;
	}
    public Circle(int x, int y, double rad) {
		p = new Point(x, y);
		radius = rad;
	}

	public void showCircleInfo() {
		//중심좌표
		//x: 4 / y: 5
		//반지름: 5.5
		p.showPointInpo();
		System.out.println("---------");
		System.out.println("반지름: "+radius);
	}
}

• 인스턴스 변수에 다른 클래스를 호출할 수 있다.

ShapeMain

Ring ring = new Ring(4,4,5.5, 5,5,6.6);
ring.showRingInfo();

Ring ring2 = new Ring(new Circle(4,4,5.5),	new Circle(5,5,6.6));
ring2.showRingInfo();

Point

public class Point {
	private int x, y;	// 0~100 음수나 100 초과의 숫자는 안 받음
	
	public Point(int x, int y) {
		setX(x);	// 밑의 메소드 호출
		setY(y);
	}

	public int getX() {
		return x;
	}
	public void setX(int x) {
		if(x<0 || x>100) return;
		this.x = x;
	}
	public int getY() {
		return y;
	}
	public void setY(int y) {
		if(y<0 || y>100) return;
		this.y = y;
	}
	
	//좌표 정보 출력
	public void showPointInpo() {
		System.out.println("======중심좌표======");
		System.out.println("x: "+x+"\ty: "+y);
	}
}

• 위의 코드 그대로 사용

Circle

public class Circle {
	private Point p;	//new Point(1,1);	//중심좌표
	private double radius;	//반지름

	public Circle(Point p, double rad) {
		this.p = p;
		radius = rad;
	}
    public Circle(int x, int y, double rad) {
		p = new Point(x, y);
		radius = rad;
	}

	public void showCircleInfo() {
		//중심좌표
		//x: 4 / y: 5
		//반지름: 5.5
		p.showPointInpo();
		System.out.println("---------");
		System.out.println("반지름: "+radius);
	}
}

• 위의 코드 그대로 사용

Ring

public class Ring {
private Point p;
private Point p2;
private Circle inCircle;	//new Circle();
private Circle outCircle;

public Ring(Point p, double r, Point p2, double r2) {
	inCircle = new Circle(p, r);
	outCircle = new Circle(p2, r2);
}

public Ring(int x, int y, double r, int x2, int y2, double r2) {
	p = new Point(x, y);
	inCircle = new Circle(p, r);
	p2 = new Point(x2, y2);
	outCircle = new Circle(p2, r2);	
}
public Ring(Circle inCircle, Circle outCircle) {
	this.inCircle = inCircle;
	this.outCircle = outCircle;
}

public void showRingInfo() {
	System.out.println("=======================");
	System.out.println("링의 안쪽");
	inCircle.showCircleInfo();
	System.out.println("\t----");
	System.out.println("링의 바깥쪽");
	outCircle.showCircleInfo();
	System.out.println("=======================");
}