【java学习】访问权限修饰符（24）

---

1. 四种访问权限修饰符

Java 权限修饰符public、protected、private 置于类的成员定义前，用来限定对象对该类成员的访问权限。

注意：
(1) 对于 class 的权限修饰只可以用 public 和 default( 缺省 ) 。
(2) public 类可以在任意地方被访问。
(3) default 类只可以被同一个包内部的类访问。

2. private修饰符

package day06;

public class Person4 {
	private int age;         //定义一个private变量
	
	private void getAge() {  //定义一个private方法
		System.out.println(age);
	}
	
	//访问方式：类内访问
	public void test() {  //只能在类内部访问private属性和方法
		getAge();
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3. 无(缺省)修饰符

项目文件结构：Person4.java和Test.java在同一个包(day06)中

代码示例：

package day06;

public class Person4 {

	int age;          //定义一个 缺省修饰符 的变量
	void getAge() {   //定义一个 缺省修饰符 的方法
		System.out.println(age);
	}
	
	//访问方式1：类内访问
	public void test() {
		getAge();
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

除了类内访问方式，还可以在同一个包中访问：

package day06;

//Test.java和Person4.java都在day06包中
public class Test {
	public static void main(String[] args) {
		
		//访问方式2：同一个包中访问
		Person4 p4 = new Person4();
		p4.test();
	}

}
1
2
3
4
5
6
7
8
9
10
11
12

3.1. 什么是父子类

假设：
    父类：class Person4
    子类命名方式：class PersonChild extends Person4

代码示例如下

package day06.test;
import day06.Person4;   //父类Person4所在的路径

/**
 * 通过extends可以构成父子类的关系
 * PersonChild就是Person4的子类
 * @author 14532
 *
 */

public class PersonChild extends Person4{

	public void test() {
		System.out.println(age);//访问父类中的age变量
		getAge();               //访问父类中的getAge()方法
		//但是上面这中访问方式 没有权限 ，因为父类中声明的修饰符是 缺省修饰符
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4. protected修饰符

父类代码：

package day06;

public class Person4 {

	protected int age;          //定义一个 protected修饰符 的变量
	protected void getAge() {   //定义一个 protected修饰符 的方法
		System.out.println(age);
	}
	//访问方式1：类内访问
	public void test() {
		getAge();
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

除了类内访问方式，还可以在同一个包中访问：

package day06;

//Test.java和Person4.java都在day06包中
public class Test {
	public static void main(String[] args) {
		
		//访问方式2：同一个包中访问
		Person4 p4 = new Person4();
		p4.test();
	}

}
1
2
3
4
5
6
7
8
9
10
11
12

    前面已经说明了类内访问方式和同一个包中访问方式，这里证明protected修饰符可以在子类中被访问：
子类代码：

package day06.test;
import day06.Person4;

/**
 * 通过extends可以构成父子类的关系
 * PersonChild就是Person4的子类
 * @author 14532
 *
 */
public class PersonChild extends Person4{
	public void test() {          //访问方式3：在子类中访问
		System.out.println(age);
		getAge();
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

    如果既不是父子类关系也不在同一个包中：比如Person4.java在day06包中，我在day06.test包中编写一个Test.java去访问Person4

package day06.test;
import day06.Person4;

public class Test {
	public static void main(String[] args) {
		
		Person4 p4 = new Person4();
		p4.age = 4;    //无法访问
		p4.getAge();   //无法访问
	}

}
1
2
3
4
5
6
7
8
9
10
11
12

5. public修饰符

访问权限最广，这里就不赘述了。

注意：在同一个java文件中可以写多个class，但是只有一个public，其他的class只能是缺省的

package day06.test;
import day06.Person4;

public class Test {
	public static void main(String[] args) {
		
		Person4 p4 = new Person4();
		
		p4.age = 4;
		p4.getAge();
	}
	
}

/**
 * 在同一个java文件中可以写多个class，但是只有一个public，其他的class只能是缺省的
 * @author 14532
 *
 */
class T0{
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

6. 练习题

1、创建程序 , 在其中定义两个类： Person 和 TestPerson 类。定义如下：
用 setAge() 设置人的合法年龄 (0~130) ，用 getAge() 返回人的年龄。在 TestPerson 类中实例化 Person 类的对象 b ，调用 setAge() 和 getAge() 方法，体会 Java 的封装性。

答案：
Person.java

package day06;

public class Person {

	private int age;
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int a) {
		if(a <= 130 && a >= 0) {
			age = a;
		}else {
			System.out.println("输入的年龄：" + a + "不在0~130之间");
		}
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

编写TestPerson.java调用Person类中的方法

package day06;

public class TestPerson {
	public static void main(String[] args) {
		Person p = new Person();

		
		p.setAge(12);
//		p.printAge();
		int a = p.getAge();
		System.out.println("输出的年龄为：" + a);
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行结果：