java中面向对象的一些小知识点（二）

一，单例设计模式

1.为什么要有单例设计？主要就是想要保证对象的唯一性。

   1）为了避免其他程序过多建立该类的对象

   2）还要为了方便其他程序访问该类对象，在本类中自定义一个该类对象，然后提供静态访问方法

2.实现方式

   1）首先，就是将构造函数私有化，让其他程序没法通过构造函数实例化对象

   2）在类中创建一个该类的对象

   3）提供一个静态方法，返回该对象

   例如：   

  class Single {

private Single() {

}

private static Single s = new Single();

public static Single getInstance() {

returns;

}

  }

  这就是一个简单的单例模式的实现方式。

3.两种表现形式（这个需要重点注意）

  1）饿汉式（先初始化对象，然后调用）

  class Single {

private Single() {

}

private static Single s = new Single();

public static Single getInstance() {

return s;

}

   }

   这个就成为“饿汉式”，这个比较常用，建议大家用这个来实现单例，一般不会出现什么问题。

  2）懒汉式（对象是在被调用时，才初始化，也叫对象的延时加载）

  class Single {

private Single() {

}

privatestatic Single s =null;

public static Single getInstance() {

if (s ==null)//减少读锁次数

{

synchronized (Single.class) 

{

if (s ==null)

s = new Single();

}

}

returns;

}

  }

  “懒汉式”在使用时需要特别注意，当多个程序同时访问时，有可能出现创建多个对象的情况，因此需要加锁来解决。因此，定义单例时，建议使用“饿汉式”。

二，多态的应用

首先，来看个例子

class Fu {

int num = 5;

void method1() {

System.out.println("fu method_1");

}

        void method2() {

System.out.println("fu method_2");

}

static void method4() {

System.out.println("fu method_4");

}

}

class Zi extends Fu {

int num = 8;

void method1() {

System.out.println("zi method_1");

}

void method3() {

System.out.println("zi method_3");

}

static void method4() {

System.out.println("zi method_4");

}

当主函数中调用：

Fu f = new Zi();

System.out.println(f.num);

f.method1();

f.method2();

f.method4();

输出结果为：

                5

                zi method_1

                fu method_2

                fu method_4

看到个结果，就需要为大家总结下，多态的几个特点：

1.多态中非静态成员函数的特点：

  1）编译期间，参阅引用型变量所属的类中是否有调用的方法

  2）运行期间，参阅对象所属的类中是否有此方法，

  简单来说，成员函数在多态调用时，编译看左边，运行看右边

2.多态中，成员变量的特点：

  1）无论编译和运行，都是参考左边（引用型变量所属的类）

3.多态中，静态成员函数的特点：

  1）无论编译和运行，都是参考左边（静态方法跟类绑定，与具体堆相无关）