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修饰的变量的时候，子类可以通过的实例来直接访问，父类不可以通过的实例来直接访问。