java 相關內容使用（關鍵字 private default protect public）

總結一下java 相關的權限的意思

分類	同一個類中	同一個包中	不一樣包的子類	不一樣包的非子類
private	〇
default	〇	〇
protected	〇	〇	〇
public	〇	〇	〇	〇

Private

private使用的樣例

class Test{
        public static void main(String[] args){
            Person person = new Person("Daming");

            System.out.println(person.name);
        }
    }

    class Person{
        private String name;

        Person(String name){
            this.name = name;
        }

        public String getName(){
            return this.name;
        }
    }

執行上訴代碼的結果以下圖所示：

經過圖片能夠了解到private修飾屬性僅能在本類中使用。

private修飾的內容也不能在子類中使用：

class Test{
    public static void main(String[] args){
        subPerson person = new subPerson("Daming");
     }
    }



class Person{
    private String name;

    Person(String name){
        this.name = name;
    }

    public String getName(){
        return this.name;
    }
}
class subPerson extends Person{
    
    subPerson(String name){
        super(name);
    }
    
    public String ShowName(){
        return name;
    }
}

上訴代碼表示子類中也不能繼承private的變量。

default

default使用樣例，default在使用的時候能夠在經過一個包中使用，例以下面的代碼：

package com.test.Demo;

    class Person{
        String name;
    
        Person(String name){
                this.name = name;
        }
    
        public String getName(){
                return this.name;
        }
    }

    public class Demo{
        public static void main(String[] args){
                Person person = new Person("Daming");
                System.out.println(person.name);
        }
    }

上訴代碼執行的結果以下：

可是在不一樣的包中的時候則會發生錯誤，樣例代碼以下：

//父類的定義
package com.test.Demo;

public class Person{
    String name;
    
    public Person(String name){
        this.name = name;
    }
    
    public String getName(){
        return this.name;
    }
}

import com.test.Demo.Person;

class Test{
    public static void main(String[] args){
        Person p = new Person("Daming");
        
        System.out.println(p.name);
    }
}

當調用的類與對象的類不在一個包中的時候，則發生以下的錯誤：

protected

protecte實驗的代碼以下：（參見其餘人寫的代碼，以爲對本身理解protected有幫助）

package com.lky.h1;

public class Base{
    private Integer id;
    protected String name;
    
    
    public Integer getId(){
        return id;
    }
    
    public void setId(Integer id){
        this.id = id;
    }
    
    public String getName(){
        return name;
    }
    
    public void setName(String name){
        this.name = name;
    }
    
    public String toString(){
        return "Base [id=" + id + ", name=" + name + "]"; 
    }
}

//在同一個包中的子類
package com.lky.h1;

class Test1 extends Base{

    public static void main(String[] args){
        Test1 test1 = new Test1();
        Base base = new Base();
        
        base.name = "Daming";
        test1.name = "hong";
        
        System.out.println(base.name);
        System.out.println(test1.name);
    }
}

運行結果以下：

此時說明在同一個包中的時候，不管是父類仍是子類均可以調用定義用protected修飾的變量。

下面則是在不一樣包中定義的子類

package com.lky.h2;

import com.lky.h1.Base;

class Test2 extends Base{

    public static void main(String[] args){
        Test2 test2 = new Test2();
        Base base = new Base();
        
        base.name = "Daming";
        test2.name = "hong";
        
        System.out.println(base.name);
        System.out.println(test2.name);
    }
}

運行的結果以下:

經過上圖能夠說明在同一個包中，父類定義一個以protected修飾的變量的時候，子類和父類的實例都是能夠訪問的。

可是在不一樣的包中的時候，父類中定義一個以protected修飾的變量的時候，子類能夠經過的實例來直接訪問，父類不能夠經過的實例來直接訪問。