Java笔记之面向对象 下（十三）

一、抽象类最佳实现-模板设计模式

1.基本介绍

抽象类体现在一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为

2.使用场景

• 当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现
• 编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式

3.最佳实践

• 有多个类，完成不同的任务job
• 编写calculateTime()方法,得到各自完成任务的时间

public class test1 {
    public static void main(String[] args) {
        AA aa = new AA("AA");
        aa.calculateTime();
        BB bb = new BB("BB");
        bb.calculateTime();
        //C类、D类..........
    }
}

class AA extends Template{
    public AA(String name) {
        super(name);
    }

    @Override
    public void job() {
        long num = 0;
        for (int i = 0; i <= 10000000; i++) {
            num += i;
        }
    }
}

class BB extends Template{
    public BB(String name) {
        super(name);
    }

    @Override
    public void job() {
        long num = 0;
        for (int i = 0; i <= 500000; i++) {
            num += i;
        }
    }
}

//抽象类-模板设计模式
abstract class Template{
    String name;

    public Template(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public abstract void job();   //抽象方法

    public void calculateTime(){    //计算执行时间
      long start = System.currentTimeMillis();  //开始的时间
      job();	//动态绑定机制
      long end = System.currentTimeMillis();  //结束的时间
      System.out.println(getName()+"执行时间为："+(end-start));
    }
}

二、接 口

1.基本介绍

接口：可以理解成是一种特殊的类，里面的方法全是公开的抽象方法（写不写abstract都一样），里面的变量全是公开常量。因为Java是单继承，仅仅只有单继承的话，扩展性就会低，接口的出现就是为了解决这一问题，Java可以多实现（多继承），接口是一个标准。

语法格式
interface 接口名{
　//属性
　//抽象方法　
}

类实现接口语法格式
class 类名 implements 接口{
　自己属性；
　自己方法；
　必须实现接口中所有的抽象方法
}

为了更好的理解接口，我们可以把接口想象成电脑的USB接口，只要带有USB功能的设备就可以插入电脑进行数据的读取和写入，这种功能能做很多事情，我们就可以把USB看做是一种标准，一种接口，只要实现了USB标准的设备我就认为你已经拥有了USB这种功能。

2.快速入门

public class test1 {
    public static void main(String[] args) {
        phone phone = new phone();
        ipad ipad = new ipad();
        compute compute = new compute();
        compute.USB(phone);
        compute.USB(ipad);
    }
}
//接口
interface UsbInterface{
    public void start();    //抽象方法
    public void close();    //抽象方法
}

//实现usbInterface接口，重写接口中所有的抽象方法
class phone implements UsbInterface{
    @Override
    public void start() {
        System.out.println("打开手机...");
    }

    @Override
    public void close() {
        System.out.println("关闭手机...");
    }
}

//实现usbInterface接口，重写接口中所有的抽象方法
class ipad implements UsbInterface{
    @Override
    public void start() {
        System.out.println("打开平板电脑...");
    }

    @Override
    public void close() {
        System.out.println("关闭平板电脑...");
    }
}

class compute{
    //UsbInterface usbInterface 形参是接口类型 UsbInterface
    //接收 实现了UsbInterface接口的类的对象实例
    public void USB(UsbInterface usbInterface){
        usbInterface.start();
        usbInterface.close();
    }
}

3.使用细节

1. 接口不能实例化
2. 接口中的所有方法都是抽象方法，可以不写abstract修饰
3. 一个普通类实现该接口，必须实现该接口中所有的方法
4. 抽象类实现接口，可以不用实现接口中的方法
5. 一个类可以同时实现多个接口
6. 接口中所有的属性都是public static final 这种修饰符，以及必须初始化 如：public static final int x = 1;
7. 接口中属性的访问形式：接口名.属性名
8. 接口不能继承其它类，但是可以继承多个接口
9. 接口的修饰符只能是public和默认，这点和类的修饰符是一样的

public class test1 {
    public static void main(String[] args) {
        //细节一
//        interface1 interface1 = new interface1();

        //细节七
        int a = interface4.a;   //静态的一种体现
        System.out.println(a);
    }
}

interface interface1{
    //细节二
    public void test(); //抽象方法
    abstract public void test1();   //抽象方法
}

//细节三
class A implements interface1{
    @Override
    public void test() { }  //实现接口的方法

    @Override
    public void test1() { } //实现接口的方法
}

//细节四
abstract class B implements interface1{ }

//细节五
interface interface2{}
interface interface3{}
class C implements interface2,interface3{}

//细节六
interface interface4{
    public static final int a = 1;
    int b = 1;  //虽然b的前面没有public static final，看不见但确实存在
//    int c;  //错误，必须初始值
//    b = 2;  //错误，不能改变
}

//细节八
class D{}
//interface interface5 extends D{ }   //错误
interface interface5 extends interface2,interface3{}

继承和接口

public class test1 {
    public static void main(String[] args) {
        man man = new man("小明");
        man.speak();
        man.run();
        man.calculation();
    }
}

class Person{
    String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void speak(){
        System.out.println(getName()+"会说话...");
    }
}

interface A{
    void run();
}

interface B{
    void calculation();
}

//单继承多实现
class man extends Person implements A,B{
    public man(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(getName()+"学会了跑步...");
    }

    @Override
    public void calculation() {
        System.out.println(getName()+"学会了计算...");
    }
}

继承：主要为了解决代码的复用性和可维护性
接口：设计好各种规范（方法），让其它类去实现这些方法 即更加的灵活，是对java单继承的一种补充
接口在一定程度上实现代码解耦 即：接口规范性+动态绑定机制

4.接口的多态特性

快速入门

public class Test {
    public static void main(String[] args) {
        A b = new B();  //接口多态的体现
        b = new C();
    }
}

interface A{}
class B implements A{}
class C implements A{}

接口类型的多态数组

public class Test {
    public static void main(String[] args) {
        //接口类型的多态数组
        A[] as = new A[2];
        as[0] = new B();
        as[1] = new C();
    }
}

interface A{}	//接口
class B implements A{}	
class C implements A{}

案例练习

要求

1. 创建一个接口USB编写一个抽象方法work()
2. 分别创建两个类phone和ipad实现USB接口，重写其中的抽象方法，phone有一个独特的方法call()
3. 创建一个多态数组，遍历数组，如果是phone对象，除了调用work()方法外，还需要调用call()方法

public class test1 {
    public static void main(String[] args) {
        //接口类型的多态数组
        USB[] usbs = new USB[2];
        usbs[0] = new phone();
        usbs[1] = new ipad();

        for (int i = 0; i < usbs.length; i++) {
            usbs[i].work();
            if (usbs[i] instanceof phone){
                ((phone)usbs[i]).call();    //多态的向下转型
            }
        }
    }
}
//接口
interface USB{
    public void work();    //抽象方法
}

//实现usbInterface接口，重写接口中所有的抽象方法
class phone implements USB{
    @Override
    public void work() {
        System.out.println("phone正在运行...");
    }

    public void call(){
        System.out.println("打电话...");
    }
}

//实现usbInterface接口，重写接口中所有的抽象方法
class ipad implements USB{
    @Override
    public void work() {
        System.out.println("ipad正在运行...");
    }
}

接口的多态传递

如果A类实现了B接口，B接口又继承了C接口，相当于A类实现B,C两个接口

public class test1 {
    public static void main(String[] args) {
        //多态
        B b = new A();
        C c = new A();
    }
}

class A implements B{
    //必须要重写C中的抽象方法
    @Override
    public void test() {

    }
}

interface B extends C{

}

interface C{
    void test();
}