[JAVA]_8일차 실습

추상 클래스 실습

p01

Cat

package p01;

public class Cat extends Pet {
	

	int age;

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

	public Cat(String name, String sex, int age) {
		super(name, sex);
		this.age = age;
	} 
	
	public String getCat()
	{
		return name + "\t" + sex + "\t" + age; 
	}
	
}

Dog

package p01;

public class Dog extends Pet {
	
	int age;
	String species;
	
	public Dog() {
	}
	
	public Dog(String name, String sex, int age, String species) {
		super(name, sex);
		this.age = age;
		this.species = species;
	} 
	
	public String getDog() {
		return name + "\t" + sex + "\t" + age + "\t" + species; 
	}

}

Pet

package p01;

// 추상 클래스 
public abstract class Pet {

	// 필드 입력
	String name; 
	String sex;
	
	// 생성자 입력 
	public Pet() {
	}
	
	public Pet(String name, String sex) {
		this.name = name;
		this.sex = sex;
	} 
	
	// 메서드 입력 
	public String getPet() {
		return name + "\t" + sex; 
	}
	
	
	
}

TestPet

package p01;

public class TestPet {

	public static void main(String[] args) {

		
		// Pet p = new Pet();  추상클래스는 객체 생성 불가능  
		
		Cat c = new Cat("야옹", "암컷", 2); 
		Dog d = new Dog("망치", "수컷", 1, "불독"); 
		
		
		// 문제점: 각 클래스의 모든 정보를 출력하는 메서드가 다르다. 관리가 어려워짐. 
		System.out.println(c.getCat());
		System.out.println(d.getDog()); 
		
	}

}

p02

Cat

package p02;

public class Cat extends Pet {
	

	int age;

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

	public Cat(String name, String sex, int age) {
		super(name, sex);
		this.age = age;
	} 
	
	@Override
	public String getPet()
	{
		return name + "\t" + sex + "\t" + age; 
	}
	
}

Dog

package p02;

public class Dog extends Pet{
	
	int age;
	String species;
	
	public Dog() {
		
	}

	public Dog(String name, String sex, int age, String species) {
		super(name, sex);
		this.age = age;
		this.species = species;
	}
	

	public String getDog() {
		return name + "\t" + sex + "\t"+ age + "\t" + species;
	}
	
	
	
	
	
}

Pet

package p02;

// 추상 클래스 
public abstract class Pet {

	// 필드 입력
	String name; 
	String sex;
	
	// 생성자 입력 
	public Pet() {
	}
	
	public Pet(String name, String sex) {
		this.name = name;
		this.sex = sex;
	} 
	
	// 메서드 입력 
	public String getPet() {
		return name + "\t" + sex; 
	}
	
	
	
}

TestPet

package p02;

public class TestPet {

	public static void main(String[] args) {

		
		// Pet p = new Pet();  추상클래스는 객체 생성 불가능  
		
		Cat c = new Cat("야옹", "암컷", 2); 
		Dog d = new Dog("망치", "수컷", 1, "불독"); 
		
		
		// 문제점: 각 클래스의 모든 정보를 출력하는 메서드가 다르다. 관리가 어려워짐. 
		System.out.println(c.getPet());
		System.out.println(d.getDog()); 
		
		
	}

}

p03

Cat

package p03;

public class Cat extends Pet {
	

	int age;

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

	public Cat(String name, String sex, int age) {
		super(name, sex);
		this.age = age;
	} 
	
	@Override
	public String getPet()
	{
		return name + "\t" + sex + "\t" + age; 
	}
	
}

Dog

package p03;

public class Dog extends Pet {
	
	int age;
	String species;
	
	public Dog() {
	}
	
	public Dog(String name, String sex, int age, String species) {
		super(name, sex);
		this.age = age;
		this.species = species;
	} 
	
	@Override
	public String getPet() {
		return name + "\t" + sex + "\t" + age + "\t" + species; 
	}

}

Pet

package p03;

// 추상 클래스 
public abstract class Pet {

	// 필드 입력
	String name; 
	String sex;
	
	// 생성자 입력 
	public Pet() {
	}
	
