asdf

最新推荐文章于 2021-05-31 17:53:02 发布
最新推荐文章于 2021-05-31 17:53:02 发布
阅读量130 收藏
点赞数 1
分类专栏： asdf 文章标签： ns
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wu0gl/article/details/83039513
版权

静态代理

要点:

公共接口
真实角色
代理角色

public class StaticProxy {
    public static void main(String[] args) {
        You you = new You();
        WeddingCompany com = new WeddingCompany(you);
        com.happyMarry();
        
        System.out.println("####################");
        
        new WeddingCompany(new You()).happyMarry();

        //new Thread(线程对象).start();
    }
    
}

interface Marry{
    void happyMarry();
}

class You implements Marry{

    @Override
    public void happyMarry() {
        System.out.println("我花开尽百花杀");
    }
}
// 代理角色
class WeddingCompany implements Marry {
    // 真实角色
    private Marry target;
    
    public WeddingCompany(Marry target) {
        super();
        this.target = target;
    }

    @Override
    public void happyMarry() {
        ready();
        this.target.happyMarry();
        after();
    }
    
    private void ready() {
        System.out.println("待到秋来九月八");
    }
    
    private void after() {
        System.out.println("冲天香阵透长安");
    }
}


/*
待到秋来九月八
我花开尽百花杀
冲天香阵透长安
####################
待到秋来九月八
我花开尽百花杀
冲天香阵透长安
满城尽带黄金甲(这句是来凑数的)
*/

lambda

使用lambda可避免匿名内部类定义过多
实质输入函数式编程的概念

(params) -> expression
(params) -> statement
(params) -> {statements}

/***************匿名内部类与接口同名时*************/
/**
 * 匿名内部类与接口同名
 * @author Administrator
 *
 */
public class TestHaHa {

    public static void main(String[] args) {
        ILike_1 like = new ILike_1() {
            public void lambda() {
                System.out.println("I like lambda(匿名内部类).");
            }
        };    
        like.lambda();

        // 这个和接口同名匿名内部类必须实现接口中的方法, 否则报错
//        ILike_1 like_1 = new ILike_1() {
//            public void lambda_1() {
//                System.out.println("I like lambda(匿名内部类).");
//            }
//        };    
    }

}

interface ILike_1{
    void lambda();
}
/*
I like lambda(匿名内部类).
*/

/**************lambda无参数形式**************/
public class LambdaTest01 {
    // 静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I like lambda(静态内部类).");
        }
    }
    
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
        
        like = new Like2();
        like.lambda();
        
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I like lambda(方法内部类).");
            }
        }
        like = new Like3();
        like.lambda();
        
        // 匿名内部类
        like = new ILike() {
            public void lambda() {
                System.out.println("I like lambda(匿名内部类).");
            }
        };
        like.lambda();
        
        // lambda, 
        like = ()->{
            System.out.println("I like lambda(lambda).");
        };
        like.lambda();
        
        /********lambda推到必须存在类型*****************
        ()->{
            System.out.println("I like lambda(lambda).");
        };
        like.lambda();
        */
    }
}

interface ILike{
    void lambda();
}

 // 外部类
class Like implements ILike{

    @Override
    public void lambda() {
        System.out.println("I like lambda(外部类).");
    }
}

/*
I like lambda(外部类).
I like lambda(静态内部类).
I like lambda(方法内部类).
I like lambda(匿名内部类).
I like lambda(lambda).
*/

/************一个形参**************/
public class LambdaTest02 {
    
    public static void main(String[] args) {
        ILove love = (int a) -> {
            System.out.println("I like lambda(外部类)---->" + a);
        };
        love.lambda(100);

        // 简化
        love = (a) -> {
            System.out.println("I like lambda(外部类)---->" + a);
        };
        love.lambda(50);
        
        // 简化, 只有一个参数时
        love = a -> {
            System.out.println("I like lambda(外部类)---->" + a);
        };
        love.lambda(5);
        
        // 简化, 只有一行代码时, 多行代码不能简化
        love = a -> System.out.println("I like lambda(外部类)---->" + a);
        love.lambda(0);
    }
}

interface ILove{
    void lambda(int a);
}

 // 外部类
