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);
}
}
代码改变了我们，也改变了世界
