06-访问权限以及封装

Posted 2021-01-20 likejiu

简介：

    访问权限作用是我们将编写的代码发布出去，我们定义哪些是可用用的，哪些是不可以的，消费者程序员不会因为修改我们的代码而导致程序异常，也不会破坏程序逻辑

    访问权限的控制被称为具体实现的隐藏，把数据和方法包装进类中，以及具体实现的隐藏，常共同被称作是封装。封装性好的程序能够是代码更加严谨和安全。

1,空间隔离

    java中相同名称内容为了避免冲突使用隔离方案，例如A类和B类中都有f()方法，那么A类和B类都是隔离方法的元素，程序通过判断方法的所属类来区分调用的是哪个方法，那么多个同名的类是如何隔离的呢?答案是包，同包下同名的类不允许的，编译器会直接报错，不同的包相同A类则起到隔离作用，那么调用区分1包和2包下的A类则是使用import导入时，导入全路径下的A类，就能区分调用的A类是哪个了,通过import和package将单一的全局名称空间分割开，使得编写程序不会出现名称冲突问题。

    所以包也被称为库单元，A类.java被称为编译单元，或者叫做转义单元。

2,访问权限

    java提供4中访问权限，分别是public，private，protected,以及默认权限，

另外private是隐式的final修饰。所以如果再给private 方法添加final修饰，是可以但没有实际意义。

结构如下：

权限	类内	同包	不同包子类	不同包非子类
private	√	×	×	×
default	√	√	×	×
protected	√	√	√	×
public	√	√	√	√

本类调用所有权限的变量和方法,示例如下：

package com.javaApi.override.publicTest;
public class Hello {
    //访问权限变量 依次private,default,public,protected
    private String strPrivate="strPrivate";
    String strDefault="strDefault";
    public String strPublic="strPublic";
    protected String strProtected="strProtected";

    public Hello(){

    }
    private Hello(int i){
        System.out.println(i);
    }
    //访问权限方法 依次private,default,public,protected
    private void privateMethod(){
        System.out.println("privateMethod");
    }
    void defaultMethod(){
        System.out.println("defaultMethod");
    }
    public void publicMethod(){
        System.out.println("public method");
    }
    protected void protectedMehtod(){
        System.out.println("protectedMethod");
    }

    @Test
    protected void runTest(){
        //本类调用各个方法以及各个变量
        Hello h=new Hello();//能够访问，能够正常调用
        h.publicMethod();//能够访问，能够正常调用
        h.privateMethod();//能够访问，能够正常调用
        h.defaultMethod(); //能够访问，能够正常调用
        h.protectedMehtod();//能够访问，能够正常调用
        h=new Hello(1);//能够访问，能够正常调用
        
        System.out.println(h.strPrivate);//能够访问，能够正常调用
        System.out.println(h.strPublic);//能够访问，能够正常调用
        System.out.println(h.strProtected);//能够访问，能够正常调用
        System.out.println(h.strDefault);//能够访问，能够正常调用
    }
}

结果：    

    本类拥有所有权限，无论是private和还是public无论是变量还是方法，本类都是可以调用和访问的

不同包下调用Hello类的各个方法，如下：

package com.javaApi.override;//与Hello不同包
public class Handler {
    //不同包的方法调用Hello类内容
    @Test
    public void  authority(){
        //不同包下只能访问public,
        Hello h=new Hello();//能够访问，能够正常调用
        
        //System.out.println(h.strPrivate);无法获取，编译器不通过
        System.out.println(h.strPublic);//能够访问，能够正常调用
        //System.out.println(h.strProtected);//无法获取，编译器不通过
        //System.out.println(h.strDefault);//无法获取，编译器不通过
        
        h.publicMethod();//能够访问，能够正常调用
    
        //h.privateMethod();无法调用方法而且编译器也不通过。
        //h.defaultMethod(); 无法访问，编译器不通过
        //h.protectedMehtod();无法访问，编译器不通过
    
        /**
         * 由于参数为int类型的构造Hello(int i)方法是private方法，
         * 所以无法方法而且编译器也不通过。
         */
        //h=new Hello(1);//无法访问，编译器不通过
    }
}

