java抽象类|接口知识点总结

抽象类

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

abstract class AB{
    private String name;

    public AB(String name) {
        this.name = name;
    }
    //思考:这里eat这里你实现了，其实没有什么意义
    //即:父类方法不确定性的问题
    //===>考虑将该方法设计为抽象(abstract)方法
    //===>所谓抽象方法就是没有实现的方法
    //===>所谓没有实现就是指，没有方法体
    //===>当一个类重存在抽象方法时，需要将该类声明为abstract类
    //一般来说，抽象类会被继承，有其子类来实现抽象方法
    public abstract void eat();
}

抽象类的介绍

1)用abstract关键字来修饰一个类时,这个类就叫抽象类

访问修饰符abstract类名{ }

2)用abstract关键字来修饰一个方法时,这个方法就是抽象方法访问修饰符abstract返回类型方法名(参数列表);//没有方法体

3)抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类()

4)抽象类，是考官比较爱问的知识点，在框架和设计模式使用较多

1)抽象类不能被实例化

2)抽象类不-定要包含abstract方法。也就是说，抽象类可以没有abstract方法

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

4) abstract只能修饰类和方法，不能修饰属性和其它的

5)抽象类可以有任意成员[因为抽象类还是类] ,比如:非抽象方法、构造器、静态属性等等

6)抽象方法不能有主体，即不能实现.

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

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

抽象类最佳实践——模板设计模式

需求

1)有多个类，完成不同的任务job 2)要求能够得到各自完成任务的时间 3)请编程实现

package Opp;

public class SS extends Tempalte{

    public void job() {//重写了Tempalte的job方法
        long num = 0;
        for (int i = 0; i < 100000000; i++) {
            num += i;
        }
    }
}

package Opp;

public class BB extends  Tempalte{
    public void job() {//重写了Tempalte的job方法
        long num = 0;
        for (int i = 0; i < 1000000; i++) {
            num *= i;
        }
    }
}

抽象类-模板设计模式：

package Opp;

abstract public class Tempalte {//抽象类-模板设计模式

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

    public void CaculateTime() {//实现方法，调用
        long start = System.currentTimeMillis();
        job();//动态绑定机制
        long end = System.currentTimeMillis();
        System.out.println("任务执行时间" +(end - start));
    }
}

package Opp;

public class fsd {
    public static void main(String[] args) {
        BB bb = new BB();
        bb.CaculateTime();
        SS ss = new SS();
        ss.CaculateTime();
    }
}

接口

接口就是给出一些没有实现的方法,封装到一起，到某个类要使用的时候,在根据具体情况把这些方法写出来。语法:

一级引用示例

interface接口名{ //属性 //方法 1.抽象方法 2.默认实现方法 3.静态方法}

class 类名implements 接口{ 自己属性; 自己方法; 必须实现的接口的抽象方法 }

1.在Jdk7.0前接口里的所有方法都没有方法体，即都是抽象方法 2. Jdk8.0后接口可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现

package inter;

public interface Usbinterface {//接口
    public void start();
    public void stop();
}

//phone实现Usbinterface接口=》规定/声明的方法

package inter;

public class phone implements Usbinterface{

    @Override
    public void start() {
        System.out.println("手机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("手机停止工作");
    }
}

//Camera实现Usbinterface接口=》规定/声明的方法

package inter;

public class Camera implements Usbinterface{

    @Override
    public void start() {
        System.out.println("相机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("相机停止工作");
    }
}

//通过接口调用方法

package inter;

public class Computer {
    //编写一个方法 计算机工作
    //1.Usbinterface usbinterface形参是接口类型
    //2.看到接收实现了Usbinterface接口的类的对象实例
    public void work(Usbinterface usbinterface){
        //通过接口调用方法
        usbinterface.start();
        usbinterface.stop();
    }
}

//把手机相机接入到计算机

package inter;

public class interface01 {
    public static void main(String[] args) {
        //创建手机相机对象
        Camera camera = new Camera();
        phone phone = new phone();
        //创建计算机
        Computer computer = new Computer();

        computer.work(phone);//把手机接入到计算机
        System.out.println("============================================");
        computer.work(camera);//把相机接入到计算机
    }
}

接口使用细节1)接口不能被实例化

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

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

4)抽象类实现接口，可以不用实现接口的方法

5)一个类同时可以实现多个接口

6)接口中的属性，只能是final的，而且是public static final修饰符。比如: int a=1;实际上是public static final int a= 1; (必须初始化)

7)接口中属性的访问形式:接口名.属性名

8)一个接口不能继承其它的类,但是可以继承多个别的接口 interface A extends B,C{}

9)接口的修饰符只能是public和默认，这点和类的修饰符是一样的。

实现接口Vs继承类

继承的价值主要在于:解决代码的复用性和可维护性。接口的价值主要在于:设计，设计好各种规范(方法)，让其它类去实现这些方法。接口比继承更加灵活接口比继承更加灵活，继承是满足is – a的关系，而接口只需满足like – a的关系。接口在一定程度上实现代码解耦

随便写一个代码看得懂就行

package inter;

public class interface01 {
    public static void main(String[] args) {
        amo amo = new amo();
        amo.run();
        amo.swing();
    }
}

class Mo{
    public void run(){
        System.out.println("会跑");
    }
}
interface AAAA{
    void swing();

}
class amo extends Mo implements AAAA{
    @Override
    public void run() {
        super.run();
    }

    @Override
    public void swing() {
        System.out.println("通过学习学会了游泳");
    }
}

接口的多态性

package inter;

public class interface01 {
    public static void main(String[] args) {
        //接口的多态体现
        //接口类型的变量mm 可以指向实现了IF接口类的对象实例 
        IF mm = new MM();
        mm = new HH();
        
        //继承的多态体现
        //父类类型的变量a 可以指向继承了AAAAA子类的对象实例 
        AAAAA a = new BBBBB();
        a = new CCCC();
    }
}

interface IF{}
class MM implements IF{}
class HH implements IF{}

class AAAAA{}
class BBBBB extends AAAAA{}
class CCCC extends AAAAA{}

向下转型

子类类型引用名= (子类类型) 父类引用

题目：给Usb数组中，存放Phone和相机对象， Phone类还有一个特有的方法call ()，请遍历Usb数组，如果是Phone对象，除了调用Usb接口定义的方法外，还需要调用Phone特有方法call

接口多态特性（多态数组）

package inter;

public class interface01 {
    public static void main(String[] args) {
        //多态数组=>接口类型数组
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone();
        usbs[1] = new Camera_();
        for (int i = 0; i < usbs.length; i++) {
            usbs[i].work();//动态绑定
            //进行类型的向下转型
            if(usbs[i] instanceof Phone){//判断他的运行类型是Phone
                Phone phone = (Phone) usbs[i];
                phone.call();
            }
        }
    }
}
interface Usb{
    void work();
}

class Phone implements Usb{
    @Override
    public void work() {
        System.out.println("手机工作");
    }
    public void call(){//特有方法 向下转型
        System.out.println("打电话");
    }
}
class Camera_ implements Usb{
    @Override
    public void work() {
        System.out.println("电脑工作");
    }
}