	public Pet(String name, String sex) {
		this.name = name;
		this.sex = sex;
	} 
	
	// 메서드 입력 
	public abstract String getPet();
	
	
	
}

TestPet

package p03;

public class TestPet {

	public static void main(String[] args) {

		
		// Pet p = new Pet();  추상클래스는 객체 생성 불가능  
		
		Cat c = new Cat("야옹", "암컷", 2); 
		Dog d = new Dog("망치", "수컷", 1, "불독"); 
		
		
		// 문제점: 각 클래스의 모든 정보를 출력하는 메서드가 다르다. 관리가 어려워짐.
		// 해결: Pet 부모 클래스를 추상클래스로 만들고 자식에서 반드시 구현해야되는 메서드를
		//     Pet 부모 클래스에서 추상 메서드로 만든다.  
		
		System.out.println(c.getPet());
		System.out.println(d.getPet()); 
		
	
		//Pet p = new Pet();  추상클래스는 객체 생성 불가능  
		Pet p = new Cat();  // 추상 클래스를 상속받은 자식 클래스의 객체를 생성
		
		
	}

}

인터페이스 실습

java08_2

p01

Flyer.java

package p01;

public interface Flyer {
	
	public static final int NUM = 10; 
	int SIZE = 20; // 자동으로 public static final 지정됨 
	
	public abstract void a(); 
	void b(); // 자동으로 public abstract 지정됨
	
	public default void c() {
		System.out.println("default c()");
	}
	
	public static void d() {
		System.out.println("static d()");
	}

}

FlyerImpl

package p01;

public class FlyerImpl implements Flyer{

	@Override
	public void a() {
		System.out.println("FlyerImpl.a()");
	}

	@Override
	public void b() {
		System.out.println("FlyerImpl.b()");
		
	}
	
	

}

TestMain

package p01;

public class TestMain {

	public static void main(String[] args) {
		
		
		// 상수와 static 메서드 사용 
		System.out.println(Flyer.NUM);
		System.out.println(Flyer.SIZE);
		// static 메서드는 인터페이스 이름으로 접근 가능 
		Flyer.d(); 
		
		// Flyer f = new flyer(); Flyer는 인터페이스이기 때문에 인스턴스화가 불가능
		
		// 변수의 데이터 타입으로 인터페이스 사용 가능 
		// 인터페이스를 구현한 클래스 FlyerImpl
		FlyerImpl f = new FlyerImpl(); 
		f.a();
		f.b(); 
		
		// default 메서드는 객체 생성 후 사용가능 
		f.c(); 

	}

}

p02

Flyer

package p02;

public interface Flyer {
	
	public abstract void a(); 

}

Flyer2

package p02;

public interface Flyer2 {

	public abstract void b(); 

}

Flyer3

package p02;

// 인터페이스 간 다중 상속 적용 
public interface Flyer3 extends Flyer, Flyer2 {

	public abstract void c(); 

}

Flyer3Impl

package p02;

public class Flyer3Impl implements Flyer3 {

	@Override
	public void a() {
		// TODO Auto-generated method stub

	}

	@Override
	public void b() {
		// TODO Auto-generated method stub

	}

	@Override
	public void c() {
		// TODO Auto-generated method stub

	}

}

FlyerImpl

package p02;

public class FlyerImpl implements Flyer, Flyer2 {

	@Override
	public void b() {
		System.out.println("b()");
	}
	
	@Override
	public void a() {
		System.out.println("a()");
	}
	

 
}

p03

DBService

package p03;

// DBService 클래스 :  DB 연결 서비스를 제공
public class DBService {

	MySQLDAO dao;
	
	public void setDB(MySQLDAO dao) {
		this.dao = dao;
	}
	
	public void connectService() {
		dao.connectMySQL();
	}
}

MySQLDAO

package p03;

//Oracle DB 연동 클래스
public class MySQLDAO {

	public void connectMySQL() {
		System.out.println("MySQLDAO.connectMySQL()");
	}
}

OracleDAO

package p03;


//Oracle DB 연동 클래스
public class OracleDAO {

	public void connectOracle() {
		System.out.println("OracleDAO.connectOracle()");
	}
}

TestMain

