java学习day10--面向对象--访问控制符+接口

接口

概述　

Java里面由于不允许多重继承，所以如果要实现多个类的功能，则可以通过实现多个接口来实现。

Java接口和Java抽象类代表的就是抽象类型，就是我们需要提出的抽象层的具体表现。
OOP面向对象的编程，如果要提高程序的复用率，增加程序的可维护性，可扩展性，
就必须是面向接口的编程，面向抽象的编程，正确地使用接口、抽象类这些太有用的抽象类型做为java结构层次上的顶层。

特点

        --接口中都是抽象方法
        --通过interface关键字创建接口
        --通过implements让子类来实现
        --可以理解成，接口是一个特殊的抽象类
        --接口突破了java的单继承的局限性
        --接口和类之间可以多实现，接口和接口之间可以多继承
        --接口是对外暴露的规则，是一套开发规范
        --接口提高了程序的功能扩展，降低了耦合性    

测试特点案例

package cn.tedu.interfacedemo;

        //这类用来测试  接口
        public class Test4_Interface {
            public static void main(String[] args) {
                //创建多态对象测试
                Inter in = new InterImpl() ;
                in.delete();
                in.save();
                //7、接口能实例化吗？  -- 不可以！！
        //        new Inter() ;
            } 
        }
        //1、创建接口，使用interface关键字
        interface Inter{
            //2、 接口中都是抽象方法
            abstract public void save() ;
            abstract public void delete() ; 
            
            //3、接口里不允许存在普通方法，但是，jdk8里也支持default或者static的普通方法。
        //    public void sleep()  {}
        }
        //4、想要使用接口里的功能，创建实现类。使用implements关键字
        //5、作为实现类，有两条路：要么把所有抽象方法都重写  +  否则就是一个抽象的实现类---------神似 抽象类
        //abstract class  InterImpl implements  Inter{
        class  InterImpl implements  Inter{
            //6、重写接口里的所有抽象方法--------神似 抽象类
            @Override
             public void save() {
                 System.out.println("save()>>>");
             }
            @Override
             public void delete() {
                System.out.println("delete()>>>");
             }
        }

接口的使用

　　接口的构造方法:接口里没有构造方法

　　接口的成员变量:接口里没有变量,都是静态的常量,接口中提供的简写形式，会为你自动拼接public static final  

　　接口的成员方法:接口中不可以有普通方法,

　　接口中的方法 ，重写时，要有足够的权限，接口里都是public的，重写>=public

package cn.tedu.interfacedemo;
        //这类用来测试 接口的使用
        public class Test5_UseInterface {
            public static void main(String[] args) {
                //创建多态对象测试
                Inter2 in = new Inter2Impl() ; 
                //4、接口里的变量的值   不能被修改 ！！！ 已经默认被final修饰
        //        in.name = "刘沛霞" ; 
                System.out.println(in.name);
                //5、接口里的变量是常量，而且已经默认被static修饰
                System.out.println( Inter2.name );
                in.add();
                in.update();
            }
        }
        //1、interface关键字创建接口
        interface Inter2{
            //2、接口里有构造方法  ？  --   没有！！
        //    public Inter2() {}
            //3、接口里有成员变量  ？  --   没有变量！！！接口里都是静态的常量！！！
        //    public static final  String  name = "皮皮霞" ;
            String  name = "皮皮霞" ;//接口中提供的简写形式，会为你自动拼接public static final  
            //6、接口里可以有普通方法吗？ -- 不可以..................
        //     public abstract void add() ;
            void add() ;  //接口中提供的简写形式，会为你自动拼接public abstract
            void update() ;
        }
        //7、实现类  实现了 接口后，需要重写所有接口里的抽象方法
        class Inter2Impl implements Inter2{
            //8、接口中的方法 ，，重写时，要有足够的权限，接口里都是public的，你重写>=也得是public
            @Override
            public void add() {
                System.out.println("add()....");
            }
            @Override
            public void update() {
                System.out.println("update()....");
            }
        }

接口的复杂用法

　　多继承:接口和接口之间　　

　　　　interface Mapper3 extends Mapper1 , Mapper2 { 重写的抽象方法}

　　多实现:实现类和接口之间　　

　　　　class Impl implements Mapper3{重写的抽象方法}

　　继承的同时多实现

　　　　class Zi extends Fu implements Mapper1 , Mapper2 {重写的普通方法(可选)以及重写的抽象方法(必写)}

　　以上如果不重写抽象方法,那么可以选择继续作为一个抽象类存在+abstract关键字.

package cn.tedu.interfacedemo;
        //这个类用来测试接口的  复杂用法：接口的多继承 + 多实现 + 继承的同时多实现。
        public class Test6_Many {
        }
        //创建接口
        interface Mapper1{
            void save() ;
            void get() ;
        }
        interface Mapper2{
            void add() ;
            void update() ;
        }
        //1、接口和接口之间：是继承 关系，3号接口  想要  同时使用  1号2号接口，逗号隔开。
        interface Mapper3  extends  Mapper1 ,  Mapper2  {
            void delete() ; 
        }
        //2、如果有个实现类  实现了3号接口，需要重写几个抽象方法？？ ---  同时重写1 2 3 接口里的所有抽象方法
        abstract class Impl implements Mapper3{
        }
        //3、实现类  和接口之间 ：是实现关系，而且可以多实现。多实现之间逗号隔开。
        abstract class Impl2 implements Mapper1 ,  Mapper2  {
        }
        class Fu{  }
        //4、Zi在继承Fu的同时，实现了多个接口
        abstract class Zi extends Fu implements  Mapper1 , Mapper2 {
        }