单例式+内部类+lanbda表达式

一.单例式

要求：确保类里面只有一个实例

类型：

饿汉式：先创建对象，保证永远使用的都是这个创建好的对象（类第一次加载完成之后就创建对象）；

优点：线程安全

缺点：效率低

操作：

1.创建一个私有构造器

2.声明一个私有的静态的该类对象

3.提供公共的访问方式

//饿汉式
public class Text {
    public static void main(String[] args) {
        //把公共的对象地址给引用
        Fu text=Fu.getId();//没用对象，类名调用方法
        System.out.println(text);
    }
}
class Fu{
        //2.声明一个私有的静态的对象
        private static Fu text=new Fu();
        //1.创建私有构造器，空构造
        private Fu() {}
        //3.提供公共的访问方式，返回对象地址
        public static Fu getId() {
            return text;
        }
}

懒汉式：当调用这个功能要对象时才会创建对象

优点：效率快

缺点：线程不安全

操作：

1.构造器私有

2.提供一个私有的静态的该类引用（判断它是否创建过对象）

3.提供公共的访问方式

public class Text {
    public static void main(String[] args) {
        Fu1 d=Fu1.getId();
        System.out.println(d);
    }
}
class Fu1{
    //2.声明一个私有静态的对象
    private static Fu1 d = null;
    //1.私有构造器
    private Fu1(){}
    //3.公共的访问方式
    public static Fu1 getId(){
        if（d==null）{
            d=new Fu1（）;
        }
        return d;
    }

二.静态代理

​ 定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用

组成：1.真实角色（一件事真实角色不合适去做就会让代理角色去做）

2.代理角色（中介，它存着真实角色的地址）

3.方法（真实角色实现问题的方法）

优点：增强代码程序的扩展性,便于后期维护,解耦

例题：房东找中介帮忙出租房子问题

package com.shsxt.interface1;
/*静态代理模式:
     *  1.真实角色
     *  2.代理角色
     * */
public class Stratic1 {
    public static void main(String[] args) {
        Landlord h = new  Landlord();//创建房东
        Medium m=new Medium(h);
        m.rent();
    }
    
}
//真实角色
class Landlord implements Rent{
    public void rent() {
        System.out.println("有空房子");
        System.out.println("带人看房子");
        System.out.println("签合同");
    }
}
//代理角色（中介）
class Medium implements Rent{
    Landlord h=null;//有真实角色的引用
    public Medium(Landlord h) {//构造器，得到房东的联系方式
        this.h=h;
    }
    public void rent() {
        System.out.println("出租房子");
        System.out.println("带人看房子");
        h.rent();//找房东看房子
    }
}
//方法（出租房子）
interface  Rent{
    void rent();
}

三.简单工厂

组成：工厂类角色：创造产品

抽象类产品角色：你要做哪一类的产品（可以干什么，方法集合）

具体产品角色：工厂创造出来的产品

例题：饭店买东西

public class Restaurant {
    public static void main(String[] args) {
        Tea t=tearoom("奶茶");//创建确定好的产品
        t.show();//调用它的功能
    }
    public static Tea tearoom(String name) {
        Tea t=null;//父类，多态
        if(name.equals(t)) {//比较判断，是哪款产品
            t=new Milk();
        }else {
            t=new Coco();
        }
        return t;//返回产品
    }
}
//产品的功能
interface Tea{
    void show();
}
//牛奶（具体产品）
class Milk implements Tea{
    public String name="牛奶";
    public void show(){
        System.out.println("你的牛奶请慢用");
    }
}
//奶茶（具体产品）
class Coco implements Tea{
    public String name="奶茶";
    public void show(){
        System.out.println("你的奶茶请慢用");
    }
}

四.内部类

定义：可以把一个类定义在另外一个类当中，这样的类可以称之为内部类

共性：1.内部类仍然是一个独立的类

2.内部类不能用不同的访问方式（内部类是外部类的成员可以自由使用外部类的成员变量，为了是不是private）

3.如果内部类是静态内部类的话，就不能随便访问外部类的成员变量，内部类只能访问外部类的静态成员变量

类型：

1.成员内部类特点：

当内部类作为外部类的成员位置,这就是一个成员内部类

具有成员的特点,可以使用成员修饰符修饰 ,也有类的特点,可以继承,可以实现

在内部类中可以直接使用外部类中的内容

外部类中可以通过内部类对象使用内部类中的成员

成员内部类中不可以定义静态的内容,除非静态的常量

如何使用成员内部类的中的内容:

员内部类的对象要通过外部类对象创建

InnerDemo01 inner=new InnerDemo01();

InnerDemo01.Inner in=inner.new Inner();

​
public class Demo1 {
public static void main(String[] args) {
    Dog b=new Dog();
    Dog.Samlldog g=new Dog().new Samlldog();
    g.play();
    b.sleep();
    
}
}
interface Play{
    void play();
}
class Big{}
class Dog{
    private String name="二哈";
    public int age;
    //成员内部类
    public class Samlldog extends Big implements Play{
        //重写方法
        @Override
        public void play() {
            System.out.println(name+"在拆家");
            
        }
        
    }
    public void sleep() {
        System.out.println("小狗崽在睡觉");
    }
}

2.静态内部类

静态内部类中可以定义静态的内容

在外部类中使用静态内部类中的内容,可以通过对象用其成员,通过类名用其静态内容

静态内部类中通过外部类的对象用其成员内容,直接使用其静态内容,因为静态内部类中静态环境

其他类中如何使用静态内部类中的内容:

通过外部类找静态内部类,通过类名使用其静态内容

通过外部类找到静态内部类,通过静态内部类的对象使用其成员

3.私有内部类

通过私有内部类的对象使用它的成员,包括私有的内容

私有内部类只能在当前的外部类中使用,其他类中无法使用

public class Demo03{
    public static void main(String[] args) {
        new Outer02().outer();
    }
}
​
class Outer02{
    private int a=5;
    //私有的成员内部类
    private class Inner{
        int b=10;
        void inner(){
            System.out.println(a);
        }
    }
    //通过私有内部类的对象使用它的成员
    void outer(){
        System.out.println(new Inner().b);
    }
}
​

4.局部内部类

将内部类移到了外部类的方法中，然后在外部类的方法中再生成一个内部类对象去调用内部类方法。

局部内部类和成员内部类的区别在于局部内部类的访问仅限于方法内

局部内部类：像局部变量一样，不能被public, protected, private和static修饰

 

5.匿名内部类

内部类有类体,没有名字,这个类体我们称它为一个匿名内部类

简化类的结构

当一个类没有自己本身的作用,只是想要使用一下类体的某个内容,并且也不会重复使用这个类,可以定义为一个匿名内部类,只在当前使用

public class Text1 {
    public static void main(String[] args) {
    //{}里的就是匿名类，只有抽象方法，没有方法体
        Dog g=new Dog() {
            @Override
            public void play() {
                System.out.println("卖萌");
            }
        };
        Dog o=new Dog() {
            @Override
            public void play() {
                System.out.println("拆家");
            }
        };
        g.play();
        o.play();   
    }
}
interface Dog{
    void play();
}

五.lanbda表达式（@FunctionalInterface）

jbk1.8推出的新特性

作用：可以简化匿名内部类的表达式

前提：函数式接口

函数式接口：接口中必须要重写的方法只有一个

语法：（）->{}

():重写的抽象方法的参数列表

->:箭头符号，lanbda符号,箭头函数,具有上下文推到的作用

{}：重写方法的方法体

写法1: Smoke s=()->{System.out.println("。。。。。。");}; 写法2: 当方法体语句只有一句的时候,前后的{}可以省略

Smoke s=()->System.out.println("。。。。。。。。");

写法3: 如果方法有参数,参数的数据类型可以省略

Smoke s=(a,b)->System.out.println("。。。。。。。。"+a);

写法4: 如果方法有参数,参数的个数只有一个,前后的()也可以省略

Smoke s= a ->System.out.println("。。。。。。。。"+a);

写法5: 如果方法有返回值类型,并且方法体只有一个return语句的时候,前后的{}+return关键字可以一起省略

Smoke s= a ->{System.out.println("。。。。。。。。。"+a); return "。。。"; };

写法6：如果返回值只有一句的时候，可以省略return

Smoke s= a ->"。。。。";

lambda可以当做方法的参数使用,前提形参的类型为一个函数式接口 test(a ->"你好就好");