오버라이딩

• 부모 클래스에서 상속받은 메서드를 자식 클래스에서 재정의하는 것
• 오버라이딩하고자 하는 메서드의 이름, 매개변수, 리턴 값이 모두 같아야 한다
• 필드는 오버라이딩이 불가능하다

상속

• 상위 클래스의 필드와 메서드를 물려받아 하위 클래스가 가져감
• 두 개 이상의 클래스를 직접적인 관계를 형성하여 불필요한 필드와 메서드의 선언을 최소화
• 자식 클래스에서 오버라이딩하는 메서드의 접근제어자는 부모 클래스보다 더 좁게 설정할 수 없다

class Parent {

    void display() {
    	System.out.println("부모 클래스의 display() 메소드입니다.");
    }
}

class Child extends Parent {

    void display() {
    	System.out.println("자식 클래스의 display() 메소드입니다.");
    }
}


public class Example {

    public static void main(String[] args) {

        Parent pa = new Parent();
        pa.display();

        Child ch = new Child();
        ch.display();

        Parent pc = new Child();
        pc.display();

    }
}

// Console
// 부모 클래스의 display() 메소드입니다.
// 자식 클래스의 display() 메소드입니다.
// 자식 클래스의 display() 메소드입니다.

super

• 부모 클래스의 필드에 접근할 때 사용
• 자식 클래스에서 부모 클래스의 재정의도 가능하다

오버로딩

• 같은 이름의 생성자나 메서드가 여러개 있더라도 파라미터의 타입이나 개수가 다르다면 사용 가능하다
• 같은 기능을 하는 메서드를 하나의 이름으로 사용 가능하다
• 메서드의 이름을 절약할 수 있다

// 변수명은 다르지만 변수 타입이 같기 때문에 불가능
int add(int a, int b) {
	return a+b;
}

int add(int x, int y) {
	return x+y;
}

// 변수 타입이 다르기 때문에 사용가능
int add(int a, int b) {
	return a+b;
}

int add(long a, long b) {
	return a+b;
}

생성자

• 클래스 명과 메서드 명이 동일
• 리턴타입을 정의하지 않음(void포함)
• 생성자를 선언하지 않으면 자동으로 디폴트 생성자를 생성한다
• 오버로딩이 가능하다

// 생성자 생략
public class Animal {
	String name;    
	static int age = 3;
 
	Animal(String name){
		this.setName(name);
	}
 
 	void setName(String name) {              
		this.name=name;
	}
}


// 생성자 입력
public class Animal {
	String name;    
	static int age = 3;
 
	Animal(String name){
		this.setName(name);
	}
 
 	void setName(String name) {              
		this.name=name;
	}
}

클래스

• 객체를 정의(설계)하는 틀, 설계도라고 이해하면 쉬움
• ex) 붕어빵 기계로 붕어빵을 만들 때, 붕어빵 기계는 클래스 붕어빵은 객체

public class Animal {
	
	public class Example{
		Animal dog = new Animal();
	}
}

Animal 클래스의 인스턴스 dog가 만들어졌다(Animal의 객체가 만들어졌다)
클래스에 의해 만들어진 객체 = 인스턴스

Animal cat = new Animal();
Animal dog = new Animal();
Animal horse = new Animal();

무수히 많은 객체를 Animal 클래스로 만들었다

public class Animal {
	String name;       // 객체변수
	
}
	
public class Example{		
	public static void main(String[] args) {
		Animal dog = new Animal();
		System.out.println(dog.name);      // 변수 호출
	}
}

객체변수 name을 생성했고 dog.name으로 변수에 접근했다
변수 name의값이 null이므로 null이 출력 될 것이다

메서드

• 클래스 내에 구현된 함수
• 변수에 값을 대입하는 가장 보편적인 방법은 메서드를 활용하는 것이다

public class Animal {
	String name;
    
    static int age = 3;                           // 정적 변수(클래스 변수)
    
    	void setName(String name) {               // 메서드 생성
		this.name=name;
	}
	
}
	
