廖雪峰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修饰
  

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修饰

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修饰的字段和方法

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

转载于:https://www.cnblogs.com/csj2018/p/10281852.html