Java面向对象之接口(interface)

1-Java接口概述

2-Java接口举例

举例1

 举例2

2-Java接口的使用

/*
 * 接口的使用
 * 1-接口使用interface来定义
 * 2-Java中，接口和类是并列的两个结构
 *
 * 3-如何定义接口：定义接口中成员
 *     3.1 JDK7及以前：只能定义全局常量和抽象方法
 *        >全局常量：public static final的，但是书写时可以省略
 *        >抽象方法：public abstract的
 *     3.2 JDK8：除了定义全局常量和抽象类方法之外，还可以定义静态方法、默认方法
 *
 * 4-接口中不能定义构造器，意味着接口不可以实例化
 *
 * 5-Java开发中，接口通过让类去实现(implements)的方式来使用
 *     如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
 *     如果实现类没有覆盖就看中所有的抽象方法，则此实现类仍为一个抽象类
 *
 * 6-Java类可以实现 多个接口 -- > 弥补了Java单继承的的局限性
 *     格式：class AA extends BB implements CC,DD,EE{}
 *
 * 7-接口与接口之间可以继承，而且可以多继承
 */

public class InterfaceTest {
    public static void main(String[] args) {
        System.out.println(Fly.MAX_SPEED);
        System.out.println(Fly.MIN_SPEED);
        // Fly.MAX_SPEED = 1;
        
        Plane plane = new Plane();
        plane.fly();
        plane.stop();
    }

}
// 定义会飞的接口
interface Fly{
    
    // 全局常量
    public static final int MAX_SPEED = 7900; // 第一宇宙速度
    public static final int MIN_SPEED = 1;
    // int MIN_SPEED = 1; 效果也是一样的
    
    // 抽象方法
    public abstract void fly();
    void stop(); // 省略了 public abstract
}
// 定义会攻击的接口
interface Attack{
    
}
// implements的使用：类Plane 实现了接口 Fly，并且需要重写接口中的抽象方法
class Plane implements Fly{
    @Override
    public void fly() {
        // TODO Auto-generated method stub
        System.out.println("飞机起飞");
        
    }
    @Override
    public void stop() {
        // TODO Auto-generated method stub
        System.out.println("飞机降落");
        
    }
}

abstract class Kite implements Fly{ // 此时只能称作抽象类，没有实现接口
    @Override
    public void fly() {
        // TODO Auto-generated method stub
        
    }
}
// 先写继承与接口
class Bullet extends Object implements Fly,Attack{

    @Override
    public void fly() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void stop() {
        // TODO Auto-generated method stub
        
    }
    
}

/*
 * 接口练习题
 */

package com.lzh.exer;
/*
 * 1.定义一个接口用来实现两个对象的比较。 
 * interface CompareObject{ 
 *     public int compareTo(Object o); //若返回值是 0 , 代表相等; 若为正数，代表当 前对象大；负数代表当前对象小 
 * }
 *  
 * 2.定义一个Circle类，声明redius属性，提供getter和setter方法
 * 
 * 3.定义一个ComparableCircle类，继承Circle类并且实现CompareObject接口。在 ComparableCircle类中
 * 给出接口中方法compareTo的实现体，用来比较两个圆的半 径大小
 * 
 */
public interface CompareObject {
    
    //若返回值是 0 , 代表相等; 若为正数，代表当 前对象大；负数代表当前对象小
    public abstract int compareObject(Object o);
}

// 定义Circle类
class Circle{
    private double redius;
    
    public void setRedius(double redius) {
        this.redius = redius;
    }
    public double getRedius() {
        return redius;
    }
    // 构造器
    public Circle() {
        super();
    }
    public Circle(double redius) {
        super();
        this.redius = redius;
    }
}

// 定义一个ComparableCircle类，继承Circle类并且实现CompareObject接口
class ComparableCircle extends Circle implements CompareObject{
    
    public ComparableCircle(double redius) {
        super(redius);
    }