public class Example{		
	public static void main(String[] args) {
		Animal dog = new Animal();
        Animal cat = new Animal();
        dog.setName("해피");                                     // 메서드 호출
        cat.setName("코코");                                     // 메서드 호출
		System.out.println(dog.name + "는 " + age+"살");
        System.out.println(cat.name);
	}
}


결과값
해피는 3살
코코

dog라는 객체를 만들고, dog.setName("해피")를 입력하게 되면 this.name=name은 dog.name="해피"가 된다.
객체 변수는 공유되지 않는다 (dog.name="해피" / cat.name="코코")
static(정적 변수) : 인스턴스를 생성하지 않아도 접근이 가능하지만 모든 인스턴스가 정적 변수의 값을 공유한다

객체지향이란?

• 객체가 각각의 역할 수행
• 객체의 결괏값 역시 다른 객체의 결괏값과 상관없이 독립적인 값을 유지
• 객체를 사용하면 객체의 개수가 늘어나더라도 객체를 생성만 하면 되기 때문에 클래스만을 사용하는 경우와 달리 매우 간단해진다.

class Calculator {
    int result = 0;               // 객체변수, 맴버변수, 필드

    int add(int num) {            // 메서드
        result += num;
        return result;
    }
}


public class Sample {
    public static void main(String[] args) {
        Calculator cal1 = new Calculator();  // 계산기1 객체
        Calculator cal2 = new Calculator();  // 계산기2 객체

    }
}

// 클래스에 의해 만들어진 객체를 인스턴스라고도 한다.
// cal1은 계산기 한 대(객체)이며, Calculator 클래스의 인스턴스이다.

class Animal {
    String name;

    public void setName(String name) {
        this.name = name;
    }
}

public class Sample {
    public static void main(String[] args) {
        Animal cat = new Animal();
        cat.setName("sad");

        Animal dog = new Animal();
        dog.setName("happy");

        System.out.println(cat.name);
        System.out.println(dog.name);
    }
}


// 결과값
body
happy


// this.name=name의 의미
// cat과 dog 인스턴스에서 setName 메서드를 호출하여 name를 입력시켜 "sad", "happy의 입력값을 전달했다
// cat.name=sad
// dog.name=happy이 된다
// 필드값은 공유되지 않는다

객체지향 프로그래밍의 장점

• 새로운 코드를 작성할 때 이미 만들어 놓은 코드를 이용해 쉽게 작성 가능
• 코드의 관리가 쉽다
• 코드의 중복을 제거하고 코드 불일치로 인한 예외방지 가능
• 보안과 신뢰성이 높은 프로그램 개발을 가능하게 함

객체지향 프로그래밍의 특징

• 추상화(추상클래스 , 인터페이스) : 필요한 정보만 간소하게
• 다형성 : 객체간의 관계를 유연하게
• 캡슐화(접근제어자) : 객체에 필요한 데이터나 기능(메서드)을 책임이 있는 객체에 그룹화
• 상속(오버라이딩) : 상위 클래스의 기능을 하위 클래스가 사용 가능

객체지향 설계원칙

• SRP(단일 책임)
• OCP(개방 폐쇄)
• LSP(리스코프 치환)
• ISP(인터페이스 분리)
• DIP(의존성 역전)

Math 클래스

• 수학과 관련된 일련의 작업들을 수행할 수 있는 클래스(java.lang 패키지안에 포함) 
• Math클래스의 다양한 메서드들은 static으로 구현되어 있어 따로 객체를 생성하지 않고 사용 가능

※ java.lang 패키지
   - java 프로그래밍에 필요한 가장 기본적인 클래스들이 모여있는 패키지
   - import구문 없이도 자동으로 프로그램에 포함

1. abs

• 주어진 값의 절대값을 반환

System.out.println(Math.abs(10));      //10
System.out.println(Math.abs(-10));     //10
System.out.println(Math.abs(-3.1037f));//3.1037

2. max / min

• 두 값중 더 큰 값, 작은 값을 반환

System.out.println(Math.max(1234, 123));      // 1234
System.out.println(Math.min(1234, 123));      // 123

3. ceil / floor / round / floorDiv

• ceil, floor, round : 올림, 내림, 반올림
• floorDiv : 몫보다 작거나 같은 가장 큰 정수 값 반환

