์ฝ๋ฉ ์ฐ์ต 2
์ฝ๋ฉ ์์ : ์ธ์น๋ฅผ ๊ฐ์ฒด๋ก(ํผํธ, ์ธ์น)
public class Dimension {
private int feet;
private int inches;
public Dimension(int inches) {
if (inches < 0) {
this.feet = -1;
this.inches = -1;
} else {
this.feet = inches / 12;
this.inches = inches % 12;
}
// TODO: Convert the total inches into feet and inches. One foot is 12 inches.
// Store the feet and inches in their respective instance variables.
}
public int getFeet() {
// TODO: Return the value of feet.
return feet;
}
public int getInches() {
// TODO: Return the value of inches.
return inches;
}
}
์ฝ๋ฉ ์์ : 2์ฐจ์ ์ขํ x, y๊ฐ ์๋ Point ํด๋์ค ๋ง๋ค๊ธฐ
public class Square {
private int side;
public Square(int side) {
// TODO: Initialize side with the passed value
this.side=side;
}
public int calculateArea() {
// TODO: Calculate and return the area of the square
if(side<=0) return -1;
return side*side;
}
public int calculatePerimeter() {
// TODO: Calculate and return the perimeter of the square
if(side<=0) return -1;
return 4*side;
}
}
์ฝ๋ฉ ์์ : 2์ฐจ์ ์ขํ x, y๊ฐ ์๋ Point ํด๋์ค ๋ง๋ค๊ธฐ
// Defining a Point class to represent a point in 2-dimensional space
public class Point {
// x-coordinate of the point
private int x;
// y-coordinate of the point
private int y;
// Constructor for the Point class
public Point(int x, int y) {
this.x = x; // Assigning x-coordinate of the point
this.y = y; // Assigning y-coordinate of the point
}
// Method to get the x-coordinate of the point
public int getX() {
return x;
}
// Method to get the y-coordinate of the point
public int getY() {
return y;
}
// TODO: Implement the method to move the point by dx and dy in x and y direction respectively
public void move(int dx, int dy) {
// Your code here
this.x=this.x+dx;
this.y=this.y+dy;
}
// TODO: Implement the method to calculate the distance from this point to another point
public double distanceTo(Point other) {
int diffX=this.x-other.x;
int diffY=this.y-other.y;
return Math.sqrt(diffX*diffX+diffY*diffY);
// Your code here
}
}
์ฝ๋ฉ ์์ : RGB Color ํด๋์ค
// RGBColor class representing a color using Red Green Blue (RGB) model.
public class RGBColor {
// The Red, Green, Blue color values range from 0 to 255.
private int red;
private int green;
private int blue;
// Constructor for RGBColor class which initializes the color with provided red, green and blue values.
public RGBColor(int red, int green, int blue) {
// write your code here
this.red=red;
this.green=green;
this.blue=blue;
}
// Getter method to get the red value of the color.
public int getRed() {
// write your code here
return this.red;
}
// Getter method to get the green value of the color.
public int getGreen() {
// write your code here
return this.green;
}
// Getter method to get the blue value of the color.
public int getBlue() {
// write your code here
return this.blue;
}
// Method to invert the color. The inversion is done by subtracting each color component from 255.
public void invert() {
// write your code here
this.red=255-this.red;
this.blue=255-this.blue;
this.green=255-this.green;
}
}
Type
Type Casting
ํ์ ์บ์คํ ์ ๋ณ์๋ ๊ฐ์ฒด๋ฅผ ๋ค๋ฅธ ํ์ ์ผ๋ก ๋ณํํ๋ ๊ณผ์ ์ ๋งํฉ๋๋ค. ์ด๋ ๋ ๊ฐ์ง ์ ํ์ผ๋ก ๋๋ ์ ์์ต๋๋ค: ์์์ (์๋) ์บ์คํ ๊ณผ ๋ช ์์ (์๋) ์บ์คํ ์ ๋๋ค.
์์์ (์๋) ์บ์คํ (Upcasting):
- ์์์ ์บ์คํ ์ ์์ ๋ฐ์ดํฐ ํ์ ์ ํฐ ๋ฐ์ดํฐ ํ์ ์ผ๋ก ์๋์ผ๋ก ๋ณํํ๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค. ์ด๋ ๋ฐ์ดํฐ ์์ค์ด ๋ฐ์ํ์ง ์๋ ๊ฒฝ์ฐ์๋ง ๊ฐ๋ฅํฉ๋๋ค.
int intValue = 10;
double doubleValue = intValue; // ์์์ ์บ์คํ
์ ์ -> ์ค์๋ก ๋์
๋ช ์์ (์๋) ์บ์คํ (Downcasting):
- ๋ช ์์ ์บ์คํ ์ ํฐ ๋ฐ์ดํฐ ํ์ ์ ์์ ๋ฐ์ดํฐ ํ์ ์ผ๋ก ๋ณํํ๋ ๊ฒ์ผ๋ก, ๋ฐ์ดํฐ ์์ค์ด ๋ฐ์ํ ์ ์์ต๋๋ค.
- โ๏ธ๊ฐ๋ฐ์๊ฐ ๋ช ์์ ์ผ๋ก ๋ณํ์ ์ง์ํด์ผ ํฉ๋๋ค.
double doubleValue = 10.5;
int intValue = (int) doubleValue; // ๋ช
์์ ์บ์คํ
์ค์ -> ์ ์๋ก ๋ณํ
BigDecimal
์๋ฐ์์ ๋ถ๋์์์ ์ฐ์ฐ์ ์ ํ์ฑ์ ์ ์งํ๊ธฐ ์ํ ํด๋์ค์ ๋๋ค. ์ด ํด๋์ค๋ float ๋๋ double๊ณผ ๊ฐ์ ๋ถ๋์์์ ํ์ ์ด ๊ฐ์ง๋ ๋ถ์ ํ์ฑ ๋ฐ ๋ฐ์ฌ๋ฆผ ์ค์ฐจ๋ฅผ ํผํ๊ณ , ๊ณ ์ ์์์ ์ฐ์ฐ์ ์ง์ํฉ๋๋ค.
jshell> 34.56789876+34.2234
$13 ==> 68.79129875999999
๋ถ๋ ์์์ ๋ค์ ๊ณ์ฐ๊ฐ์ด ์ ํํ ๊ฒฐ๊ณผ๊ฐ ๋์ค์ง์๋๊ฒ์ ํ์ธํ ์ ์๋ค. → BigDecimal์ผ๋ก ์ฐ์ฐ
์ ํํ ์ฐ์ฐ ๊ฒฐ๊ณผ๊ฐ ๋์ค๋ ๊ฒ์ ํ์ธํ ์ ์๋ค!
โ๏ธBigDecimal์ ์์ฑํ ๋ String์ ์ฌ์ฉํ๋ ๊ฒ์ด ๊ถ์ฅ๋ฉ๋๋ค. Stirng์ ์ฌ์ฉํด์ผ ๋ถ๋์์์ ์ ์ ํํ ํํ์ ๋ณด์ฅํ๊ณ , ๋ถ๋์์์ ํ์ ์ ๋ถํ์ค์ฑ๊ณผ ์ค์ฐจ๋ฅผ ๋ฐฉ์งํ๊ธฐ ์ํ ๊ฒ์ ๋๋ค.
๋ถ๋์์์ ๋ฆฌํฐ๋ด์ ์ฌ์ฉํ๋ฉด ์ด์ ๊ฐ์ด ์์์น ๋ชปํ ๋ฐ์ฌ๋ฆผ ์ค์ฐจ๊ฐ ๋ฐ์ํ ์ ์๋ค!
package com.firstjavaproject;
import java.math.BigDecimal;
public class BigdecimalPrac {
BigDecimal principal;
BigDecimal interest;
//์์ฑ
public BigdecimalPrac(Stirng prinicipal, Stirng interest) {
this.principal=new BigDecimal(principal);
this.interest=new BigDecimal(interest);
}
public BigDecimal calculateTotalValue(int noOfYears) {
//Total=principal+principal*interest*noOfYears
principal.add(
principal.multiply(interest).multiply(new BigDecimal(noOfYears))
}
}
๐๐ป ํ๊ณ์์๋ float,double ํ์์ด ์๋ BigDecimal์ ํ์ฉํ๋ฉด ํจ์ฌ ์ ํํ๊ณ , BigDeciaml์๋ String์ ์ฌ์ฉํด ์์ฑํ์.
์ฐ์ฐ์
โ ++i (์ ์น)์ i++ (ํ์น) ์ฐจ์ด์
++i (์ ์ ์ฆ๊ฐ ์ฐ์ฐ์):
- ๋ณ์๋ฅผ ๋จผ์ 1 ์ฆ๊ฐ์ํจ ํ, ๊ทธ ๊ฐ์ ์ฌ์ฉํฉ๋๋ค.
int i = 5;
int result = ++i; // i๋ ๋จผ์ 1 ์ฆ๊ฐ๋ ํ, result์ ํ ๋น๋จ
// result๋ 6, i๋ 6
i++ (ํ์ ์ฆ๊ฐ ์ฐ์ฐ์):
- ๋ณ์์ ํ์ฌ ๊ฐ์ ์ฌ์ฉํ ํ์ 1์ ์ฆ๊ฐ์ํต๋๋ค.
int i = 5;
int result = i++; // result์ ๋จผ์ i์ ํ์ฌ ๊ฐ์ด ํ ๋น๋๊ณ , ๊ทธ ํ i๊ฐ 1 ์ฆ๊ฐ๋จ
// result๋ 5, i๋ 6
๐๐ป ์ผ๋ฐ์ ์ผ๋ก๋ ์ ์ ์ฆ๊ฐ ์ฐ์ฐ์ ++i๊ฐ ํ์ ์ฆ๊ฐ ์ฐ์ฐ์ i++๋ณด๋ค ์ฝ๊ฐ ๋น ๋ฅด๊ณ ํจ์จ์ ์ด์ง๋ง, ์ฝ๋์ ๊ฐ๋ ์ฑ์ด๋ ํน์ ์ํฉ์ ๋ฐ๋ผ ์ ํํ๋ ๊ฒ์ด ์ข๋ค.
โ &์ && ์ฐจ์ด์
& (๋นํธ ๋จ์ AND ์ฐ์ฐ์):
- &๋ ๋นํธ ๋จ์ AND ์ฐ์ฐ์๋ก ์ฌ์ฉ์๋ก, ์ ์ ๋ฐ์ดํฐ ์ ํ์ ๋ํด ๊ฐ ๋นํธ๋ฅผ ๋น๊ตํ๊ณ AND ์ฐ์ฐ์ ์ํํฉ๋๋ค.
&& (๋ ผ๋ฆฌ AND ์ฐ์ฐ์):
- &&๋ ๋ ผ๋ฆฌ AND ์ฐ์ฐ์๋ก , ์ฃผ๋ก ์กฐ๊ฑด๋ฌธ์์ ๋ ๊ฐ์ ์กฐ๊ฑด์ ๋ชจ๋ ๋ง์กฑํ ๋๋ง true๋ฅผ ๋ฐํํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
- ๋ ๊ฐ์ ์กฐ๊ฑด ์ค ํ๋๋ผ๋ false์ด๋ฉด ๋๋จธ์ง ์กฐ๊ฑด์ ํ๊ฐํ์ง ์๊ณ ๋ฐ๋ก false๋ฅผ ๋ฐํํฉ๋๋ค. ์ด๋ฅผ "Short-circuit" ํ๊ฐ๋ผ๊ณ ํฉ๋๋ค.
๋์ ๊ฐ์ฅ ํฐ ์ฐจ์ด๋ Short-circuit์ ์ฐจ์ด์ด๋ค.
์ฒซ ํผ์ฐ์ฐ์๊ฐ์ด ๊ฑฐ์ง์ด๋ฉด, ๋๋ฒ์งธ ์ฐ์ฐ์๋ ์ด์ฐจํผ ๊ฑฐ์ง์ด๋ฏ๋ก ์คํ์ ํ์ง ์๋๋ค. (i++)
๋ฐ๋ผ์ i์ ๊ฐ์ด ๋ค๋ฅด๊ฒ ๋์ค๋๊ฒ์ ํ์ธํ ์์๋ค.
์กฐ๊ฑด๋ฌธ
nested if-else๋ฌธ
int k=15;
if(k>20){
System.out.println(1);
} else if(k>10){
System.out.println(2);
} else if(k<20){
System.out.println(3);
} else {
System.out.println(4);
}
k>10๊ณผ k<20์ ์กฐ๊ฑด์ ๋ ๋ค ๋ถํฉํ๊ธฐ ๋๋ฌธ์, 2์ 3์ ๋ชจ๋ ์ถ๋ ฅํ ๊ฒ ๊ฐ์ง๋ง → 2๋ง ์ถ๋ ฅํ๋ค!
โ๏ธํ ๋ธ๋ก๋ง ์คํ๋๊ธฐ ๋๋ฌธ์ด๋ค!
let l=15;
if(l<20) System.out.println(1);
if(l>20) System.out.println(2);
else System.out.println(3);
์ฒซ๋ฒ์งธ if๋ฌธ๊ณผ else๋ฌธ์ ๋ ๋ฆฝ์ ์ด๊ธฐ ๋๋ฌธ์, 1๊ณผ3์ด ๋ชจ๋ ์ถ๋ ฅ๋๋ค.
Switch-case๋ฌธ
โ๏ธbreak๋ฌธ์ ์ฌ์ฉํ์ง ์์ผ๋ฉด, ํด๋น ์ผ์ด์ค ์ดํ์ ๋ชจ๋ ๊ตฌ๋ฌธ์ด ์ถ๋ ฅ๋๋ค.
switch(dayNumber) {
case0:return false;
case1:return true;
case2:return true;
case3:return true;
case4:return true;
case5:return true;
case6:return false;
}
switch(dayNumber) {
case0:
case6:return false;
case2:
case3:
case4:
case5:
case6:return true;
}
์ด๋ฌํ ํน์ง (fall-through)๋ฅผ ์ฌ์ฉํ์ฌ, ์ด์ ๊ฐ์ด ์ฝ๋๋ฅผ ์์ ํ์ฌ ์์ฑํ ์ ์๋ค!
์ผํญ ์ฐ์ฐ์
์กฐ๊ฑด๋ฌธ์ ๊ธฐ๋ฐํ์ฌ ๋ ๊ฐ์ ํํ์ ์ค ํ๋๋ฅผ ์ ํ์ ์ผ๋ก ์คํํ๋ ๋ฐ ์ฌ์ฉ๋๋ค.
โ๏ธ์ฃผ์ํด์ผํ ์ ์, ๋ฐํ์ ํ์ด ๋์ผํด์ผํ๋ค๊ณ ํ๋ค.
result = (์กฐ๊ฑด์) ? ํํ์1 : ํํ์2;