    @Override
    public int compareObject(Object o) {
        if(this == o) {
            return 0;
        }
        if(o instanceof ComparableCircle) {
            ComparableCircle c = (ComparableCircle)o;
            // return (int) (this.getRedius() - c.getRedius()); 强转的时候会精度损失
            if(this.getRedius() > c.getRedius()) {
                return 1;
            }else if(this.getRedius() < c.getRedius()) {
                return -1;
            }else {
                return 0;
            }
        }
        throw new RuntimeException("传入的数据类型不匹配！"); // 给出异常
    }
}

package com.lzh.exer;

public class ComparableCircleTest{
    public static void main(String[] args) { // 程序的入口
        ComparableCircle c1 = new ComparableCircle(2);
        ComparableCircle c2 = new ComparableCircle(3);
        
        int compar = c1.compareObject(c2);
        if(compar > 0) {
            System.out.println("c1比c2大");
        }else if(compar < 0) {
            System.out.println("c1比c2小");
        }else {
            System.out.println("c1和c2一样大");
        }
        
    }
}

3-Java接口的多继承关系

 * 接口与接口之间可以继承，而且可以多继承

// 接口与接口之间可以继承，而且可以多继承
interface AA{
    // 抽象方法
    public abstract void method1();
}
interface BB{
    // 抽象方法
    public abstract void method2();
}
interface CC extends AA,BB{
}

class DD extends Object implements CC{

    @Override
    public void method1() {

    }
    @Override
    public void method2() {

    }
}

4-Java接口的应用举例->体现多态性

/*
 * 接口的具体使用，体现多态性
 * 1-接口上使用也满足多态性
 *
 * 2-接口，实际上可以看做是一种规范
 *
 * 3-开发中，体会面向接口编程！
 */

public class USBTest {
    public static void main(String[] args) {
        
        Computer computer = new Computer();
        // 1.创建了接口的非匿名实现类的非匿名对象
        USB flash = new Flash(); // 体现多态性
        computer.transferData(flash);
        
        // 2.创建了接口的非匿名实现类的匿名对象
        computer.transferData(new Printer());
        
        // 3.创建了接口匿名实现类的非匿名对象
        USB phone = new USB() {
            @Override
            public void start() {
                // TODO Auto-generated method stub
                System.out.println("手机开始工作");
            }
            
            @Override
            public void end() {
                // TODO Auto-generated method stub
                System.out.println("手机停止工作");
            }
        };
        
        // 4.创建了接口匿名实现类的匿名对象
        computer.transferData(new USB() {
            @Override
            public void start() {
                // TODO Auto-generated method stub
                System.out.println("mp3开始工作");
            }
            
            @Override
            public void end() {
                // TODO Auto-generated method stub
                System.out.println("mp3止工作");
            }
        });
    }

}
class Computer{
    public void transferData(USB u) {
        u.start();
        System.out.println("具体传输细节");
        u.end();
    }
}

// 设置USB接口
interface USB{
    // 全局常量：长、宽、最大最小传输速度等
    
    // 抽象方法
    public abstract void start();
    public abstract void end();
}

// 
class Flash extends Object implements USB{
    
    @Override
    public void start() {
        // TODO Auto-generated method stub
        System.out.println("u盘开始工作");
    }
    
    @Override
    public void end() {
        // TODO Auto-generated method stub
        System.out.println("u盘停止工作");
    }    
}

class Printer implements USB{
    
    @Override
    public void start() {
        // TODO Auto-generated method stub
        System.out.println("打印机开始工作");
    }
    
    @Override
    public void end() {
        // TODO Auto-generated method stub
        System.out.println("打印机停止工作");
    }
}

5-接口的应用：代理模式(Proxy)

package com.lzh.java1;
/*
 * 接口的应用：代理模式
 */
