** 문법 **
trim() : 문자열의 맨앞과 맨 뒤 공백만 제거
replace(" ","") : 문자열에서 첫번째 인수를 찾아 두번쨰 인수로 변경
replaceAll(" ", "") : 문자열에서 첫번째인수를 찾아 두번째 인수로 변경
public class MyProject1121_7 {
public static void main(String[] args) {
//접근제어자
//******************************************************************************
/* 문법
trim() : 문자열의 맨앞과 맨 뒤 공백만 제거
replace(" ","") : 문자열에서 첫번째 인수를 찾아 두번쨰 인수로 변경
replaceAll(" ", "") : 문자열에서 첫번째인수를 찾아 두번째 인수로 변경
*/
String tmp = " 홍 길동 ";
System.out.println("trim() : [" + tmp.trim() + "]");
System.out.println("replace() : [" + tmp.replace(" ", "") + "]");
System.out.println("replace() : [" + tmp.replaceAll(" ", "홍") + "]");
//******************************************************************************
}
}
** 실습 1122 (접근제어자 + 오버라이딩)**
/* 접근제어자, 오버라이딩
*출력예)좋은 아침입니다. 오전에는 맑음 입니다.
* 즐거운 점심입니다. 점심에는 흐림입니다.
* 행복한 오후되세요. 오후에는 비가 내리겠습니다.
*단, greeting메서드를 이용함
*/
class Today{ //extends Object 생략
private String weather;
public String getWeather() {
return this.weather;
}
public void setWeather(String weather) {
this.weather = weather;
}
void greeting() {
System.out.println("즐거운 하루 되세요.");
}
// //자식클래스 생성자에 super(weather); 사용할 경우
// Today(String weather){
// setWeather(weather);
// }
}
class Morning extends Today{
Morning(String weather){
//super(); //생략되어있다.
setWeather(weather); //super. 생략됨 (Morning 클래스에 setWeather 메서드가 없기때문)
// //super(weather);
}
void greeting() {
System.out.println("좋은 아침입니다. 오전에는 " + super.getWeather() + "입니다.");
//super. 생략가능 (Morning 클래스에 setWeather 메서드가 없기때문)
}
}
class Lunch extends Today{
Lunch(String weather){
setWeather(weather);
}
void greeting() {
System.out.println("즐거운 점심 입니다. 점심에는 " + getWeather() + "입니다.");
}
}
class Dinner extends Today{
Dinner(String weather){
super.setWeather(weather);
}
void greeting() {
System.out.println("행복한 오후되세요. 오후에는 " + getWeather() + "가 내리겠습니다.");
}
}
public class MySample1122 {
public static void main(String[] args) {
//상속 + 오버라이딩
Morning m = new Morning("맑음");
Lunch l = new Lunch("흐림");
Dinner d = new Dinner("비");
m.greeting();
l.greeting();
d.greeting();
}
}
** 실습 1122_2 (오버라이딩 + 접근제어자) **
class Car3{
private int door;
private String gearType;
private String color;
Car3(String color){
//setColor(color);
//setGearType("auto");
//setDoor(4);
this(color, "auto", 4); //this. 같은 클래스 내에있는 타입갯수와 종류에 맞는 생성자 불러옴
}
Car3(String color, String gearType){
//setColor(color);
//setGearType(gearType);
//setDoor(4);
this(color, gearType, 4);
}
Car3(String color, String gearType, int door){
setColor(color);
setGearType(gearType);
setDoor(door);
}
public int getDoor() {
return this.door;
}
public void setDoor(int door) {
this.door = door;
}
public String getGearType() {
return this.gearType;
}
public void setGearType(String gearType) {
this.gearType = gearType;
}
public String getColor() {
return this.color;
}
public void setColor(String color) {
this.color = color;
}
}
class SportsCar extends Car3{
int speedLimit; //제한속도
SportsCar(String color){
super(color);
//setColor(color); //super(); 생략되어있어서 오류남
this.speedLimit = 200;
}
SportsCar(String color, int speedLimit){
super(color);
this.speedLimit = speedLimit;
}
SportsCar(String color, String gearType){
super(color, gearType);
this.speedLimit = 200;
}
SportsCar(String color, String gearType, int speedLimit){
super(color, gearType);
this.speedLimit = speedLimit;
}
SportsCar(String color, String gearType, int door, int speedLimit){
super(color, gearType, door);
this.speedLimit = speedLimit;
}
public String toString() {
return "차량의 색은 "+ getColor() +"이고, " + getGearType() + "이며, 문의 개수는 " + getDoor() + "개이며," + " 제한 속도는 " + speedLimit + " 입니다.";
}
}
public class MySample1122_2 {
public static void main(String[] args) {
/*
실행결과)차량의 색은 red이고, auto이며, 문의 개수는 4개이며,
제한 속도는 330 입니다.
(단, 차량 색은 반드시 입력받고, 제한속도가 없을 경우 200, 기어타입이 없을 경우 auto로 정의함)
문 개수가 없을 경우 기본 4개로 정의함.
클래스와 변수는 세팅되있는것만 사용한다.
단 정수가 하나만들어온 경우 speedLimit으로 여긴다.
*/
SportsCar cs = new SportsCar("red", 330);
System.out.println(cs.toString()); //.toString 생략되어있음
}
}
** 다형성(polymorphism) **
하나의 객체가 여러가지 타입을 가질 수 있는 것을 의미.
부모 클래스 타입의 참조 변수로 자식클래스 타입의 인스턴스를 참조 할 수 있도록 구현.
참조 변수의 다형성
class Parent{...}
class Chlid extends Parent{...}
...
Parent pa = new Parent(); // 허용
chlid ch = new Child(); // 허용
Parent pc = new Chlid(); // 허용
Child cp = new Parent(); // 오류 발생
//상속을 통해 확장된 수 있으나 축소될수는 없음. 자식클래스에서 사용할 수 있는 멤버(인스턴스변수, 인스턴스 메소드...)의 개수가 언제나 부모 클래스와 같거나 많게됨
instanceof : 연산자 / 참조변수가 참조하고 있는 인스턴스 실제 타입 확인
문법)참조변수 instanceof 클래스이름 -> true, false 리턴
다형성에서 어떠한 변수와 메소드를 사용할 것인가? * 인스턴스 변수 // 부모에게 있고 자식에도 있으면 -> 부모꺼 실행 // 부모에게 있고 자식에게 없으면 -> 부모꺼 실행 // 부모에는 없고 자식에게 있으면 -> 오류2 * 메소드 // 부모에게 있고 자식에도 있으면 -> 자식꺼 실행 (메소드 오버라이딩) // 부모에게 있고 자식에게 없으면 -> 부모꺼 실행 // 부모에는 없고 자식에게 있으면 -> 오류2 |
** 1122_3 예제 (다형성) **
class A{
void methodA() {
System.out.println("methodA()...");
}
}
class B extends A{
void methodB() {
System.out.println("methodB()...");
}
}
public class MySample1122_3 {
public static void main(String[] args) {
A obj = new B();
obj.methodA(); //가능
// obj.methodB(); //불가능
B obj2 = new B();
obj.methodA(); //가능
obj2.methodB(); //가능
}
}
** 예제 1122_4 (다형성) **
class Car4{
String color;
int door;
void drive() {
System.out.println("drive()...Car4");
}
void stop() {
System.out.println("stop()...Car4");
}
}
class FireEngine extends Car4{
void water() {
System.out.println("water()...FireEngine");
}
}
public class MySample1122_4 {
public static void main(String[] args) {
// 다형성
// Car4 c = null;
// FireEngine f = new FireEngine();
// FireEngine f2 = null;
//
// f.water();
// c = f; //다형성 => Car4 c = new FireEngine(); 과 같다.
// //내부적으로 형변환이 발생했음.(up-casting)
//
// //c.water(); //불가능(부모형 참조변수로 자식객체를 바라볼수 있으나 자식객체에 메서드는 사용할 수 없음)
//
// f2 = (FireEngine)c; //안되지만 (FireEngine)으로 강제 형변환해서 사용가능
// //down-casting이므로 강제 형변환 꼭해야함.
// f2.water();
//불가능한예제
Car4 c = new Car4(); //= new FireEngine();로 변경하면 1.싫애시에도오류안남
// Car4 c = new FireEngine();
Car4 c2 = null;
FireEngine f = null;
Car4 c3 = new FireEngine();
c.drive();
//f = (FireEngine)c; //f = c; 는 불가능 하나 형변환을 통해서 가능
//컴파일은 가능하나 시행시 오류 발생
f.drive(); // 실행시오류
c2 = f; //up-casting
//c2.water(); //불가능 : c2 참조변수는 클래스 타입이 Sard4이고 water()a메서드는
c2.drive();
c2.stop(); // FireEngine클래스의 메서드이기 떄문에 호출불가
}
}
** 예제 1122_6 (다형성) **
class Animal3{
void breath() {
System.out.println("숨쉬기");
}
public String toString() {
return "몰라";
}
}
class Lion3 extends Animal3{
public String toString() {
return "사자";
}
}
class Rabbit extends Animal3{
public String toString() {
return "토끼";
}
}
class Monkey extends Animal3{
public String toString() {
return "원숭이";
}
public void printA() {
System.out.println("printA()...");
}
}
class ZooKeeper{
// void feed(Lion3 lion) {
// System.out.println(lion + "에게 먹이주기...");
// }
//
// void feed(Rabbit rabbit) {
// System.out.println(rabbit + "에게 먹이주기...");
// }
//
// void feed(Monkey monkey) {
// System.out.println(monkey + "에게 먹이주기...");
// }
void feed(Animal3 animal) {
System.out.println(animal + "에게 먹이주기...");
}
}
public class MySample1122_5 {
public static void main(String[] args) {
// 다형성
ZooKeeper j = new ZooKeeper();
//
// Lion3 lion1 = new Lion3();
// j.feed(lion1);
//
// Rabbit rabbit = new Rabbit();
// j.feed(rabbit);
//
// Monkey monkey = new Monkey();
// j.feed(monkey);
Animal3 lion1 = new Lion3(); //객체생성은 Lion3, 바라보는관점은 Animal3 -> Animal3에 있는 것들을 사용할 수 있음
j.feed(lion1);
Animal3 rabbit = new Rabbit();
j.feed(rabbit);
Animal3 monkey = new Monkey();
j.feed(monkey);
j.feed(new Animal3()); // Animal3 animal = new Monkey(); //다시보기!!!!
monkey.printA(); // 오류 : monkey참조변수는 Animal3클래스의 참조변수이므로
// Monkey() 클래스에 있는 printA()메서드 접근 불가능
}
}
** 예제 1122_6 (다형성_ 연산자 instanceof) **
class Parent3{
}
class Child3 extends Parent3{
}
class Brother extends Parent3{
}
public class MySample1122_6 {
public static void main(String[] args) {
// 다형성 (instanceof 연산자)
Parent3 p = new Parent3();
System.out.println(p instanceof Object); // true
System.out.println(p instanceof Parent3); // true
System.out.println(p instanceof Child3); // false
Parent3 p2 = new Child3();
System.out.println(p2 instanceof Object); // true
System.out.println(p2 instanceof Parent3); // true
System.out.println(p2 instanceof Child3); // true
//부모에게 있고 자식에도 있으면 -> 자식꺼 실행
//부모에게 있고 자식에게 없으면 -> 부모꺼 실행
//부모에는 없고 자식에게 있으면 -> 오류
}
}
'수업끄적끄적_7MONTH > Java' 카테고리의 다른 글
11/28 수업 (19회차) _ 인터페이스 (0) | 2023.11.28 |
---|---|
11/23 수업 (18회차) _ 다형성 예제 / Vector 클래스 / 추상 클래스 (1) | 2023.11.23 |
11/21 수업 (16일차) _ 오버라이딩 / 접근 제어자 (3) | 2023.11.21 |
11/17 수업 (15회차) _ 상속 (1) | 2023.11.17 |
11/16 수업 (14회차) _ 메소드 오버로딩 / 생성자 (0) | 2023.11.16 |