java面向对象之接口（定义与实现、涵数式接口、比较对象大小）

接口:

　　普通类：只有具体实现

　　抽象类：具体实现和规范（抽象方法）都有

　　接口：只有规范！自己无法写方法~专业的约束

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
    
    }
}
//定义接口:接口都要有实现类
public interface UserDou{
    //内部无法定义实现
    //接口中所有的定义其实都是抽象的，public 
    //定义增删改查方法
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

public interface Tim{
    //内部无法定义实现
 
}
//实现了接口的类，必须要实现接口里的方法
class UserDouImpl implements UserDou,Tim{//实现多继承方法
    public void add(String name){
        
    }
    public void delete(String name){
        
    }
    public void update(String name){
        
    }
    public void query(String name){
        
    }
    
}

/*作用：
    1.约束
    2.定义一些方法，让不同的人实现，相当于有时候会让10个人实现一个接口
    3.接口中的方法都是抽象的 public abstract
    4.所有的常量都是静态和不可修改的,public static final
    5.接口不能直接被实例化，并且没有有构造方法
    6.接口可以使用implements关键字来实现多个接口
    7.实现接口必须要重写接口中的方法，
*/

使用方法：

package com.de.接口;

/*
 * 接口的使用：
 * 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 exetends BB implements CC,DD,EE   BB是继承的父类，CC,DD,EE是接口 
 *
 *7、接口与接口之间可以继承，而且可以多继承 
 */
public class RukkTest {
    public static void main(String[] args) {
        System.out.println(khqn.MAX_SPEED);
        System.out.println(khqn.MIX_SPEED);
//        khqn.MAX_SPEED=200;无法改变，因为是final的
        pad f = new pad();
        f.fiy();

    }

}

interface khqn {
    // 全局常量
    // 可以省略public static final
    int MAX_SPEED = 7900;// 第一宇宙速度
    public static final int MIX_SPEED = 1;

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

    void wypk();// 可以省略public abstract

//    public khqn() {不能定义构造器
//        
//    }
}
interface bbxuj{
    void bbxu();
}
class pad implements khqn {

    @Override
    public void fiy() {
        // TODO Auto-generated method stub
        System.out.println("飞机飞");
    }

    @Override
    public void wypk() {
        // TODO Auto-generated method stub
        System.out.println("驾驶员：减速");
    }

}

abstract class kif implements khqn {
//想只实现一个抽象方法，那就把类定义为抽象类，然后再用其他类来实现这个类的方法
    @Override
    public void fiy() {
        // TODO Auto-generated method stub

    }
 
}
class Bullet extends Object implements bbxuj,khqn,CC{

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

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

    @Override
    public void bbxu() {
        // TODO Auto-generated method stub
        
    }//实现多个接口

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

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


//*************************
interface AA{void buxj();}
interface BB{void tnsm();}
interface CC extends AA,BB{
    
}

应用举例：

代码如下：

package com.de.接口;
/*
 * 接口的使用:
 *1、 接口使用上也满足了多态性
 *2、接口实际上就是定义了一种规范
 * 下面的代码已经明确的写出，因为我在电脑类定义了一个USB接口的方法，
 * 所以谁要想跟电脑传输数据就要
 * 实现USB接口的抽象方法
 */
public class USBTest {
public static void main(String[] args) {
    Computer computer=new Computer();
    USB f=new Flash();
    computer.transferDate(f);
    
}


}
interface USB{
    //常量：定义了长、宽、最大最小的传输速度等
    void start();
    void stop();
}
class Computer{//电脑
    public void transferDate(USB usb) {
        usb.start();//开启
        System.out.println("具体的传输数据细节");
        usb.stop();//结束 
    }
}
class Flash implements USB{//打印机

    @Override
    public void start() {
    System.out.println("U盘开启工作");
        
    }

    @Override
    public void stop() {
        System.out.println("U盘结束工作");        
    }
    
}
class Printer implements USB{

    @Override
    public void start() {
        System.out.println("打印机：开启工作");
        
    }