System.out.println(Math.ceil(10.4));      // 11.0
System.out.println(Math.floor(10.5));     // 10
System.out.println(Math.round(10.5));     // 3.1037


// 이런식으로 활용 가능 ( 자릿수 지정 )
System.out.println(Math.ceil(10.454545*10)/10);        // 10.5
System.out.println(Math.floor(10.545454*1000)/1000);   // 10.555

// floorDiv
System.out.println(Math.floorDiv(100, 3));     // 33
System.out.println(Math.floorDiv(3, 100));     // 0

4. sqrt / cbrt

• 제곱근, 세제곱근

System.out.println(Math.sqrt(25));           // 5.0
System.out.printf("%.4f",Math.cbrt(25));     // 2.9240

5. pow

• 제곱 함수 ( pow(밑,지수) )

System.out.println(Math.pow(2,5));     // 32

6. signum

• 주어진 값의 부호 출력

System.out.println(Math.signum(1.3f));     // 1.0
System.out.println(Math.signum(0));        // 0.0
System.out.println(Math.signum(-3.14));    //-1.0

7. copySign / nextAfter / nextUp / nextDown / ulp

• copySign : 두 번째 인수에 지정된 부호 + 첫 번째 인수의 절대값 반환
• nextAfter(x,y) : y를 향한 x 다음의 부동 소수점 값을 반환, x=y이면 y반환
• nextUp : 양의 무한대방향으로  인접한 부동 소수점 값을 반환
• nextDown : 음의 무한대방향으로  인접한 부동 소수점 값을 반환
• ulp : float x의 최하위 비트 반환

System.out.println(Math.copySign(-3,2));     // 3.0
System.out.println(Math.nextAfter(-3.1,2));  // -3.0999999999999996
System.out.println(Math.nextUp(-3.1));       // -3.0999999999999996
System.out.println(Math.nextDown(-3.1));     // -3.1000000000000005
System.out.println(Math.ulp(3f));            // 2.3841858E-7

8. random

• 난수 생성
• 범위 미지정 시 0.0~1.0사이의 double값 반환
• 범위 지정 방법 : (Math.random()*x)+y

// 범위 미지정 시
for(int i=0; i<10; i++) {
	System.out.println(Math.random());
}

0.9016855235047694
0.615614968623635
0.04077792462493879
0.7617507858319714
0.9148626832492266
0.3241254670110941
0.3912494309871509
0.9820537595650879
0.9322974745562934
0.0019263079896513213

// 원하는 정수 범위의 random을 만들어보자
for(int i=0; i<10; i++) {
	System.out.print((int)(Math.random()*10)+1 + " ");
}

>> 5 3 3 1 10 4 4 5 8 8

9. rint

• 인자 값에 가장 가까운 정수를 double값으로 반환

System.out.println(Math.rint(3.33333333));   // 3.0
System.out.println(Math.rint(3.55555555));   // 4.0

10. hypot

• sqrt(x²+y²)의 값

System.out.println(Math.hypot(2, 2));
System.out.println(Math.sqrt(8));

// 두 값은 같다
// hypot(2,2)=sqrt(2²+2²) = 2.8284271247461903

11. getExponent / IEEEremainder ( ? )

• getExponent : 편향되지 않은 지수를 반환
• IEEEremainder : IEEE 754 규정된 두 인수에 대한 나머지 연산을 계산

double a = 345.65;
double b = 1.0 / 0;
double c = 0;

float d = 237.2f;
float e = 1.0f / 0;
float f = 0f;

System.out.println(Math.getExponent(a));    // 8
System.out.println(Math.getExponent(b));    // 1024
System.out.println(Math.getExponent(c));    // -1023      
System.out.println(Math.getExponent(d));    // 7
System.out.println(Math.getExponent(e));    // 128
System.out.println(Math.getExponent(f));    // -127

double a1 = 31.34;
double a2 = 2.2;
double b1 = -21.0;
double b2 = 7.0;
double c1 = 1.0 / 0;
double c2 = 0.0;
double d1 = -2.34;
double d2 = 1.0 / 0;  
  
