java基础-单利模式/继承/多态

版权声明：中华人民共和国持有版权 https://blog.csdn.net/Fly_Fly_Zhang/article/details/83552195

单利模式：23种设计模式

• 单例类只能有一个实例。
• 单例类必须自己创建自己唯一的实例。
• 单例类必须给所有其他对象提供这个实例。
• 饿汉式单利模式

/*
饿汉式单利模式
 */
class MySingleTon{
     private static  MySingleTon singleton=new MySingleTon(); //创建唯一实例
     private MySingleTon(){ //构造函数

     }
     public static MySingleTon getinstance(){ //提供一个全局的访问点
         return singleton ;
     }

}

• 懒汉式单利模式
• 线程安全：是否竞态条件？》临界区代码块>原子性操作>加锁（互斥，自旋，读写）；

/*
懒汉式单利模式
 */
class MySingleTon1{
    private static Object lock=new Object();
    private static MySingleTon1 mysingleton1=null;
    private MySingleTon1(){

    }
    //可重入函数也叫线程安全函数
    public static MySingleTon1 getinstance(){ //提供一个全局访问点。
        if(mysingleton1==null){ //双重锁，如果已经有实例，这边直接返回。么有他对于单线程来说cpu效率太低
            synchronized (lock){
                if(mysingleton1==null){ //当锁关闭的时候，第一个mysinleton1下面已经有线程了，这里返回那些漏网的。
                    mysingleton1=new MySingleTon1();
                }
            }
        }
        return mysingleton1; //返回一个类实例
    }
}

• 内部类单例模式：静态内部类。

/*
内部类单利模式
 */
class Overclass{
    private Overclass(){//构造函数

    }
    private static class innerClass{
    //只有访问静态内部类的时候才会创建对象。
        private static Overclass overclass=new Overclass();//static内部类特点,调用外部类非静态，传入一个外部类对象。
        private static innerClass innerClass=null;
        private static Object lock=new Object();
        private innerClass(){

        }
        public static innerClass getinstance(){  //线程安全函数。提供一个访问对象。
            if(innerClass==null){
                synchronized(lock){   //线程安全
                    if(innerClass==null){
                        innerClass=new innerClass();
                    }
                }
            }
            return innerClass.overclass;
        }
    }
}

继承：一种机制，可以进行代码的重用，基类（父类，超类） 子类（派生类）

• 面试问题1：派生类继承了父类的什么？？
  除构造函数外的所有属性。

• super:

• super(a) :调用基类的构造函数 。这个必须放在第一行。

• super.date ：访问基类的数据成员。

• super.fun: 调用基类的成员方法。

• 基类和派生类的之间的相互赋值 ： base=derieve（多态的基础)

• 重载（overloade）: 函数名相同，参数列表不同。并不一定在同一个类中，继承关系中也可以构成重载。

• 重写/覆盖（overwrite）:函数名相同，参数列表相同，返回值类型相同。 可以遵守协变类型。

• 协变类型：在导出类（子类）的覆写基类（父类）的方法的返回值可以是基类方法返回值的导出类型。
  基类（父类）中的方法：Fu f(){}
  那么在导出类（子类）中重写该方法可以是：Zi f(){}
  注：返回值类型 Zi 继承自 Fu

• 派生类构造对象的初始化顺序:

base.static{}  //基态的静态块；
derieve.static{}   //派生类的静态块
base.instance{}   //基态的实例块
base.init{}   //基态的构造函数
derieve.instance{} //派生类的实例块
derieve.init{}  //派生类的构造函数

• （public）基类的数据成员在派生类当中的访问权限

类型	同包子类	同包非子类	不同包子类	不同包非子类
public（公有）	y	y	y	y
private（类访问权限）	n	n	n	n
protected（继承/包 访问权限)	y	y	y	n
默认权限（包访问权限）	y	y	n	n

多态:基类引用了派生类的对象，并且基类和派生类有同名的覆盖方法。

• class对象
• 位置：class对象放在方法区。class对象放的是当前类的信息。
• 方法表：在编译的时候生成的。
• 方法表和类型一一对应。class对象也和类型一一对应。并不是一个对象一个class对象。
• 静多态：在编译的时候确定。调用的是基态的fun
• 动多态: 在运行的时候确定。调用的是子类的fun
• 构造函数能否发生多态？可以。
• invokevirtual ：（动多态）一种动态分派的调用指令：也就是引用的类型并不能决定方法属于哪个类型。
• invokestatic ：静多态
• invokespecial：invokespecial只能调用三类方法：方法；private方法；super.method()。因为这三类方法的调用对象在编译时就可以确定。