继承和单例设计模式

 

     一、单例设计模式：java中总共有23中国设计模式，设计模式就是当我们遇到同样问题的时候直接套用模式就可以了，而单例设计模式是用来解决一个类在内存中只存在一个对象的问题。

思路：

1.只存在一个对象，那么我们必须把构造方法私有化，不让它创建对象。

2.不让它创建对象，那么就得自己在本类中创建一个对象。

3、提供一个方法然其他调用者来访问。

代码实现如下：（饿汉式）

public class MainTest
{
 public static void main(String[]args)
 {
   Single s1=Single.getInstance();//静态方法，可以直接用类名来调用
   Single s2=Single.getInstance();
   s1.age=19;
   System.out.println(s2.age);
 }
}
class Single
{
 int age;
 private Single(){}//私有化构造方法
 static Single s=new Single();//在本类创建一个对象
 public static Single getInstance()//因为方法中没有使用非静态成员，所以定义成静态的
 {
  return s;
 }
}

懒汉式：只有方法被调用时，才创建对象，延时加载；

懒汉式设计模式用到了锁，这在多线程中很常见，下面分析一下一下程序：如果s为空，那么条件成立，进入判断体，一个线程进入锁中，然后锁上，其他先线程进不来，如果s为空就创建对象，然后跳出，返回s，那么其他线程在进入方法中时，在第一个判断if中如果不满足，就退出程序了，不用在判断锁了，所以提高的程序执行的效率。如果每个线程都要判断锁，当然也可以，但是非常浪费cpu的资源。

class Single
{
 int age;
 private Single(){}
 static Single s=null;
 public static Single getInstance()
 {
   if(s==null){
    synchronized(Single.class)
   {    
    if(s==null)
     s = new Single();
   }
   }
 }
}

        二、继承：我们现实生活中有很多继承的例子，儿子继承父亲。所谓继承就拥有了被继承者的一切属性，比如，学生、工人、农民，军人都是人，那么人就是一个父类，学生类、工人类、农民类，继承这个父类，父类中有name  age   country 等属性，那么子类中就继承了这些属性。

extends：关键字，继承，x  extends y，x是子类，y是父类、根类也叫超类

 

继承的好处：

1、提高了代码的复用性，父类中拥有的，子类就不用在重新定义，直接继承就可以了。

2.继承的使用，使类与类之间产生了关系，那么就有了后面的多态的产生，多态就是多种形态的体现，农民这个子类，我们可以叫农民，也可以叫人，这就是两种体现形态。

注意：不能单纯为了获取其他类中的属性，而继承其他类，而是真真正正存在所属关系， is   a  

就是什么是什么的一种。

3、子类不能拥有父类中被private修饰的成员

4、java支持单继承，不支持多继承，如果同时继承几个类，而几个父类中的方法名相同，那么子类就不知道要执行哪一个，但是java保留了这一机制，在接口中实现，因为接口中的方法都是抽象方法，没有实体，必须子类重写，所以子类实现后就全部重写了。

5.java支持多层继承，子类继承父类，父类在继承它的父类，最底层的子类拥有继承体系中所有的方法。

        三、继承中的成员（变量、方法、构造方法）

1.继承中的成员变量，this代表当前对象的引用，如果调用属性首先在本类中查找，如果找不到再去父类中查找是否有这个属性。而super（）代表直接到父类中去查找。

继承中父类属性的由来：是子类共性的抽取

2、继承中的成员方法：如果很多子类中拥有同样的方法，那么我们可以把它抽取到父类中，比如Person这个父类，就有eat（）的方法、sleep（）的方法，那么我们在子类中就不用再次定义了，直接继承父类中的这个方法，但是有些时候，父类要考虑全部子类共性问题，描述的不是很详细，那么我们就可以在子类中重新定义这个方法，把父类中的这个方法给重写（覆盖）了。

注意：

（1）.子类在重写父类的时候必须保证子类的访问权限大于父类的访问权限，这样才能够覆盖，否则编译会出错。

（2）.静态函数只能覆盖静态的函数，不能覆盖非静态的，这是存在的先后问题。

（3）、重写和重载的区别：重写时子父类多态的体现，子类父类中函数签名相同，对象在调用函数时，就会调用子类的函数，相当于对父类的函数进行了覆盖。而重载是在一个类中多态的体现，方法名是相同的，但是参数类型和参数个数不同，那么对象在调用函数是就是产生重载，调用与它匹配的那一个。

4.继承中的构造方法：在子类对象进行初始化时，会默认调用父类的构造方法，因为在子类的构造方法中，有一条默认语句super（）；它在执行语句的第一行，而且子类中每一个构造方法都要调用父类构造方法，每个子类构造方法的第一行都是super（）；如果子类调用本类的构造方法，就使用this（）；放在第一行。

注意：

1.this（）和super（）不能同时被调用，因为它们都要放在第一行，产生冲突。

2.如果要调用父类中有参数构造方法就要手动写上super（参数）；

           四、对象的转型和类型的匹配

1.对象转型：Animal  a=new Cat（）；这是向上转型，你要一只动物，我给你一只猫，这是可以的，这是默认的，  Cat  c=Cat（a）；这是向下转型，其实这里面是一只猫，但是我们把它看成了一只动物，所以要把它给强制转回来。

2.类型的匹配问题：还是接上面的语句，如果Dog d=Dog（a）；这就不能运行了，因为a虽然是一个动物，但它对应的对象时一只猫。你强行把它转换为一只狗是不行的，运行不能通过，所以我们有了判断能否转换的机制

关键字instanceof      测试左边的对象是否为右边的实例，如果是返回true，不是返回false

 a    instanceof  d

如果true，就转，false（else）  就返回false；