package p03;
// DAO 패턴을 구현
public class TestMain {

	public static void main(String[] args) {
		
		//  DBService 객체를 생성
		DBService service = new DBService();
		// MySQLDAO 객체를 생성
		MySQLDAO dao = new MySQLDAO();
		// DBService 객체에 설정
		service.setDB(dao); 
		
		// DBService 객체의 connectService() 메서드를 호출하여 DB와 연결
		service.connectService();

	}

}

/*
 * 
 * 인터페이스를 활용하여 
 * DBService와 MySQLDAO 간의 결합도를 낮추고, 
 * 유연성을 높이는 것이 loosely coupling 또는 decoupling입니다.
 * 
 * 
 * 
 * DAO 패턴이 적용된 부분은 DBService 클래스와 MySQLDAO 클래스 사이의 인터페이스 활용입니다.
 *  DBService 클래스에서는 DB 인터페이스를 사용하여 MySQLDAO 클래스와의 결합도를 낮춥니다. 
 * */

java08_3

p01

TestMain

package p01;

class Outer{
	
	public int n = 10;
	protected int n2 = 20;
	int n3 = 30;
	private int n4 = 40;
	static int n5 = 50;
	
	public void a() {
		Inner inner = new Inner();
		inner.b();
	}
	
	//Member Inner Class
	static class Inner{		//Inner를 static으로 주면 static을 접근할 수 있지만 outer는 사용불가 아직 new가 생성되어있지않아서
		
		int x = 10;
		static int k = 10;		//Inner 클래스는 static을 가질 수 없다 생성 순서에 의해
		public void b() {
//			System.out.println(n);
//			System.out.println(n2);
//			System.out.println(n3);
//			System.out.println(n4);	//private 이라도 접근 가능
			System.out.println(n5);
			System.out.println(x);
		}
		
	}//end Inner
	
}//end Outer

public class TestMain {

	public static void main(String[] args) {
		
		// Outer 생성할 필요가 없음
		Outer.Inner inner = new Outer.Inner();
		inner.b();
		
		
	}

}

p02

TestMain

package p02;

class Outer{
	
	public int n = 10;
	protected int n2 = 20;
	int n3 = 30;
	private int n4 = 40;
	static int n5 = 50;
	
	public void a() {
		Inner inner = new Inner();
		inner.b();
	}
	
	//Member Inner Class
	class Inner{
		
		int x = 10;
//		static int k = 10;		//Inner 클래스는 static을 가질 수 없다 생성 순서에 의해
		public void b() {
			System.out.println(n);
			System.out.println(n2);
			System.out.println(n3);
			System.out.println(n4);	//private 이라도 접근 가능
			System.out.println(n5);
			System.out.println(x);
		}
	}//end Inner
	
}//end Outer


public class TestMain {

	public static void main(String[] args) {
		
		// Inner 사용 방법 1 - Outer생성하고 outer의 메서드 이용해서 Inner를 사용할 수 있다.
		Outer outer = new Outer();
		outer.a();
		
		// Inner 사용 방법 2 - 직접 호출
		Outer outer2 = new Outer();
		
		Outer.Inner inner = outer2.new Inner();
		inner.b();
		
		
	}

}

p03

TestMain

package p03;

interface Flyer {
	public abstract void a();
}

// 이름있는 클래스 
class Bird implements Flyer{
	
	@Override
	public void a() {
		System.out.println("bird.a()");
	}
} 

public class TestMain {
	
	public static void main(String[] args) {
		
		// 이름있는 클래스 
		Flyer f = new Bird(); 
		f.a(); 
		
		// 익명 클래스 (이름 없는 클래스, anonymous class)
		Flyer f2 = new Flyer() {
			
			@Override
			public void a() {
				System.out.println("Anonymous.a()");
				
			}
		};
		f2.a(); 
		
		Flyer f3 = new Flyer() {
			
			@Override
			public void a() {
				System.out.println("Anonymous22.a()");
			}
		};
		f3.a(); 
		
		
	}
	
	
}

java08_4

p01

TestMain

package p01;

@FunctionalInterface	// 추상메서드를 하나만 쓰게 강제하는 것
interface Flyer {
	public abstract void a();
}

