P401-P410接口

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

``

package singleTon;
​
public class Abstract {
    public static void main(String[] args) {
        B b = new B();
        b.cal();//动态绑定，执行到job()
    }
}
abstract class A{
    public void cal(){
        long start = System.currentTimeMillis();
        job();
        long end= System.currentTimeMillis();
        System.out.println("执行时间="+(end-start));
    }
    public abstract void job() ;
}
class B extends A{
    @Override
    public void job(){
        //得到开始时间
        long num = 0;
        for (int i = 0; i <= 199999; i++) {
            num += i;
        }//得到结束时间
    }
}

​

P402接口

//
public interface UsbInterface {//接口
    //接口方法
    public void start();
    public void end();
}
//
public class Camera implements UsbInterface {
    @Override
    public void start(){
        System.out.println("相机开始工作");
    }
    @Override
    public void end(){
        System.out.println("相机end工作");
    }
}
//
public class Phone implements UsbInterface {
    //类实现UsbInterface接口，规定声明方法
    @Override
    public void start(){
        System.out.println("手机开始工作");
    }
    @Override
    public void end(){
        System.out.println("手机end工作");
    }
   
}
//
public class Computer {
    //编写一个方法
    public void work(UsbInterface usbInterface){
        //通过接口来调用方法
        usbInterface.start();
        usbInterface.end();
    }
}
//
public class Interface {
    public static void main(String[] args) {
        Camera c =new Camera();
        Phone p = new Phone();
        Computer cp = new Computer();
        cp.work(c);//把相机接入计算
        cp.work(p);
    }
}

P404接口基本介绍

public interface AInterface {
    //写属性
    public int n1=10;
    //写方法,在接口中抽象方法可以省略
    public void hi();
    //在jdk8之后，可以默认实现方法，需要用default关键字修饰
    default public void ok(){
        System.out.println("ok.....");
    }
    //jdk8后，可以有静态方法
    public static void cry(){
        System.out.println("静态方法");
    }
}

package In.interface01;
public interface DBinterface {//项目经理写的
    public void connect();//连接方法
    public void close();//关闭方法
}
​
//
package In.interface01;
​
public class Mysql implements DBinterface{//A程序员
    @Override
    public void connect(){
        System.out.println("连接mysql数据库");
    }
    @Override
    public void close(){
        System.out.println("关闭mysql");
    }
}
//
package In.interface01;
​
public class Oracle implements DBinterface {
    @Override
    public void connect() {
        System.out.println("连接oracle数据库");
    }
    @Override
    public void close() {
        System.out.println("关闭oracle数据库");
    }
}
//
public class Interface03 {
    public static void main(String[] args) {
        Mysql mysql = new Mysql();
        t(mysql);//输出连接mysql数据库关闭mysql
        Oracle oracle = new Oracle();
        t(oracle);//连接oracle数据库关闭oracle数据库
        //具体是创建每个对象，调用方法，动态绑定
    }
    public static void t(DBinterface db){
        db.connect();
        db.close();
    }
}

p406接口使用细节

public class InterfaceDetial {
    public static void main(String[] args) {
        //new IA();1.接口不能实例化
    }
}
interface IA{
  //2.接口中所有方法是public方法，接口中的抽象方法，可以不用abstract修饰
    void say();
    void hi();
}
class B implements IA{可以用alt+enter点击IA出现override重写实现3
    //3.一个普通类实现接口就必须实现该接口的所有方法
    @Override
    public void say(){
    }
    @Override
    public void hi(){
    }
}
abstract class Tiger implements IA{
    //4.抽象类实现接口，可以不用实现接口的方法
}

package In.interface01;
​
public class InterfaceDetial {
    public static void main(String[] args) {
        //证明一下6
        System.out.println(IA.n1);//静态属性
    }
}//9.接口只能和类一样修饰符是public和默认
interface ID extends IA,IB{};//8.接口不能继承其他类，但是能够继承多个别的接口；
interface IA{
    //6.接口中的属性只能是final，而且是public static final修饰
    int n1=10;
  void say();
}
interface IB{
    void hi();
}
class Pig implements IA,IB{//5.一个类可以实现多个接口
    @Override
    public void say(){
    }
    @Override
    public void hi(){
    }
}
​

package In.interface01;
​
public class ExtendVsInterface {
    public static void main(String[] args) {
        LiterM wukong = new LiterM("wuko");
        wukong.climbing();
        wukong.swiming();
        wukong.fly();
    }//当子类继承父类，就直接拥有父类的功能
    //如果需要扩展功能，可以通过接口的方式扩展
    //实现接口是对java单继承机制的一种补充
}
//接口
interface Fish{
    void swiming();
}
interface Bird{
    void fly();
}
//继承
class LiterM extends Monky implements Fish,Bird{
    public LiterM(String name) {
        super(name);
    }
    @Override
    public void swiming(){
        System.out.println(getName()+"通过学习学会了相鱼儿般游泳");
    }
    @Override
    public void fly(){
        System.out.println(getName()+"通过学习像鸟儿一样飞翔");
    }
}
class Monky{
    private String name;
    public void climbing(){
        System.out.println(getName()+"猴子在爬树");
    }
​
    public String getName() {
        return name;
    }
​
    public Monky(String name) {
        this.name = name;
    }
}

P410java接口的多态

public class Computer {
    //编写一个方法
    //1UsbInterface usbInterface 形参是接口类型UsbInterface
    //看到，接收，UsbInterface接口的类的对象实例(内含向上转型和动态绑定)
    public void work(UsbInterface usbInterface){
        //通过接口来调用方法
        usbInterface.start();
        usbInterface.end();
    }
}
​

package In.interface01;

public class InterfacePolyArr {
    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_) usbs[i]).call();//向下转形
            }
        }
    }
}
interface Usb{
    void work();
}
class Phone_ implements Usb{
    public void call(){
        System.out.println("手机打电话");
    }
    @Override
    public void work() {
        System.out.println("手机workong中");
    }
}
class Camera_ implements Usb{
    @Override
    public void work() {
        System.out.println("相机workong中");
    }
}
package In.interface01;

public class InterfacePolyPass {//多态的传递
    public static void main(String[] args) {
        IC ic=new Teacher();//接口类型可以指向实现该接口的类的对象实例
        IH ih=new Teacher();//如果IC继承IH接口，而Teacher类实现了IC接口
        //那么实际上相当于Teacher类实现了IC接口。
        //这就是多态的传递
    }
}
interface IH{}
interface IC extends IH{}
class Teacher implements IC{
}
public class InterfaceExercise {
    public static void main(String[] args) {
    }
}
interface A { // 1min 看看
    int x = 0;//想到等价public static final int x = 0;
}
class B {
    int x = 1;//普通属性
}
class C extends B implements A {
    public void pX() {
        System.out.println(A.x + " " + super.x);
        //System.out.println(x); //错误，原因不明确x
    }
//可以明确的指定x
//访问接口的x 就使用A.x
//访问父类的x 就使用super.x
    public static void main(String[] args) {
        new C().pX();
    }
}