java进阶 - api接口 -规则 -定义格式 -定义特点 -多态引入 -对象多态和行为多态 -多态成员的访问特点 -多态的转型特点以及问题 -支付系统案例31

　　

 

 

package com.cyjt97.minterface;

public class minterface {
    //    接口：
//      接口的思想提现就是规则
//    如果一个类，所有的组成都是抽象方法，
//        -没有成员变量
//        -没有普通方法
//        这种类我们会设计为java中的接口，因为这个类的唯一价值就是声明规则
//    -----------------------------------------
//    接口的定义格式：
//        interface 接口名字{}
//        接口不允许实例化
//    接口与类中间是实现关系，通过implements关键字来完成
//        实现类（口的子类）：
//            1，重写所有的抽象方法
//            2，将实现类变成抽象类
    public static void main(String[] args) {
        interimp inp = new interimp();
        inp.ter();
        inp.www();

    }
}

interface inter{
    public abstract void ter();
    public abstract void www();
}
//1，重写所有的抽象方法
class interimp implements inter{

    @Override
    public void ter() {
        System.out.println("吃饭睡觉");
    }

    @Override
    public void www() {
        System.out.println("打豆豆");
    }
}
//2，将实现类变成抽象类
//    然后子类接收这个抽象类
//    一般来说用的比较少
abstract class interimp2 implements inter{

}

　　

package com.cyjt97.minterface;

public class minterface2 {
    public static void main(String[] args) {
//        接口的成员特点
           /* 1成员变量：
                只能定义常量，系统会默认加入三个关键字
                    public ， static，final
            2成员方法：
                只能定义抽象方法，因为系统会默认加入两个关键字
                    public，abstract
            3构造方法：没有*/

//        系统会默认加入三个关键字static
        System.out.println(give.age);
    }
}

interface give {
//        系统会默认加入三个关键字
//    public final static int age = 20;
    int age = 20;
//    只能定义抽象方法，abstract加不加系统都会自动帮我们加上去
    public abstract void SHOW();
}

　　

 

 

package com.cyjt97.minterface;

public class minterface3 {
    /*    接口和类之间的关系：
                1，类与类之间的关系：继承关系，可以单继承，也可以多层继承，不支持多继承关系
                2，接口与类直接的关系，实现关系，可以单实现，也可以多实现，甚至可以继承一个类的同时，实现多个接口
                3，接口和接口之间的关系：继承关系，可以单继承，也可以多继承
    */
    public static void main(String[] args) {

    }
}

//可以单实现，也可以多实现，没有逻辑性
//不会逻辑冲突
interface A {
    void A();
}

interface B {
    void B();
}

interface C {
    void C();
}

class ABC implements A, B, C {

    @Override
    public void A() {

    }

    @Override
    public void B() {

    }

    @Override
    public void C() {

    }
}


class fu {
    public void show() {
        System.out.println("父");
    }
}

//甚至可以继承一个类的同时，实现多个接口
class zi extends fu implements A, B, C {

    @Override
    public void A() {

    }

    @Override
    public void B() {

    }

    @Override
    public void C() {

    }
}

interface interA {
    void SHOW();
}

interface interB {
    void SHOW();
}

//继承关系，可以单继承，也可以多继承
interface interC extends interA, interB {
    void SHOW();
};

class interD implements interC {

    @Override
    public void SHOW() {

    }
};

　　

package com.cyjt97.minterface;

public class minterface4 {
//    抽象类和接口的对比
        /*
        成员变量：
            抽象类：可以定义常量，也可以定义变量
            接口：只能定义常量
        成员方法：
            抽象类：可以定义具体方法，可以定义抽象方法
            接口：只能定义抽象方法
        构造方法：
            抽象类：有
            接口：无
            */
//        抽象类：对事物进行抽象（描述事物）
//        接口：对行为抽象（指定规则）
    
    
}

　　

package com.cyjt97.order;

public interface order {
    //    创建订单
    void create();

    //    查单个订单
    void single();

    //查多个订单
    void Multiple();

    //    取消订单
    void cancel();

    //    完结订单
    void end();

    //    支付订单
    void pay();
}

package com.cyjt97.order;

public class orderInterface implements order {
    //    创建订单
    @Override
    public void create() {
        System.out.println("创建订单");
    }