    @Override
    public void stop() {
        System.out.println("打印机：结束工作");
        
    }
    
}

创建接口的匿名实现类的对象：

package com.de.接口;

import com.sun.org.apache.bcel.internal.generic.NEW;

/*
 * 接口的使用:
 *1、 接口使用上也满足了多态性
 *2、接口实际上就是定义了一种规范
 * 下面的代码已经明确的写出，因为我在电脑类定义了一个USB接口的方法，
 * 所以谁要想跟电脑传输数据就要
 * 实现USB接口的抽象方法
 */
public class USBTest {
public static void main(String[] args) {
    Computer computer=new Computer();
    //创建了接口的非匿名子类的非匿名对象
    Flash f=new Flash();
    computer.transferDate(f);
    //创建了接口的非匿名子类的匿名对象
    computer.transferDate(new Printer());
    //创建了接口的匿名实现类的非匿名对象
    USB phq=new USB() {
        
        @Override
        public void stop() {
            System.out.println("手机：开始工作");
            
        }
        
        @Override
        public void start() {
            System.out.println("手机：结束工作");
            
            
        }
    };
    computer.transferDate(phq);
    //创建接口的匿名实现类的匿名对象
    computer.transferDate(new USB() {
        
        @Override
        public void stop() {
            System.out.println("MP3：开始工作");
            
        }
        
        @Override
        public void start() {
            System.out.println("mp3：结束工作");
            
        }
    });
    
        

}


}
interface USB{
    //常量：定义了长、宽、最大最小的传输速度等
    void start();
    void stop();
}
class Computer{//电脑
    public void transferDate(USB usb) {
        usb.start();//开启
        System.out.println("具体的传输数据细节");
        usb.stop();//结束 
    }
}
class Flash implements USB{//打印机

    @Override
    public void start() {
    System.out.println("U盘开启工作");
        
    }

    @Override
    public void stop() {
        System.out.println("U盘结束工作");        
    }
    
}
class Printer implements USB{

    @Override
    public void start() {
        System.out.println("打印机：开启工作");
        
    }

    @Override
    public void stop() {
        System.out.println("打印机：结束工作");
        
    }
    
}

接口应该：代理模式

代码举例

package com.de.代理类举例;
/**
 * 接口的应用：代理模式
 * @author hu
 *
 */
public class WagjOd {
public static void main(String[] args) {
        Server server=    new Server();//服务器
        ProxyServer proxyServer=new ProxyServer(server);//代理类
        proxyServer.browse();
}
}
interface Mqqxt{//网络
    //只要能连上网，就会有下面的浏览的方法
    public void browse() ;
        

    
}
//被代理类
class Server implements Mqqxt{

    @Override
    public void browse() {
        System.out.println("真实的服务器访问网络");
        
    }
    
}
//代理类
class ProxyServer implements Mqqxt{
    private Mqqxt wor;
    public ProxyServer(Mqqxt wor) {
        this.wor=wor;
        
    }
    public void chek1() {
        System.out.println("连网之前的检查工作");
    }
    @Override
    public void browse() {
    chek1();
    
    wor.browse();
        
    }
    
}

比较对象大小：

接口：

package com.de.比较对象大小;



/**
 * interface CompareObject{
 * 
 * public int compareTo(Object o);
 * }
 *     若返回值为0，代表相等；若为正数，代表当前对象大，
 *     若为负数代表当前对象小
 *
 */
public interface CompareObject {
    //若返回值为0，代表相等；若为正数，代表当前对象大，若为负数代表当前对象小
    public int compareTo(Object o);
}

System.out.println("*************");分行


package com.de.比较对象大小;
/*
 * 定义一个方法，声明属性radius属性，提供getter，setter方法
 */
public class Circle {
//private double radius;
    private double radius;

public Double  getRadius() {
    return radius;
}

public void setRadius(Double radius) {
    this.radius = radius;
}

public Circle() {
    super();
}

public Circle(Double radius) {
    super();
    this.radius = radius;
}

}



System.out.println("*************");




package com.de.比较对象大小;

import javax.management.RuntimeErrorException;



/*
 * 定义一个ComparableCircle类，继承Circle类并实现
 * CompareObject接口，在ComparableCircle类中给出接口中方法compareTo的实现体
 * 用来比较两个圆的大小
 */
public class ComparableCircle extends Circle implements CompareObject{

    public     ComparableCircle(double radius){
        super(radius);
    }
    @Override 
    
