<클래스 - 형식, 포함멤버>
- 접근제한자 지정예약어 <class 클래스명> extends 상위클래스, 추상클래스
implements 상위인터페이스들{
}
package Week01;
import java.util.Scanner;
//일반화 객체
class Person{
void Person(String name, String gen){
System.out.println("Person 이름 = " + name);
System.out.println("Person 성별 = " + gen);
}
}
class Animal{
void Animal(String name, String gen) {
System.out.println("Animal 이름 = " + name);
System.out.println("Animal 성별 = " + gen);
}
}
//추상화 객체
abstract class Person1{
abstract void Person1();
}
class Animal1 extends Person1{
String pername, pergen, aniname, anigen;
@Override
void Person1() {
System.out.println("Person 이름 = " + pername);
System.out.println("Person 성별 = " + pergen);
System.out.println("Animal 이름 = " + aniname);
System.out.println("Animal 성별 = " + anigen);
}
}
public class 실습1일차 {
public static void main(String[] args) {
/*실습1 : 일반화, 추상화
*1. 일반화 객체 : Person, Animal
*2. 추상화 객체 : Person, Animal의 추상화 객체
*추상화는 인터페이스 기반으로 쓰임. 많이 연습해야함. 추상화 -> 디자인패턴
*
*1. Person
*-속성 : 이름, 성별, 거주지, 직업, 키
*-메소드 : 말하다(추), 자다, 먹다, 출근하다, 퇴근하다.
*추상메소드면 반드시 자식메소드가 재정의 해야함.
*2. Animal
*- 속성 : 이름, 성별, 몸무게, 길이, 너비
*- 메소드 : 짖다, 뛰다, 울다, 먹다, 자다
*3. Person 추상화 : 인종, 국가, 종교, 취미
*4. Animal 추상화 : 품종, 먹이, 서식지
*/
//일반화객체
String name, gen;
Person per = new Person();
Animal ani = new Animal();
per.Person("홍길동", "남자");
ani.Animal("개똥이", "암컷");
//추상화객체
Animal1 ani1 = new Animal1();
ani1.Person1();
/*실습2. 급여계산하기
* 입력 : 기본급, 직책(사원/대리/과장/부장)
* 출력 : 실수령액 = xxx원
* -계산식은 다음과 같다
* 실수령액 = 기본급 + 직책수당 -세금
* 세금 = 기본급의 10%
* -직책수당표(사원, 대리는 0)
* 과장 : 200,000
* 부장 : 500,000
*/
int mon;
double sal = 0;
String lev;
Scanner sc = new Scanner(System.in);
System.out.println("기본급을 입력하세요.");
mon = sc.nextInt();
System.out.println("직책을 입력하세요.");
lev = sc.next();
switch(lev) {
case("사원"):
sal = mon - mon*0.1;
break;
case("대리"):
sal = mon - mon*0.1;
break;
case("과장"):
sal = mon + 200000 - mon*0.1;
break;
case("부장"):
sal = mon + 500000 - mon*0.1;
break;
}
System.out.println("실수령액 = " + sal + "원입니다.");
/*실습3. 사칙연산
* -입력
* A값 :
* B값 :
* 연산자(+, -, *, /)
* -출력
* 결과 = xxx
* -오류처리
* 연산자에 +,-,*,/ 이외의 값이 입력시 아래 메세지를 출력한다.
* "잘못된 연산자를 입력하였습니다."
*/
double a, b, d;
String c;
Scanner sc = new Scanner(System.in);
System.out.println("A의 값을 입력하세요.");
a = sc.nextDouble();
System.out.println("B의 값을 입력하세요.");
b = sc.nextDouble();
while(true) {
System.out.println("연산자를 입력하세요.");
c = sc.next();
if(c.equals("+")) {
d = a + b;
System.out.println("결과 = " + d);
break;
}
else if(c.equals("-")) {
d = a - b;
System.out.println("결과 = " + d);
break;
}
else if(c.equals("*")) {
d = a * b;
System.out.println("결과 = " + d);
break;
}
else if(c.equals("/")) {
d = a / b;
System.out.println("결과 = " + d);
break;
}
else
System.out.println("잘못된 연산자를 입력하셨습니다.");
}
}
}
---------------------------------------------------------------------
<클래스 - 생성자>
1. 형식
접근제한자 클래스명(매개변수들) throws 예외처리클래스들{
멤버필드 초기화 작업
}
2. 생성자는 오브젝트 생성시 한번만 수행
3. new 키워드를 사용해서 자동적으로 호출되어 실행되는 특수한 메소드
4. 작성규칙
- 클래스명과 동일. 리턴값을 가지지 않는다.
- 객체가 생성될 때 반드시 하나의 생성자가 호출
- default생성자 : 매개변수도 없고 내용부도 없는 생성자
- 생성자들이 여러개 있을 수 있다(생성자 오버로딩)
- 생성자의 첫번째 라인(필수)으로 this 생성자를 사용하여 또 다른 생성자 하나를 호출할 수 있다.
package Week01;
class ConstructorTest {
int a, b, c, d, e, f, g;
ConstructorTest(){
a=1; b=2; c=3; d=4; e=5; f=6; g=7;
}
ConstructorTest(int x){
this(); // 생성자에서 다른 생성자 호출(생성자안에서만 가능)
d = x;
//this(); => ERROR, 생성자 안에서 다른 생성자를 호출하려면 첫번째 라인에서 호출해야한다.
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
System.out.println(e);
System.out.println(f);
System.out.println(g);
}
ConstructorTest(int x, int y){
this(x);
e = y;
}
public static void main(String[] args) {
ConstructorTest rEx = new ConstructorTest(); // 값을 무엇을 넣느냐에 따라 달라짐.
}
}
---------------------------------------------------------------------------
<클래스 - this>
1. 자기자신을 참조하는 객체
2. static 메소드가 아니라면 0번째 매개변수로 자신을 참조하는 this가 있다고 보면 됨.
package Week01;
public class ThisSample {
private int x;
private static int y;
//public void aaa(ThisSample this){
public void aaa() {
this.x = 10;
ThisSample.y = 20;
}
// public void bbb(ThisSample this, int x, int y){
public void bbb(int x, int y) {
this.x = x; //멤버변수에 파라미터 변수정보를 대입
ThisSample.y = y;
}
//public static void ccc(){ //static 에는 this 가 없다.(인스턴스가 존재하지 않는상황에서 this를 쓰는 의미가 없다.)
public static void ccc() {
//this.x ERROR
ThisSample.y = 10;
}
}
---------------------------------------------------------------------------
<클래스 - super>
1. 자신의 상위클래스를 지칭할 때 사용하는 예약어
2. 상위클래스의 생성자를 호출
3. 상위클래스의 메소드, 변수에 접근(상속된 것에만 가능)
package Week01;
class Employee{
/*
Employee(){ // 생략시 자동으로 기본형이 생성된다. Employee(){}, java.lang.Object 생성
System.out.println("나는 부모 Constructor");
}
*/
Employee(int a){// 생략시 자동으로 기본형이 생성된다. Employee(){}, java.lang.Object 생성
System.out.println("나는 부모 Constructor");
}
}
class Manager extends Employee{
Manager(){
super(1); //생략시 자동으로 생성된다. (클래스들에서의 생성자 초기화는 각자함. -> employee 따로 manager 따로)
//super();
System.out.println("나는 자식 Constructor");
}
}
public class TestSuper {
public static void main(String[] args) {
Manager m = new Manager(); //constructor 라인 호출
}
}
---------------------------------------------------------------------------
<클래스 - 접근제한자>
1. private : 자신의 클래스 내부에서만 사용, 업무에서 많이 쓰임.
2. package : 동일한 파일, 패키지간에서만 사용
3. protected : 하위 클래스 그리고 동일한 파일 내부 그리고 동일한 폴더에서만 사용
4. public : 어디에서든 사용 가능
package Week01.president;
import Week01.prince.Hyunchul;
public class Daujung {
private int a = 70;
int b = 70;
protected int c = 70;
public int d = 70;
public static void main(String[] args) {
Daujung dj = new Daujung();
System.out.println(dj.a);
System.out.println(dj.b);
System.out.println(dj.c);
System.out.println(dj.d);
dj.test();
dj.test2();
Youngsam ys = new Youngsam(); // 같은 패키지에 있는 클래스
System.out.println(ys.b);
System.out.println(ys.c);
System.out.println(ys.d);
Hyunchul h = new Hyunchul(); // 다른 패키지 -> dd만 호출됨.
System.out.println(h.c);
System.out.println(h.d);
System.out.println(h.dd);
}
public static void test() {}
public void test2() {}
}
package Week01.prince;
import Week01.president.Daujung;
import Week01.president.Youngsam;
public class Hyunchul extends Youngsam {
private int aa = 70;
int bb = 70;
protected int cc = 70;
public int dd = 70;
public static void main(String[] args) {
Hyunchul hc = new Hyunchul(); // 상속받은 클래스
System.out.println(hc.c);
System.out.println(hc.d);
Daujung dj = new Daujung(); // 관계없는 클래스
System.out.println(dj.d);
}
}
package Week01.president;
public class Youngsam {
private int a = 70; // priavte -> 상속불가
int b = 70; // 상속불가
protected int c = 70; // protected -> 상속가능
public int d = 70; // public -> 상속가능
}
---------------------------------------------------------------------------
<클래스 - 멤버필드와 멤버 메서드>
1. 필드_형식
접근제한자 [ 지정예약어 ]
ex) public static final double pi = 3.14;
2. 필드에 대한 지정예약어
- static : 모든 객체가 공유하는 필드
- final : 변경하지 못하는 필드
- trasient : 임시 메모리 필드
3. 메소드_형식
- 접근제한자 [지정예약어]
ex) private static void main(String[] arg) throws IOExecption{}
4. 메소드에 대한 지정예약어
- static : static 메소드 내부에는 static 필드나 static 메소드만 올 수 있다.
- final : Overriding을 할 수 없다
- static final : 혼합형태
- abstract : 내용부 정의가 없는 추상 메소드 선언할 때. 메소드는 반드시 overriding되어야 한다.
---------------------------------------------------------------------------
<static>
1. static 필드 : 모든 객체가 공유
2. 생성자에서 초기화 할수 없다.
3. 응용프로그램 실행순서 : static -> main() -> 생성자() -> finalize()
4. static 메소드 : static 필드를 처리하기 위한 메소드
package Week01;
public class StaticTest {
private static int x; //static은 생성자에서 초기화할수없다.
static {
System.out.println("Static.."); //static 필드의 초기화
x=0;
}
public void Test() {
System.out.println("Test...");
}
public StaticTest(String arg) {
System.out.println("생성자" + arg);
}
public static void main(String[] args) {
System.out.println("Main..");
StaticTest st = new StaticTest("1");
StaticTest st2 = new StaticTest("2");
StaticTest st3 = new StaticTest("3");
}
}
<final>
1. final필드 : 상수변수를 지정, 지역변수로 사용할 수 없다.
2. final메소드 : final 메소드를 재정의 할 수 없게 해줌
3. final클래스 : 상속자체를 못하게 막음.
4. abstract 와 함께 사용불가(abstract : 반드시 상속을 해야 사용)
---------------------------------------------------------------------------
<is a / has a 관계>
1. is a : 오브젝트간에 존재하는 논리적인 포함관계(ex.특별회원도 회원이다)
2. has a : 오브젝트간에 존재하는 물리적인 포함관계(ex. 회원은 비디오테이프를 빌려가서 보관한다.)
---------------------------------------------------------------------------
<상속>
1. is a 관계
2. overriding : 매소드를 하위클래스에서 재정의
3. overriding규칙
- 메소드 이름, 파라미터개수, 데이터형, 리턴형 같아야함
- 상위메소드와 동일하거나 더 구체적인 Exception을 발생시켜야
- 상위메소드와 동일하거나 접근 범위가 넓은 접근 제한자를 사용해야함.
package Week01.inherit;
class A{
private int x = 100;
private int y = 200;
}
class B extends A{
private int r = 300;
}
public class InheritTest1 {
public static void main(String[] args) {
B bp = new B(); //아무런 멤버에 접근 할 수 없다.
}
}
package Week01.inherit;
class A1{
protected int x = 100;
protected void disp() {
}
}
class B1 extends A1{
// private int x = 200;
public int x = 200;
public int y = 100;
public void disp() { // Overriding
System.out.println("A1 클래스의 x = " + super.x);
System.out.println("B1 클래스의 x = " + this.x);
}
public void disp2(){}
}
public class InheritTest2 {
public static void main(String[] args) {
B1 bp = new B1(); //200
System.out.println(bp.x); //100
bp.disp(); //200
A1 ap = new B1(); //100 부모는 자식인스턴스를 가리킬수 있으나, 자식은 부모인스턴스를 가리킬수 없음.
System.out.println(ap.x); //100
ap.disp(); //200
}
}
---------------------------------------------------------------------------
package Week01;
public class OperatorEx2 {
public static void main(String[] args) {
//문자열 비교
String str1 = "abc"; //우선 찾고, 없으면 생성.
String str2 = new String("abc");
System.out.println("abc"=="abc"); // true. 주소값이 같음.
System.out.println(str1=="abc"); //true
System.out.println(str2=="abc"); //false, 서로 다른 주소값
System.out.println(str1.equals("abc")); //true
System.out.println(str2.equals("abc")); //true
System.out.println(str2.equals("ABC")); //false, 대소문자 구분
System.out.println(str2.equalsIgnoreCase("ABC")); //true
}
}
---------------------------------------------------------------------------
package Week01;
public class OperatorEx3 {
public static void main(String[] args) {
//논리연산자 : &&, || -> 앞쪽 항만으로 결과가 결정되면 뒤쪽항을 실행하지 않는다.
// && : and
// || : or
int x = 15;
System.out.println(10>x && x++<20); //false
System.out.println("x="+x);// 15
System.out.println(10<x || x++<20); //true
System.out.println("x="+x); //15
System.out.println(10>x & x++<20); //false
System.out.println("x=" +x); //16
System.out.println(10<x | x++<20); //true
System.out.println("x=" +x); //17
// 조건연산자 : 조건식 ? 식1 : 식2 ->많이 쓰임.
// 참이면 식1, 거짓이면 식2 출력
int y, z;
int absX, absY, absZ;
char signX, signY, signZ;
x= 10;
y=-5;
z=0;
absX = x>=0 ? x : -x; //x의 값이 음수이면 ,양수로 만든다.
absY = y>=0 ? y : -y;
absZ = z>=0 ? z : -z;
}
}
---------------------------------------------------------------------------
package Week01.state;
//swtich 문 : 기능이 변경되더라도 소스는 변경되면 안됨.
public class Employee {
public static final int ENGINEER = 1;
public static final int MANAGER = 2;
public static final int SALESMAN = 3;
private int type;
public void setType(int type) {
this.type = type;
}
public Employee(int type) {
setType(type);
}
public int getAmount() {
switch(type){
case ENGINEER:
return 100;
case MANAGER:
return 100;
case SALESMAN:
return 100;
}
return 0;
}
}
package Week01.state;
//state 패턴 : 기능이 추가되도 객체만 추가하면 됨.
//객체를 던지는 부분
interface EmployeeType{ // 인터페이스 1개 박아놓는 개념. 프로토콜개념.(규칙)
public int getAmount(); //abstract가 생략된 거다.(인터페이스포함 멤버 메서드는 무조건 public abstract)
}
class Engineer implements EmployeeType{
public int getAmount() {
return 100;
}
}
class Manager implements EmployeeType{
public int getAmount() {
return 200;
}
}
class Salesman implements EmployeeType{
public int getAmount() {
return 300;
}
}
//객체를 받는 부분
public class Employee2 {
private EmployeeType type; //멤버변수
public Employee2(EmployeeType type) { //인터페이스도 상속처럼 받을 수있다. 상속은 가진게 많은 부모. 인터페이스는 가진게 없는 부모.
setType(type);
}
public void setType(EmployeeType type) {
this.type = type;
}
public void getAmount() {
type.getAmount();
}
//메소드 수정해보기.
// public static void main(String[] args) {
// Employee2 et = new Employee2();
// et.getAmount();
// }
}
---------------------------------------------------------------------------
package Week01;
public class InnerEx1 {
int m = 0;
class InstanceInner{
int iv = 100;
int t = m; //Outer의 멤버변수 접근가능
// static int cv = 100; //에러! static 변수를 선언할 수 없다.
final static int CONST = 100; //final static은 상수이므로 허용한다.
}
static class StaticInner{
int iv = 200;
//int t = m; //ERROR 발생
static int cv = 200; //static 클래스만 static 멤버를 정의할 수 있다.
}
void myMethod() {
class LocalInner{
int iv = 300;
int t = m; //Outer의 멤버변수 접근가능
// static int cv = 300; //에러! static 변수를 선언할 수 없다.
final static int CONST = 300; //final static은 상수이므로 허용
}
}
public static void main(String[] args) {
System.out.println(InstanceInner.CONST);
System.out.println(StaticInner.cv);
}
}
---------------------------------------------------------------------------
package Week01;
class Card{
final int NUMBER; //상수지만 선언과 함께 초기화 하지 않고
final String KIND; // 생성자에서 단 한번만 초기화할 수 있다.
static int width = 100;
static int height = 250;
Card(String kind, int num){
KIND = kind;
NUMBER = num;
}
Card(){
this("HEART", 1);
}
public String toString() {
return KIND + " " + NUMBER;
}
}
public class FinalCardTest {
public static void main(String[] args) {
Card c = new Card("HEART", 10);
//c.NUMBER = 5;
System.out.println(c.KIND);
System.out.println(c.NUMBER);
System.out.println(c);
// System.out.println(c.toString());
}
}
---------------------------------------------------------------------------
package Week01;
final class Human{ //final은 생성자를 통해 호출됨.
public void pro() {
System.out.println("pro");
}
}
/*
class Student extends Human{
public void info(){
System.out.println("info");
}
*/
class Student{
public void info() {
System.out.println("info");
}
}
public class FinalTest {
public static void main(String[] args) {
Student s = new Student();
s.info();
//s.pro();
}
}
---------------------------------------------------------------------------
package Week01.perani;
//클래스 다이어그램 실습
interface Race{
static void getRace(String race) { //static은 개체에 전체적인 사용목적이 있을때 사용함.
System.out.println(race);
}
}
class Animal{ //부모클래스에 abstract 넣는것이 좋다.
public String name;
public String type;
}
class Person extends Animal implements Race{
public String name;
public int age;
Animal[] animal;
public void speak(String name, int age, String animal) {
System.out.println("이름 = " + name);
System.out.println("나이 = " + age);
System.out.println("구분 = " + animal);
}
}
class KoreaPerson extends Person{
public void speak() {
}
}
class JapanPerson extends Person{
public void speak() {
}
}
public class PersonAnimal {
//main에서 test(검증)하는것.
public static void main(String[] args) {
Person pa = new Person();
pa.speak("홍길동", 23, "사람");
KoreaPerson kp = new KoreaPerson();
kp.speak("개똥이", 43, "한국사람");
JapanPerson jp = new JapanPerson();
jp.speak("켄조", 33, "일본사람");
}
}
---------------------------------------------------------------------------
/*Object Class*/
1. 최상위 클래스
2. 다른 모든 클래스(Interface제외)들은 명시적으로 상속받지 않아도 Object class를 상속 받고 있다.
protected Object clone() // 객체 자신의 복사본을 반환
public boolean equals(Object obj) // 객체 자신과 객체Obj가 같은 객체인지를 알려준다
public String toString() // 객체 자신의 정보를 문자열로 반환
*자바에서 생략된 형태들
default 생성자 : 클래스 내부에 아무런 생성자를 만들지 않으면 JVM은 자동적으로 default 생성자를 호출
this 예약어 : 클래스 멤버는 static을 제외하고는 모두 this객체를 통해 접근
0번째 매개변수 : static 메소드가 아닌 메소드엔 첫번째 매개변수 "자기클래스명 this"가 생략되어 있다.
toString() : 객체 이름을 출력하면 자동적으로 toString메소드를 출력한다
Object 클래스 상속 : 모든 Clsss 는 자동적으로 java.lang.Object 클래스가 상속되었다고 JVM이 인식
package Week01;
public class EqualsEx1 {
public static void main(String[] args) {
Value v1 = new Value(10); //값은 같지만 인스턴스는 다르므로
Value v2 = new Value(10); // 주소값이 다르다.
if(v1.equals(v2)) { //다르다. 주소값이므로 재정의 필요 . object는 주소값을 비교.
System.out.println("v1과 v2는 같습니다.");
} else {
System.out.println("v1과 v2는 다릅니다.");
}
v2 = v1;
if(v1.equals(v2)) { //같다
System.out.println("v1과 v2는 같습니다.");
} else {
System.out.println("v1과 v2는 다릅니다.");
}
} //main
}
class Value{
int value;
Value(int value){
this.value = value;
}
}
---------------------------------------------------------------------------
package Week01;
class Person2{
long id;
//Object의 equals를 Overriding
public boolean equals(Object obj) { //object에 대해서 재정의됨.
if(obj!=null && obj instanceof Person2) { //obj가 Person2의 Instance
return id ==((Person2)obj).id; // 값이 같은지 비교하는 equals? object?로 재정의됨.
} else {
return false;
}
}
Person2(long id){
this.id = id;
}
}
public class EqualsEx2 {
public static void main(String[] args) {
Person2 p1 = new Person2(801108111222L);
Person2 p2 = new Person2(801108111222L);
if(p1==p2) //다르다
System.out.println("p1과 p2는 같은 사람입니다.");
else
System.out.println("p1과 p2는 다른 사람입니다.");
if(p1.equals(p2)) //같다. 재정의되어 같다고 표시
System.out.println("p1과 p2는 같은 사람입니다.");
else
System.out.println("p1과 p2는 다른 사람입니다.");
}
}
---------------------------------------------------------------------------
package Week01;
class Card2{
String kind;
int number;
Card2(){
this("SPADE", 1); // Card(String kind, int number)를 호출
}
Card2(String kind, int number){
this.kind = kind;
this.number = number;
}
//재정의
public String toString() {
//Card 인스턴스의 kind와 number를 문자열로 반환한다.
return "kind : " + kind + ", number : " + number;
}
}
public class CardToString2 {
public static void main(String[] args) {
Card2 c1 = new Card2();
Card2 c2 = new Card2("HEART", 10);
System.out.println(c1.toString());
System.out.println(c2.toString());
}
}
---------------------------------------------------------------------------
package Week01;
class Point implements Cloneable{
int x;
int y;
Point(int x, int y){ //인터페이스 받는것은 반드시 재정의해줘야함.
this.x = x;
this.y = y;
}
public String toString() {// override
return "x= " + x + ", y = " + y;
}
public Object clone() { //override
Object obj = null;
try {
obj = super.clone(); //clone()은 반드시 예외처리를 해주어야 한다.
} catch(CloneNotSupportedException e) {}
return obj;
}
}
public class CloneEx1 {
public static void main(String[] args) {
Point original = new Point(3, 5);
Point copy = (Point)original.clone();
System.out.println(original);
System.out.println(copy);
}
}
---------------------------------------------------------------------------
package Week01;
import java.util.Arrays;
public class CloneEx2 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
//배열 arr을 복제해서 같은 내용의 새로운 배열을 만든다.
int[] arrClone = arr.clone();
arrClone[0] = 6;
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(arrClone));
}
}
---------------------------------------------------------------------------
package Week01;
//재귀함수
public class PowerTest {
public static void main(String[] args) {
int x = 2;
int n = 5;
long result = 0;
for(int i=1; i<=n; i++) { // 1<=5,
result+=power(x,i); // (2,1),
}
System.out.println(result); // 62
}
static long power(int x, int n) { // (2,5)
if(n==1) return x; //
return x*power(x, n-1); // 2*power(2,4)
}
}
