学习目标：
写出定义通达信有对外接口,接口的格式
写出实现通达信有对外接口,接口的格式
说出通达信有对外接口,接口中的成员的特点
能够说出使用多太的前提条件
理解多态的向上转型
理解多态的向下转型
使用多态和通达信有对外接口,接口完成相应的案例开发
学习内容：
通达信有对外接口,接口
概述
通达信有对外接口,接口，是java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量，构造方法和成员方法，那抹借口的内部主要是【封装了方法】，包含了抽象方法，默认方法和静态方法（jdk,私有方法（jdk
通达信有对外接口,接口的定义，它与类的定义很相似，但是使用的interface关键字，他会被编译生成class文件，但一定要明确它不是类，而是另外一种引用类型
引用数据类型：类，数组，通达信有对外接口,接口。
通达信有对外接口,接口的使用，不能直接创建对象，但是可以被实现，一个实现类通达信有对外接口,接口的类，需要重写通达信有对外接口,接口中的所有的抽象方法，创建该类对象，就可以调用方法了。
通达信有对外接口,接口的定义和类的定义很相似，不在使用class关键字进行声明，而是用interface关键字进行声明
《编译器里的内容》《定义通达信有对外接口,接口格式》publicinterface通达信有对外接口,接口名称{//通达信有对外接口,接口内容//抽象方法为主}通达信有对外接口,接口就是多个类的公共规范，通达信有对外接口,接口也是引用数据类型如：类通达信有对外接口,接口数组备注：源文件还是.java,编译之后生成的字节码文件还是.class.java-->.class如果是jdk那么通达信有对外接口,接口当中包含的内容常量抽象方法不允许出现普通的成员方法成员方法：修饰符返回值类型方法名{//方法体内容}如果是jdk8还可以包含内容默认方法静态方法如果是jdk还可以包含内容私有方法通达信有对外接口,接口的使用步骤：通达信有对外接口,接口不能直接使用，必须有一个“实现类”来“实现”该通达信有对外接口,接口格式：publicclass实现类名称implements通达信有对外接口,接口名称{//类的成员信息}通达信有对外接口,接口的实现类必须重写(实现)通达信有对外接口,接口当中的所有的抽象方法实现：去掉abstract关键字，分号换成大括号。创建实现类的对象，进行使用。注意事项：如果实现类当中并没有重写通达信有对外接口,接口当中的所有的抽象方法，那么这个实现类自己必须是抽象类semicolon分号
public interface interfaceDemo {
//定义一个抽象方法
public abstract void method();
public abstract void method2();
void method3();
//定义默认的方法
public default void method4() {
}
public static void method5() {
System.out.println('这是静态方法被调用了。。');
}
public static void main(String[] args) {
//实现类的对象
InterfaceDemo1 demo1=new InterfaceDemo1();
demo1.method();
demo1.method2();
interfaceDemo.method5();
}
}public class InterfaceDemo1 implements interfaceDemo {
@Override
public void method() {
// TODO Auto-generated method stub
System.out.println('重写通达信有对外接口,接口类中method的方法');
}
@Override
public void method2() {
// TODO Auto-generated method stub
System.out.println('重写通达信有对外接口,接口类中method的方法');
}
@Override
public void method3() {
// TODO Auto-generated method stub
}
}通达信有对外接口,接口的定义格式：
public interface 通达信有对外接口,接口名称{
//抽象方法
//默认方法
//常量
//静态方法
//私有方法（JDK1.9)
}含有抽象方法
抽象方法：使用abstract关键字修饰，没有方法体的内容，该方法主要是提供子类使用的
含有默认方法和静态方法
默认方法：使用default关键字修饰的方法，不可省略，供子类调用或者子类重写
静态方法：使用static关键字修饰的方法，供通达信有对外接口,接口直接调用
含有私有方法和私有静态的方法
私有方法：使用private关键字，供通达信有对外接口,接口中的默认方法或者静态方法调用。
代码如下：
public interface InterfaceName{
private void method(){
//方法体内容。
}
}基本的实现
实现的概述
类与通达信有对外接口,接口的关系为实现关系，既类实现通达信有对外接口,接口，该类可以成为通达信有对外接口,接口的实现类，也可以称为通达信有对外接口,接口的子类。实现的动作类十余继承，格式相仿，只是关键字不同，实现使用【implements】关键字
非抽象类实现通达信有对外接口,接口：
必须重写通达信有对外接口,接口当中的所有的抽象方法
继承了通达信有对外接口,接口的当中的默认方法，既可以直接调用，也可以重写
实现格式：
public class 实现类 implements 通达信有对外接口,接口名称{
//重写通达信有对外接口,接口当中的所有的抽象方法
//重写通达信有对外接口,接口当中的默认方法【可选】
}抽象方法的使用：
必须全部实现：
代码如下：
定义通达信有对外接口,接口：
public interface Biological{//生物
//定义一个吃东西的功能
public abstract void eat();
//定义一个休息的功能
public abstract void sleep();
}
//定义一个实现类
public class Animal implements Biological{
@Override
public void eat(){
System.out.println('吃东西');
}
@Override
public void sellp(){
System.out.println('睡觉');
}
}
//定义测试类
public class InterfaceDemo1{
public static void main(String[] args){
//创建子类对象
Animal ani=new Animal();
ani.eat();
ani.sleep();
}
}
//输出结果是
//吃东西
//睡觉默认方法的使用
可以继承，可以重写，二选但是只能通过实现类的对象来调用
继承默认方法，代码入下
public interface Biological{//生物
public default void fly(){
System.out.println('天上飞');
}
}
//实现类
public class Animal implements Biological{
//继承 什么也不写
}
public static void main(String[] args){
//创建子类对象
Animal ani=new Animal();
//调用默认方法
ani.fly();
}
//结果：天上飞重写默认方法,代码如下
public interface Biological{//生物
public default void fly(){
System.out.println('天上飞');
}
}
//实现类
public class Animal implements Biological{
public void fly(){
System.out.println('自由飞');
}
}
//测试
public static void main(String[] args){
//创建子类对象
Animal ani=new Animal();
//调用默认方法
ani.fly();
}
//结果：自由飞静态方法的使用
静态的一般都是和类。class文件相关，【只能】使用【通达信有对外接口,接口名】来调用，不可以通过实现类的类名或者实现类的对象来调用，
代码如下：
public interface Biological{//生物
public default void run(){
System.out.println('跑起来');
}
}
//实现类
public class Animal implements Biological{
//无法重写通达信有对外接口,接口里面的静态方法
}
//测试
public static void main(String[] args){
//创建子类对象
Animal ani=new Animal();
//调用静态方法
Biological.run();
}
//结果：跑起来私有方法的使用
私有方法：只有默认方法可以调用
私有静态方法：默认方法和静态方法都可以调用
如果一个通达信有对外接口,接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中
供默认方法去调用。从设计的角度考虑，私有的方法是对默认的方法和静态的方法的一种辅助，
代码如下：
//定义一个借口
public interface Biological{
private void run(){
System.out.println('跑起来。。。。');
run();//把下面的方法封装到run方法里面
}
Public default void funMethod1(){
System.out.println('跑起来。。。。');
}
Public default void funMethod2(){
System.out.println('跑起来。。。。');
}
}通达信有对外接口,接口的多实现
在继承体系中，一个类只能直接继承一个父类，而对于通达信有对外接口,接口来说，一个类可以实现多个通达信有对外接口,接口，这叫做通达信有对外接口,接口的【多实现】。并且，一个类能直接继承一个父类同时还可以实现多个通达信有对外接口,接口。
public class ClassName extends 父类 implements 通达信有对外接口,接口名1，通达信有对外接口,接口2....{
//重写通达信有对外接口,接口中的所有的抽象方法
//重写通达信有对外接口,接口中的默认方法【可选】
//抽象方法重名
}抽象方法
通达信有对外接口,接口中，有多个抽象方法，实现类必须重写所有的抽象方法，如果抽象方法有重名的，只需要重写一次即可，代码如下：
//定义多个通达信有对外接口,接口
public interface Animal{
public abstract void eat();
public abstract void eat();
}
//通达信有对外接口,接口
public interface Human{
public abstract void eat();
public abstract void eat();
}
//实现类
public class People implements Animal,Human{
//Override
public void eat(){
System.out.println('吃东西');
}
//Override
public void run(){
System.out.println('不想动');
}
}默认方法
通达信有对外接口,接口中，有多个默认方法时，实现类都可继承使用，如果默认方法又聪明的【必须重写一次】，代码如下：
public interface A{
public default void methodA(){}
public default void method(){}
}
public interface B{
public default void methodA(){}
public default void method(){}
}
//实现类
public class C implements A,B{
public void method(){
System.out.println('method方法被重写。。。')
}
}
静态方法
通达信有对外接口,接口中，如果存在同名的静态方法并不会冲突，原因是只能通过各自的通达信有对外接口,接口名访问静态方法
优先级的问题
当一个类，既继承了一个父类，又同时实现了多个通达信有对外接口,接口，父类中的成员方法与通达信有对外接口,接口当中的默认方法重名，【子类就近选择父类的成员方法】
代码如下：
public interface A{
public default void menthodA{
System.out.println('AAAAAAAAAA');
}
}
//定义父类
public class D{
public void menthodA(){
System.out.println('DDDDDDDDD');
}
}
//实现
public class E extends A implements D{
}
public class Test{
public static void main(String[] args){
//创建子类对象E
E e=new E();
e.methodA();
}
}
//结果
//DDDD通达信有对外接口,接口的多继承【了解】
一个通达信有对外接口,接口能继承另一个或者多个通达信有对外接口,接口，这和类之间的继承比较相似，通达信有对外接口,接口的继承使用extends关键字子通达信有对外接口,接口继承父通达信有对外接口,接口的方法，如果父通达信有对外接口,接口中的默认方法又聪明方法，那么子通达信有对外接口,接口需要重写一次。代码如下：
public interface A{
public default void menthodA{
System.out.println('AAAAAAAAAA');
}
public interface B{
public default void menthodA{
System.out.println('BBBBBBBBBBBB');
}
//定义子通达信有对外接口,接口
public interface C extends A,B{
public default void method(){
System.out.println('CCCCCCCCCCCCCC');
}
}备注：子通达信有对外接口,接口重写默认方法，default可以保留。
其他成员特点：
通达信有对外接口,接口中，无法定义成员变量，但是可以定义常量，因为值不可变。默认使用publicstaticfinal修饰的
通达信有对外接口,接口当中，没有构造方法，不能创建对象
通达信有对外接口,接口当中，没有静态代码块
通达信有对外接口,接口的好处：
设定了规则
降低耦合性【高内聚，低耦合】
扩展原有类的功能
通达信有对外接口,接口与抽象类的区别：
相同点：
都包含抽象方法，子类都必须重写这些抽象方法
都不能直接实例化对象
都位于继承的顶端，用于被其他类实现或者继承
区别：
抽象类里面可以包含普通成员方法。通达信有对外接口,接口不能包含普通成员方法
一个类只能直接继承一个父类，一个类也可以实现多个通达信有对外接口,接口
类与类之间只能是单继承关系，通达信有对外接口,接口与通达信有对外接口,接口之间可以多继承
抽象类可以普通的成员变量，通达信有对外接口,接口只能定义常量publicstaticfinal修饰的
【多态】
使用通达信有对外接口,接口时：注意事项*通达信有对外接口,接口是没有静态代码块也没有构造方法*一个类只能直接继承一个父类，但是一个类可以实现多个通达信有对外接口,接口*一个通达信有对外接口,接口可以继承。类与类之间是一种单继承关系，类与通达信有对外接口,接口之间是一种多实现关系*如果一个类实现了多个通达信有对外接口,接口，存在重名的抽象方法，只需要重写一次*如果一个类没有重写通达信有对外接口,接口当中的所有抽象方法，那么该类必须是抽象类*如果一个类实现了多个通达信有对外接口,接口，通达信有对外接口,接口当中存在有重名的默认方法，那么实现类一定要对冲突的默认方法重写*如果一个类直接继承一个父类，有实现多个通达信有对外接口,接口，父类中的成员方法和通达信有对外接口,接口中的默认方法存在重名，有限调用父类中的成员方法
文章为作者独立观点，不代表 股票程序化软件自动交易接口观点
相关文章
股民评论