    public int compareTo(Object o) {
        if (this==o) {
            return 0;
            
        }
        if (o instanceof ComparableCircle) {
            ComparableCircle c =(ComparableCircle)o;
            //错误的
//            return (int)(this.getRadius()-c.getRadius());
            //正确的
//            if (this.getRadius()>c.getRadius()) {
//                return 1;
//                
//            }else if (this.getRadius()<c.getRadius()) {
//                return -1;
//                
//            }
//            else {
//                return 0;
//            }
            //当属性radius声明为Double类型时，可以调用包装类的方法
            return this.getRadius().compareTo(c.getRadius());
        }else {
            return 0;
//            throw new RuntimeException("传入的数据类型不匹配");
        }
    }

}


System.out.println("*************");



package com.de.比较对象大小;

import com.sun.org.apache.bcel.internal.generic.NEW;

public class ComparableCircleTest {
public static void main(String[] args) {
    ComparableCircle c1=new ComparableCircle(3.1);
    ComparableCircle c2=new ComparableCircle(3.6);
    int comqe=c1.compareTo(c2);
    if (comqe>0) {
        System.out.println("c1大");
    }else if (comqe<0) {
        System.out.println("c2大");
    }else {
        System.out.println("一样大");
    }
    int cone1=c1.compareTo(new String("AA"));
    System.out.println(cone1);
}
}

java8特性：

代码：
package com.de.java8接口的新特性;
/*
 *     JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法和默认方法
 * 
 * 
 */
public interface ComparA {
//静态方法
    public static void maiw() {
        System.out.println("ComparA：西");
    }
    //默认方法
    public default void mtq() {
        System.out.println("ComparA：2");
    }
    //这个也是public修饰的
     default void mtq1() {
        System.out.println("ComparA：1");
    }
     public default void method3() {
            System.out.println("SuperClass:120");
        }
}


System.out.println("*************************************************");





package com.de.java8接口的新特性;

public class ScbClassTest {
public static void main(String[] args) {
    ScvClass s=new ScvClass();
    
//    s.maiw();
    //知识点1：接口中定义的静态方法，只能通过接口来调用
    ComparA.maiw();
    //知识点2：通过实现类的对象，可以调用接口中的默认方法
    //如果实现类重写了接口中的默认方法，调用时仍然调用的是重写以后的方法
    
    s.mtq1();
    s.mtq();
    //知识点3：如果子类（实现类）继承的父类和实现的接口中声明的同名同参数的方法
    //那么子类在没有重写此方法的情况下默认调用父类中的同名
    //同参数的方法----》类优先原则
    //知识点4：如果实现类实现了多个接口，而这个接口中定义了同名同参数的默认方法
    //那么在实现类没有重写此方法的情况下，报错----》接口冲突
    //这就需要我们必须在实现类中重写此方法
    s.method3();
}
}
class ScvClass extends SuperClass implements ComparA,ComapareB{
    //可以重写接口中的默认类
    public  void mtq() {
        System.out.println("ComparA：23");
    }

    @Override
    public void method3() {
        // TODO Auto-generated method stub
        System.out.println("ScvClass：港");
    }
    //知识点5：如何在子类（或实现类）的方法中调用父类，接口中被重写的方法
    public void myMethod() {
        method3();//调用自己定义的重写的方法
        super.method3();//调用的是父类声明的
        //调用接口中的默认方法
        ComparA.super.method3();
        ComapareB.super.method3();
    }
}






System.out.println("*************************************************");




package com.de.java8接口的新特性;

public class SuperClass {
    public void method3() {
        System.out.println("SuperClass:你好");
    }
}


System.out.println("*************************************************");


package com.de.java8接口的新特性;

public interface ComapareB {
     default void method3() {
        System.out.println("ComapareB:中国");
    }
}

涵数式接口：

*5、如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口




package Lambda表达式;

/**自定义函数式接口

详细内容可以去java8的新特性看函数式接口
 * 版权 (C), 2017-2020,
 * 作者:
 * 时间: 2020-02-25 22:35
 * 文件名: dd
 * 位置:
 */
@FunctionalInterface//这个可写可不写，写这个只是为了验证他是否是一个函数式接口，当然你不写也可以
public interface dd {
    void yt();
}

posted @ 2022-04-06 15:58 hollg 阅读(174) 评论(0) 收藏举报

刷新页面返回顶部

hollg

java面向对象之接口（定义与实现、涵数式接口、比较对象大小）

公告