第二阶段（二）抽象 接口 代码块 单例 多态 权限修饰符

单例

为什么使用单例模式，首先单例模式有一定的场景限定，一个任务管理器就是一个单例，一个jvm运行环境就是一个单例。单例的意思是一个类只能创建一个实例对象而不能创建多个对象。单例的模式有两种，饿汉式和懒汉式。

1、饿汉式 — 调用的时候对象已经创建完毕

public class SingleDemo_one {

    public static void main(String[] args) {
        //创建的第一个对象和第二个对象是相同的
        SingleDemo singleDemo1 = SingleDemo.getSingleInstance();
        SingleDemo singleDemo2 = SingleDemo.getSingleInstance();
        System.out.println(singleDemo1);
        System.out.println(singleDemo1 == singleDemo2);
    }

}

class SingleDemo{

    private String name;

    public static SingleDemo singleDemo = new SingleDemo("name");

    //无参构造私有化——这个是关键
    private SingleDemo(String name){
        this.name = name;
    }

    public static SingleDemo getSingleInstance(){
        return singleDemo;
    }

}

2、懒汉式 — 调用的时候再去进行对象的创建

(1)饿汉式是在使用时候已经创建完毕，懒汉式是在使用时候才去进行创建

(2)在使用过程中更加的倾向使用懒汉式，支取声明，需要的时候才去进行对象的创建

public class SingleDemo_two {
}

class SingleDem{

    public static SingleDem singleDem;

    /**
     * 构造器私有化
     */
    private SingleDem(){
    }

    public static SingleDem getInstance(){
        if (singleDem == null){
            singleDem = new SingleDem();
        }
        //进行对应对象的创建
        return singleDem;
    }
}

多态

/**
 * 1、多态：首先多态是针对方法的一种行为而不是属性
 * 2、多态的形式：
 * 父类对象 父类对象名称 = new 子类对象（）
 * 接口     对象名称  = new 接口实现类（）
 * 3、多态的前提：
 *  （1）必须存在继承或者实现
 *  （2）必须存在方法的重写
 *  （3）必须存在父类类型的变量引用子类的对象
 * 4、多态的优略势：
 *  优势：
 *  （1）实现右边的组件化切换，业务功能也随之更换和改变，便于拓展和维护
 *  （2）实际开发过程中，父类类型作为方法的参数，更能体现出方法的扩展性与便利
 *  略势：
 *  （1）在多态条件去去调用子类独有的方法是无法实现的 —— 大转小去进行强转，去调用子类的方法
 */
public class PolymorphicDemo_one {

    public static void main(String[] args) {
        Anm cat = new Cat();
        cat.sleep();
        //无法去调用子类的方法
//        cat.test();
        System.out.println(cat.name);
        think(cat);

        Anm dog = new Dog();
        dog.sleep();
        System.out.println(dog.name);
        think(dog);

        //大专小进行强转去实现
         Dog dog1 = (Dog) new Anm();
        System.out.println(dog1.name);
    }

    public static void think(Anm anm){
        System.out.println(anm.name);
    }
}

class Anm {

    public String name = "father";
    public void sleep() {
        System.out.println("sleep");
    }

}

class Cat extends Anm {

    public String name = "cat";
    @Override
    public void sleep() {

        System.out.println("cat sleep");

    }

    public void test(){
        System.out.println("qqqqq");
    }
}

class Dog extends Anm {

    public String name = "dog";
    @Override
    public void sleep() {
        System.out.println("dog sleep");
    }
}

 注意：在多态中需注意大转小时候的情况，只有在多态中选用对应的子类型，再去强转该子类型才会生效，在强转过程中需要去使用instanceof去进行判别

public class PolymorphicDemo_two {

    public static void main(String[] args) {
        Person p = new Girl();
        Person person = new Person();
        Girl g = new Girl();
        Boy b = new Boy();

        g = (Girl) p;
//        b = (Boy) person;

        person = b;
        if (p instanceof Boy){
            System.out.println(1);
        }
        if (p instanceof Girl){
            System.out.println(2);
        }
//        son son = new son();
//        son.run();
//        father father = son;
//        father.run();
    }

}

class Person{}
class Girl extends Person{}
class Boy extends Person{}

interface father{
    void run();
}

class son implements father{
    @Override
    public void run() {
        System.out.println("son");
    }
}

权限修饰符

1、private只限定于当前的类中使用；

2、default只限定于当前的包中使用；

3、protected只限定于在该包的类下与其他包的子类中使用；

4、public相当于共享。

拓展：final关键字

/**
 *
 * 1、final作为关键词，可以用来修饰类，方法，变量
 * 2、当final修饰类的时候：这个类是不能被继承的；
 *    当final修饰方法的时候：这个方法是不能被重写的；
 *    当final修饰变量的时候：这个变量只能被赋值一次
 * 3、final与abstract是互斥的，不论是在使用意义上还是在底层构造上
 * 4、变量分为两种：
 *  ——成员变量：静态变量-static修饰
 *             实例变量-无static修饰
 *  ——局部变量
 * 5、当final修饰变量的时候——就预示着这个值不能被改变
 */

public class FinalDemo_one {

    public static void main(String[] args) {
        final String name = "xue";

        //一般作为一个固定值去进行处理
        final double rate = 3.14;

        //第一次调用该方法
        t(1);
        //第二次调用该方法
        t(2);
    }

    public static void t(final int a){
//        a = 1;//报错——这个方法一旦被调用，a这个值就会保持不变
        System.out.println(a);
    }

}