class Love implements ILove{

    @Override
    public void lambda(int a) {
        System.out.println("I like lambda(外部类)---->" + a);
    }
}

/*
I like lambda(外部类)---->100
I like lambda(外部类)---->50
I like lambda(外部类)---->5
I like lambda(外部类)---->0
*/

/************形参+返回值**************/
public class LambdaTest03 {
    public static void main(String[] args) {
        IInterest interest = (int a1, int b1) -> {
            System.out.println("I like lambda(外部类)---->" + a1 + b1);
            return a1 + b1;
        };
        System.out.println(interest.lambda(100, 200));

        // 简化
        interest = (a1, b1) -> {
            System.out.println("I like lambda(外部类)---->" + a1 + b1);
            return a1 + b1;
        };
        interest.lambda(100, 40);
        
        interest = (a, c) -> {return a + c;};

        interest = (a, c) -> a + c;

        interest = (a, c) -> 0;
        
        System.out.println(interest.lambda(10, 29));
    }
}

interface IInterest{
    int lambda(int a, int b);
}

 // 外部类
class Interest implements IInterest{

    @Override
    public int lambda(int a1, int b1) {
        System.out.println("I like lambda(外部类)---->" + a1 + b1);
        return a1 + b1;
    }
}

/*
I like lambda(外部类)---->100200
300
I like lambda(外部类)---->10040
0
*/

/*****************还能这么玩*****************/
public class TestHaHa {

    public static void main(String[] args) {
        ILike_1 like_1 = () -> {
                System.out.println("haha");
        };
        
        like_1.haha();
    }

}

interface ILike_1{
    void haha();
}

/*
haha
*/

/************Thread + Lambda**************/
public class LambdaTest04 {
    public static void main(String[] args) {
        new Thread(()->{
            System.out.println("学习lambda");
        }).start();
        new Thread(()->System.out.println("学习lambda")).start();
    }
}

