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

接口

什么是接口？

• 硬件接口：两个硬件设备之间的连接方式，包含数据传输协议

• 软件接口：程序代码，包含一种规范

  统一接口以后的意义：根据规范设计产品，可以做到适配性 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.....

• 子类继承父类，同时父类也可以实现接口

• 抽象类可以不用实现接口的抽象方法

接口和抽象的选择

1. 抽象类，接口都属于顶端

2. 抽象类里有抽象方法，还会有实例方法。

3. 接口，定义规范

模板方法设计模式

需求：统计不同 操作的耗时，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的常用方法

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

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

2. getClass() 获取类的权限定类名class cn.xiaojun.objectdemo.Test

   public final native Class<?> getClass();

3. hashCode() 每一个存储在堆里面的对象，都有一个哈希编码，不会重复，方便区分

   public native int hashCode();

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

    protected void finalize() throws Throwable { }

1. 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();

1. 接口和类都可以产生多态， is 形式 （什么 是 什么）

2. 实际开发中，面向接口编程

3. 如果多态的调用中，父类或者接口里面没有的方法，也不能调用

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

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

内部类

1. 成员内部类

   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();
       }
   }

匿名对象

1. 定义格式

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

1. 优缺点：

   • 方便GC垃圾的回收，节约内存开销

   • 创建对象过于频繁，用一次创一次

代码块

1. 静态代码块

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

2. 局部代码块

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

3. 构造代码块

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

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

如果有父类：

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