개발일기

public class Car {
    //Car 클래스에는 다음과 같은 3개의 메소드가 들어있다.
    public void carOn() {
        System.out.println("시동을 겁니다.");
    }
    public void drive() {//오버라이딩 될 메소드
        System.out.println("일반 주행 중입니다.");
    }
    public void carOff() {
        System.out.println("시동을 끕니다.");
    }
}

public class SmartCar extends Car{
    public static final int NORMAL = 1;
    public static final int SMART = 2;

    public int driveMode = NORMAL;//driveMode는 기본적으로 NORMAL임

    @Override // 밑의 메소드가 오버라이딩된것이라는 것을 알려주는 어노테이션
    public void drive() {
        if(driveMode == NORMAL) {//driveMode가 NORMAL일 경우 부모 클래스인 Car 클래스의 drive 메소드를 사용.
            super.drive();
        }
        else {
            System.out.println("자동 주행 중입니다.");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        SmartCar smartCar = new SmartCar(); //객체 생성
        smartCar.carOn();
        smartCar.drive();
        smartCar.driveMode = SmartCar.SMART; //driveMode를 SMART로 바꿈
        smartCar.drive();
        smartCar.carOff();
    }
}

시동을 겁니다.
일반 주행 중입니다.
자동 주행 중입니다.
시동을 끕니다.

Car 클래서에서 정의된 drive 메소드를 SmartCar에서 오버라이딩한다.

driveMode가 NORMAL이면 super 키워드를 통해 부모 클래스의 drive메소드를 실행하고

SMART이면 자동주행중입니다를 출력한다.

super를 통해서 부모 클래스의 메소드를 접근했다.

class Animal {
    String name;

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

class Dog extends Animal {
    void sleep() {
        System.out.println(this.name + " zzz");
    }
}

class HouseDog extends Dog {
    void sleep() {
        System.out.println(this.name + " zzz in house");
    }

    void sleep(int hour) {
        System.out.println(this.name + " zzz in house for " + hour + " hours");
    }
}

public class Sample {
    public static void main(String[] args) {
        HouseDog houseDog = new HouseDog();
        houseDog.setName("happy");
        houseDog.sleep();  // happy zzz in house 출력
        houseDog.sleep(3);  // happy zzz in house for 3 hours 출력
    }
}

happy zzz in house
happy zzz in house for 3 hours

Dog 클래스의 sleep 함수를 상속받은 HouseDog 클래스에서 sleep 함수를 재정의 한다.

이것을 메소드 오버라이딩이라한다.

부모 클래스에 들어있는 함수 이름은 그대로 사용하되 내가 원하는 대로 내용만 바꿔서 사용한다.

실행결과는 HouseDog에서 정의한대로 in house가 붙어서 나온다.

public class Parent {
	String name;
	int age;
	private int money;
	
	Parent() {
		System.out.println("Parent 생성자 호출됨");
	}
	
	void print() {
		System.out.println("name : " + name);
		System.out.println("age : " + age);	
	}
	
	public int getMoney() {
		return money;
	}

	public void setMoney(int money) {
		this.money = money;
	}
	
}

public class Child extends Parent {
	// 이 클래스는, Parent 클래스가 가지고 있는
	// 속성들을, 상속받을 것이다.
	
	String hobby;
	
	Child() {
		System.out.println("Child 생성자 호출됨");
	}
	
	// setMoney()
	// getMoney()
	// print()
	
	// Method Overriding 메소드 오버라이딩
	// 상속받는 클래스엣!! 즉 자식클래스에서
	// 부모 클래스에 들어있는 함수 이름을 그대로 사용하되!!
	// 내가 원하는대로 내용만 바꿔서 사용하는거!!
	void print() {
		super.print();
		System.out.println("hooby : " + hobby);
	}
	// Method Overloading :
	// 하나의 클래스 안에서!! 똑같은 이름의 함수를 여러개 만드는거!!
}

public class ParentMain {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		// Parent 클래스를 변수로 생성 (객체 생성)
		Parent p = new Parent();
		p.name = "부모";
		p.age = 50;
		p.setMoney(1000000000);
		p.print();
		System.out.println("돈은 : " + p.getMoney() + "원");
		
		System.out.println();
		
		// 상속받은 Child 클래스를 메모리에 생성(객체 생성)
		Child c = new Child();
		c.name = "자식";
		c.age = 20;
		c.hobby = "게임";
		c.setMoney(1000000);
		System.out.println(c.getMoney());
		c.print();
		