    //    查单个订单
    @Override
    public void single() {
        System.out.println("查单个订单");
    }

    //查多个订单
    @Override
    public void Multiple() {
        System.out.println("查多个订单");
    }

    //    取消订单
    @Override
    public void cancel() {
        System.out.println("取消订单");
    }

    //    完结订单
    @Override
    public void end() {
        System.out.println("完结订单");
    }

    //    支付订单
    @Override
    public void pay() {
        System.out.println("支付订单");
    }
}

package com.cyjt97.order;

public class foreignOrders implements order{
    //    创建订单
    @Override
    public void create() {
        System.out.println("创建订单-国外");
    }
    //    查单个订单
    @Override
    public void single() {
        System.out.println("查单个订单-国外");
    }
    //查多个订单
    @Override
    public void Multiple() {
        System.out.println("查多个订单-国外");
    }
    //    取消订单
    @Override
    public void cancel() {
        System.out.println("取消订单-国外");
    }
    //    完结订单
    @Override
    public void end() {
        System.out.println("完结订单-国外");
    }
    //    支付订单
    @Override
    public void pay() {
        System.out.println("支付订单-国外");
    }
}

package com.cyjt97.order;

import java.util.Scanner;

public class orderSystem {
//    同一个行为具有多个不同表现形式或形态的能力
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入：1国内订单，2国外订单");
        int choice = sc.nextInt();

        order order = null;

        switch (choice) {
            case 1:
//                创建对象的时候，左右两边类型不一致，是所有对象都可以这样创建吗？
//                得有前提条件：父类引用指向子类条件，或者接口类引用指向实现类引用
                order = new orderInterface();
                break;
            case 2:
                order = new foreignOrders();
                break;
        }
//        为什么调用的方法是同一套方法，却有不同的表现形式？
//        给他不同的子类对象，走的是不同的内容
        order.create();
        order.single();
        order.Multiple();
        order.cancel();
        order.end();
        order.pay();
    }
}

　　对象多态和行为多态：

package com.cyjt97.polymorphic;

public class polymorphic {
    /*
    多态的前提：
        有继承/实现关系
        有方法重写
        有父类引用子类对象
    1对象多态：
        animal a = new cat();
        animal b = new dog();
        好处：方法的形参定义为父类类型，这个方法就可以接收到父类任意子类对象了

        */
    public static void main(String[] args) {
//        对象多态
        animal a = new cat();
        animal b = new dog();

//          行为多态
        useAnimal(new dog());
        useAnimal(new cat());
    }

    //          行为多态
    public static void useAnimal(animal a) {
        a.eat();
    }

}

abstract class animal {
    public abstract void eat();
}

class cat extends animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

class dog extends animal {

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

　　多态成员的访问特点：

package com.cyjt97.polymorphic;

public class polymorphic2 {
    //    多态的成员访问特点：
//          1.成员变量:编译看左边(父类),运行看左边〔父类）
//          2.成员方法:编译看左边(父类),运行看右边〔子类）
//                  在编译的时候,会检查父类中有没有这个方法
//                      没有:编译出错
//                      有:编译通过,但是运行的时候,一定会执行子类的方法逻辑
//                      原因:担心你调用的方法,在父类中是一个抽象方法
//    多态创建对象，调用静态成员:
//            静态的成员，推荐类名进行调用
//            细节：静态的成员，可以使用对象名调用，但这是一种假象
//                    -改成字节码文件后，会自动将对象名调用，改成类名调用
//    好处：提高程序的扩展性
//    弊端：不能使用子类特有的成员
    public static void main(String[] args) {
//        编译看左边(父类),运行看左边〔父类）
        fu f = new zi();
        System.out.println(f.num);
        f.show();
//        多态创建对象，调用静态成员
//        静态的成员，可以使用对象名调用，但这是一种假象
        f.pink();

//        编译看左边(父类),运行看右边〔子类）
        InterMpl i = new InterMpl();
        i.method();
    }
}

interface Inter {
    //    编译通过,但是运行的时候,一定会执行子类的方法逻辑
//    担心你调用的方法,在父类中是一个抽象方法
    void method();
}

class InterMpl implements Inter {

    @Override
    public void method() {
        System.out.println("+11111111");
    }
}

class fu {
    int num = 10;

