廖雪峰Java2面向对象编程-5包和classpath-3作用域

1.访问权限

Java的类、接口、字段和方法都可以设置访问权限

• 访问权限是指在一个类的内部，能否引用另一个类以及访问它的字段和方法
• 访问权限有public、protected、private和package四种

2.public

定义为public 的class、interface、field、method可以被其他类访问

//包含public 接口、类、field、method的例子
public interface Person{
    void run();
}
public class Student implements Person{
    public String name;
    public int age;
    public Student(String name){
        this.name = name;
    }
    public void run(){
        System.out.println(this.name+" 跑 啊 跑");
    }
}
public class Hello{
    public static void main(String[] args){
        Student s = new Student("张三");
        s.run();
        System.out.println(s.age);
    }
}

3.private

3.1private修饰的field、method

• 定义为private的field、method无法被其他类访问
  
  
• 但是在类的内部，其他方法是可以调用field和method的
• private访问权限限定在类的内部，与方法声明顺序无关。
• 推荐：把public放在前面，private放在后面。public对外提供了功能，阅读代码时，首要关心public代码。

//关于private field、method的例子
public class Student {
    private String name;
    private int age;
    public void info(){
        this.run();
        System.out.println(this.name);
    }
    private void run(){
        System.out.println("Student: " +name + " is running");
        System.out.println("name is "+age + " years old.");
    }
}
public class Hello{
    public static void main(String[] args){
        Student s = new Student();
        s.info();
    }
}

## 3.2private 修饰的内置class
* 定义为private的class无法被其他类访问
* 访问private class被限定在外层class的内部
* 定义在一个class内部的class成为内部类inner class
* 不能对最外层的类用private修饰

```#java
public class Student {
private String name;
private int age;
public void info(){
School s = new School("飞扬学院");
System.out.printf("My name is %s.\nI am %d years old. \n%s",this.name,this.age,s.info());
}
private class School{
public School(String school){
this.school = school;
}
private String school;
public String info(){
return "I am student of " + this.school;
}
}
}
public class Hello{
public static void main(String[] args){
Student s = new Student();
s.info();
}
}
```

4.protected作用于继承关系

• 定义为protected的字段和方法可以被子类访问
• 不能对最外层的类使用protected修饰

```#java
public class Student {
protected String name;
protected int age;
protected void info(){
System.out.printf("My name is %s.\nI am %d years old",this.name,this.age);
}
}
public static void main(String[] args){
Student s = new Student();
s.info();
}
}
```
# 5.作用域
* 包作用域是指一个类允许访问同一个package的
* 没有public、private修饰的class
* 没有public、protected、private修饰的字段和方法
```#java
package abc;
class Student {
String name;
int age;
void info(){
System.out.printf("My name is %s.\nI am %d years old",this.name,this.age);
}
}
package abc;
class Hello{
public static void main(String[] args){
Student s = new Student();
s.info();
}
}
```

如果不确定是否需要public，就不声明为public，即尽可能少的暴露对外方法。

6.局部变量

在方法内部定义的变量成为局部变量

局部变量作用域从变量声明处开始到对应的块结束

class Hello{
    void hi(String name){
        //方法hi的作用域到方法结束
        //name作用域从到方法结束
        String s = name.toLowerCase();
        //s的作用域到方法结束
        int len = s.length();
        //len到方法结束
        if (len <10){
            int p = 10 -len;//到if语句结束
            for(int i = 0;i < 10;i++){
                //i到循环结束
                System.out.println();
            }
        }
    }
}

一个Java文件中，只能定义一个public class，但可以定义多个非public class ，并把它们保存在同一个Java文件中

public class Hello{
    public static void main(String[] args){
        Say s = new Say("Tom");
        Run r = new Run(5);
        System.out.println(s.say());
        System.out.println(r.run());

    }
}
class Say{
    private final String name;
    public Say(String name){
        this.name = name;
    }
    public String say(){
        return "Hello,"+name+"!";
    }
}
class Run{
    private final int distance;
    public Run(int distance){
        this.distance = distance;
    }
    String run(){
        return "I can run "+this.distance+" Km.";
    }
}

最佳实践

• 尽可能把局部变量的作用域缩小
• 尽可能延后声明局部变量

7.final

• final与访问权限不冲突
• 用final修饰class可以阻止被继承
  
  
• 用final修饰method可以阻止被子类覆写
  
  
• 用final修饰field可以阻止被重新赋值，即只允许在初始化的时候赋值
  
  
• 用final修饰局部变量可以阻止其被重新赋值
  
  

8.总结：

Java内建的访问权限包括 public、protected、private和package

Java在方法内部定义的变量是局部变量

局部变量的作用域从变量声明开始，到一个块结束

final修饰符不是访问权限

一个Java文件只能包含一个public class，但可以包含多个非public class