@FunctionalInterface
interface Flyer2 {
	public abstract void b(int n, int n2);
}

@FunctionalInterface
interface Flyer3 {
	public abstract int c();
}

@FunctionalInterface
interface Flyer4 {
	public abstract int d(int n, int n2);
}

public class TestMain {

	public static void main(String[] args) {
		
		// 익명 클래스
		Flyer f1 = new Flyer() {
			
			@Override
			public void a() {
				System.out.println("Flyer.a()");
			}
		};
		
		f1.a();
		
		
		// 람다 표현식 (lambda expression, arrow expression)
		// 자바 스크립트 : => , 자바 : ->
		Flyer ff1 = () -> {
			System.out.println("람다1 Flyer.a()");
		};
		
		ff1.a();
		
		Flyer fff1 = () -> System.out.println("람다2 Flyer.a()");
		fff1.a();
		
		
		/////////////////////////////////////////////////
		
		Flyer2 f2 = new Flyer2() {
			
			@Override
			public void b(int n, int n2) {
				System.out.println("Flyer2.b()" + n + "\t" + n2);
			}
		};
		
		f2.b(10, 20);
		
		// 람다 표현식 -1
		Flyer2 ff2 = (int n, int n2) -> {
			System.out.println("람다표현식1 Flyer2.b()" + n + "\t" + n2);
		};
		ff2.b(10, 20);

		
		// 람다 표현식 -2
		Flyer2 fff2 = (n, n2) -> System.out.println("람다표현식1 Flyer2.b()" + n + "\t" + n2);
		fff2.b(10, 20);
		
		
		// ########################################
		// 익명 클래스
		Flyer3 f3 = new Flyer3() {
			
			@Override
			public int c() {
				return 100;
			}
		};
		System.out.println(f3.c());
		
		
		// 람다 표현식 -1
		Flyer3 ff3 = () -> {
			return 100;
		};
		System.out.println(ff3.c());
		
		
		// 람다 표현식 -2
		Flyer3 fff3 = () -> 100;
		System.out.println(fff3.c());
		
		
		
		// ########################################
		Flyer4 f4 = new Flyer4() {
			
			@Override
			public int d(int n, int n2) {
				return n + n2;
			}
		};
		System.out.println(f4.d(100, 200));
		
		
		// 람다 표현식 -1
		Flyer4 ff4 = (int n, int n2) -> {
			return n + n2;
		};
		System.out.println(ff4.d(100, 200));
		
		
		// 람다 표현식 -2 (매우 중요. 익숙해져야 된다)
		Flyer4 fff4 = (n, n2) -> n + n2;
		System.out.println(fff4.d(100, 200));
		
		
	}	// end main

}package p01;

@FunctionalInterface	// 추상메서드를 하나만 쓰게 강제하는 것
interface Flyer {
	public abstract void a();
}

@FunctionalInterface
interface Flyer2 {
	public abstract void b(int n, int n2);
}

@FunctionalInterface
interface Flyer3 {
	public abstract int c();
}

@FunctionalInterface
interface Flyer4 {
	public abstract int d(int n, int n2);
}

public class TestMain {