		System.out.println();
		
		c.print();
		
		// name :
		// age :
		// hobby :
	}

}

부모클래스의 모든 속성을 상속받지만 private 변수는 억세스가 제한되고 getter setter를 이용해서 접근해야한다.

class Animal {
    String name;

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

class Dog extends Animal {
}

public class Sample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("poppy");
        System.out.println(dog.name);  // poppy 출력
    }
}

Animal 이라는 클래스를 상속받은 Dog클래스의 객체를 만들고 상속받은 setName함수를 실행해서 속성을 출력한다.

package main;

import main.caculate.Data;
import main.caculate.Data2;

public class AddMain {

	public static void main(String[] args) {
		
		// Data2 클래스를 객체 생성하면서!
		// 두 정수 3과 5를 넘겨주면, 두 정수의 합을 저장하도록
		// 하는 코드를 작성하세요.
		Data2 data2 = new Data2(3,5);
		
		data2.printInt();
		
		// 두 더블형 실수를 넘겨주면, 두 실수의 합을 저장
		Data2 data3 = new Data2(3.5, 4.6);
		data3.printDouble();
		
		// 두 문자열을 넘겨주면, 두 문자열을 붙여서 저장
		Data2 data4 = new Data2("aa", "bb");
		data4.printStr();
		
		
		Data data = new Data();
		
		int result = data.add(3, 5);
		
		System.out.println(result);
		
		// 두 실수(더블형) 더해서 화면에 출력!
		
		double result2 = data.add(1.3, 1.2);
		
		System.out.println(result2);
		
		// 두 문자열 더해서 화면에 출력!
		
		String result3 = data.add("aa", "bb");
		
		System.out.println(result3);
		
	}

}

package main.caculate;

public class Data2 {
	
	int resultInt;
	double resultDouble;
	String resultStr;
	
	public Data2(int x, int y) {
		resultInt = x + y;
	}
	
	public Data2(Double x, Double y) {
		resultDouble = x + y;
	}
	
	public Data2(String x, String y) {
		resultStr = x + y;
	}
	
	public void printInt() {
		System.out.println(resultInt);
	}
	
	public void printDouble() {
		System.out.println(resultDouble);
	}
	
	public void printStr() {
		System.out.println(resultStr);
	}


}

멤버변수는 메소드 밖에서 선언된 변수고 

로컬변수는 메소드 안에서 선언된 변수고 

로컬변수는 함수가 끝나면 사라지므로 객체에 저장하고 싶으면 멤버변수에 대입해야 한다.

위의 예제는 생성자에서 두 변수를 받아서 멤버변수에 저장하고 프린트하는 예제다.

package main;

import main.book.Member;

public class PhoneBookMain {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		// 멤버 클래스 생성하면서, 이름과 전화번호
		// 저장할 수 잇도록 만들어 주새요/
		Member m1 = new Member("Mike", "010-1222-2222");
		
		// 저장한 이름과 전화번호를
		// "Name : Mike, Phone : 010-1222-2222"
		// 출력해 주세요.
		
		m1.print();
		
		// 이름을, Harry로 변경하려 한다.
		// 왜냐하면, 보안 관점애서@@@
		// 따라서, 멤버변수들은 보통은, private으로 만들어놓는다)
		// 그리고, 함수로 접근을 허용해준다.
		
		m1.setName("Harry");
		m1.print();
		
		m1.setPhone("010-7777-2324");
		m1.print();
		
		
		
		// 두번째 멤버 데이터를 저장하려고 합니다.
		// 이번에는 객체를 먼저 생성하고 나서
		// 이름과 전번을 저장하도록 코드를 작성해 주세요.
		Member m2 = new Member();
		m2.setName("Hong");
		m2.setPhone("010-1234-5555");
		m2.print();
	}

}

package main.book;

public class Member {
	
	String name;
	String phone;
	
	public String getName() {
		return name;
	}

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

	public String getPhone() {
		return phone;
	}

	public void setPhone(String phone) {
		this.phone = phone;
	}

	public Member (String name, String phone) {
		this.name = name;
		this.phone = phone;
	}

	public Member() {
		// TODO Auto-generated constructor stub
	}

	public void print() {
		System.out.println("Name : " + name + ", Phone : " + phone);
	}
}

멤버 변수를 public으로하면 다른 패키지의 클래스에서도 직접 대입이 가능하다.

