【学习笔记】Java 入门学习-Day4_序列化时会跳过哪个修饰符修饰的变量-CSDN博客

本文链接：https://blog.csdn.net/qirandi/article/details/119881327

Java 学习-Day4

标识符

定义

在编程中各种变量、常量、方法和类等命名时使用的字符串称为标识符

命名规则

标识符首字符必须是英文字母、$ 或 _
标识符除首字符外必须由英文字母、数字、$ 或 _ 组成
标识符不能包含空格
关键字和保留字不能作为标识符
标识符对大小写敏感，无长度限制

命名规范

命名使用英文单词组合进行命名
标识符命名的首要规则是达意，其次是简洁，善用英文缩写缩减较长的英文单词
包名——由多个单词组成时全用小写，如 com.richy.crm
类名、接口名——所有单词首字母大写，即大驼峰命名法，如 UserInfo
变量、方法名——除第一个单词小写外,其后单词首字母大写，即小驼峰命名法，如 userInfo
常量名——所有字母大写，单词之间用 _ 隔开

关键字

在 Java 语言中具有特殊含义，具备特定功能的字符串
所有的 Java 关键字都是小写英文字母组成

保留字

在现有的 Java 版本中没有使用到，但在未来的版本中可能用到作为关键字的字符串称为保留字

修饰符

Java 中提供了一系列修饰符给编程人员在定义类、方法、变量等地方时对其进行修饰

主要分为以下两类：

访问修饰符
非访问修饰符

访问控制修饰符

访问控制修饰符是对定义的类、方法、变量的访问权限进行限定，以实现保护

Java 中有四种不同的访问控制修饰符，对应四种访问权限：

default——默认权限，在同一包内可见，当不使用访问控制符时就默认访问权限为default
private——在同一类可见，仅用于修饰方法和变量
protected——对同一包内的类和所有子类可见，仅用于修饰方法和变量
public——对所有类可见

默认访问修饰符

使用默认访问修饰符修饰的变量和方法对同一包内的类都是可见的
接口中的变量在未作出修饰的情况下都隐式的声明为 public static final，而接口里的方法默认声明为 public

私有访问修饰符

private——私有访问修饰符，是最严格的访问权限级别，被声明为 private 的方法、构造方法和变量都只能对所属的类可见，且类和接口不能声明为 private
声明为 private 的变量只能通过类中公共的 get 方法被外部获取
合理利用 private 声明变量和方法能够保护和隐藏类中的数据和实现细节

实例：

public class Richy {
   private String assets;
   public String getAssets() {
      return this.assets;
   }
   public void setAssets(String assets) {
      this.assets = assets;
   }
}

受保护的访问修饰符

当子类和基类在同一包中时，被声明为 protected 的方法、变量对同一包内的任意类可见
当子类和基类不在同一包中时，子类的实例可以访问从基类继承来的 protected 方法，但不能访问基类实例的 protected 方法
protected 不能修饰外部类
接口及其数据成员和成员方法都不能声明为 protected
子类能访问 protected 修饰的方法和变量，同样能保护和隐藏类中的数据和实现细节

实例：

class Person {
   protected boolean setAssets(String assets) {
      //定义setAssets
   }
}
 
class Richy extends Person {
   protected boolean setAssets(String assets) {
      //重写setAssets
   }
}

公有访问修饰符

被声明为 public 的类、方法、接口、变量对任何类都可见
访问不同包中的 public 类时，需要导入相应的包
类的公有方法都能被其子类继承

实例：

public static void main(String[] arguments) {
   // ...
}

访问控制修饰符与继承

父类中的 public 类在子类中也必须声明为 public
父类中的 protected 类在子类中必须声明为 public 或 protected
父类中的 private 不能被子类继承

非访问修饰符

在 Java 中，还有一些修饰符不是用来控制访问权限的，例如：

static——用来修饰类方法和类变量，将其变为全局、静态的，被类的所有实例共享
final——用来修饰类、方法和变量，其修饰的类不能被继承、修饰的方法不能被重写、修饰的变量变为常量
abstract——用来修饰类和方法，使其变为抽象类和抽象方法
synchronize、volatile——用于线程编程
transient——用于跳过序列化

static 修饰符

static 修饰的变量称为静态变量，一个类的所有实例化对象都共用一个静态变量
static 修饰的方法称为静态方法，静态方法只能使用类的静态变量
类的实例化对象可以通过 className.variableName 的方式来访问该类的静态变量

实例：

public class InstanceCounter {
   private static int numInstances = 0;
   protected static int getCount() {
      return numInstances;
   }
 
   private static void addInstance() {
      numInstances++;
   }
 
   InstanceCounter() {
      InstanceCounter.addInstance();
   }
 
   public static void main(String[] arguments) {
      System.out.println("Starting with " +
      InstanceCounter.getCount() + " instances");
      for (int i = 0; i < 500; i++){
         new InstanceCounter();
      }
      System.out.println("Created " +
      InstanceCounter.getCount() + " instances");
   }
}

final 修饰符

final 修饰的变量在定义式就必须指定值，之后其值不会再改变
在定义类变量时常和 static 搭配使用
当设计的类功能已经完善，不需要子类且实现细节不能改变，就将其声明为 final
当设计的方法实现细节已经完善，且不需要扩展，为了防止其被修改，可以声明为 final，且能够提高该方法的执行效率

实例：

public class Demo {
    private String version = "1.0.0";
   	final int MAX = 128;
  	static final String AUTHOR = "Richy";
    public final Double PI = 3.14;
 
  	public final void getVersion(){
     	return version;
  	}
}

public final class Test{
    // ...
}

abstract 修饰符

被 abstract 修饰的类即抽象类，不能实例化对象，其作用是将来对其进行扩展
abstract 和 final 不能共用，否则会出现编译错误
抽象类中可以有抽象方法，也可以有非抽象的方法
继承抽象类的子类必须实现父类的所有抽象方法，或其也声明为抽象类
抽象方法不能声明为 final 或 static

实例：

abstract class User {
   	protected int id;
   	protected String name;
   	protected double balance;
    
    //抽象方法
   	public abstract void changeName(); 
   	public abstract void setBalance();
}

class UserControl extends User {
     void changeName(String name) {
         //实现方法
     }
    
    void setBalance(double balance) {
         //实现方法
     }
}

synchronize 修饰符

用 synchronize 声明的方法同一时间只能被一个线程访问
常用于实现线程同步、读写锁等

实例：

class User {
	public synchronized void setBalance(){
		// ...
	}
}

volatile 修饰符

用 volatile 声明的成员变量每次被线程访问时，都会强制的从共享内存中重新获取值，且成员变量的值发生改变时也会强制的将变化写入共享内存
通过 volatile 声明可以保证不同的线程总是能够实时访问到某个成员变量相同的值

实例：

public class Demo {
    private volatile double balance;
    public void setBalance(double newBalance) {
        balance = newBalance;
    }
    public void getBalance() {
        return balance;
    }
}

transient 修饰符

被 transient 修饰的实例变量在序列化对象时会被跳过
用于预处理类和变量的数据类型，在一定程度上可以节约空间

实例：

public class Demo {
	public transient String name = "Richy";   // 不会持久化
	public int age; // 持久化
}