	public static void main(String[] args) {
		
		// 익명 클래스
		Flyer f1 = new Flyer() {
			
			@Override
			public void a() {
				System.out.println("Flyer.a()");
			}
		};
		
		f1.a();
		
		
		// 람다 표현식 (lambda expression, arrow expression)
		// 자바 스크립트 : => , 자바 : ->
		Flyer ff1 = () -> {
			System.out.println("람다1 Flyer.a()");
		};
		
		ff1.a();
		
		Flyer fff1 = () -> System.out.println("람다2 Flyer.a()");
		fff1.a();
		
		
		/////////////////////////////////////////////////
		
		Flyer2 f2 = new Flyer2() {
			
			@Override
			public void b(int n, int n2) {
				System.out.println("Flyer2.b()" + n + "\t" + n2);
			}
		};
		
		f2.b(10, 20);
		
		// 람다 표현식 -1
		Flyer2 ff2 = (int n, int n2) -> {
			System.out.println("람다표현식1 Flyer2.b()" + n + "\t" + n2);
		};
		ff2.b(10, 20);

		
		// 람다 표현식 -2
		Flyer2 fff2 = (n, n2) -> System.out.println("람다표현식1 Flyer2.b()" + n + "\t" + n2);
		fff2.b(10, 20);
		
		
		// ########################################
		// 익명 클래스
		Flyer3 f3 = new Flyer3() {
			
			@Override
			public int c() {
				return 100;
			}
		};
		System.out.println(f3.c());
		
		
		// 람다 표현식 -1
		Flyer3 ff3 = () -> {
			return 100;
		};
		System.out.println(ff3.c());
		
		
		// 람다 표현식 -2
		Flyer3 fff3 = () -> 100;
		System.out.println(fff3.c());
		
		
		
		// ########################################
		Flyer4 f4 = new Flyer4() {
			
			@Override
			public int d(int n, int n2) {
				return n + n2;
			}
		};
		System.out.println(f4.d(100, 200));
		
		
		// 람다 표현식 -1
		Flyer4 ff4 = (int n, int n2) -> {
			return n + n2;
		};
		System.out.println(ff4.d(100, 200));
		
		
		// 람다 표현식 -2 (매우 중요. 익숙해져야 된다)
		Flyer4 fff4 = (n, n2) -> n + n2;
		System.out.println(fff4.d(100, 200));
		
		
	}	// end main

}package p01;

@FunctionalInterface	// 추상메서드를 하나만 쓰게 강제하는 것
interface Flyer {
	public abstract void a();
}

@FunctionalInterface
interface Flyer2 {
	public abstract void b(int n, int n2);
}

@FunctionalInterface
interface Flyer3 {
	public abstract int c();
}

@FunctionalInterface
interface Flyer4 {
	public abstract int d(int n, int n2);
}

public class TestMain {

	public static void main(String[] args) {
		
		// 익명 클래스
		Flyer f1 = new Flyer() {
			
			@Override
			public void a() {
				System.out.println("Flyer.a()");
			}
		};
		
		f1.a();
		
		
		// 람다 표현식 (lambda expression, arrow expression)
		// 자바 스크립트 : => , 자바 : ->
		Flyer ff1 = () -> {
			System.out.println("람다1 Flyer.a()");
		};
		
		ff1.a();
		
		Flyer fff1 = () -> System.out.println("람다2 Flyer.a()");
		fff1.a();
		
		
		/////////////////////////////////////////////////
		
		Flyer2 f2 = new Flyer2() {
			
			@Override
			public void b(int n, int n2) {
				System.out.println("Flyer2.b()" + n + "\t" + n2);
			}
		};
		
		f2.b(10, 20);
		
		// 람다 표현식 -1
		Flyer2 ff2 = (int n, int n2) -> {
			System.out.println("람다표현식1 Flyer2.b()" + n + "\t" + n2);
		};
		ff2.b(10, 20);

		
		// 람다 표현식 -2
		Flyer2 fff2 = (n, n2) -> System.out.println("람다표현식1 Flyer2.b()" + n + "\t" + n2);
		fff2.b(10, 20);
		
		
		// ########################################
		// 익명 클래스
		Flyer3 f3 = new Flyer3() {
			
			@Override
			public int c() {
				return 100;
			}
		};
		System.out.println(f3.c());
		
		
		// 람다 표현식 -1
		Flyer3 ff3 = () -> {
			return 100;
		};
		System.out.println(ff3.c());
		
		
		// 람다 표현식 -2
		Flyer3 fff3 = () -> 100;
		System.out.println(fff3.c());
		
		
		
		// ########################################
		Flyer4 f4 = new Flyer4() {
			
			@Override
			public int d(int n, int n2) {
				return n + n2;
			}
		};
		System.out.println(f4.d(100, 200));
		
		
		// 람다 표현식 -1
		Flyer4 ff4 = (int n, int n2) -> {
			return n + n2;
		};
		System.out.println(ff4.d(100, 200));
		
		
		// 람다 표현식 -2 (매우 중요. 익숙해져야 된다)
		Flyer4 fff4 = (n, n2) -> n + n2;
		System.out.println(fff4.d(100, 200));
		
		
	}	// end main

}