Java基础学习笔记（九）—— java中的private,protected,public与静态代码块
Life was like a box of chocolates, you never know what you’re gonna get.
| @Author：TTODS
封装性与访问控制
java面向对象的封装性是通过对成员变量和方法进行访问控制实现的，访问控制分为4个等级：私有、默认、保护和公有。
私有级别
私有级别的关键字是private,私有级别限制性最高，私有级别的成员变量和方法只能在其所在的类内部自由使用，在其他类中则不允许直接访问。
//first包中的MyFirstClass.java文件
package first;
public class MyFirstClass{
private int privateData; //私有成员变量
public MyFirstClass() {
privateData =1;
}
//私有方法
private void printData() {
System.out.println(privateData);
}
}
//first 包中的MySecondClass.java文件
package first;
public class MySecondClass{
public static void main(String[] args) {
MyFirstClass firstClass = new MyFirstClass();
firstClass.privateData=0; //报错 字段 MyFirstClass.privateData 不可视
firstClass.printData(); //报错 类型 MyFirstClass 中的方法 printData（）不可视
}
}
默认级别
默认级别就是在声明变量不加修饰词，它的限制性介于private和protected之间。默认级别的成员变量和方法，可以在其所在的类内部和同一个包的其他类中被直接访问，但在不同的包的类中则不允许直接访问
//first包内的MyFristClass.java文件
package first;
public class MyFirstClass{
int defaultData; //默认级别成员变量
public MyFirstClass() {
defaultData =1;
}
//默认级别方法
void printData() {
System.out.println(defaultData);
}
}
//first包内的MySecondClass.java文件
package first;
public class MySecondClass{
public static void main(String[] args) {
MyFirstClass firstClass = new MyFirstClass();
firstClass.defaultData=0; //可以访问
firstClass.printData(); //可以访问
}
}
//second 包内的MyThridClass.java文件
package second;
import first.MyFirstClass;
public class MyThridClass{
public static void main(String[] args) {
MyFirstClass firstClass = new MyFirstClass();
firstClass.defaultData;// 报错 字段 MyFirstClass.defaultData 不可视
firstClass.printData();// 报错 类型 MyFirstClass 中的方法 printData（）不可视
}
}
保护级别
保护级别的关键字是protected，保护级别在同一包中完全与默认访问级别一样（可以在其所在的类内部和同一个包的其他类中被直接访问），但是不同包中子类能够继承父类中的protected变量和方法，这就是所谓的保护级别，“保护”就是保护某个类的子类都能继承该类的变量和方法。
//first包内的MyFristClass.java文件
package first;
public class MyFirstClass{
protected int protectedData; //保护级别成员变量
public MyFirstClass() {
protectedData =1;
}
//保护级别方法
protected void printData() {
System.out.println(protectedData);
}
}
//first包内的MySecondClass.java文件
package first;
public class MySecondClass{
public static void main(String[] args) {
MyFirstClass firstClass = new MyFirstClass();
firstClass.protectedData=0;
firstClass.printData();
}
}
//second 包内的MyThridtClass.java文件
package second;
import first.MyFirstClass;
public class MyThridClass extends MyFirstClass{
void show() {
printData(); //printData方法是从父类继承下来的
System.out.println(protectedData); //protectedData 也是从父类继承下来的
}
}
公有级别
公有级别的关键字是public，公有级别的成员变量和方法可以在任何场合被直接访问，是最宽松的一种访问控制等级。
简单总结
访问成员有两种方式：一种是调用，即通过类或对象调用它的成员，如firstClass.printData()语句；另一种是继承，即子类继承父类的成员变量和方法。
- 公有访问级别任何情况下两种方式都可以；
- 默认访问级别在同一包中两种访问方式都可以，不能在包之外访问；
- 保护访问级别在同一包中与默认访问级别一样，两种访问方式都可以。但是在不同包之外只能继承访问；
- 私有访问级别只能在本类中通过调用方法访问，不能继承访问。
静态变量和静态方法
类中的变量可以分为“实例变量”和“静态变量”，其中“实例变量”是与个体有关的有关的变量比如圆的半径，对于不同的圆来说，半径是不同的。“静态变量”也叫做“类变量”，是与类实例无关的变量，例如圆周率，对于不同的圆而言，圆周率的值是不变的。
静态变量用static修饰，同理，用static修饰的方法称为静态方法。静态方法可以访问静态变量和其他的静态方法。
对静态变量和静态方法的调用有两种方法：①通过类名调用，②通过类的实例调用
//first包内Circle.java文件
package first;
public class Circle{
protected int radius;
//静态变量
public static float PI = 1415926f;
//默认构造
public Circle(){
radius = 1;
};
public Circle(int r) {
this.radius = r;
}
//静态方法
public static void showPI() {
System.out.printf("PI is %f\n",PI);
}
}
//default包内的Draw.java 文件
import first.Circle;
public class Draw{
public static void main(String[] args) {
//通过类名调用静态方法
Circle.showPI(); //输出 PI is 3.141593
//通过类名调用静态变量
System.out.println(Circle.PI); //输出 3.1415925
//实例化一个Cricle 对象
Circle myCircle = new Circle(2);
//通过类的实例调用静态变量
System.out.println(myCircle.PI); //输出 3.1415925
//通过类的实例调用静态方法
myCircle.showPI(); //输出 PI is 3.141593
}
}
静态代码块
上面我们对静态变量PI是在声明的同时就赋值了。但有时静态变量的值要经过计算才能得到，这时就要用到静态代码块。静态代码块只在第一次类加载时执行。
稍微修改上例代码：
//first包中的Circle.java文件
package first;
public class Circle{
protected int radius;
public static float PI;
//默认构造
public Circle(){
radius = 1;
};
public Circle(int r) {
this.radius = r;
}
public void setRadius(int r) {
this.radius = r;
}
public int getRadius() {
return this.radius;
}
public float getArea() {
return PI*this.radius*this.radius;
}
public static void showPI() {
System.out.printf("PI is %f\n",PI);
}
//静态代码块
static {
PI = 3.1415926f;
System.out.println("This is static code block...");
}
}
//default包中的Draw.java文件
import first.Circle;
public class Draw{
public static void main(String[] args) {
//通过类名调用静态方法
Circle.showPI(); //此时第一次加载类，调用静态代码块。
//通过类名调用静态变量
System.out.println(Circle.PI);
//实例化一个Cricle 对象
Circle myCircle = new Circle(2);
//通过类的实例调用静态变量
System.out.println(myCircle.PI);
//通过类的实例调用静态方法
myCircle.showPI();
}
}
运行Draw.java文件，输出：
This is static code block...
PI is 3.141593
3.1415925
3.1415925
PI is 3.141593
来源：CSDN
作者：TTODS.
链接：https://blog.csdn.net/qq_44525150/article/details/104641707