第十章：面向对象编程（高级部分）（下）

目录

10.15单例模式

10.15.1 饿汉式VS懒汉式

10.16 Final关键字

10.16.1基本介绍

10.16.2什么时候会使用到final关键字呢？

10.16.3final使用的注意事项和细节讨论

10.17 抽象类

10.17.1介绍：

10.17.2抽象类的注意事项，使用细节

10.18 接口

10.18.1 介绍 ：接口就是给出一些没有实现的方法封装到一起，到某个类需要使用的时候，再根据具体情况把这些方法写出来。

10.18.2 注意事项和细节

10.18.3 实现接口VS继承类

10.18.4 接口的多态性

10.18.5 多态传递现象

---

10.15单例模式

介绍：单例设计模式，就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。

1、单例模式有两种方式：(1)饿汉式（2）懒汉式

2、演示饿汉式、懒汉式、单例模式的实现

步骤如下：

1）构造器私有化-->防止直接new

2）类的内部创建对象

3）向外暴露一个静态的公共方法。getInstance（）

饿汉式源码：

package com.cds.singleCase;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

//写出单例模式，饿汉式，懒汉式
public class Single {
    public static void main(String[] args) {

    //GirlFriend girlFriend = new GirlFriend("小美");
    }
}
class GirlFriend{
    private String name;

private static GirlFriend gf = new GirlFriend("刘欣桦");
    private GirlFriend(String name) {//将构造器私有化
        this.name = name;
    }
    public static GirlFriend getInstance(){
        return gf;
    }

    @Override
    public String toString() {
        return "GirlFriend{" +
                "name='" + name + '\'' +
                '}';
    }
}

懒汉式源码：

package com.cds.singleCase;

public class Single02 {
    public static void main(String[] args) {
        //演示懒汉式
        Cat c1 = Cat.getInstance();
        Cat c2 = Cat.getInstance();
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c1==c2);

    }
}
class  Cat{
    private String name;
    private static Cat cat;
    //步骤
    //1、私有化构造器
    //2、定义一个static静态属性对象
    //3、提供一个公共的getInstance()方法，返回Cat对象
    //4、懒汉式：只有当用户使用getInstance()方法时，才创建并返回cat对象，
    //当再次调用时，返回上次创建的cat对象

    private Cat(String name) {
        this.name = name;
    }
    public static Cat getInstance(){
        if(cat==null){
            cat = new Cat("小花猫");
        }
        return cat;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}

10.15.1 饿汉式VS懒汉式

1. 二者最主要的区别在于创建对象的时机不同，饿汉式是在类加载的时候就创建了，而懒汉式是在使用时才创建
2. 饿汉式不存在线程安全的问题，懒汉式存在线程安全的问题
3. 饿汉式存在资源浪费的可能。

10.16 Final关键字

10.16.1基本介绍

final：最后的

final可以修饰类。属性、方法、和局部变量

10.16.2什么时候会使用到final关键字呢？

1. 当不希望类被继承的时候可以用final修饰
2. 当父类的方法不希望被子类覆盖（重写）格式：访问修饰符 final 返回类型 方法名（）
3. 当不希望某个类中的属性被修改时可以使用final关键字
4. 当不希望某个局部变量被修改

10.16.3final使用的注意事项和细节讨论

1. final修饰的属性又叫常量，一般用XX_XX_XX
2. final修饰的属性在定义时就必须赋初始值，并且以后不能在修改
3. 赋值的位置1、定义时 private final int TXT = 10;    2、在构造器中    3、在代码块中
4. 如果final修饰的属性是静态的那么她初始化的位置就只有1、定义时 2、在静态代码块中 不能在构造器中赋值  // ??????
5. final 类不能继承，但是可以实例化 对象
6. 如果类不是final 类，但是含有final方法，则该方法虽然不能被重写，但是可以被继承
7. 一般来说，当一个类已经是final类的话，那么就没有必要再将方法修饰成final方法论了
8. final 不能修饰构造方法，及构造器
9. final 和 static 往往搭配使用，效率更高，不会导致类加载，底层编译器做了优化处理//???

10.17 抽象类

10.17.1介绍：

1、当父类的某些方法，需要声明但是又不确定如何实现时，就可以将其声明为抽象方法，则这个类就是抽象类

2、用 abstract 修饰类时，这个类就是抽象类

访问修饰符 abstract 类名{}

3、用 abstract 修饰一个方法时，这个方法就是抽象方法，该方法没有方法体

4、抽象类的价值更多的是在于设计，设计者设计好后让子类去实现

10.17.2抽象类的注意事项，使用细节

1. 抽象类不能被实例化