    public void show() {
        System.out.println("fu");
    }

    public void pink() {
        System.out.println("pink_fu");
    }
}

class zi extends fu {
    int num = 20;

    @Override
    public void show() {
        System.out.println("zi");
    }

    public void pink() {
        System.out.println("pink_zi");
    }
}

　　

 

 

 

 

 

 

package com.cyjt97.order;

public interface order {
    //    创建订单
    void create();

    //    查单个订单
    void single();

    //查多个订单
    void Multiple();

    //    取消订单
    void cancel();

    //    完结订单
    void end();

    //    支付订单
    void pay();
}

package com.cyjt97.order;

public class foreignOrders implements order{
    //    创建订单
    @Override
    public void create() {
        System.out.println("创建订单-国外");
    }
    //    查单个订单
    @Override
    public void single() {
        System.out.println("查单个订单-国外");
    }
    //查多个订单
    @Override
    public void Multiple() {
        System.out.println("查多个订单-国外");
    }
    //    取消订单
    @Override
    public void cancel() {
        System.out.println("取消订单-国外");
    }
    //    完结订单
    @Override
    public void end() {
        System.out.println("完结订单-国外");
    }
    //    支付订单
    @Override
    public void pay() {
        System.out.println("支付订单-国外");
    }
}

package com.cyjt97.order;

public class orderInterface implements order {
    public void check() {
        System.out.println("选择");
    }
    //    创建订单
    @Override
    public void create() {
        System.out.println("创建订单");
    }

    //    查单个订单
    @Override
    public void single() {
        System.out.println("查单个订单");
    }

    //查多个订单
    @Override
    public void Multiple() {
        System.out.println("查多个订单");
    }

    //    取消订单
    @Override
    public void cancel() {
        System.out.println("取消订单");
    }

    //    完结订单
    @Override
    public void end() {
        System.out.println("完结订单");
    }

    //    支付订单
    @Override
    public void pay() {
        System.out.println("支付订单");
    }
}

package com.cyjt97.order;

import java.util.Scanner;

public class orderSystem {
    //    同一个行为具有多个不同表现形式或形态的能力
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入：1国内订单，2国外订单");
        int choice = sc.nextInt();

        order order = null;

        switch (choice) {
            case 1:
//                创建对象的时候，左右两边类型不一致，是所有对象都可以这样创建吗？
//                得有前提条件：父类引用指向子类条件，或者接口类引用指向实现类引用
                order = new orderInterface();
                break;
            case 2:
                order = new foreignOrders();
                break;
        }
//        为什么调用的方法是同一套方法，却有不同的表现形式？
//        给他不同的子类对象，走的是不同的内容
//        向下转型
//            ClassCastException：类型转换异常
//            在引用数据类型中，[实际类型]和[目标类型]不匹配,就会出现该异常，所以就需要做判断
//                instanceof判断左边的引用是否是右边的的数据类型
        if (order instanceof orderInterface) {
            orderInterface ort = (orderInterface) order;
            ort.check();
        }
        order.create();
        order.single();
        order.Multiple();
        order.cancel();
        order.end();
        order.pay();
    }
}

　　支付系统案例：

package com.cyjt97.Paymentsystem;

public interface pay {
    void money(double money);
}

package com.cyjt97.Paymentsystem;

public class bankCard implements pay{

    @Override
    public void money(double money) {
        System.out.println("已用银行卡支付"+money);
    }
}

package com.cyjt97.Paymentsystem;

public class onlineBanking implements pay{

    @Override
    public void money(double money) {
        System.out.println("已用网银支付"+money);
    }
}

package com.cyjt97.Paymentsystem;

public class platform implements pay{
    @Override
    public void money(double money) {
        System.out.println("已用支付平台支付"+money);
    }
}

package com.cyjt97.Paymentsystem;

import java.util.Scanner;

public class payment {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请选择您的支付平台:1,支付平台   2，银行卡支付   3，网银支付");
        int check = sc.nextInt();
        pay pay = null;
        switch (check){
            case 1:
                pay =new platform();
                break;
            case 2:
                pay =new bankCard();
                break;
            case 3:
                pay =new onlineBanking();
                break;
        }
        System.out.println("请输入您的支付金额");
        double money = sc.nextDouble();
        pay.money(money);
    }
}