System.out.println(Math.IEEEremainder(a1, a2));      // 0.5399999999999974
// b1와 출력은 음수 0
System.out.println(Math.IEEEremainder(b1, b2));      // -0.0 
// 첫 번째 인수는 무한대이고 두 번째 인수는 0
System.out.println(Math.IEEEremainder(c1, c2));      // NaN
// 첫 번째 인수는 유한하고 두 번째 인수는 무한대
System.out.println(Math.IEEEremainder(d1, d2));      // -2.34

12. Exact ( JAVA 8부터 추가 )

• addExact : 더하기
• subtractExact : 빼기
• multiplyExact : 곱하기
• incrementExact : 값 1 증가
• decrementExact : 값 1 감소
• negateExact : 부호 변경
• tolnExact : long 타입을 int로 변경

※ 인수값으로 int / long이 오버로딩되어있으며 오버플로우된 경우 예외가 발생

System.out.println(Math.addExact(2, 3));         // 5
System.out.println(Math.subtractExact(2,3));     // -1
System.out.println(Math.multiplyExact(2,3));     // 6
System.out.println(Math.incrementExact(3));      // 4
System.out.println(Math.decrementExact(3));      // 2
System.out.println(Math.negateExact(3));         // -3

// int 범위를 넘어가는 값을 넘기면 오버플로우가 발생
double a = 9223372036854775807L;
System.out.println(Math.toIntExact(a));

13. log

• log : log를 반환
• log10 : 밑이 10인 로그를 반환
• log1p : 인수와 1의 합의 로그를 반환 (log(x)=log1p(x-1))

System.out.println(Math.log(100));            // 4.605170185988092
System.out.println(Math.log10(100));          // 2.0
System.out.println(Math.log1p(99));           // 4.605170185988092



// 메서드 활용
public class BaseLog

	static double baseLog(int x, int base) {
		return Math.log10(x) / Math.log10(base);
	}

	public static void main(String[] args){
	    System.out.println(baseLog(8,2));          // 3.0
	    System.out.println(baseLog(9,3));          // 2.0
	}

14. exp / expm1

• exp : 입력받은 인자의 값에서 E(오일러 수)를 거듭제곱 / E ≒ (2.71828)
• expm1 : E의 거듭제곱을 계산하고 1을 뺀다

// Math.exp(a) = a의 E승
System.out.println(Math.exp(1));         // 2.718281828459045
System.out.println(Math.expm1(1));       // 1.718281828459045

15. 삼각법 ( sin / cos / tan / asin / acos / atan )

• 주어진 double 값의 사인,코사인,탄젠트, 아크사인, 아크코사인, 아크탄젠트 값을 반환

System.out.println(Math.sin(1));   // 0.8414709848078965
System.out.println(Math.cos(1));   // 0.5403023058681398
System.out.println(Math.tan(1));   // 1.5574077246549023
System.out.println(Math.asin(1));  // 1.5707963267948966
System.out.println(Math.acos(1));  // 0.0
System.out.println(Math.atan(1));  // 0.7853981633974483

16. 쌍곡선 ( sinh / cosh / tanh )

• 주어진 double 값의 쌍곡선 코사인 / 사인 / 탄젠트 값을 반환

System.out.println(Math.sinh(1));  // 1.1752011936438014
System.out.println(Math.cosh(1));  // 1.543080634815244
System.out.println(Math.tanh(1));  // 0.7615941559557649

17. 각도

• toDegrees : 라디안 각도를 일반 각도로
• toRadians : 일반 각도(0~360˚)를 라디안 각도로

System.out.println(Math.toRadians(360));                          // 6.283185307179586
System.out.println(Math.toDegrees(6.283185307179586));            // 360

String 관련 문자열

• length : 문자열의 길이

String text="1234"
System.out.println(text.length());


>> 4

• contains  : 문자열 포함 여부 확인

String text="안녕하세요 제 이름은"
boolean isContains= text.contains("가나");
boolean isContains= text.contains("하세");


>> false
>> true

• startsWith : 해당 문자열이 비교하는 문자열과 시작부분이 동일한지 확인

