Java第十四课类与对象（4）——访问权限

由于类与对象的知识点相对抽象，所以二白在这里整理的也相对困难，希望能用更加容易理解的方式来整理。

访问权限

（1）默认修饰符（default）修饰的类中创建同包里使用默认修饰符修饰的对象

（2）在default修饰的类中创建另外一个包中使用public修饰的类

需要导包，如下所示：

package demo02;

import demo01.PublicClass01;

/**
 * @JdkVersion: 17
 * @Author: 二白程序员
 * @Date 2024/4/16 19:49
 * QQ：1512015112
 * VX：18056394367
 */


public class DefaultClass03 {
    public static void main(String[] args) {

        //在default修饰的类中创建另外一个包中使用public修饰的类
        PublicClass01 publicClass01 = new PublicClass01();
        System.out.println(publicClass01);

        //在默认修饰的类中创建另外一个包中使用默认修饰符修饰的类DefaultClass01
        //DefaultClass01 defaultClass01 = new DefaultClass01();
    }
}

（3）创建同包中的public修饰的类对象

在调用时，不需要导包

（4）在public修饰的类中创建另外一个包中使用public修饰的类

使用其他包中的类，需要导包

package demo02;
 ​
 import demo01.PublicClass01;
 ​
 /**
  * @JdkVersion: 17
  * @Author: 二白程序员
  * @Date 2024/4/16 19:49
  * QQ：1512015112
  * VX：18056394367
  */
 ​
 ​
 public class PublicClass03 {
     public static void main(String[] args) {
 ​
         //在public修饰的类中创建另外一个包中使用public修饰的类,使用其他包中的类，需要导包
         PublicClass01 publicClass01 = new PublicClass01();
         System.out.println(publicClass01);
 ​
         //在Public修饰的类中创建另外一个包中使用默认修饰符修饰的类DefaultClass01
         //DefaultClass01 defaultClass01 = new DefaultClass01();
     }
 ​
 ​
 }

总结：

经过上述代码的测试，发现： 1）类的修饰符有public和默认修饰符 2）public修饰符是公有访问级别，在任何位置都可以直接访问 3）默认修饰符是包级私有，被默认修饰符修饰的类，只能被同一个包中的类访问

（5）使用不同的修饰符定义属性

分别使用 public、protect、默认、private来定义属性（借用黑马程序员网课的图片）

创建另外一个包中类对象，需要导包

使用了protected修饰，只能在同包中被访问

使用了默认修饰符修饰，属于包级私有，只能被同包中的类访问

使用private修饰，只能在其所在的类中被直接访问

（6）static修饰符

1）定义：

在类中，用static声明的成员变量为静态成员变量，也成为类变量。类变量的生命周期和类相同，在整个应用程序执行期间都有效。

2）static关键字的用途：

一句话描述就是：方便在没有创建对象的情况下进行调用(方法/变量)。

显然，被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

static可以用来修饰类的成员方法、类的成员变量，另外也可以编写static代码块来优化程序性能

静态方法中只能访问静态变量和静态方法

非静态方法中可以访问非静态变量和非静态方法，也可以访问静态变量和静态方法

总结：静态的只能访问静态，非静态可以访问所有的

3）static方法

static方法也成为静态方法，由于静态方法不依赖于任何对象就可以直接访问，因此对于静态方法来说，是没有this的，因为不依附于任何对象，既然都没有对象，就谈不上this了，并且由于此特性，在静态方法中不能访问类的非静态成员变量和非静态方法，因为非静态成员变量和非静态方法都必须依赖于具体的对象才能被调用。

 package demo05;
 ​
 /**
  * @JdkVersion: 17
  * @Author: 二白程序员
  * @Date 2024/4/16 19:59
  * QQ：1512015112
  * VX：18056394367
  */
 ​
 ​
 public class StaticDemo04 {
     //定义静态变量和非静态变量
     int num1 = 10;
     static int num2 = 20;
 ​
     //定义2个非静态方法
     public void m1(){
         System.out.println("m1()......");
         //在实例方法中不能定义静态变量
         //static int num3 = 300;//Modifier 'static' not allowed here
     }
 ​
     public void m2(){
         System.out.println("m2()......");
         //访问m1()
         m1();
         //访问静态变量和非静态变量
         System.out.println("num1="+num1);
         System.out.println("num2="+num2);
         //访问静态方法m3()
         m3();
     }
 ​
     //定义2个静态方法
     public static void m3(){
         System.out.println("static m3().......");
 ​
         //在静态方法中不能定义静态变量
         //static int num3 = 300;//Modifier 'static' not allowed here
     }
 ​
     //定义2个静态方法
     public static void m4(){
         // this.m1();//在静态方法内不能使用this关键字，因为this关键字表示某个具体对象，static修饰的方法是整个类所拥有的
         System.out.println("static m4().......");
         //访问非静态变量
         // System.out.println("num1="+num1);//静态方法中不能访问非静态变脸
         //访问静态变量
         System.out.println("num2="+num2);
 ​
         //访问非静态方法m1()
         //m1();//静态方法中不能访问非静态方法
         //访问静态方法m3()
         m3();
 ​
     }
 }

 package demo05;
 ​
 /**
  * @JdkVersion: 17
  * @Author: 二白程序员
  * @Date 2024/4/16 20:00
  * QQ：1512015112
  * VX：18056394367
  */
 ​
 ​
 public class StaticDemo04Test {
     public static void main(String[] args) {
 ​
         //创建StaticDemo04类对象
         StaticDemo04 staticDemo04 = new StaticDemo04();
         staticDemo04.m2();
 ​
         System.out.println("---------------------");
 ​
         staticDemo04.m4();
 ​
         System.out.println("---------------------");
 ​
         //m4()方法是静态方法，可以通过类名直接调用
         StaticDemo04.m4();
 ​
     }
 }

 ​