하지만 보안상 멤버 변수를 public으로 하기 보다는 getter setter함수를 만드는 게 더 낫다.

getter는 멤버변수를 리턴해주고

setter는 파라미터를 멤버변수에 대입해준다.

package myPack.test;

public class Member {
	
	public String name;
	public String phone;
	
	public Member (String name, String phone) {
		this.name = name;
		this.phone = phone;
	}

	public Member() {
		// TODO Auto-generated constructor stub
	}

	public void setMember(String name, String phone) {
		this.name = name;
		this.phone = phone;
	}

package myPack;

import myPack.test.Member;

public class PackMain {

	public static void main(String[] args) {
		System.out.println("Hello");
		
		// 친구 전번을 저장하기 위한 Member 객체를 저장한다.
		Member m1 = new Member();
		
		// 친구 Mike, 010-12345를 저장하세요.
		
		// 1. 다이렉트로 저장하는 방법
		m1.name = "Mike";
		m1.phone = "010-12345";
		
		// 2. Member 가 제공하는 함수로 저장하는 방법
		m1.setMember("Mike", "010-12345");
		
		// 객체를 생성한 후에, 데이터를 셋팅하려면
		// 따로 무엇인가를 해줘야 한다. "접근 제어자"
		
		
		
		// "Mike", "010-12345"를 아예
		// 객체 생성할때 저장하도록 하자.
		// 3. 생성자로 만드는 방법
		Member m2 = new Member("Mike", "010-12345");
	}

}

첫번째. 클래스의 속성에 직접 대입한다.

두번째. 클래스의 setter 함수를 이용한다.

세번째. 클래스의 생성자를 이용한다.

class Member {
	String name;
	String tel;
	String address;
	
	// 생성자 : 함수의 리턴타입이 없고! 클래스의 이름과 같은함수
	// 메모리에 영역을 확보하고, 바로 멤버변수에 데이터를 셋팅!
	public Member(String name, String tel, String address) {
		this.name = name;
		this.tel = tel;
		this.address = address;
	}
	
	public Member() {
		 
	}
	
	public void setMember(String name, String tel, String address) {
		this.name = name;
		this.tel = tel;
		this.address = address;
	}
	public void print() {
		System.out.println("name:" + name + " , tel : " + tel);
		System.out.println("Address : " + address);
	}
}
public class MemberMain {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		Member m1 = new Member("Mike", "010-1234-5678", "Seoul 101");
		
		m1.print();
		
		
		Member m2 = new Member();
		m2.setMember("Hong", "333-3333", "Incheon");
		
		m2.print();

	}

}

생성자의 리턴타입은 없고 클래스의 이름과 같은 함수다.

클래스 객체 생성할 때 파라미터 대입해주면 된다.

생성자도 파라미터를 다르게 하여 메소드 오버로딩을 할 수 있다.

public class Member {
	String name;
	String tel;
	String address;
    
    void setMember(String name, String tel, String address) {
		this.name = name;
		this.tel = tel;
		this.address = address;
	}
}

this로 클래스의 멤버변수에 위와같이 대입할 수 있다.

// 두 데이터를 더하는 클래스
class Add {
	// 두개의 정수를 더해서 리턴하는 함수
	
	// 함수의 파라미터나, 리턴데이터타입이 다르면,
	// 함수의 이름을 똑같이 할 수 있다.
	// 이런방법을 메소드 오버로딩 이라고 한다.
	public int add(int x, int y) {
		return x + y;
	}
	
	public float add(float x, float y) {
		return x + y;
	}
	
	public double add(double x, double y) {
		return x + y;
	}
	
	public String add(String x, String y) {
		return x + y;
	}
}

public class AddMain {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		// 클래스를 가지고 변수를 만드는것을
		// 객체 생성 이라고 한다.
		Add a = new Add();
		
		int result = a.add(3, 5);
		System.out.println(result);

		float result2 = a.add(3.5f, 1.8f);
		System.out.println(result2);
        
		double result3 = a.add(3.8, 1.9);	
		System.out.println(result3);

		String result4 = a.add("Hello", "bye");	
		System.out.println(result4);
		

	}

}

함수의 이름은 같으나 함수의 리턴타입이나 파라미터가 다른 함수들을 만들 수 있다.

이것을 메소드 오버로딩이라한다.

위의 예제 처럼 함수 이름은 add로 같지만 파라미터를 다르게 받아서 더하기를 수행한다.