关于java:Java基础接口

接口

简略介绍

1.1 概念

接口是 java 中 最重要 的概念，接口能够了解为一种非凡的类，外面 全副 是由 全局常量 和公共的形象办法 所组成。
如果一个类中齐全是由全局常量（static final）和形象办法组成，就能够将其定义成一个 接口
接口来的目标就是为了冲破 Java 单继承的局限性。
接口的益处：灵便，能够同时应用多个接口的性能。
接口次要体现的是 一套开发标准。

1.2 特点

1. 接口中都是形象办法
2. 通过 interface 关键字创立接口
3. 通过 implements 让子类来实现
4. 能够了解成，接口就是一个非凡的抽象类
5. 接口冲破了 java 的单继承的局限性
6. 接口和类之间能够多实现，接口和接口之间能够多继承
7. 接口是对外裸露的规定，是一套开发标准
8. 接口进步了程序的性能扩大，升高了耦合性

1.3 入门案例

package cn.tedu.oop;
    // 测试 接口
public class Test1_Interface {public static void main(String[] args) {
        //TODO 创立多态对象测试
        //9, 接口能够被实例化吗?-- 不能够, 接口和抽象类一样都不能被实例化
//        new Demo() 
//8, 用了接口里的形象办法的申明, 实现类的办法体
        Demo demo = new DemoImpl();
        demo.eat();
        demo.game();
        demo.hi();}
}
//1, 抽象类里能够有形象办法(必须被 abstract 润饰), 也能够有一般办法(提供办法体)
//3, 通过 interface 关键字定义接口, 语法:interface 接口名
interface Demo{
//2, 接口里的办法都是形象办法
    abstract public void eat() ;
    abstract public void game() ;
    //4, 在 jdk1.8 里容许接口中呈现一般办法, 要求被 static 或者 default 润饰
//    static public void hi() {}
//    default public void hi() {}

    //5, 接口为办法的编写提供了简写形式, 会主动拼接 public abstract 
//    public abstract void hi() ;
    void hi() ;// 简写模式}
//6, 如果想用接口里的性能, 怎么用呢?-- 和接口产生实现关系
//class Dog extends Animal{// 继承时, 是子类继承抽象类, 来应用抽象类的性能
class DemoImpl implements Demo{// 当初是, 实现类 实现 接口, 来应用接口的性能
    //7, 实现接口后, 因为接口里都是形象办法, 所以须要全都重写, 否则就是一个抽象类
    @Override
    public void hi() {System.out.println("hi()...");
    }
    @Override
    public void eat() {System.out.println("eat()...");
    }
    @Override
    public void game() {System.out.println("game()...");
    }
}
//abstract class DemoImpl implements Demo{// 当初是, 实现类 实现 接口, 来应用接口的性能

2. 接口的用法

1. 接口必须有子类，子类依附 implements 关键字能够同时实现多个接口。
2. 接口的子类（如果不是抽象类）必须实现接口之中的全副形象办法。
3. 接口能够利用对象多态性，利用子类实现对象的实例化。
4. 接口和一般的类一样，自身也有数据成员和办法，但数据成员肯定要初始赋值，并且此值不能再有批改，定义的办法能够有形象办法和默认办法，形象办法 abstact 关键字能够省略，默认办法须要带上 default 关键字，默认办法能够带有办法体。
5. 默认办法的调用和一般办法的调用一样

2.1 用法测试

package cn.tedu.oop;
// 测试 接口
// 总结
// 接口里没有构造方法 / 没有变量都是常量
// 接口里都是形象办法(jdk1.8 能够有非凡的一般办法)
// 接口里的常量能够简写, 会主动拼接 public static final
// 接口里的办法能够简写, 会主动拼接 public abstract
public class Test2_Interface2 {public static void main(String[] args) {
        //3, 接口不能被实例化
        Inter in = new InterImpl();
        //in.age = 20; // 批改值, 失败 ---age 是 final 的
        System.out.println(in.age);// 获取值
        System.out.println(Inter.age);// 获取值,age 是 static 的
//TODO 7, 测试接口里的办法
    String desc = in.save();
    System.out.println(desc);

