学习笔记--接口和抽象类

抽象类

抽象类的作用：如果定义了一个类Shape，这个类有计算周长的clper()方法,并且不同子类有不同的就按方法，Shape类无法准确知道调用哪个子类的clper()方法，如果需要引用，需要将Shape类强制转换成子类型才能使用clper()方法

抽象类用abstrat关键字来定义:

public abstract class abts{}

1.抽象类不能被实例化,无法使用New关键字

2.抽象方法没有方法体 即没有方法后面花括号{}

3.抽象类的构造器不能创建实例，主要是被用于其子类的调用

4.含有抽象方法的类只能被定义成抽象类

抽象类中的行为 可以执行也可以不被执行

public class abts {
    public static void main(String[] args){
        abstractts dg = new dog("dog"); //以abstractts为原型创建dog类对象
        dg.jump("dog");
        dg.run("dog");
    }
}
 abstract class abstractts{
    abstractts(){
        System.out.println("正在执行abstractts构造器");
    }
    public abstract void run(String anm);//定义一个抽象方法 没有方法体
    public abstract void jump(String anm);
}
 class dog extends abstractts{
    //定义一个普通对象继承于abstractts抽象类
    String anm;
    //重写抽象方法run
    dog(String anm){
        this.anm = anm;
    }
    public void run(String anm){
        this.anm = anm;
        System.out.println(anm + "跑");
    }
    //重写抽象方法jump
    public void jump(String anm){
        this.anm = anm;
        System.out.println(anm + "跳");
    }


 }

abstract修饰的时候表示该类必须被继承 ,方法必须被重写 ，所以Final和abstract不能同时存在.

static和abstract并不是绝对互斥的，他们虽然不能同时修饰一个方法，但是能同时修饰一个类

接口

接口的定义：

[修饰符] interface 接口名 extends 父接口1,父接口2

{

​ 零到多个常量定义

​ 零到多个抽象方法的定义

​ 零到多个内部类

​ 零到多个默认方法或类方法定义

}

接口的特性:

系统自动为接口里定义的成员变量增加public static final修饰符:

String name = “lsk”;

public static final String name = “lsk”;//这两句等价

接口里面普通定义的方法只能是public 抽象方法

如果需要定义默认方法 需要加default 修饰:default void print() {}

在接口中定义类方法 需要用 static修饰

因为接口不能被实例化 ，如果默认方法没有使用static修饰，就不能通过接口来调用默认方法，需要使用接口实现类来实例化使用默认方法

因为接口中的方法默认使用 public static final修饰，所以即使一个类在不同的包下，可以直接使用接口来访问接口中的成员变量

package lsk;
public interface abts {
   String name = "my name is lsk";
}

input lsk;
public class void main(String[] args){
    System.out.println(lsk.abts.name);
}

接口的继承

接口继承与类继承不同，接口可以继承多个接口:

public class abts {
    public static void main(String[] args){
        System.out.println(ifts3.ts);
        System.out.println(ifts3.ts2);
        System.out.println(ifts3.ts3);
    }
}
interface ifts1{
    int ts = 1;
}
interface ifts2{
    int ts2 = 2;
}
interface ifts3 extends ifts1,ifts2{
    int ts3 = 3;
} 

接口的使用

一个类可以实现一个到多个接口，使用extends关键字继承父类，使用implements继承接口

public class lsk extends 父类 implements 接口1，接口2{
    xxx
        }

public class abts {
    public static void main(String[] args){
    ifts o = new print();//可以以接口为原型给它赋对象  接口也可以参与对象的多态行为
        o.getData("lsk");
        o.getData("nb");
        o.out();
        o.print("lsk","nb");
    }
}

interface ifts{
    //定义抽象方法，准备重写
    int max_line = 10;
    void out();
    void getData(String msg);
    //定义一个默认方法，编历出字符数组
    default void print(String...msg){
        for(String msgs : msg){
            System.out.println(msgs);
        }
    }
}
interface ifts1{
    int getseries();
}
class print implements ifts1,ifts{
    //定义一个字符串组，用来存储输入
    private String[] printdata = new String[max_line];
    @Override
    public int getseries() {
        return 0;
    }
    private int num = 0;
    @Override
    public void getData(String msg) {
        if(num >=max_line){
            System.out.println("队列已满");
        }
        else {
            printdata[num++] = msg;
        }
    }

    @Override
    public void out() {
        while(num >0){
            System.out.println(printdata[0]);//输出printdata字符串第一个字符串
            System.arraycopy(printdata,1,printdata,0,--num);//将第一个字符串移动的第0个字符串的位置 --左移一位
        }
    }
}

由此可见，如果我们不使用接口实现两种不同的打印方法的时候需要写两个不同的类存放不同的编历方法
还需要给两个对象实例化。如果使用接口，可以只通过一个对象来进行不同打印方法的实现

接口和抽象类的特点:

1.接口和抽象类都不能实例化,它们都位于继承树的顶端，需要被继承

2.接口和抽象类都可以包含抽象方法，他的实现接口和继承抽象类的子类 必须实现这些方法

3.接口对于设计者而言是一种设计的规范，接口对于使用者而言规定了使用者可以调用哪些服务。

4.抽象类是一个子类的父类，必须被继承，是 实现过程的中间产品你可以使用它或者不使用它

5.抽象类不能包含普通方法，但抽象类完全可以

6.抽象类可以包含构造器，但接口不行

7.接口只能定义静态类变量，抽象类则可以