结果：

    1，不同包下除了public方法和public变量其他方法和变量都无法调用，包括构造器方法，这里调用时通过new出Hello类对象，通过该对象调用的。

同包下调用Hello类方法，如下

package com.javaApi.override.publicTest;//与Hello同包
public class Handler {
    @Test
    public void  authority(){
        Hello h=new Hello();//能够访问，能够正常调用
        
        //System.out.println(h.strPrivate);无法获取，编译器不通过
        System.out.println(h.strPublic);//能够访问，能够正常调用
        System.out.println(h.strProtected);//能够访问，能够正常调用
        System.out.println(h.strDefault);//能够访问，能够正常调用
    
        h.publicMethod();//能够访问，能够正常调用
        //h.privateMethod();无法访问，编译器不通过
        h.defaultMethod();//能够访问，能够正常调用
        h.protectedMehtod();//能够访问，能够正常调用
    
        /**
         * 由于参数为int类型的构造Hello(int i)方法是private方法，
         * 所以无法方法而且编译器也不通过。
         */
        //h=new Hello(1);无法访问，编译器不通过
    }
}

结果如下：

    1，同包下调用，除了private方法和private变量，即private修饰的都不能被调用，其他都能被正常调用，这里调用时通过new出Hello类对象，通过该对象调用的。

不同包继承权限情况如下：

package com.javaApi.override;;//与Hello不同包
//本HelloChild和父类Hello不同包
class HelloChild extends Hello{
    @Test
    @Override
    public void runTest(){
        HelloChild h=new HelloChild();
        h.publicMethod();//正常被继承，能够访问，能够正常调用
        //h.privateMethod();不能被继承，不能够访问，能够正常调用
        //h.defaultMethod(); 不能被继承，不能够访问，能够正常调用
        h.protectedMehtod();//正常被继承，能够访问，能够正常调用
        
        Hello h2=new HelloChild();
        //h2.protectedMehtod();不能够访问，不能够正常调用
        
        //System.out.println(h.strPrivate);无法获取，编译器不通过
        System.out.println(h.strPublic);//能够访问，能够正常调用
        System.out.println(h.strProtected);//能够访问，能够正常调用
        //System.out.println(h.strDefault);无法获取，编译器不通过
    }
}

结果如下：

    1，不同包下，public和protected能够被继承，默认和private不能被继承。

    2，注意在不同包下，引用为父类时如本示例h2，不能访问protected方法，只能是子类引用可以方法，如本示例引用h，就能够调用protected方法

同包继承权限情况如下：

package com.javaApi.override.publicTest;//与Hello同包
//本HelloChild和父类Hello同包
class HelloChild extends Hello{
    @Test
    @Override
    public void runTest(){
        HelloChild h=new HelloChild();
        h.publicMethod();//正常被继承，能够访问，能够正常调用
        //h.privateMethod();不能被继承，不能够访问，能够正常调用
        h.defaultMethod(); //正常被继承，能够访问，能够正常调用
        h.protectedMehtod();//正常被继承，能够访问，能够正常调用
        
        Hello h2=new HelloChild();
        h2.protectedMehtod();//能够访问，能够正常调用
        
         //System.out.println(h.strPrivate);无法获取，编译器不通过
        System.out.println(h.strPublic);//能够访问，能够正常调用
        System.out.println(h.strProtected);//能够访问，能够正常调用
        System.out.println(h.strDefault);//能够访问，能够正常调用
    }
}

结果如下：

    1，同包下，只有private不能被继承，其他都能被继承,即只要拥有能访问的权限就用能被继承的权限

    2，注意在同包下，引用为父类和子类都能够正常调用protected方法，如本示例h2，和h

总结：

    代码封装和访问权限在日常开发是最常见的,基本上就是java的全部，包括java设计模式以及OO设计原则都是对它们的各种运用。