/*
学习lambda
学习lambda
*/
```# 静态代理 #

要点:   
> 公共接口  
> 真实角色  
> 代理角色

public class StaticProxy {
public static void main(String[] args) {
You you = new You();
WeddingCompany com = new WeddingCompany(you);
com.happyMarry();

    System.out.println("####################");
    
    new WeddingCompany(new You()).happyMarry();

    //new Thread(线程对象).start();
}

}

interface Marry{
void happyMarry();
}

class You implements Marry{

@Override
public void happyMarry() {
    System.out.println("我花开尽百花杀");
}

}
// 代理角色
class WeddingCompany implements Marry {
// 真实角色
private Marry target;

public WeddingCompany(Marry target) {
    super();
    this.target = target;
}

@Override
public void happyMarry() {
    ready();
    this.target.happyMarry();
    after();
}

private void ready() {
    System.out.println("待到秋来九月八");
}

private void after() {
    System.out.println("冲天香阵透长安");
}

}

/*
待到秋来九月八
我花开尽百花杀
冲天香阵透长安
####################
待到秋来九月八
我花开尽百花杀
冲天香阵透长安
满城尽带黄金甲(这句是来凑数的)
*/


# lambda #

使用lambda可避免匿名内部类定义过多  
实质输入函数式编程的概念

(params) -> expression
(params) -> statement
(params) -> {statements}

/匿名内部类与接口同名时/
/

  • 匿名内部类与接口同名
  • @author Administrator

*/
public class TestHaHa {

public static void main(String[] args) {
    ILike_1 like = new ILike_1() {
        public void lambda() {
            System.out.println("I like lambda(匿名内部类).");
        }
    };    
    like.lambda();

    // 这个和接口同名匿名内部类必须实现接口中的方法, 否则报错

// ILike_1 like_1 = new ILike_1() {
// public void lambda_1() {
// System.out.println(“I like lambda(匿名内部类).”);
// }
// };
}

}

interface ILike_1{
void lambda();
}
/*
I like lambda(匿名内部类).
*/

/lambda无参数形式/
public class LambdaTest01 {
// 静态内部类
static class Like2 implements ILike{
@Override
public void lambda() {
System.out.println(“I like lambda(静态内部类).”);
}
}

public static void main(String[] args) {
    ILike like = new Like();
    like.lambda();
    
    like = new Like2();
    like.lambda();
    
    class Like3 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I like lambda(方法内部类).");
        }
    }
    like = new Like3();
    like.lambda();
    
    // 匿名内部类
    like = new ILike() {
        public void lambda() {
            System.out.println("I like lambda(匿名内部类).");
        }
    };
    like.lambda();
    
    // lambda, 
    like = ()->{
        System.out.println("I like lambda(lambda).");
    };
    like.lambda();
    
    /********lambda推到必须存在类型*****************
    ()->{
        System.out.println("I like lambda(lambda).");
    };
    like.lambda();
    */
}

}

interface ILike{
void lambda();
}

// 外部类
class Like implements ILike{

@Override
public void lambda() {
    System.out.println("I like lambda(外部类).");
}

}

/*
I like lambda(外部类).
I like lambda(静态内部类).
I like lambda(方法内部类).
I like lambda(匿名内部类).
I like lambda(lambda).
*/

/一个形参**/
public class LambdaTest02 {

public static void main(String[] args) {
    ILove love = (int a) -> {
        System.out.println("I like lambda(外部类)---->" + a);
    };
    love.lambda(100);

    // 简化
    love = (a) -> {
        System.out.println("I like lambda(外部类)---->" + a);
    };
    love.lambda(50);
    
    // 简化, 只有一个参数时
    love = a -> {
        System.out.println("I like lambda(外部类)---->" + a);
    };
    love.lambda(5);
    
    // 简化, 只有一行代码时, 多行代码不能简化
    love = a -> System.out.println("I like lambda(外部类)---->" + a);
    love.lambda(0);
}

}

interface ILove{
void lambda(int a);
}

// 外部类
class Love implements ILove{

@Override
public void lambda(int a) {
    System.out.println("I like lambda(外部类)---->" + a);
}

}

/*
I like lambda(外部类)---->100
I like lambda(外部类)---->50
I like lambda(外部类)---->5
I like lambda(外部类)---->0
*/

/形参+返回值**/
public class LambdaTest03 {
public static void main(String[] args) {
IInterest interest = (int a1, int b1) -> {
System.out.println(“I like lambda(外部类)---->” + a1 + b1);
return a1 + b1;
};
System.out.println(interest.lambda(100, 200));

    // 简化
    interest = (a1, b1) -> {
        System.out.println("I like lambda(外部类)---->" + a1 + b1);
        return a1 + b1;
    };
    interest.lambda(100, 40);
    
    interest = (a, c) -> {return a + c;};

    interest = (a, c) -> a + c;

    interest = (a, c) -> 0;
    
    System.out.println(interest.lambda(10, 29));
}

}

interface IInterest{
int lambda(int a, int b);
}

// 外部类
class Interest implements IInterest{

@Override
public int lambda(int a1, int b1) {
    System.out.println("I like lambda(外部类)---->" + a1 + b1);
    return a1 + b1;
}

}

/*
I like lambda(外部类)---->100200
300
I like lambda(外部类)---->10040
0
*/

/还能这么玩/
public class TestHaHa {

public static void main(String[] args) {
    ILike_1 like_1 = () -> {
            System.out.println("haha");
    };
    
    like_1.haha();
}

}

interface ILike_1{
void haha();
}

/*
haha
*/

/Thread + Lambda**/
public class LambdaTest04 {
public static void main(String[] args) {
new Thread(()->{
System.out.println(“学习lambda”);
}).start();
new Thread(()->System.out.println(“学习lambda”)).start();
}
}

/*
学习lambda
学习lambda
*/


要点:   
> 公共接口  
> 真实角色  
> 代理角色

public class StaticProxy {
public static void main(String[] args) {
You you = new You();
WeddingCompany com = new WeddingCompany(you);
com.happyMarry();

    System.out.println("####################");
    
    new WeddingCompany(new You()).happyMarry();

    //new Thread(线程对象).start();
}

}

interface Marry{
void happyMarry();
}

class You implements Marry{

@Override
public void happyMarry() {
    System.out.println("我花开尽百花杀");
}

}
// 代理角色
class WeddingCompany implements Marry {
// 真实角色
private Marry target;

public WeddingCompany(Marry target) {
    super();
    this.target = target;
}

@Override
public void happyMarry() {
    ready();
    this.target.happyMarry();
    after();
}

private void ready() {
    System.out.println("待到秋来九月八");
}

private void after() {
    System.out.println("冲天香阵透长安");
}

}

/*
待到秋来九月八
我花开尽百花杀
冲天香阵透长安
####################
待到秋来九月八
我花开尽百花杀
冲天香阵透长安
满城尽带黄金甲(这句是来凑数的)
*/


# lambda #

使用lambda可避免匿名内部类定义过多  
实质输入函数式编程的概念

(params) -> expression
(params) -> statement
(params) -> {statements}

/匿名内部类与接口同名时/
/

  • 匿名内部类与接口同名
  • @author Administrator

*/
public class TestHaHa {

public static void main(String[] args) {
    ILike_1 like = new ILike_1() {
        public void lambda() {
            System.out.println("I like lambda(匿名内部类).");
        }
    };    
    like.lambda();

    // 这个和接口同名匿名内部类必须实现接口中的方法, 否则报错

// ILike_1 like_1 = new ILike_1() {
// public void lambda_1() {
// System.out.println(“I like lambda(匿名内部类).”);
// }
// };
}

}

interface ILike_1{
void lambda();
}
/*
I like lambda(匿名内部类).
*/

/lambda无参数形式/
public class LambdaTest01 {
// 静态内部类
static class Like2 implements ILike{
@Override
public void lambda() {
System.out.println(“I like lambda(静态内部类).”);
}
}

public static void main(String[] args) {
    ILike like = new Like();
    like.lambda();
    
    like = new Like2();
    like.lambda();
    
    class Like3 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I like lambda(方法内部类).");
        }
    }
    like = new Like3();
    like.lambda();
    
    // 匿名内部类
    like = new ILike() {
        public void lambda() {
            System.out.println("I like lambda(匿名内部类).");
        }
    };
    like.lambda();
    
    // lambda, 
    like = ()->{
        System.out.println("I like lambda(lambda).");
    };
    like.lambda();
    
    /********lambda推到必须存在类型*****************
    ()->{
        System.out.println("I like lambda(lambda).");
    };
    like.lambda();
    */
}

}

interface ILike{
void lambda();
}

// 外部类
class Like implements ILike{

@Override
public void lambda() {
    System.out.println("I like lambda(外部类).");
}

}

/*
I like lambda(外部类).
I like lambda(静态内部类).
I like lambda(方法内部类).
I like lambda(匿名内部类).
I like lambda(lambda).
*/

/一个形参**/
public class LambdaTest02 {

public static void main(String[] args) {
    ILove love = (int a) -> {
        System.out.println("I like lambda(外部类)---->" + a);
    };
    love.lambda(100);

    // 简化
    love = (a) -> {
        System.out.println("I like lambda(外部类)---->" + a);
    };
    love.lambda(50);
    
    // 简化, 只有一个参数时
    love = a -> {
        System.out.println("I like lambda(外部类)---->" + a);
    };
    love.lambda(5);
    
    // 简化, 只有一行代码时, 多行代码不能简化
    love = a -> System.out.println("I like lambda(外部类)---->" + a);
    love.lambda(0);
}

}

interface ILove{
void lambda(int a);
}

// 外部类
class Love implements ILove{

@Override
public void lambda(int a) {
    System.out.println("I like lambda(外部类)---->" + a);
}

}

/*
I like lambda(外部类)---->100
I like lambda(外部类)---->50
I like lambda(外部类)---->5
I like lambda(外部类)---->0
*/

/形参+返回值**/
public class LambdaTest03 {
public static void main(String[] args) {
IInterest interest = (int a1, int b1) -> {
System.out.println(“I like lambda(外部类)---->” + a1 + b1);
return a1 + b1;
};
System.out.println(interest.lambda(100, 200));

    // 简化
    interest = (a1, b1) -> {
        System.out.println("I like lambda(外部类)---->" + a1 + b1);
        return a1 + b1;
    };
    interest.lambda(100, 40);
    
    interest = (a, c) -> {return a + c;};

    interest = (a, c) -> a + c;

    interest = (a, c) -> 0;
    
    System.out.println(interest.lambda(10, 29));
}

}

interface IInterest{
int lambda(int a, int b);
}

// 外部类
class Interest implements IInterest{

@Override
public int lambda(int a1, int b1) {
    System.out.println("I like lambda(外部类)---->" + a1 + b1);
    return a1 + b1;
}

}

/*
I like lambda(外部类)---->100200
300
I like lambda(外部类)---->10040
0
*/

/还能这么玩/
public class TestHaHa {

public static void main(String[] args) {
    ILike_1 like_1 = () -> {
            System.out.println("haha");
    };
    
    like_1.haha();
}

}

interface ILike_1{
void haha();
}

/*
haha
*/

/Thread + Lambda**/
public class LambdaTest04 {
public static void main(String[] args) {
new Thread(()->{
System.out.println(“学习lambda”);
}).start();
new Thread(()->System.out.println(“学习lambda”)).start();
}
}

/*
学习lambda
学习lambda
*/


要点:   
> 公共接口  
> 真实角色  
> 代理角色

public class StaticProxy {
    public static void main(String[] args) {
        You you = new You();
        WeddingCompany com = new WeddingCompany(you);
        com.happyMarry();
        
        System.out.println("####################");
        
        new WeddingCompany(new You()).happyMarry();

//new Thread(线程对象).start();
    }
    
}

interface Marry{
    void happyMarry();
}

class You implements Marry{

@Override
    public void happyMarry() {
        System.out.println(“我花开尽百花杀”);
    }
}
// 代理角色
class WeddingCompany implements Marry {
    // 真实角色
    private Marry target;
    
    public WeddingCompany(Marry target) {
        super();
        this.target = target;
    }

@Override
    public void happyMarry() {
        ready();
        this.target.happyMarry();
        after();
    }
    
    private void ready() {
        System.out.println(“待到秋来九月八”);
    }
    
    private void after() {
        System.out.println(“冲天香阵透长安”);
    }
}

/*
待到秋来九月八
我花开尽百花杀
冲天香阵透长安
####################
待到秋来九月八
我花开尽百花杀
冲天香阵透长安
满城尽带黄金甲(这句是来凑数的)
*/


# lambda #

使用lambda可避免匿名内部类定义过多  
实质输入函数式编程的概念  

(params) -> expression
(params) -> statement
(params) -> {statements}

/匿名内部类与接口同名时/
/
 * 匿名内部类与接口同名
 * @author Administrator
 *
 */
public class TestHaHa {

public static void main(String[] args) {
        ILike_1 like = new ILike_1() {
            public void lambda() {
                System.out.println(“I like lambda(匿名内部类).”);
            }
        };    
        like.lambda();

// 这个和接口同名匿名内部类必须实现接口中的方法, 否则报错
//        ILike_1 like_1 = new ILike_1() {
//            public void lambda_1() {
//                System.out.println(“I like lambda(匿名内部类).”);
//            }
//        };    
    }

}

interface ILike_1{
    void lambda();
}
/*
I like lambda(匿名内部类).
*/

/lambda无参数形式/
public class LambdaTest01 {
    // 静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println(“I like lambda(静态内部类).”);
        }
    }
    
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
        
        like = new Like2();
        like.lambda();
        
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println(“I like lambda(方法内部类).”);
            }
        }
        like = new Like3();
        like.lambda();
        
        // 匿名内部类
        like = new ILike() {
            public void lambda() {
                System.out.println(“I like lambda(匿名内部类).”);
            }
        };
        like.lambda();
        
        // lambda, 
        like = ()->{
            System.out.println(“I like lambda(lambda).”);
        };
        like.lambda();
        
        /lambda推到必须存在类型*********
        ()->{
            System.out.println(“I like lambda(lambda).”);
        };
        like.lambda();
        */
    }
}

interface ILike{
    void lambda();
}

// 外部类
class Like implements ILike{

@Override
    public void lambda() {
        System.out.println(“I like lambda(外部类).”);
    }
}

/*
I like lambda(外部类).
I like lambda(静态内部类).
I like lambda(方法内部类).
I like lambda(匿名内部类).
I like lambda(lambda).
*/

/一个形参**/
public class LambdaTest02 {
    
    public static void main(String[] args) {
        ILove love = (int a) -> {
            System.out.println(“I like lambda(外部类)---->” + a);
        };
        love.lambda(100);

// 简化
        love = (a) -> {
            System.out.println(“I like lambda(外部类)---->” + a);
        };
        love.lambda(50);
        
        // 简化, 只有一个参数时
        love = a -> {
            System.out.println(“I like lambda(外部类)---->” + a);
        };
        love.lambda(5);
        
        // 简化, 只有一行代码时, 多行代码不能简化
        love = a -> System.out.println(“I like lambda(外部类)---->” + a);
        love.lambda(0);
    }
}

interface ILove{
    void lambda(int a);
}

// 外部类
class Love implements ILove{

@Override
    public void lambda(int a) {
        System.out.println(“I like lambda(外部类)---->” + a);
    }
}

/*
I like lambda(外部类)---->100
I like lambda(外部类)---->50
I like lambda(外部类)---->5
I like lambda(外部类)---->0
*/

/形参+返回值**/
public class LambdaTest03 {
    public static void main(String[] args) {
        IInterest interest = (int a1, int b1) -> {
            System.out.println(“I like lambda(外部类)---->” + a1 + b1);
            return a1 + b1;
        };
        System.out.println(interest.lambda(100, 200));

// 简化
        interest = (a1, b1) -> {
            System.out.println(“I like lambda(外部类)---->” + a1 + b1);
            return a1 + b1;
        };
        interest.lambda(100, 40);
        
        interest = (a, c) -> {return a + c;};

interest = (a, c) -> a + c;

interest = (a, c) -> 0;
        
        System.out.println(interest.lambda(10, 29));
    }
}

interface IInterest{
    int lambda(int a, int b);
}

// 外部类
class Interest implements IInterest{

@Override
    public int lambda(int a1, int b1) {
        System.out.println(“I like lambda(外部类)---->” + a1 + b1);
        return a1 + b1;
    }
}

/*
I like lambda(外部类)---->100200
300
I like lambda(外部类)---->10040
0
*/

/还能这么玩/
public class TestHaHa {

public static void main(String[] args) {
        ILike_1 like_1 = () -> {
                System.out.println(“haha”);
        };
        
        like_1.haha();
    }

}

interface ILike_1{
    void haha();
}

/*
haha
*/

/Thread + Lambda**/
public class LambdaTest04 {
    public static void main(String[] args) {
        new Thread(()->{
            System.out.println(“学习lambda”);
        }).start();
        new Thread(()->System.out.println(“学习lambda”)).start();
    }
}

/*
学习lambda
学习lambda
*/

wu0gl
关注
专栏目录
asdf：asdf安装脚本
02-03
`asdf`就是这样一款强大的多语言版本管理器，它允许用户在一个系统上安装和切换不同的软件版本，如Node.js、Ruby、Elixir等。本文将深入探讨`asdf`及其安装脚本的相关知识点。 ### asdf：概述 `asdf`（Another ...
多线程详解（狂神），补充：以阿里巴巴推荐的使用 ThreadPoolExecutor 构造函数自定义参数的方式来创建线程池
兴趣是最好的老师
04-26 560
https://blog.csdn.net/qq_36188127/article/details/108867650
最详细的Java知识点--多线程
The_Beacon的博客
09-05 451
多线程 process与Thread 说起进程，就不得不说一下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。 而进程则是执行程序的依次执行过程，它是一个动态的概念。是系统资源分配的单位。 通常在一个进程中可以包含若干个线程，当然一个进程中至少包含一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。 注意： 很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只能执行
Java静态代理
weixin_55710465的博客
05-31 71
静态代理 实现同一个接口 代理要代理真实角色 好处是代理可以做真多代理对象做不了的事情 真实对象可以专注自己的事情 public class StaticProxy { public static void main(String[] args) { ​ new Thread(()-> System.out.println("爱你")).start(); //lamda 表达式 WeddingCompany company...
asdf.zip_asdf_带宽
09-20
《带宽监控软件开发详解——基于"asdf.zip_asdf_带宽"的分析》 在当今信息化社会，网络带宽的管理和监控对于个人用户和企业来说都至关重要。"asdf.zip_asdf_带宽"是一个专注于带宽使用量监控的工具，它的功能界面...
4_asdf_
10-02
很抱歉，但根据您给出的信息，标题"4_asdf_"和描述中的"这只是一个测试，不代表具体功能的代码，嗯嗯"并没有提供任何特定的IT知识点。标签"asdf"同样没有明确的IT含义，它可能是一个占位符或者错误的输入。至于压缩...
asdf.rar_asdf
09-22
这个是当年毕业设计的参考资料，也许对正在准备毕业设计的同学有点帮助。
VB程序实例-运用Mschat图表显示数据(方法二).zip
11-03
VB程序实例-运用Mschat图表显示数据(方法二).zip
VB程序实例-改变Windows图标大小.zip
11-03
VB程序实例，可供参考学习使用，希望对你有所帮助
技术资料分享ZigBee协议栈的研究与实现非常好的技术资料.zip
11-03
技术资料分享ZigBee协议栈的研究与实现非常好的技术资料.zip
pytz-2016.10-py3.1.egg
最新发布
11-03
pytz库的主要功能 时区转换：pytz库允许用户将时间从一个时区转换到另一个时区，这对于处理跨国业务或需要处理多地时间的数据分析尤为重要。 历史时区数据支持：pytz库不仅提供了当前的时区数据，还包含了历史上不同时期的时区信息，这使得它在处理历史数据时具有无与伦比的优势。 夏令时处理：pytz库能够自动处理夏令时的变化，当获取某个时区的时间时，它会自动考虑是否处于夏令时期间。 与datetime模块集成：pytz库可以与Python标准库中的datetime模块一起使用，以确保在涉及不同时区的场景中时间的准确性。
技术资料分享ADV7123非常好的技术资料.zip
11-03
技术资料分享ADV7123非常好的技术资料.zip
技术资料分享MP1541非常好的技术资料.zip
11-03
技术资料分享MP1541非常好的技术资料.zip
QT学习笔记 by blast
11-03
安装教程 https://blog.csdn.net/Python_0011/article/details/131699443 学习教程 https://www.bilibili.com/video/BV1S7411e7wL?p=21&spm_id_from=pageDriver&vd_source=6aad76f7b7008647b29d73a9f9003a93
VB程序实例17_控件应用_跳动的小球.zip
11-03
VB程序实例，可供参考学习使用，希望对你有所帮助
js中只输入数字的输入框
11-03
在JavaScript中，如果想要创建一个只能输入数字的文本框，通常我们会利用HTML的<input>元素结合客户端验证。这种文本框可以设置type="text"属性，使其默认只接受整数或小数。文字描述可以这样表达： “这是一个专为输入数字设计的输入框，用户只能在这里输入数值，包括正负整数或小数点后的有限位数。如果你尝试输入非数字字符，浏览器会自动清除或者阻止输入，提供更直观的用户体验。”
FiddlerSetup.5.0安装包
11-03
FiddlerSetup.5.0安装包
yolo算法-停车位占用检测数据集-217张图像带标签-被占领-未占用.zip
11-03
yolo系列算法目标检测数据集，包含标签，可以直接训练模型和验证测试，数据集已经划分好，包含数据集配置文件data.yaml，适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法； 包含两种标签格:yolo格式（txt文件）和voc格式（xml文件），分别保存在两个文件夹中; yolo格式：<class> <x_center> <y_center> <width> <height>， 其中： <class> 是目标的类别索引（从0开始）。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标，这些坐标是相对于图像宽度和高度的比例值，范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度，也是相对于图像宽度和高度的比例值
技术资料分享Zigbee协议栈OSAL层API函数(译)非常好的技术资料.zip
11-03
技术资料分享Zigbee协议栈OSAL层API函数(译)非常好的技术资料.zip
javascript 判断asdf是否包含g
10-26
如果你想检查字符串"asdf"是否包含字母"g"，可以这样做： ```javascript let str = "asdf"; let containsG = str.includes("g"); console.log(containsG); // 输出：false ``` 在这个例子中，`str.includes("g")`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值