@Override 어노테이션
package kr.or.ksmart;
class Car{
private int num;
private int gas;
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public int getGas() {
return gas;
}
public void setGas(int gas) {
this.gas = gas;
}
}
class Bus extends Car{
@Override
public void setGas(int gas) {
super.setGas(gas + 1000);
}
}
class Sport extends Car{
@Override
public void setGas(int gas) {
super.setGas(gas + 500);
}
}
public class JavaBasic01 {
public static void main(String[] args) {
/**
* 오버라이딩
* - 슈퍼클래스의 메서드와 동일한 메서드 명과 인수로 재 구현하는 방식
* - 슈퍼클래스의 메서드를 재 구현 할시 @Override 어노테이션이 붙는다.
*/
String type = "bus";
Car car = null;
if("car".equals(type)) {
car = new Car();
}else if("bus".equals(type)) {
car = new Bus();
}else if("sport".equals(type)) {
car = new Sport();
}
car.setGas(1000);
System.out.println(car.getGas() + " << " + type + " gas");
}
}
final
package kr.or.ksmart;
class Sample{
public void print(String print) {
System.out.println(print);
}
public final void print(String print, String type) {
System.out.println(print + " : " + type);
}
}
class SubSample extends Sample{
@Override
public void print(String print) {
super.print(print);
}
}
public class JavaBasic02 {
//상수 만들기
public final static String ADD = "전주시";
public static void main(String[] args) {
/**
* final
* - 더 이상 변경이 불가능하도록 만드는 키워드
*
* 상수 : final 키워드가 붙으며 변수명은 주로 대문자로 쓰인다.
* 메서드 : 메서드에 final이 붙을 경우 오버라이딩을 할 수 없다.
* 클래스 : 클래스에 final이 붙으면 상속을 할 수 없다.
*/
//ADD = "전북 전주시";
}
}
extends 키워드가 (상속)이 없는 클래스는 기본적으로 Object 클래스를 상속 받는다.
package kr.or.ksmart;
import java.lang.reflect.Method;
class Sample2{
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class JavaBasic03 {
public static void main(String[] args) {
Sample2 s = new Sample2();
/**
* Sample2클래스는 extends 키워드가 (상속)이 없기때문에 기본적으로
* Object 클래스를 상속 받는다.
*/
Class sampleClass = s.getClass();
//네임스페이스 가지고 오기
System.out.println(sampleClass.getName() + " << Class 명 가지고 오기");
Method[] mArray = sampleClass.getMethods();
for(int i=0; i < mArray.length; i++) {
Method m = mArray[i];
System.out.println(m.getName());
}
}
}
추상클래스
package kr.or.ksmart;
abstract class Sample3{
public abstract void print();
}
class SubSample3 extends Sample3{
@Override
public void print() {
System.out.println("추상 메서드 구현");
}
}
public class JavaBasic04 {
public static void main(String[] args) {
/**
* 추상클래스
* - 클래스명 앞에 abstract 키워드가 붙는다.
* - abstract 키워드가 붙은 추상 메서드를 구현할 수 있다.
* - 추상클래스는 일반적은 메서드 및 필드도 구현이 가능하다.
* - 추상적인 클래스는 직접 인스턴스화를 할 수 없다.
* - 추상 메서드는 몸체가 없다. ('{ }' 구현부가 생략되어야 한다.)
* - 추상 메서드는 서브 클래스에서 필히 구현이 되어야한다.(오버라이딩)
*/
//추상 클래스는 직접 인스턴스화를 할 수 없다.
//Sample3 sample3 = new Sample3();
//추상적인 클래스를 상속받아 구현된 서브클래스
//추상클래스가 직접 인스턴스화를 하는게 아니라 슈퍼클래스
//참조타입으로 서브클래스가 인스턴스화된다.
Sample3 s = new SubSample3();
}
}
package kr.or.ksmart;
abstract class Calculator {
protected int n1;
protected int n2;
public abstract void sum(int n1, int n2);
public final int print() {
return n1 + n2;
}
}
class Sum extends Calculator {
@Override
public void sum(int n1, int n2) {
super.n1 = n1;
super.n2 = n2;
}
}
public class JavaBasic05 {
public static void main(String[] args) {
Calculator cal = new Sum();
cal.sum(10,20);
System.out.println(cal.print());
}
}
package kr.or.ksmart;
class User{
private String name;
private String age;
public User(String name, String age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public String getAge() {
return age;
}
@Override
public String toString() {
return "User [name=" + name + ", age=" + age + "]";
}
}
class ComPanyUser extends User{
public ComPanyUser(String name, String age) {
super(name, age);
}
}
public class JavaBasicEx01 {
public static void main(String[] args) {
/**
* 실습1. User클래스가 있다. User클래스를 확장시켜
* ComPanyUser를 구현하고 인스턴스화를 하여 호출하여라.
*/
ComPanyUser comUser = new ComPanyUser("홍길동","20");
User user = comUser;
}
}
package kr.or.ksmart;
class Car2{
private String number;
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
}
class Bus2 extends Car2{
@Override
public void setNumber(String number) {
super.setNumber("B " + number);
}
}
class Sport2 extends Car2{
@Override
public void setNumber(String number) {
super.setNumber("S " + number);
}
}
public class JavaBasicEx02 {
public static void main(String[] args) {
/**
* 실습2. Car2라는 클래스가 있다. Car2의 필드에는 String 타입의 number변수가 있다.
* 그리고 setNumber, getNumber 메서드도 가지고 있다.
* Car2를 상속받아 구현된 클래스는 Bus2와 Sport2클래스가 있으며,
* Bus2와 Sport2의 클래스에서 Car2의 메서드 setNumber를 오버라이딩하여
* 메서드를 재구현하였다.
* Bus2와 Sport2의 클래스에서 getNumber 메서드 호출시
* Bus2클래스의 getNumber 결과값은 'B 번호'로 가공되서 결과물 출력
* Sport2클래스의 getNumber 결과값은 'S 번호'로 가공되서 결과물 출력 되도록 하여라.
*/
Car2 car = null;
String type = "bus";
if("car".equals(type)) {
car = new Car2();
}else if("bus".equals(type)) {
car = new Bus2();
}else if("sport".equals(type)) {
car = new Sport2();
}
car.setNumber("1234");
System.out.println(car.getNumber() + " << " + type + " number");
}
}
package kr.or.ksmart;
abstract class Document{
protected String documentName;
public abstract int writeProcess(String documentName) ;
public final int approval() {
System.out.println(documentName + " 결재 완료");
return 1;
}
}
class Vacation extends Document{
@Override
public int writeProcess(String documentName) {
//휴가 관련된 데이타 db에 등록
this.documentName = documentName;
System.out.println(documentName + " 작성 완료");
return 1;
}
}
class BusinessTrip extends Document{
@Override
public int writeProcess(String documentName) {
//출장에 관련된 데이타 db에 등록
this.documentName = documentName;
System.out.println(documentName + " 작성 완료");
return 0;
}
}
public class JavaBasicEx03 {
public static void main(String[] args) {
/*
* 실습3. Document라는 추상 클래스가 있다.
* writeProcess라는 추상 메서드를 가지고
* approval이라는 final 메서드가 있다.
* Document를 상속받아 구현되는 휴가신청서, 출장신청서 클래스를 만들어 구현하고
* 호출하여라.
* */
Document doc = null;
String type = "vacation";
if("vacation".equals(type)) {
doc = new Vacation();
}else if("businessTrip".equals(type)) {
doc = new BusinessTrip();
}
doc.writeProcess(type);
doc.approval();
}
}