Java マルチスレッド拡張の静的プロキシとラムダ式の進化
1. 静的プロキシ
1.コンセプト
実際のオブジェクトとプロキシ オブジェクトは両方とも同じインターフェイスを実装する必要があり、
プロキシ オブジェクトは実際の役割を表す必要があります。
2. 利点
プロキシ オブジェクトは、実際のオブジェクトでは実行できない多くのことを行うことができます。
実際のオブジェクトは、独自の処理に重点を置いています。
3. サンプル
package com.example.multithreading.demo3;
public class StaticProxy {
public static void main(String[] args) {
You you = new You();
// 1、没加多线程的操作
// WeddingCompany weddingCompany = new WeddingCompany(you);
// weddingCompany.HappyMarray();
// 2、使用多线程的操作
new Thread(() ->System.out.println("开始")).start();
new WeddingCompany(new You()).HappyMarray();
}
}
interface Marray{
void HappyMarray();
}
// 真实角色
class You implements Marray{
@Override
public void HappyMarray(){
System.out.println("主体操作");
}
}
// 代理角色
class WeddingCompany implements Marray{
//代理真实目标角色
private Marray target;
public WeddingCompany(Marray target) {
this.target = target;
}
@Override
public void HappyMarray(){
before();
// 这就是真实对象
this.target.HappyMarray();
after();
}
private void before(){
System.out.println("代理之前的操作");
}
private void after(){
System.out.println("代理之后的操作");
}
}
結果
2. ラムダ表現（進化過程の表示）
1. 関数インターフェースを定義し、クラスを実装する（初期状態）
最初にインターフェイスを定義します。その後、メインプログラムが正常に呼び出されます。
package com.example.multithreading.demo4;
/**
* 推导lambda表达式
*/
public class lamda {
public static void main(String[] args) {
Ilike like = new Like();
like.lambda(1);
}
}
// 1、定义一个函数式接口
interface Ilike{
void lambda(int a);
}
// 2、实现类
class Like implements Ilike {
@Override
public void lambda(int a) {
System.out.println("lambda:" + a);
}
}
結果
2. 静的内部クラス (状態進化 2)
静的内部クラスに進化し、正常に呼び出されました
package com.example.multithreading.demo4;
/**
* 推导lambda表达式
*/
public class lamda {
// 3、静态内部类
static class Like2 implements Ilike{
@Override
public void lambda(int a){
System.out.println("lambda2:" + a);
}
}
public static void main(String[] args) {
Ilike like = new Like2();
like.lambda(2);
}
}
// 1、定义一个函数式接口
interface Ilike{
void lambda(int a);
}
結果
3. ローカル内部クラス (状態進化 3)
ローカルの内部クラスに進化しましたが、呼び出しがまだ正常であることがわかりました
package com.example.multithreading.demo4;
/**
* 推导lambda表达式
*/
public class lamda {
public static void main(String[] args) {
// 4、局部内部类
class Like3 implements Ilike{
@Override
public void lambda(int a) {
System.out.println("lambda3:" + a);
}
}
Ilike like = new Like3();
like.lambda(3);
}
}
// 1、定义一个函数式接口
interface Ilike{
void lambda(int a);
}
結果
4. 匿名内部クラス (状態進化 4)
匿名内部クラスに単純化した後も、呼び出しは成功します。
package com.example.multithreading.demo4;
/**
* 推导lambda表达式
*/
public class lamda {
public static void main(String[] args) {
// 5、匿名内部类，没有类的名称，必须借助接口或者父类
Ilike like = new Ilike() {
@Override
public void lambda(int a) {
System.out.println("lambda4:" + a);
}
};
like.lambda(4);
}
}
// 1、定义一个函数式接口
interface Ilike{
void lambda(int a);
}
結果
5. ラムダで簡略化する (状態進化 5)
package com.example.multithreading.demo4;
/**
* 推导lambda表达式
*/
public class lamda {
public static void main(String[] args) {
// 6、用lambda简化
Ilike like = (int a) -> {
System.out.println("lambda5:" + a);
};
like.lambda(5);
}
}
// 1、定义一个函数式接口
interface Ilike{
void lambda(int a);
}
結果
6. ラムダを使用して単純化します (パラメータの型を削除します)。
package com.example.multithreading.demo4;
/**
* 推导lambda表达式
*/
public class lamda {
public static void main(String[] args) {
// 7、用lambda简化二
Ilike like = (a) -> {
System.out.println("lambda5:" + a);
};
like.lambda(6);
}
}
// 1、定义一个函数式接口
interface Ilike{
void lambda(int a);
}
結果
7. ラムダで 2 を簡略化します (括弧を簡略化します)
package com.example.multithreading.demo4;
/**
* 推导lambda表达式
*/
public class lamda {
public static void main(String[] args) {
// 8、用lambda简化三
Ilike like = a -> {
System.out.println("lambda5:" + a);
};
like.lambda(7);
}
}
// 1、定义一个函数式接口
interface Ilike{
void lambda(int a);
}
結果
8. ラムダを使用して 3 つを簡略化します (中括弧を削除します)。
package com.example.multithreading.demo4;
/**
* 推导lambda表达式
*/
public class lamda {
public static void main(String[] args) {
// 9、用lambda简化四
Ilike like = a -> System.out.println("lambda5:" + a);
like.lambda(8);
}
}
// 1、定义一个函数式接口
interface Ilike{
void lambda(int a);
}
結果
9. 注意してください
ラムダ式はコードが 1 行の場合のみ 1 行に減らすことができ、複数行ある場合はコード ブロックで囲む必要があります。
前提条件は、インターフェイスが機能的なインターフェイスであることです。
複数のパラメーターによってパラメーター タイプを削除することもできます。削除する場合は、それを削除し、かっこを追加する必要があります。