public class NetWorkTest {
    public static void main(String[] args) {
        Server server = new Server();
        ProxyServer p = new ProxyServer(server);
        p.browse();
    }

}
interface NetWork{
    public abstract void browse();
}

// 被代理类
class Server implements NetWork{
    @Override
    public void browse() {
        // TODO Auto-generated method stub
        System.out.println("真实的服务器访问网络");
    }
}

// 代理类
class ProxyServer implements NetWork{
    private NetWork work;
    
    public ProxyServer(NetWork work) {
        this.work = work;
    }
    public void check() {
        System.out.println("联网之前的检查工作");
    }
    
    @Override
    public void browse() {
        // TODO Auto-generated method stub
        check();
        work.browse();
    }
}

public class StaticProxyTest {

    public static void main(String[] args) {
        Star s = new Proxy(new RealStar());
        s.confer();
        s.signContract();
        s.bookTicket();
        s.sing();
        s.collectMoney();
    }
}

interface Star {
    void confer();// 面谈

    void signContract();// 签合同

    void bookTicket();// 订票

    void sing();// 唱歌

    void collectMoney();// 收钱
}

class RealStar implements Star {

    public void confer() {
    }

    public void signContract() {
    }

    public void bookTicket() {
    }

    public void sing() {
        System.out.println("明星：歌唱~~~");
    }

    public void collectMoney() {
    }
}

class Proxy implements Star {
    private Star real;

    public Proxy(Star real) {
        this.real = real;
    }

    public void confer() {
        System.out.println("经纪人面谈");
    }

    public void signContract() {
        System.out.println("经纪人签合同");
    }

    public void bookTicket() {
        System.out.println("经纪人订票");
    }

    public void sing() {
        real.sing();
    }

    public void collectMoney() {
        System.out.println("经纪人收钱");
    }
}

/*
 * 应用场景
 */

6-接口和抽象类之间的对比

7-Java 8中关于接口的改进

 *
 * Java 8中关于接口的改进：除了定义全局常量和抽象类方法之外，还可以定义静态方法、默认方法
 * 知识点1：接口中定义的静态方法，只能通过接口来调用
 * 
 * 知识点2：通过实现类的对象，可以调用接口中的默认方法，如果实现类重写了接口中的默认方法，调用时，任然调用的是重写以后的方法
 * 
 * 知识点3(类优先原则)：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的方法，那么子类在没有重写此方法的情况下，默认调用的父类中同名同参方法。
 * 
 * 知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错 -->接口冲突。这就需要在实现类中重写此方法。
 * 
 * 知识点5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法？
 *        method3(); // 自己定义的重写方法
      super.method3(); // 调用的是父类中声明的
      
      // 调用接口中的方法
      Compare.super.method3();
      Compare2.super.method3();
 */

public class SubClassTest{
    public static void main(String[] args) {
        SubClass c = new SubClass();
        // c.method1(); 报错：接口中定义的静态方法，只能通过接口来调用
        Compare.method1();
        
        c.method2();
        c.method3();
    }
}

// 接口
interface Compare {
    // 静态方法
    public static void method1() {
        System.out.println("CompareA：北京");
    }
    //默认方法
    public default void method2() {
        System.out.println("CompareA：上海");
    }
    default void method3() {
        System.out.println("Compare：上海");
    }
}

class SubClass extends SuperSubClass implements Compare,Compare2{
    @Override
    public void method2() {
        System.out.println("现在执行重写过的呀");
    }
    public void myMethod() {
        method3(); // 自己定义的重写方法
        super.method3(); // 调用的是父类中声明的
        
        // 调用接口中的方法
        Compare.super.method3();
        Compare2.super.method3();
    }
}

// 定义SubClass的父类
class SuperSubClass{
    public void method3() {
        System.out.println("我是SubClass的父类。");
    }
}

// 定义另一个接口
interface Compare2{
    public default void method3() {
        System.out.println("我是另一个接口Compare2呀");
    }
}

/*
 * 练习
 */