4）static变量

static变量也称为静态变量，静态变量和非静态变量的区别：

静态变量被所有对象共享，在内存中只有一个副本，在类初次加载的时候才会初始化

非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响 

package demo05;
 ​
 /**
  * @JdkVersion: 17
  * @Author: 二白程序员
  * @Date 2024/4/16 19:57
  * QQ：1512015112
  * VX：18056394367
  */
 ​
 ​
 public class StaticDemo02 {
     //定义一个使用static修饰的变量
     static int num1 = 100;
 ​
     //定义一个没有使用static修饰的变量
     int num2 = 200;
 ​
     //定义一个使用static修饰的方法staticM1()
     public static void staticM1(){
         //输出静态变量num1
         System.out.println("num1="+num1);
         //输出非静态变量num2
         //System.out.println("num2="+num2);//静态方法中不能直接操作非静态变量
     }
 ​
     //定义一个没有使用static修饰的方法m2()
     public void m2(){
         //输出静态变量num1
         System.out.println("num1="+num1);
         //输出非静态变量num2
         System.out.println("num2="+num2);
     }
 }

 package demo05;
 ​
 /**
  * @JdkVersion: 17
  * @Author: 二白程序员
  * @Date 2024/4/16 19:57
  * QQ：1512015112
  * VX：18056394367
  */
 ​
 ​
 public class StaticDemo02 {
     //定义一个使用static修饰的变量
     static int num1 = 100;
 ​
     //定义一个没有使用static修饰的变量
     int num2 = 200;
 ​
     //定义一个使用static修饰的方法staticM1()
     public static void staticM1(){
         //输出静态变量num1
         System.out.println("num1="+num1);
         //输出非静态变量num2
         //System.out.println("num2="+num2);//静态方法中不能直接操作非静态变量
     }
 ​
     //定义一个没有使用static修饰的方法m2()
     public void m2(){
         //输出静态变量num1
         System.out.println("num1="+num1);
         //输出非静态变量num2
         System.out.println("num2="+num2);
     }
 }

 ​

全局变量

package demo05;
 ​
 /**
  * @JdkVersion: 17
  * @Author: 二白程序员
  * @Date 2024/4/16 20:01
  * QQ：1512015112
  * VX：18056394367
  */
 ​
 ​
 public class StaticTest {
     static int num;//num=0 全局变量有默认值，int类型默认值为0
     public static void main(String[] args) {
         num++;//num=1
         StaticTest st1=new StaticTest();
         st1.num++;//num=2
         StaticTest st2=new StaticTest();
         st2.num++;//num=3
         StaticTest.num++;//num4=4
         System.out.println(num);//4
     }
 }

5）static块

构造方法用于对象的初始化。静态初始化块，用于类的初始化操作。

在静态初始化块中不能直接访问非static成员。

JVM加载类时，加载静态代码块

如果有多个静态块，按顺序加载

每个静态代码块只会被执行一次

static代码块可以用来设置相关配置信息，例如数据库的相关信息，还可以用来初始化数据

package demo05;
 ​
 /**
  * @JdkVersion: 17
  * @Author: 二白程序员
  * @Date 2024/4/16 19:55
  * QQ：1512015112
  * VX：18056394367
  */
 ​
 ​
 public class StaticDemo01 {
     public StaticDemo01() {
         System.out.println("无参构造方法被执行了......");
     }
 ​
     //定义Static代码块
     static {
         System.out.println("静态代码块1");
     }
 ​
     //定义方法
     public void m1(){
         System.out.println("m1()方法执行了.....");
     }
 ​
     static {
         System.out.println("静态代码块2");
     }
 ​
     static {
         System.out.println("静态代码块3");
     }
 ​
     static{
         int[] nums = {11,22,33,44,55};
     }
 }

package demo05;
 ​
 /**
  * @JdkVersion: 17
  * @Author: 二白程序员
  * @Date 2024/4/16 19:56
  * QQ：1512015112
  * VX：18056394367
  */
 ​
 ​
 public class StaticDemo01Test {
     public static void main(String[] args) {
 ​
         /*
          * JVM加载类时，加载静态代码块
          * 如果有多个静态块，按顺序加载
          * 每个静态代码块只会被执行一次
          * static代码块可以用来设置相关配置信息，例如数据库的相关信息，还可以用来初始化数据
          * */
         StaticDemo01 staticDemo01 = new StaticDemo01();
     }
 }

 ​

6）静态常量

如果类的所有实例（对象）都拥有一个相同值的常量，那么可以把这个常量定义为静态常量

 package demo05;
 ​
 /**
  * @JdkVersion: 17
  * @Author: 二白程序员
  * @Date 2024/4/16 19:59
  * QQ：1512015112
  * VX：18056394367
  */
 ​
 ​
 public class StaticDemo03 {
     //如果类的所有实例（对象）都拥有一个相同值的常量，那么可以把这个常量定义为静态常量
     static final  double PI = 3.1415;
     final static double PP = 3.14;
 }

 ​