String text="안녕하세요 오늘의 날씨는";
System.out.println(text.startsWith("안녕"));
System.out.println(text.startsWith("안"));

>> true
>> true

• trim  : 앞 뒤 공백제거

String text="    바보      멍청이   ";
System.out.println(text.trim());

>> 바보      멍청이

• replace  : 문자변경

String text="안녕하세요 오늘의 날씨는 맑음";
System.out.println(text.replace("맑음","비"));

>> 안녕하세요 오늘의 날씨는 비

• subString  : 문자열 자르기

String text="123456789";
System.out.println(text.substring(3));
System.out.println(text.substring(3,7));


>> 456789
>> 4567

• toLowerCase / toUpperCase: 모든 문자 소/대문자 변경

String text="QweRtY";
System.out.println(text.toUpperCase());
System.out.println(text.toLowerCase());

>> QWERTY
>> qwerty

• indexOf  : 특정 문자 찾기 / 특정 문자(열)의 위치를 리턴

String text="오늘의 점심 메뉴는 닭갈비";
System.out.println(text.indexOf("심"));
System.out.println(text.indexOf("점심"));
System.out.println(text.indexOf("닭갈비"));

>> 5
>> 4
>> 11

• charAt  : 특정한 index의 문자 리턴

String text="1234567890";
char ch = text.charAt(2);
System.out.println(ch);

>> 3

• compareTo  : 문자열 비교 시 사용

// 오름, 내림차순으로 어떤 문자열이 더 앞이나 뒤에 있는지 확인할 때 사용하며 정렬을 위해 문자열을 비교할 때도 사용
// 비교기준 : 맨 앞글자
// 왼쪽 문자열과 오른쪽 문자열을 비교햐여 음수, 양수, 0 중 하나를 리턴
// 왼쪽 문자열이 오른쪽 문자열보다 더 앞에 있으면 음수 리턴(차이만큼)
// 왼쪽 문자열이 오른쪽 문자열보다 더 뒤에 있으면 양수 리턴(차이만큼)
// 동일하면 0을 리턴
// 맨 앞글자가 동일하나 개수가 다르면 개수의 차 만큼 계산하여 리턴

System.out.println("abc".compareTo("def"));
System.out.println("def".compareTo("abc"));
System.out.println("aa".compareTo("aaaads")); 
System.out.println("aaa".compareTo("aaa"));

>> -3
>> 3
>> -4
>> 0

문자열 포맷 코드

• %a : 16진법 문자열
• %b : boolean
• %c : char(유니코드/아스키코드)
• %d : 정수(10진법)
• %e : 지수표기법(부동소수점)
• %f : 실수
• %g : 부동소수점(더 큰 표기)
• %h : hashcode
• %o : 8진법 문자열
• %s : 문자열 값
• %t : 시간
• %x : 16진법 정수값

반복문

• 프로그램 내에서 똑같은 명령을 일정 횟수만큼 반복하여 수행하도록 제어하는 명령문
• for, while, do~while, 향상된 for문(Enhanced for)

for 문

for(초기값; 조건값; 증감값){
	조건값이 참일 경우 실행되는 코드들
}​

• 실행 순서

1.  초기화
2.  조건식 확인
3.  코드 수행
4.  증감식 수행
5.  다시 조건식 확인
6.  조건식이 false일 때까지 2 ~ 4 무한반복

• for문과 배열

// 배열 요소들을 한꺼번에 출력하는 방법
String[] cars = {"현대", "기아", "쌍용", "벤츠", "아우디", "BMW"}
for(int i=0; i<cars.length; i++){
	System.out.println(cars[i]);
}
// length = 배열 전체의 길이를 찾는 메서드

• 이중 for문의 실행 순서

1.  외부 for문 실행(외부 for문 초기화)
2.  외부 for문 조건식 확인
3.  외부 for문 코드 실행(내부 for문을 만나기 전까지)
4.  내부 for문 실행(내부 for문 초기화)
5.  내부 for문 조건식 확인
6.  내부 for문 코드 실행
7.  내부 for문 조건이 false일 때까지 반복
8.  내부 for문이 false가 되면 대기중이던 외부 for문 실행
9.  이 과정을 외부 for문이 끝날 때까지 반복

