小王Java学习打卡day07——模板方法设计，接口，多态

最新推荐文章于 2023-09-08 21:08:58 发布

原创最新推荐文章于 2023-09-08 21:08:58 发布 · 247 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

学习打卡专栏收录该内容

14 篇文章

订阅专栏

本文主要探讨了Java中的接口概念，包括接口的定义、注意事项、实现方式及多继承。此外，讲解了模板方法设计模式的应用，如何统计不同操作的耗时。还涉及了Object类的常用方法，多态的概念及其在实际开发中的应用，以及内部类、匿名对象和代码块的相关知识。

接口

什么是接口？

硬件接口：两个硬件设备之间的连接方式，包含数据传输协议
软件接口：程序代码，包含一种规范

统一接口以后的意义：根据规范设计产品，可以做到适配性 type-c

JAVA接口

定义：需要使用 interface 关键字

public interface interfaceDemo {
    
}

接口的注意点：

接口里面只能定义抽象方法。
接口里的方法默认是public 和 static 修饰符

接口里面不能有方法主体，因为默认为抽象类

接口里面只能定义常量，final是多余的

怎么去实现接口？

创建接口的实现类，然后创建测试类去实例化实现类，调用方法

package cn.xiaojun.practice;

public class interfaceClass implements interfaceDemo{
    @Override
    public void eat() {
        System.out.println("接口的实现类方法");
        System.out.println(a);
    }
}

接口的多实现

注意：分别把每个接口的抽象方法都要实现

public interface interfaceDemo1 {
    void usb();
}
public interface interfaceDemo2 {

        void typeC();
}

public class implementsDemo implements interfaceDemo1,interfaceDemo2{
    @Override
    public void usb() {
    }

    @Override
    public void typeC() {
    }
}

接口的多继承

接口与接口之间可以使用extends关键字
当接口继承接口时，实现类只需要去实现最终的接口就可以了

public interface interfaceDemo2 {
        void typeC();
}
public interface interfaceDemo3 {
    void walk();
}

public interface interfaceDemo1 extends interfaceDemo2,interfaceDemo3{
    void usb();

    @Override
    void typeC();

    @Override
    void walk();
}

注意：

接口可以多继承，类不可以，类与类之间只能单继承
类与类之间可以叠加继承，1 继承 2 ，2 继承3，3继承4.....
子类继承父类，同时父类也可以实现接口
抽象类可以不用实现接口的抽象方法

接口和抽象的选择

抽象类，接口都属于顶端
抽象类里有抽象方法，还会有实例方法。
接口，定义规范

模板方法设计模式

需求：统计不同操作的耗时，String拼接一万次时间，int 加和一万次的时间

逻辑：运用抽象类制作模板，相同的代码定义为final，不同的代码设置调用自身的抽象方法，然后子类继承模板，重写抽象方法。

//模板
public abstract class TimeTemplate {

    final public long getTimeTotal(){
        //final修饰，获取开始时间
        long begin = System.currentTimeMillis();
        //调用可被子类重写的doWork方法
        this.doWork();
        //final 修饰，获取结束时间
        long end = System.currentTimeMillis();
        //返回时间差
        return end-begin;
    }
    //构造用于被子类 重写的方法
    protected abstract void doWork();
}


//子类继承
public class StringDemo2 extends TimeTemplate{
    //重写 doWork方法
    @Override
    protected void doWork() {
        String str = "";
        for (int i = 0; i < 10000; i++) {
            str += i;
        }
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        StringDemo2 stringDemo2 = new StringDemo2();
        long timeTotal = stringDemo2.getTimeTotal();
        System.out.println("string 加和一万次 的耗时："+timeTotal);
    }
}

object类

object类是所有类的超类（父类）。

ctrl + h ：查看当前类的继承结构

object的常用方法

toString 直接打印对象就是打印对象的 toString 方法

public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
 }

getClass() 获取类的权限定类名class cn.xiaojun.objectdemo.Test
```
public final native Class<?> getClass();
```
hashCode() 每一个存储在堆里面的对象，都有一个哈希编码，不会重复，方便区分

   public native int hashCode();

finalize 当垃圾收集gc确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。（不需要程序员去调用，它会自动调用）对于任何给定的对象，Java 虚拟机永远不会多次调用finalize方法。

    protected void finalize() throws Throwable { }

equals方法与 == 的区别（本身是没有区别的，因为equals底层调用的也是 == ，只是某些实现类给他进行了重写，String重写之后比较的就是内容值，而不是地址值）

    == 比较的是地址值
    
    
    equals比较的是值
    public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }

多态

为什么产生？

学生是学生，学生也是人

1.语法：

Student
    
    
Person

Student student = new Student();
Person person = new Person();

接口和类都可以产生多态， is 形式（什么是什么）
实际开发中，面向接口编程
如果多态的调用中，父类或者接口里面没有的方法，也不能调用

向上转型 优点：可以快速的调用和重写父类方法，使代码简洁，大大减少程序员的工作量，这就是面向对象的思想缺点：比起Cat t=new Cat()不能直接调用子类的私有属性和方法，但这种情况可以用强制向下转型来解决

关于多态向上转型和向下转型的要点一、向上转型后子类不能调用自己的私有属性和私有方法，只能调用父类属性和重写父类方法二、如果向上转型后想要调用子类的私有属性和方法，可以强制向下转型 Animal t1=(Animal)t 1 新创建了一个Animal类型的对象t1指向强制转换类型后的t 注：t1和t的地址一样 1 三、向下转型是有风险的，必须是继承关系才能转型成功，否则程序运行时就会抛出异常，为了防止这种情况，就要使用instanceof运算符

内部类

成员内部类

public class Outer {
    private String name;
    public static class Inner{
    }
}
访问方式：先创建外部对象，再用外部对象创建内部对象，再调用内部方法
    public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = new Outer.Inner();
        inner.run();
    }
}

匿名对象

定义格式

创建对象的时候不用接收
    public class StudentTest {
    public static void main(String[] args) {
        new Student().eat(); //不用接收
    }
}

优缺点：
- 方便GC垃圾的回收，节约内存开销
- 创建对象过于频繁，用一次创一次

代码块

静态代码块

static {
       System.out.println("静态代码块");
   }

局部代码块

void eat(){
       {
           System.out.println("局部代码块");
       }
   }

构造代码块

{
      System.out.println("构造代码块");
  }

执行顺序：静态代码块，构造代码块，构造器，局部代码块。

如果有父类：

父类静态代码块，子类静态代码块，父类构造代码块，父类构造器，子类构造代码块，子类构造器。。。