 2、抽象类不一定包含abstract方法

3、一旦包含了abstract方法，则这个类必须声明为abstract

 4、abstract只能修饰类和方法不能修饰属性和其他的

5、抽象类可以又任意成员，它的本质还是类 比如：非抽象方法，构造器，静态属性等

6、抽象方法不能有主体

7、如果一个类继承了抽象类。则她必须实现抽象类的所有抽象方法，除非自己也声明是抽象类

8、抽象方法不能使用 private  final static修饰，因为这些关键字都和重写是相违背的

10.18 接口

10.18.1 介绍 ：接口就是给出一些没有实现的方法封装到一起，到某个类需要使用的时候，再根据具体情况把这些方法写出来。

语法：interface 接口名{

        //       属性

        //抽象方法

}

class 类名 implements 接口{

//自己属性

//自己的方法

//实现接口的所有方法

}

小结：接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，而接口里面的方法全部没有方法体。【jdk7.0】接口体现了程序设计的多态和高内聚低耦合的设计思想

特别说明：jdk8.0往后接口类可以有静态方法默认方法，也就是说接口中可以有方法的具体实现

10.18.2 注意事项和细节

（1）接口不能被实例化

（2）接口中的所有方法是public方法，接口中的抽象方法，可以不用abstract修饰 ：接口中

void AAA()；实际上是  public  abstract void aa(); 

(3)一个普通类实现接口的话就必须将接口中的所有方法都实现

（4）抽象类 实现接口的话，不需要将接口中的所有方法实现

（5）接口中的属性 一定是 public static final 修饰符，比如 int  n1 = 10;实际上是 public static final int  n1 = 10;

（6）接口中的属性访问形式 接口名.属性名

（7）接口不能继承其他的类，但是可以继承多个其他接口

（8）接口的修饰符 只有public 默认，这点和类是一样的

10.18.3 实现接口VS继承类

一句话总结就是：继承是天生就有的，实现接口则是后天学习拓展实现的。

继承：解决代码的复用性和可维护性

接口：设计好各种规范（方法）让其他类去实现这些方法，更加的灵活

继承满足：is-a 而接口满足like-a

接口在一定程度上实现代码的解耦：及接口规范性+动态绑定机制

10.18.4 接口的多态性

package com.cds.interface_.interface01;

public class interface01_ {
    public static void main(String[] args) {
        Camera camera = new Camera();
        Phone phone = new Phone();
        Computer computer = new Computer();
        computer.work(phone);
        computer.work(camera);
    }
}

package com.cds.interface_.interface01;

public class Phone implements UsbInterface {
    @Override
    public void start() {
        System.out.println("手机开始使用");
    }

    @Override
    public void end() {
        System.out.println("手机停止使用");
    }

package com.cds.interface_.interface01;

public class Camera implements UsbInterface{
    @Override
    public void start() {
        System.out.println("相机开始使用");
    }

    @Override
    public void end() {
        System.out.println("相机结束使用");
    }
}
package com.cds.interface_.interface01;

public class Computer {
    public void work(UsbInterface usb){
        usb.start();
        usb.end();
    }
}


package com.cds.interface_.interface01;

public interface UsbInterface {
    public abstract void start();
    public abstract void end();
}

在本案例中usbInterface usb 既能接收Phone对象，又能接收Camera对象，就体现了接口的多态。

10.18.5 多态传递现象

usb2继承了usb接口，而phone实现了usb2则实际上也实现了usb接口

这就是所谓的 接口传递多态现象

package com.cds.interface_.interface02;

public class InterfacePolyPass {
    public static void main(String[] args) {
        //演示多态的传递现象
    

    }
}


package com.cds.interface_.interface02;

public class Phone_ implements usb2{
    @Override
    public void s1() {

    }

    @Override
    public void s2() {

    }

    @Override
    public void s3() {

    }

    @Override
    public void s4() {

    }
}



package com.cds.interface_.interface02;

public interface usb {
    void s1();
    void s2();
}



package com.cds.interface_.interface02;

public interface usb2 extends usb{
    void s3();
    void s4();
}