程序猿需要手写的代码

A.通过接口回调进行类与类直接参数的传递


//1.定义一个接口,里面的代码是抽象方法,

public interface ScrollVIewListener{

    //抽象方法:就是把我们这个类想要暴露出去实现的具体逻辑和传递对应参数(view的监听对象要有)

    void onScrollChanger(ObservableScrollView scrollView,int l, int t, int oldl, int oldt );

}

//2.定义一个接口的成员变量,假的对象(接口不能创建对象)

private ScrollVIewListener mScrollVIewListener;

//3.提供方法,让外界可以设置ScrollView的监听对象,也就是我们要暴露出去的唯一方法

public void setScrollVIewListener(ScrollVIewListener scrollVIewListener){

    mScrollVIewListener = scrollVIewListener ;

}

//4.接口的具体使用,可以狸猫换太子的应用逻辑

if (mScrollVIewListener !=null){

    mScrollVIewListener.onScrollChanger(this,l,t,oldl,oldt);

}

//5.外部创建实现接口的对象,使用回调

实现接口的对象() ycf=new 实现接口的对象();

ycf.setScrollVIewListener(this);




B.单例模式(饿汉式,懒汉式):


public class Singleton {//饿汉式 


private final static Singleton INSTANCE = new Singleton();


private Singleton(){}


public static Singleton getInstance(){ 


    return INSTANCE; 


} 

}

优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。

缺点：在类装载的时候就完成实例化，没有达到懒加载的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

public class Singleton {//懒汉式
    private static volatile Singleton singleton;
    private Singleton() {}
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}
线程安全；延迟加载；效率较高:进行了两次if (singleton == null)检查，这样就可以保证线程安全了。
这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)，直接return实例化对象。





C.冒泡排序

　/**
     * 比较相邻的元素。如果第一个比第二个大，就交换他们两个。  
     * 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。  
     * 针对所有的元素重复以上的步骤，除了最后一个。
     * 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 
     * @param numbers 需要排序的整型数组 */
    public static void bubbleSort(int[] numbers)
    {
        int temp = 0;
        int size = numbers.length;
        for(int i = 0 ; i < size-1; i ++)
        {
        for(int j = 0 ;j < size-1-i ; j++)
        {
            if(numbers[j] > numbers[j+1])  //交换两数位置
            {
            temp = numbers[j];
            numbers[j] = numbers[j+1];
            numbers[j+1] = temp;
            }
        }
        }
    }


快速排序的基本思想：过一趟排序将待排序记录分割成独立的两部分，
其中一部分记录的关键字均比另一部分关键字小，则分别对这两部分继续进行排序，直到整个序列有序


　　　/**
     * 查找出中轴（默认是最低位low）的在numbers数组排序后所在位置
     * @param numbers 带查找数组
     * @param low   开始位置
     * @param high  结束位置
     * @return  中轴所在位置 */
    public static int getMiddle(int[] numbers, int low,int high)
    {
        int temp = numbers[low]; //数组的第一个作为中轴
        while(low < high)
        {
        while(low < high && numbers[high] > temp)
        {
            high--;
        }
        numbers[low] = numbers[high];//比中轴小的记录移到低端
        while(low < high && numbers[low] < temp)
        {
            low++;
        }
        numbers[high] = numbers[low] ; //比中轴大的记录移到高端
        }
        numbers[low] = temp ; //中轴记录到尾
        return low ; // 返回中轴的位置
    }




参考网址:
单例模式:https://www.cnblogs.com/zhaoyan001/p/6365064.html

排序:https://www.cnblogs.com/0201zcr/p/4763806.html