修饰词（java）

Love The Way You Lie 2023-10-01 21:59 23阅读 0赞

今天我们来浅谈一下修饰词

<table style="width:500px;">  修饰词  
 <tbody> 
  <tr> 
   <td style="text-align:center;width:101px;">修饰词</td> 
   <td style="text-align:center;width:129px;">使用对象</td> 
   <td style="text-align:center;width:269px;">介绍</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:101px;">public</td> 
   <td style="text-align:center;width:129px;">类、接口、成员（自身类）</td> 
   <td style="text-align:center;width:269px;">无论它所在的包定义在哪，该类（接口、成员）都是可访问的</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:101px;">private</td> 
   <td style="text-align:center;width:129px;">成员（自身类）</td> 
   <td style="text-align:center;width:269px;">成员只可以在定义它的类中被访问</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:101px;">static</td> 
   <td style="text-align:center;width:129px;">类、方法、字段、初始函数</td> 
   <td style="text-align:center;width:269px;">成名为static的内部类是一个顶级类，它和包含的成员是不相关的。静态方法是类方法，是被指向到所属的类而不是类的实例。静态字段是类字段，无论该字段所在的类创建了多少实例，该字段只存在一个实例被指向到所属的类而不是类的实例。初始化函数是在装载类时执行的，而不是在创建实例时执行的。</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:101px;">final</td> 
   <td style="text-align:center;width:129px;">类、方法、字段、变量</td> 
   <td style="text-align:center;width:269px;">被定义成final的类不允许出现子类，不能被覆盖（不应用于动态查询），字段值不允许被修改。</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:101px;">abstract</td> 
   <td style="text-align:center;width:129px;">类、接口、方法</td> 
   <td style="text-align:center;width:269px;">类中包括没有实现的方法，不能被实例化。如果是一个abstract方法，则方法体为空，还方法的实现在子类中被定义，并且包含一个abstract方法的类必须是一个abstract类</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:101px;">protected</td> 
   <td style="text-align:center;width:129px;">成员（自身类）</td> 
   <td style="text-align:center;width:269px;">成员只能在定义它的包中被访问，如果在其他包中被访问，则实现这个方法的类必须是改该成员所属的子类。</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:101px;">native</td> 
   <td style="text-align:center;width:129px;">成员（自身类）</td> 
   <td style="text-align:center;width:269px;">与操作平台相关，定义时并不定义其方法，方法的实现被一个外部的库实现。</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:101px;">strictfp</td> 
   <td style="text-align:center;width:129px;">类、方法</td> 
   <td style="text-align:center;width:269px;">strictfp修饰的类中所有的方法都隐藏了strictfp修饰词，方法执行的所有浮点。</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:101px;">synchronized</td> 
   <td style="text-align:center;width:129px;">方法</td> 
   <td style="text-align:center;width:269px;">对于一个静态的方法，在执行之前jvm把它所在的类锁定；对于一个非静态的方法，执行前把某个特定对象实例锁定。</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:101px;">volatile</td> 
   <td style="text-align:center;width:129px;">字段</td> 
   <td style="text-align:center;width:269px;">因为异步线程可以访问字段，所以有些优化操作是一点不能作用在字段上的。</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:101px;">transient</td> 
   <td style="text-align:center;width:129px;">字段</td> 
   <td style="text-align:center;width:269px;">字段不是对象持久别的一部分，不应该把字段和对象放在一起。</td> 
  </tr> 
 </tbody> 
</table>

> 公共类型 public;
> 
> public 可以修饰类，成员变量。构造方法被public修饰的成员，可以在任何一个类是权限最大的一个修饰符。

> 私有类型 private;
> 
> 可以修饰成员变量，构造方法，成员方法，不能修饰类（此处指外部，不考虑内部类）。被private\\修饰的成员，只能在定义它们的类中使用，在其他类中不能调用 。

> 默认类型：default;
> 
> 可用于修饰类，成员变量，构造方法，方法，都能够使用默认权限，即不写任何的关键字。默认权限即同包权限，同包权限的元素只能定义它们的类中，以及同包的类中被调用。

> 保护类型protected;
> 
> 可以修饰数据成员，构造方法，方法成员，不能修饰类（此处指外部类，不考虑内部类）。
> 
> 被protected修饰的成员，能在定义它们的类中，同包的类中被调用。
> 
> 如果有不同包的类想调用它们，那么这个类必须是定义它们的子类。