// 이중 for문으로
// 구구단 2단부터 9단까지 출력하기

for(int i=2; i<=9; i++){
	System.out.println(i+"단입니다");
    for(int j=1; j<=9; j++){
    	System.out.println(i + " * "+j+ " = "+j * i);
        }
}

• for 문의 무한 반복

// 무한히 번호가 찍히는 안녕 출력

int aa=0;
for(;;){
	System.out.println("안녕"+aa);
}

while 문

• 특정한 조건을 만족할 때 까지 계속해서 주어진 명령문을 반복 실행하는 코드
• while문은 무한반복에 많이 사용된다
• or문과는 다르게 조건지정이 관대하다
• while문 사용 시 종료조건을 지정해야 한다

while(조건식){
	조건식의 결과가 참인동안 반복적으로 실행하고자 하는 명령문
}

// while문 예시
int i=0;
while(true){
	i++;
    System.out.println("나무를 "+i+"번 째 찍고있습니다.");
}

// 종료조건 지정방법
// 1. 조건을 명확히 작성하기.
int i =1;
while(i<=10) {
	System.out.println("나무를 "+i+"번째 찍었습니다.");
	i+=1;
}


// 2. 키워드를 활용하기
int i =1;
while(i<=10) {
	System.out.println("폭주기관차가 "+i+"km째 달리고 있습니다.");
	i+=1;
if(i>10) {
	System.out.println("슈퍼맨이 폭주기관차를 부셔버림 ㅇㅇ");
	break;
	}
}

do~while 문

• 반복문 내부를 한번 실행한 후 조건식을 검사
• 조건식을 만족하지 못해도 무조건 한번은 실행

int k = 100;
do {
	System.out.println("ㅋㅋㅋ");
 	}while(k>200);     // k는 100이지만 한번은 실행된다.

break, continue

• break : 하나의 반복문을 빠져나올 때 사용
• continue : continue가 포함된 반복문을 계속 반복한다. continue이후의 반복문은 실행 x

배열

• 같은 타입의 변수들로 이루어진 유한한 집합
• 인덱스 : 배열의 위치를 가리키는 숫자(0번부터 시작)
• 요소(element) : 배열을 구성하는 각각의 값
• 1차원, 2차원.......n차원까지 만들 수 있다
• length = 배열 전체의 길이를 찾는 매서드

// 변수타입[] 변수명; = {배열요소1, 2, 3, 4, ....};
// 변수타입 변수명[]

// 배열 예시 1
String subject1 = "한국어";
String subject2 = "수학";
String subject3 = "영어";
String[] subject = {"한국어", "수학", "영어"};
System.out.println(subject[2]);


// 배열 예시 2
String[] human = new String[3];
human[0] = "인간1";
human[1] = "인간2";
human[2] = "인간3";
System.out.println(human[2]);
System.out.println(human.length); // 배열 전체의 길이를 찾는 메서드

배열과 for 문

// 배열과 for문
int[] arr2 = new int[] {60, 80, 70, 50};
for(int i=0; i<arr2.length; i++) {
	if(arr2[i]>=65) {
		System.out.println((i+1)+"번째 학생은 합격입니다");
	}
	else if(arr2[i]<65) {
		System.out.println((i+1)+"번째 학생은 불합격입니다");
	}
//	System.out.println(arr2[i]>=65 ?
//			(i+1)+"번째 학생은 합격입니다" :        // 삼항연산자 사용 가능하다
//			(i+1)+"번째 학생은 불합격입니다");
	}

1번째 학생은 불합격입니다
2번째 학생은 합격입니다
3번째 학생은 합격입니다
4번째 학생은 불합격입니다

다차원 배열

// 배열 요소의 합 구하기

// int[][] test12 = new int[3][3]; // 3x3의 배열 생성 , 행 ㅡ> 열 순
int[][] test12 = {{10,20,30}, {40,50,60}, {70,80,90}};
int sum=0;
for(int i=0; i<test12.length; i++) {
	for(int j=0; j<test12[i].length; j++) {
		sum+=test12[i][j];
	}
}
System.out.print(sum);


출력된 값 : 450