JavaSE（四）之接口、访问控制

上面我们学习了几个修饰符，在开发中经常会用的到，所以必须熟练的掌握。接下来我学习一下接口和访问控制。

一、接口

一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

　　1.1、接口与抽象类的区别

　　　　　抽象类也是类,除了可以写抽象方法以及不能直接new对象之外,其他的和普通类没有什么不一样的。接口已经另一种类型了,和类是有本质的区别的,所有不能用类的标准去衡量接口。

       　　 声明类的关键字是class,声明接口的关键字是interface。

      　　  抽象类是用来被继承的,java中的类是单继承。
         　　   类A继承了抽象类B,那么类A的对象就属于B类型了,可以使用多态
         　　   一个父类的引用,可以指向这个父类的任意子类对象
          　　  注:继承的关键字是extends

      　　  接口是用来被类实现的,java中的接口可以被多实现。
        　　    类A实现接口B、C、D、E..,那么类A的对象就属于B、C、D、E等类型了,可以使用多态
         　　   一个接口的引用,可以指向这个接口的任意实现类对象
         　　   注:实现的关键字是implements

　　1.2、接口中的方法都是抽象方法

　　　　接口中可以不写任何方法,但如果写方法了,该方法必须是抽象方法
      　　  例如:
       　　 public interface Action{
           　　 public abstract void run();

          　　  //默认就是public abstract修饰的
          　　  void test();
          　　  public void go();
     　　   }

　　1.3、接口中的变量都是静态常量(public static final修饰)

　　　　接口中可以不写任何属性,但如果写属性了,该属性必须是public static final修饰的静态常量。
       　　 注:可以直接使用接口名访问其属性。因为是public static修饰的
       　　 例如:
      　　  注:声明的同时就必须赋值.(因为接口中不能编写静态代码块)
      　　  public interface Action{
       　　     public static final String NAME = "tom";
      　　      //默认就是public static final修饰的
    　　        int AGE = 20;
       　　 }
    　　    main:
     　　       System.out.println(Action.NAME);
       　　     System.out.println(Action.AGE);

　　1.4、一个类可以实现多个接口　　

public class Student implements A,B,C,D{
            //Student需要实现接口A B C D中所有的抽象方法
            //否则Student类就要声明为抽象类,因为有抽象方法没实现
        }
        main:
            A s1 = new Student();
            B s2 = new Student();
            C s3 = new Student();
            D s4 = new Student();

            注:
            s1只能调用接口A中声明的方法以及Object中的方法
            s2只能调用接口B中声明的方法以及Object中的方法
            s3只能调用接口C中声明的方法以及Object中的方法
            s4只能调用接口D中声明的方法以及Object中的方法

            注:必要时可以类型强制转换
            
            例如:
            接口A 中有test()
            接口B 中有run()

            A s1 = new Student();
            s1.test();

            B s2 = new Student();
            s2.run();
            
            if(s1 instanceof B){
                ((B)s1).run();
            }

 

　　1.5、一个接口可以继承多个父接口

public interface A{
            public void testA();
        }

        public interface B{
            public void testB();
        }
        
        //接口C把接口A B中的方法都继承过来了
        public interface C extends A,B{
            public void testC();
        }
        
        //Student相当于实现了A B C三个接口,需要实现所有的抽象方法
        //Student的对象也就同时属于A类型 B类型 C类型
        public class Student implements C{
            public viod testA(){}
            public viod testB(){}
            public viod testC(){}
        }

        main:
        C o = new Student();
        System.out.println(o instanceof A);//true
        System.out.println(o instanceof B);//true
        System.out.println(o instanceof C);//true
        System.out.println(o instanceof Student);//true
        System.out.println(o instanceof Object);//true
        System.out.println(o instanceof Teacher);//false

 

　　//编译报错
        System.out.println(o instanceof String);
        
        注:
        System.out.println(o instanceof X);
        如果o是一个接口类型声明的变量,那么只要X不是一个final修饰的类,该代码就能通过编译,至于其结果是不是true,就要看变量o指向的对象的实际类型,是不是X的子类或者实现类了。

        注:一个引用所指向的对象,是有可能实现任何一个接口的。(java中的多实现)