我们可以用一个表格更加直观的看到它们的区别

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td style="text-align:center;width:128px;"></td> 
   <td style="text-align:center;width:76px;">public</td> 
   <td style="text-align:center;width:127px;">protected</td> 
   <td style="text-align:center;width:86px;">defult</td> 
   <td style="text-align:center;width:82px;">private</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:128px;">同类</td> 
   <td style="text-align:center;width:76px;">✔</td> 
   <td style="text-align:center;width:127px;">✔</td> 
   <td style="text-align:center;width:86px;">✔</td> 
   <td style="text-align:center;width:82px;">✔</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:128px;">同包</td> 
   <td style="text-align:center;width:76px;">✔</td> 
   <td style="text-align:center;width:127px;">✔</td> 
   <td style="text-align:center;width:86px;">✔</td> 
   <td style="text-align:center;width:82px;"></td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:128px;">不同包子类</td> 
   <td style="text-align:center;width:76px;">✔</td> 
   <td style="text-align:center;width:127px;">✔</td> 
   <td style="text-align:center;width:86px;"></td> 
   <td style="text-align:center;width:82px;"></td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:128px;">不同包的其他类</td> 
   <td style="text-align:center;width:76px;">✔</td> 
   <td style="text-align:center;width:127px;"></td> 
   <td style="text-align:center;width:86px;"></td> 
   <td style="text-align:center;width:82px;"></td> 
  </tr> 
 </tbody> 
</table>

关于权限修饰符还要有注意几个问题：

> 1.并不是每个修饰符都可以修饰类（指外部类），只有public和default可以。
> 
> 2.所有修饰符都可以修饰数据成员，方法成员，构造方法。
> 
> 3.为了代码安全起见，修饰符不要尽量使用权限大的，而是适用即可。比如，数据成员，如果没有特殊需要。
> 
> 4.修饰符修饰的是“被访问”的权限。

public class Demo2 {
        public int a;//定义一个公共类型的整型变量a
        protected int b;//定义一个保护类型的整型变量b
        int c;//定义一个默认类型的整型变量b=c
        private int d;//定义一个私有类型的整型变量d
        Demo2 demo2 = new Demo2();
        //在本类中4种修饰符都可以调用
        {
            System.out.println(demo2.a);
            System.out.println(demo2.b);
            System.out.println(demo2.c);
            System.out.println(demo2.d);
        }
    
        public void run()
        {
            System.out.println("跑步"); }
        protected void run1(){
            System.out.println("跑步"); }
        void run2(){
            System.out.println("跑步"); }
        private void run3(){
            System.out.println("跑步");
        }
        {
            demo2.run();
            demo2.run1();
            demo2.run3();
            demo2.run2();
        }
    
    }

//同包下不同类
    public class Demo3 {
        public static void main(String[] args) {
            Demo2 demo2=new Demo2();
            //私有类型不能被进行调用
            System.out.println(demo2.a);
            System.out.println(demo2.b);
            System.out.println(demo2.c);
            demo2.run1();
            demo2.run2();
            demo2.run();

package com.pratice.Cfx;//不同包的子类
    
    import com.pratice.day2.Demo2;
    //extends 子类继承父类，但并不是全部继承！
    public class Demo1 extends Demo2 {
        public static void main(String[] args) {
            Demo1 demo=new Demo1();
    //可以调用公共还有保护类型的变量
            System.out.println(demo.a);
            System.out.println(demo.b);
    
        }
    }

在修饰符中我们最常见的就是static（静态），今天我们总结一下它的用法吧

1.  随着类的加载而加载。
2.  优于对象而存在。
3.  修饰的成员被所有成员共享。
4.  可不创建对象，直接可被调用。

顾名思义， static(静态）随着类加载只能加载一次，分配空间也是只能分配一次，就好比是一个类是一个父亲，static是父亲所拥有的的财富，只有父亲出现的时候父亲所用的财富才会跟着出现，对象就好比是类的儿子，父亲的财富被儿子们共享，也可以单独给父亲使用，而不是某个儿子所私有的财产。这样说，大家应该别有一番领悟。

#### 注意：静态的只能调用静态变量，非静态的可以调用静态和非静态的变量。 ####

#### 代码块： ####

1.静态代码块

2.实际代码块

package com.pratice.day2;
    /*代码块：类似于一个没有名称的方法
    分为实例代码块（非静态），静态代码块
    实例代码块在每次创建对象时自动执行
    静态代码块在类第一次加载时自动执行
     */
    public class Dmk {
        int a=20;
        static int b=60;
        {
            System.out.println("实际代码块"+a);
        }
        {
            System.out.println("实际代码块"+b);
        }
        static{
            System.out.println("静态代码块"+b);
        }
        static{
            System.out.println("静态代码块"+b);
        }
    }

package com.pratice.day2;
    public class Dt {
        public static void main(String[] args) {
            System.out.println(Dmk.b);//执行静态代码块
            new Dmk();//先类后对象，类只加载一次
            new Dmk();
        }
    }

![80139547098c4c8b9fd730667c1cbc63.png][]

类加载时静态代码块按照从上自下的顺序依次加载，对象加载完之后，非静态代码块从上自下依次加载。

[80139547098c4c8b9fd730667c1cbc63.png]: https://img-blog.csdnimg.cn/80139547098c4c8b9fd730667c1cbc63.png