    in.delete(10);
}
}
//0, 通过 interface 定义接口
interface Inter{
//1, 接口里不让呈现构造方法.Interfaces cannot have constructors
//    public Inter() {}
//2, 接口里没有变量!!! -- 会主动拼接 public static final 把变量变成常量!!
//public static final int age = 10; 
int age = 10 ; // 简写模式
//4, 接口里的办法 -- 会主动拼接 public abstract 
//     public abstract void save() ;
//     public abstract void delete() ;
String save() ;// 简写模式
void delete(int id) ;
}
//5, 接口的实现类, 要么重写所有形象办法, 要么是一个抽象类
//abstract class InterImpl implements Inter{
class InterImpl implements Inter{
//6, 在进行办法重写时, 要有足够的权限. 接口里的所有资源默认的权限都是 public
 @Override
 public String save() {return "保留胜利!" ;}
 @Override
 public void delete(int id) {System.out.println("delete()..."+id);
 }
}           

3 接口的简单用法

接口和类之间能够多实现，接口和接口之间能够多继承
测试

import java.io.Reader;

// 测试 接口的简单用法
// 接口和类之间能够多实现，接口和接口之间能够多继承
public class Test3_Interface3 {public static void main(String[] args) {
    //4,-- 2 号接口的性能, 接口那么多, 想用谁的性能, 右边就写谁
    Inter2 in = new Inter2Impl() ;
    in.update();
    in.save();
    in.delete(5);
    in.get();}
}    
interface Inter1{void save();
}
interface Inter3{void update();
void get();}
//5, 实现类能够在继承的同时, 多实现
abstract class Impl2 extends Object implements Inter1 , Inter3{

}
//3, 接口和实现类之间 -- 是实现关系 , 能够多实现(逗号隔开)
//--Impl 实现类, 同时实现了 Inter1 和 Inter3 接口的性能,
//-- 须要同时重写多个形象办法, 否则就是一个抽象类
class Impl implements Inter1 , Inter3{
@Override
public void update() {}
@Override
public void get() {}
@Override
public void save() {}
}
//1, 接口和接口之间 -- 是继承关系, 能够多继承(逗号隔开)
//-- 2 号接口同时应用了 1 号和 3 号接口的性能! 
interface Inter2 extends Inter1 , Inter3{void delete(int id) ;
}
//2, 想要应用 2 号接口的性能, 找一个实现类来实现接口
class Inter2Impl implements Inter2{
@Override
public void save() {System.out.println(1);
}
@Override
public void update() {System.out.println(2);
}
@Override
public void get() {System.out.println(3);
}
@Override
public void delete(int id) {System.out.println(4);
}
}

4 总结

1. 类和类之间的关系是: 继承关系
java 里只反对单继承
class A extends B
其中 A 是子类,B 是父类. 子类能够应用父类的所有性能。
办法的重写 override: 如果想要批改父类的原有性能, 能够进行办法重写。
2. 接口和接口之间的关系：是继承关系
接口的呈现就是为了冲破 java 单继承的局限性。
接口间能够多继承。
interface A extends B , C
其中 A 是子接口,B 和 C 是父接口。
A 就领有了 B 和 C 的所有性能,A 的性能是最全的。
class Impl implements A
Impl 实现类就须要同时重写 A B C 接口里的所有形象办法, 否则就是一个抽象类。
3. 类和接口之间的关系：是实现关系
实现类能够实现接口, 而且能够多实现
class A implements B,C
A 是实现类,B 和 C 是接口.
A 须要同时重写 B 和 C 接口里的所有形象办法, 否则就是一个抽象类
类能够在继承的同时多实现
class A extends B implements C , D
A 能够叫子类, 也能够叫是实现类
A 同时领有父类 B 的性能, 也同时领有接口 C 和 D 的性能
A 须要同时重写 C 和 D 接口里的所有形象办法, 否则就是一个抽象类
对于父类 B 里的办法吗? 看需要,B 类是父类, 外面如果都是一般办法, 只有须要批改才会产生重写。
4. 接口和抽象类的区别
相同点
抽象类和接口都是形象层，个别用来提取共性
两者都不能被实例化
不同点
构造方法：抽象类里有，接口里没有！
成员变量: 抽象类里有, 接口里没有, 接口里都是常量。
成员办法: 抽象类能够有一般办法和形象办法, 然而接口里都是形象办法 (jdk1.8 当前能够有)
接口存在简写模式, 抽象类里没有
接口里的常量,int age= 10; 会主动拼接 public static final
接口里的办法,void save(), 会主动拼接 public abstract
怎么去设计你的形象层，到底是体现为一个抽象类还是接口？
要害就看你需不需要提供办法体，如果类里的办法都不须要提供办法体，能够设计为接口，如果类里的办法须要提供办法，设计为抽象类。
形象层到底设计为抽象类好还是接口好
如果实现类想要同时领有多个性能，最好抉择接口，因为接口能够多继承多实现。
如果就是设计为抽象类，子类就只能继承一个父类，只有一次的继承权。

5 程序设计

需要：
具体事务：培优班老师，高手班老师
共性：备课，讲课
测试：常见多态对象测试
剖析：
利用面向接口编程的设计思维
1. 把子类见的共性功能，向上提取，造成父类
2. 要不要把父类润饰成形象层，看程序设计的后果 – 形象层能够是抽象类也能够是接口
3. 如果形象层都是形象办法，间接设计为接口
4. 如果形象成还须要一般办法，那就设计成抽象类

package cn.tedu.oop;
interface Teacher {void ready() ;
    void teach() ;}
--ActTeacher 类
package cn.tedu.oop;
// 形容培优班老师的事物
// 共性: 备课 / 讲课
public class ActTeacher implements Teacher{public void ready() {System.out.println("高手班老师正在 备课");
    }
    public void teach() {System.out.println("高手班老师正在 讲课");
    }
}

--CgbTeacher 类
package cn.tedu.oop;
// 形容培优班老师的事物
// 共性: 备课  / 讲课
//6, 实现类实现了接口当前, 须要重写所有形象办法, 否则就是抽象类
abstract public class CgbTeacher implements Teacher{

}

-- 测试类
package cn.tedu.oop;
// 测试 程序设计
public class Test4_Design {public static void main(String[] args) {
        // 接口和抽象类一样, 不能够被实例化
//        Teacher t  = new Teacher();
        // 创立多态对象测试 -- 多态体现的是调用规范
        Teacher t  =  new ActTeacher() ;
        // 规范就是父类, 只能用父类提供的性能
        t.ready();
        t.teach();}
}