　　1.6、接口的作用　　　

　　　　接口的最主要的作用是达到统一访问，就是在创建对象的时候用接口创建，【接口名】 【对象名】=new 【实现接口的类】，这样你像用哪个类的对象就可以new哪个对象了，不需要改原来的代码。

　　　　假如我们两个类中都有个function()的方法，如果我用接口，那样我new a（）；就是用a的方法，new b（）就是用b的方法

　　　　这个就叫统一访问，因为你实现这个接口的类的方法名相同，但是实现内容不同

　　总结：　　　　

　　　　1、Java接口中的成员变量默认都是public,static,final类型的(都可省略),必须被显示初始化,即接口中的成员变量为常量(大写,单词之间用"_"分隔)

　　　　2、Java接口中的方法默认都是public,abstract类型的(都可省略),没有方法体,不能被实例化

　　　　3、Java接口中只能包含public,static,final类型的成员变量和public,abstract类型的成员方法

　　　　4、接口中没有构造方法,不能被实例化

　　　　5、一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口

　　　　6、Java接口必须通过类来实现它的抽象方法

　　　　7、当类实现了某个Java接口时,它必须实现接口中的所有抽象方法,否则这个类必须声明为抽象类

　　　　8、不允许创建接口的实例(实例化),但允许定义接口类型的引用变量,该引用变量引用实现了这个接口的类的实例

　　　　9、  一个类只能继承一个直接的父类,但可以实现多个接口,间接的实现了多继承.

　　1.7、实例　　

package com.frewen.interfacedemo;

    interface SwimInterface{   
       void swim();
    }
    class   Fish{   
       int  fins=4;
    }
    class  Duck {   
      int  leg=2;
      void egg(){};
    }
    
    class Goldfish extends Fish implements  SwimInterface {
        @Override
        public void swim() {
             System.out.println("Goldfish  can swim ");
        }  
    }
    
    class SmallDuck  extends Duck implements  SwimInterface { 
       public void egg(){
           System.out.println("SmallDuck  can lay  eggs ");
       }
       @Override
       public void swim() {
           System.out.println("SmallDuck  can swim ");
       }
    }

    public class InterfaceDemo {        
        public static void main(String[] args) {
            Goldfish goldfish=new Goldfish();
            goldfish.swim();

            SmallDuck smallDuck= new SmallDuck();
            smallDuck.swim();
            smallDuck.egg();
    }
}

 

二、访问控制

　　　　public protected default private是java中的访问控制修饰符.
   　　 注:这里的default的意思是什么都不写
      　　  例如:
      　　  public String name;
      　　  protected String name;
      　　  //default就表示这种情况
      　　  String name;
     　　   private String name;

　　2.1、修饰类

　　　　1）普通类

　　　　只能使用public和default来修饰源文件中编写的java类
          　　  public表示其他任何地方都有权限访问这个类
            　　default表示只有和当前类在同一个包的类才有权限访问

　　　　例如: Test.java中有俩个类

public class Test{
                    private class A{}
                    class B{}
                    protected class C{}
                    public class D{}
                }

                class Action{}

                //编译报错
                protected class Action2{}
                private class Action3{}

 

　　　　2）内部类

　　　　四个修饰符可以修饰特定的内部类

//四个内部类
                public class Test{
                    private class A{}
                    class B{}
                    protected class C{}
                    public class D{}
                }

 

　　2.2、修饰属性和方法

　　　　四个修饰都可以修饰类中的属性和方法,那么就以修饰属性为例来说明.(效果和修饰方法是一样的)

　　　　public class Person{
            public      String pubStr = "pubStr";
            protected String proStr = "proStr";
            String defStr = "defStr";
            private   String priStr = "priStr";
        }
        
        从四个地方测试这些属性的可见性:
                    类中     同包类中    子类中    不同包类中
        public         Y            Y            Y            Y
        protected     Y            Y            Y            N
        default         Y            Y            N            N
        private         Y            N            N            N    
        
        注:这里的子类中默认指的是不同包下面的子类