访问修饰符和final的学习

java学习第六周

对idea的一些认知。

1、 创建的package名字首不能为数字，或者带有一些字符。不然在这包下面创建的文件是建立不了java.class的。（虽然可以去Project Structure里面把文件改为sources。不过现在才刚开始摸索还有很多不会的。）

这一次blog是对private，protected，final 等修饰符关键字的学习。

• 1、 private 修饰的变量。（private一般不修饰类，但是可以修饰内部类。）

  一个类中由private修饰的变量在外部类使不允许被使用的。

  package 四种修饰.Private;
  
  public class PrivateTest1_1 {
      private int age;
      private String name;
  
  }
  

  package 四种修饰.Private;
  
  public class Test1_1 {
      public static void main(String[] args) {
          PrivateTest1_1 test = new PrivateTest1_1();
          test.age = 10;
         test.name = "pz";
          System.out.println(test.age+"   "+test.name);
      }
  }
  
  

  调用明显会报错。报错为：java: age 在 四种修饰.Private.PrivateTest1_1 中是 private 访问控制

  ---

  但如果我就要在别的类中使用private修饰的变量呢？

1、 可以使用封装函数。

public class PrivateTest1_1 {
    public PrivateTest1_1() {//建议在类中写一个无参的构造语句。可能以后出错也好查。（大概）
    }
    private int age;
    private String name;
    public void setName (String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    public void show() {
        System.out.println("age="+getAge()+"  "+"name="+getName());
    }

//测试类
package 四种修饰.Private;

public class Test1_1 {
    public static void main(String[] args) {
        PrivateTest1_1 test = new PrivateTest1_1();
        test.setName("pz");
        test.setAge(18);
        test.show();
    }
}
//之前我不知道写get和set的用途，因为我一直自己使用的要么就在这个类中输出语句，根本就没有用到set语句。

输出为：

age=18  name=pz

2、既然他只允许自己使用的话，那我就在他自己的类中使用他就好了。

   public PrivateTest1_1(String name,int age) {
        this.name = name;
        this.age = age;
        System.out.println("name="+name+"  "+"age="+age);
    }

//测试类
PrivateTest1_1 test = new PrivateTest1_1("pz",18);

其他语句跟上面一致，就是这里直接用构造方法，然后在PrivateTest1_1中输出语句也可以。

• 2、关键字final（用final关键字修饰的变量，只能进行一次赋值操作，并且在生存期内不可以改变它的值，final修饰的类不能被继承。）

这里给一段简单的final可以初步认识到他的作用。

package 四种修饰.Final;

public class Test1_2 {
    public static void main(String[] args) {
    final int age = 10;
        age = 10;
        System.out.println(age);
    }
}

报错: java: 无法为最终变量age分配值。

---

package 四种修饰.Final;

public class Test1_2 {
    public static void main(String[] args) {
        final int a = 10;
              int b = 12;
              int newFinalA = 10;
              int newB1 = a+2;
              int newB2 = newFinalA+2;
        System.out.println(b==newB1);
        System.out.println(b==newB2);
       
    }
}

通过final修饰的 整型a 经过计算后，是否和b相等。（中间用了一个整型newFinalA数据来与a进行比较。）

输出为：

true
true

---

   final String x = "pz";
            String y = "pzL";
            String newFinalX = "pz";
            String newY1 = x+"L";
            String newY2 = newFinalX+"L";
        System.out.println(y==newY1);
        System.out.println(y==newY2);

这个跟上面的int类型就不一样了。

输出为：

true
false

（不过现在我还不太清楚这其中的原理。所以在这里也解释不清楚。）

都是一样的语句，只不过是类型发生了变换。

（String用final修饰来说即安全又高效。）

package 四种修饰.Final;

public  class FinalTest1_2 {
    public FinalTest1_2() {
    }

    public final void message() {//这里如果加上final就会报错。
        System.out.println("地址");
    }
}
    class Final extends FinalTest1_2 {
        @Override
        public  final void message() {
            //这里去掉final和不去掉是一样的。看来只需要父类中的方法没有被final修饰就可以。
            System.out.println("居住");
        }
    }

//测试类
Final test = new Final();
     test.message();
//把父类 FinalTest1_2中的message方法的final去掉。输出为 ：居住

报错为：java: 四种修饰.Final.Final中的message()无法覆盖四种修饰.Final.FinalTest1_2中的message()

被覆盖的方法为final

所以被final修饰的方法不能被重写。（需要注意的是重载和重写别搞混淆了。重载是一个类中定义多个同名的方法，要求参数个数或类型不同（返回值不同时，不能构成重载哦）。）

• 3、protected修饰的，可以从这个类继承的任何东西或者同一个包内的其他任何访问。

//测试类 
ProtectedTest1_3 test = new ProtectedTest1_3();
	test.age = 100;
        System.out.println(test.age);

package 四种修饰.Protected;

public class ProtectedTest1_3 {
    protected int age;
}

输出为；

100

与private不同，protected修饰的可以访问。（因为在同一个包中的。）

访问修饰符对应的访问权限

访问修饰符	本类	同一个包中的类	其他包中的子类	其他包中的类
public	√	√	√	√
protected	√	√	√	×
缺少	√	√	×	×
private	√	×	×	×