05.18 람다표현식, 스레드
package l1_example;
public class MessageButton {
private String title;
public MessageButton(String title) {
this.title = title;
}
public void onTouch() {
System.out.println("메세지를 전달합니다.");
}
@Override
public String toString() {
return "MessageButton [title=" + title + "]";
}
}
package l1_example;
public class MessageListener implements OnClickListener {
@Override
public void onClick() {
System.out.println("click! 메세지를 전달합니다.");
}
}
package l1_example;
public class CallListener implements OnClickListener{
@Override
public void onClick() {
System.out.println("click 전화 걸기 뚜~ 뚜~");
}
}
package l1_example;
@FunctionalInterface //(인터페이스의 메소드가1개여야 람다식 쓸 수 있다.)
interface OnClickListener{
void onClick();
}
public class Button {
private OnClickListener listener;
private String title;
public Button(String title) {
this.title = title;
}
void setOnClickListener(OnClickListener listener) {
this.listener = listener;
}
public void onTouch() {
listener.onClick();
}
@Override
public String toString() {
return "Button [" + "title=" + title + "]";
}
}
package l1_example;
public class ButtonExample {
public static void main(String[] args) {
MessageButton mButton = new MessageButton("메세지");
mButton.onTouch();
Button button = new Button("메세지");
button.setOnClickListener(new MessageListener());
button.onTouch();
Button callButton = new Button("전화");
callButton.setOnClickListener(new CallListener());
callButton.onTouch();
Button loginButton = new Button("로그인");
//재활용성 없으니까 일일이 클래스 만들 필요 없이 익명구현객체 생성도 가능
OnClickListener clickListener = new OnClickListener() {
@Override
public void onClick() {
System.out.println("로그인 수행");
}
};
loginButton.setOnClickListener(clickListener);
loginButton.onTouch();
//변수저장없이 바로 익명구현객체 생성
Button joinButton = new Button("회원가입");
joinButton.setOnClickListener(new OnClickListener() {
@Override
public void onClick() {
System.out.println("회원가입 수행");
}
});
joinButton.onTouch();
// lambda expression
Button btnClick = new Button("페이지이동");
btnClick.setOnClickListener(()->{
System.out.println("로그인페이지로 이동");
});
btnClick.onTouch();
}
}
package l2_basic;
@FunctionalInterface
public interface MyInterface {
void method();
}
package l2_basic;
import javax.annotation.processing.SupportedSourceVersion;
public class LambdaExample {
public static void main(String[] args) {
// 람다 표현식 - 메소드를 하나의 식으로 표현 한 것
// 프로그래밍 언어에서는 익명 함수를 지칭한다.
MyInterface myInterface = new MyInterface() {
@Override
public void method() {
System.out.println("myInterface method 실행");
}
};
myInterface.method();
// 함수에서 수행될 실행문이 하나면 {} 블럭 생략 가능
myInterface = () -> System.out.println("rambda method 실행");
myInterface.method();
myInterface = () -> {
String str = "method Call";
System.out.println(str + "실행 블럭 1");
System.out.println("실행 블럭 2");
};
myInterface.method();
}
}
package l3_args;
public interface MyInterface {
void method(int x);
}
interface MyInterface1{
void method(int x, int y);
}
package l3_args;
public class LambdaExample {
public static void main(String[] args) {
MyInterface1 i1 = new MyInterface1() {
@Override
public void method(int x, int y) {
int sum = x + y;
System.out.println("sum : " + sum);
}
};
i1.method(10, 30);
//i1 = (int a, int b) ->{
// 매개변수 타입 생략 가능
i1 = (a, b) ->{
int result = a * b;
System.out.println("result : " + result);
};
i1.method(10, 30);
// 전달 받는 매개변수가 1개 일때는 () 소괄호 블럭 생략 가능
MyInterface my2 = a -> {
System.out.println("hello!" + a);
};
my2.method(10);
}// end main
}
package l4_return;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
interface MyInterface{
int method(int x, int y, String s);
}
public class LambdaReturnExample {
public static void main(String[] args) {
MyInterface m1 = new MyInterface() {
@Override
public int method(int x, int y, String s) {
System.out.println(s);
return x * y;
}
};
int result = m1.method(10, 5, "multiply");
System.out.println("result : "+ result);
m1 = (a,b,s) -> {
System.out.println(s);
return a + b;
};
Set<Integer> set = new TreeSet<>(new Comparator<>() {
@Override
public int compare(Integer o1, Integer o2) {
// 오름차순
return o1-o2;
}
});
//람다표현식
set = new TreeSet<>((o1,o2)->{
return o2 - o1;
});
}
}
package t01_create_thread;
import java.awt.Toolkit;
public class BeepThreadExample {
//프로그램 실행 시 생성되는 thread - Main thread
// main thread는 main 함수를 호출하고
// main 함수가 종료되면 thread도 종료된다.
public static void main(String[] args) {
System.out.println("Main 시작");
// 현재 실행문이 실행중인 스레드를 반환
System.out.println(Thread.currentThread());
for(int i = 0; i < 5; i++) {
System.out.println("띵!");
// 현재 작업 중인 스레드를 0.5초(millis)만큼 blocking
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//운영체제의 하드웨어 제어를 하는 툴 킷
Toolkit tool = Toolkit.getDefaultToolkit();
//모니터 스크린 사이즈
System.out.println(tool.getScreenSize());
for(int i = 0; i< 5; i++) {
tool.beep();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Main 종료");
}
}
package t01_create_thread;
import java.awt.Toolkit;
public class BeepThread extends Thread{
@Override
public void run() {
Toolkit tool = Toolkit.getDefaultToolkit();
for(int i = 0; i < 5; i++) {
System.out.println("BeepThread");
tool.beep();
try {
Thread.sleep(1000);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
package t01_create_thread;
public class MultiThreadExample {
public static void main(String[] args) {
System.out.println("Main 시작");
Thread t = new BeepThread();
//t.run();
//새로운 작업 스레드 생성 및 스레드 작업 수행
t.start();
// 2. 작업을 전달받는 스레드 생성
Runnable run = new PrintTask();
Thread t1 = new Thread(run);
t1.start();
// 3. Runnable 익명 구현 객체 전달
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0; i< 5; i++) {
System.out.println("t2");
}
}
});
t2.start();
// 4. Runnable 익명 구현 객체를 람다식으로 표현(제일 많이 사용됨)
Thread t3 = new Thread(()->{
for(int i = 0; i<5; i++) {
System.out.println("t3");
}
});
t3.start();
System.out.println("Main 종료");
}
}
package t01_create_thread;
//Runnable : 스레드가 수행해야할 작업을 구현하는 인터페이스~
public class PrintTask implements Runnable{
@Override
public void run() {
for(int i = 0; i < 5; i++) {
System.out.println("PrintTask : 띵!");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
package t02_priority;
public class CalcThread extends Thread {
public CalcThread(String name) {
// thread 이름 지정
// Thread 부모 생성자를 통해 스레드 이름 초기화
super(name);
}
@Override
public void run() {
for(int i = 0; i < 2000000000; i++);
// thread 이름, 스레드의 우선 순위 출력
System.out.println(getName()+":"+getPriority());
// 현재 런메소드를 실행중인 Thread 정보
System.out.println(Thread.currentThread());
}
}
package t02_priority;
public class PriorityExample {
public static void main(String[] args) {
// Thread 는 상수값으로 우선순위의 범위를 알려줌 1 ~ 5 ~ 10
System.out.println(Thread.MAX_PRIORITY); // 10
System.out.println(Thread.NORM_PRIORITY); // 5
System.out.println(Thread.MIN_PRIORITY); // 1
for(int i = 1; i <= 10; i++) {
Thread calc = new CalcThread("THREAD-"+i);
if(i == 5) {
calc.setPriority(Thread.MAX_PRIORITY); // 우선순위 제일 높게함
}
calc.start();
}
}
}
package t03_state;
public class TargetThread extends Thread{
public void run() {
// RUNNABLE
for(long i = 0; i < 1000000000000000L; i++);
try {
// TIMED_WATTING
Thread.sleep(1500);
// Interrupt - 끼어들다 가로막다 중단시키다.
} catch (InterruptedException e) {
e.printStackTrace();
}
// RUNNABLE
for(long i = 0; i < 1000000000000000L; i++);
// TERMINATED
} // end run
}
package t03_state;
public class StatePrintThread extends Thread{
Thread targetThread;
public StatePrintThread(Thread targetThread) {
this.targetThread = targetThread;
}
public void run() {
while(true) {
State state = targetThread.getState();
System.out.println("target state :" + state);
// State class 에서는 class의 상태를 상수로 표현
if(state == State.NEW) {
targetThread.start();
}
if(state == State.TERMINATED) {
break;
}
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} // end Run
}
package t03_state;
public class StateExample {
public static void main(String[] args) {
// NEW
TargetThread targetThread = new TargetThread();
Thread print = new StatePrintThread(targetThread);
print.start();
System.out.println("MAIN 종료");
}
}