面向对象第五天

1：单例模式

         单个实例，一个实例。如何让一个类只能产生一个对象？构造方法私有化，提供静态公共方法放回这个类的对象。

         单例模式的两种形式：

懒汉式：一开始对象是空的

                   饿汉式：一开始就创建了对象

//设计模式：
//单例模式：单个实例，一个实例。需求：如何让一个类只能产生一个对象
/*
模式：解决一个问题的一种方式。
单例模式：
1：懒汉式。
    1.1：构造方法私有化。
    1.2：声明一个静态的这个类型的成员变量。
    1.3：提供一个公共的方法返回这个类型的对象，在方法体里判断成员变量
        是否为null,如果null则创建对象，否则返回这个对象。
2：饿汉式
    1.1:

*/
/*懒汉式：面试用，这个程序会出现线程安全问题，有可能出现多个对象。
需要进行修改。*/
class SingleInstance
{
    //定义一个变量来保存对象。
    private static SingleInstance single; 
    //构造方法私有化
    private SingleInstance(){
    }
    //提供一个公共的方法将这个类的对象返回出去
    public static SingleInstance newInstance(){
        //创建之前要判断。
        if(single==null)
         single = new SingleInstance();
        return single;
    }

}
//饿汉式：开发用
class SingleInstance2
{
    private static SingleInstance2 single = new SingleInstance2();
    private SingleInstance2(){
    }
    public static SingleInstance2  newInstance(){
        return single;
    }
}
class  TestSingleInstance
{
    public static void main(String[] args) 
    {
        SingleInstance single1 =SingleInstance.newInstance();
        SingleInstance single2 =SingleInstance.newInstance();
        SingleInstance single3 =SingleInstance.newInstance();
        //判断对象指的是否为同一个对象。
        if(single1==single2&&single1==single3){
            System.out.println("单例");
        }else{
        System.out.println("非单例");
        }
    }
}

2：内部类

         2.1：成员内部类

                   2.1.1：将类定义在一个类的里面，成员方法的外面。

                   2.1.2：内部类可以访问外部类的所有成员，外部类如果需要访问内部类，需要创建内部类对象，再用对象去访问。

外部类名.内部类名 变量名 =  外部类对象.内部类对象;

Outer.Inner in = new Outer.new Inner();//这种形式很少用。

         2.2：匿名内部类

                   2.2.1：没有名字的内部类。

                   2.2.2：当一个内部类在需求中只创建一个对象的时候，这样的类就可以不用取名字，这样的类就叫匿名内部类。匿名内部类一般情况下都会重写父类的方法。

                   语法：

                            new   父类名(){

                                     重写父类的方法。

                            } 后面可以接上 .方法名();

                   2.2.3匿名内部类其实就是一个匿名子类对象。想要定义匿名内部类：需要前提，内部类必须继承一个类（不管是抽象类还是普通类）或者实现接口。

                   匿名对象：没有名字的对象，这样的对象由于没有名字，所以只能使用一次。

         2.3：静态内部类

                   2.3.1：当内部类中出现静态成员时，内部类必须声明为静态内部类。

                   2.3.2：静态内部类只能访问外部类的静态成员。

Outer.Inner in = new Outer. Inner();

         2.4：局部内部类。

                   2.4.1：当将一个类定义在方法内时，这样的内部类局部内部类。

                   2.4.2：局部内部类只能在定义它的方法内使用。由于在方法内，所以这样的类是不能添加访问权限的。

         2.5：接口回调。(多态的一个体现，也类似于接口的实现)

                   

//需求：写一个类，有一个方法专门是下载网络数据。
//接口回调
class Utils
{
    //方法
    public static void loadImage(String path,CallBack callBack){
        System.out.println("下载了数据");
        String str = "我是下载的数据";
/*下面应该对数据进行处理。设计阶段只知道会处理这些数据，
但是怎样去处理这些数据，并不是很清楚.只能用户调用这个方法的时候
才能确定。
*/
        callBack.getData(str);
    }
}
interface CallBack
{
    //专门处理下载数据的行为
    public abstract  void getData(String str); 
}
class  TestCallBack
{
    public static void main(String[] args) 
    {
        String path = "www.baidu.com/image/logo.png";
        Utils.loadImage(path,new CallBack(){
            public void getData(String str){
                //将数据写到文件中
                System.out.println("我将数据写到了文件中"+str);
            }
        });

    }
}