六、java变量类型、修饰符、运算符

谁借莪１个温暖的怀抱￠ 2024-04-07 12:43 34阅读 0赞

## java变量类型 ##

**java变量类型有3种：**

1.  类变量：独立于方法之外的变量，用 `static`修饰。
2.  实例变量：独立于方法之外的变量，不过没有 static 修饰。
3.  局部变量：类的方法中的变量。

代码示例：

public class Variable{
        
        static int allClicks=0;    // 类变量
     
        String str="hello world";  // 实例变量
     
        public void method(){
        
     
            int i =0;  // 局部变量
     
        }
    }

### 局部变量 ###

*  局部变量声明在`方法、构造方法或者语句块`中；
 *  局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
 *  访问修饰符不能用于局部变量;
 *  局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

代码示例：

public class Test{
         
       public void pupAge(){
        
          int age = 0;
          age = age + 7;
          System.out.println("小狗的年龄是: " + age);
       }

如果局部变量没有初始化，则会报错：`variable number might not have been initialized`  
![在这里插入图片描述][32e331a80f0a4ce78ff8a6286f0b629e.png]

### 实例变量 ###

*  实例变量声明在一个类中，但在方法、构造方法和语句块之外；
 *  当一个对象被实例化之后，每个实例变量的值就跟着确定；
 *  实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
 *  访问修饰符可以修饰实例变量；
 *  实例变量对于类中的方法、构造方法或者语句块是可见的。`一般情况下应该把实例变量设为私有`。通过使用访问修饰符可以使实例变量对子类可见；
 *  实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；

代码示例：

public class Employee{
        
       // 这个实例变量对子类可见
       public String name;
       // 私有变量，仅在该类可见
       private double salary;
       //在构造器中对name赋值
       public Employee (String empName){
        
          name = empName;
       }
       //设定salary的值
       public void setSalary(double empSal){
        
          salary = empSal;
       }  
       // 打印信息
       public void printEmp(){
        
          System.out.println("名字 : " + name );
          System.out.println("薪水 : " + salary);
       }
     
       public static void main(String[] args){
        
          Employee empOne = new Employee("RUNOOB");
          empOne.setSalary(1000.0);
          empOne.printEmp();
       }
    }

### 类变量（静态变量） ###

*  类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。
 *  静态变量除了被声明为常量外很少使用，静态变量是指声明为 public/private，final 和 static 类型的变量。静态变量初始化后不可改变。
 *  静态变量在第一次被访问时创建，在程序结束时销毁。
 *  数值型变量默认值是 0，布尔型默认值是 false，引用类型默认值是 null。
 *  类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母。如果静态变量不是 public 和 final 类型，其命名方式与实例变量以及局部变量的命名方式一致。

代码示例：

public class Employee {
        
        //salary是静态的私有变量
        private static double salary;
        // DEPARTMENT是一个常量
        public static final String DEPARTMENT = "开发人员";
        public static void main(String[] args){
        
        salary = 10000;
            System.out.println(DEPARTMENT+"平均工资:"+salary);
        }
    }

### 成员变量、局部变量、静态变量的区别 ###

![在这里插入图片描述][9dd2ea4ed74c4cd4afecb3c9e36ce505.png]

## java修饰符 ##

**java修饰符主要分成两类：**

1.  访问修饰符
2.  非访问修饰符

修饰符用来定义类、方法或者变量，通常放在语句的最前端。

代码示例：

public class ClassName {
        
       // ...
    }
    private boolean myFlag;
    static final double weeks = 9.5;
    protected static final int BOXWIDTH = 42;
    public static void main(String[] arguments) {
        
       // 方法体
    }

### java修饰符访问权限 ###

*  public：公共的。对所有类可见。
 *  default（默认的，什么也不写）：同一个包下可见。
 *  protected：对同一个包以及外包子类可见。**注意：不能修饰类（外部类）**
 *  private：只对当前类可见。**注意：不能修饰类（外部类）**

### java extends继承与修饰符 ###

*  父类中声明为 public 的方法在子类中也必须为 public。
 *  父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
 *  父类中声明为 private 的方法，不能够被子类继承。

### 非访问修饰符 ###

1.  static 修饰符，用来修饰类方法和类变量。
2.  final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
3.  abstract 修饰符，用来创建抽象类和抽象方法。
4.  synchronized 和 volatile 修饰符，主要用于线程的编程。

#### static 修饰符 ####

1.  被static修饰的属于类，用`类.成员`调用

public class Test {
        
        static int num = 10;
    
        public static void main(String[] args) {
        
            int a = Test.num;
        }
    }

*  静态变量称为类变量，局部变量不能被static修饰。

#### final修饰符 ####

*  final修饰变量表示常量，不能被修改
 *  final修饰方法不能被重写
 *  final修饰类不能被继承

#### abstract 修饰符 ####

##### 抽象类 #####

*  抽象类不能创建对象，其目的是为了继承进行扩充。
 *  一个类不能同时被 abstract 和 final 修饰。
 *  如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
 *  抽象类可以包含抽象方法和非抽象方法。

代码示例：

abstract class Cat {
        
        private int age;
        public abstract void run();
    }

##### 抽象方法 #####

*  定义：被abstract修饰，没有方法体的方法。
 *  抽象方法不能被声明成 final 和 static。
 *  任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
 *  如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

代码示例：

abstract class Cat {
        
        private int age;
        public abstract void run();
    }
    
    public class shixian extends Cat {
        
        @Override
        public void run() {
        
    
        }
    }

#### synchronized 修饰符 ####

synchronized 关键字是一种同步锁，声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。

它修饰的对象有以下几种：

1.  修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号\{\}括起来的代码，作用的对象是调用这个代码块的对象；
2.  修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
3.  修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
4.  修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

#### transient 修饰符 ####

序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。

该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

public transient int limit = 55;   // 不会持久化
    public int b; // 持久化

#### volatile 修饰符 ####

volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

一个 volatile 对象引用可能是 null。

public class MyRunnable implements Runnable
    {
        
        private volatile boolean active;
        public void run()
        {
        
            active = true;
            while (active) // 第一行
            {
        
                // 代码
            }
        }
        public void stop()
        {
        
            active = false; // 第二行
        }
    }

## java运算符 ##

链接： [java运算符][java]

### 补充：instanceof 运算符 ###

String name = "James";
    boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

[32e331a80f0a4ce78ff8a6286f0b629e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/6c4e0e2264a74e47895202f98d7ffa3b.png
[9dd2ea4ed74c4cd4afecb3c9e36ce505.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/16cf5bb17c034a86b39b19fb0fe0d211.png
[java]: https://blog.csdn.net/m0_58680865/article/details/119489080