关于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();
    }
}