Java语言提供了很多修饰符,主要分为以下两类:

  • 访问修饰符
  • 非访问修饰符

    修饰符用来定义类、方法或者变量,通常放在语句的最前端。我们通过下面的例子来说明:

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中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限:

  • default (即缺省,什么也不写): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。

  • private : 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)

  • public : 对所有类可见。使用对象:类、接口、变量、方法

  • protected : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)

    我们通过以下表来说明访问权限:

修饰符 当前类 同一包内 子孙类 其他包 其他包子孙类
public Y Y Y Y Y
protected Y Y Y N Y/N(说明
default Y Y N N N
private Y N N N N

    使用默认访问修饰符声明的变量和方法,对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。如下例所示,变量和方法的声明可以不使用任何修饰符:

String version = "1.5.1";
boolean processOrder() {
   return true;
}

    私有访问修饰符是最严格的访问级别,所以被声明为 private 的方法、变量和构造方法只能被所属类访问,并且类和接口不能声明为 private。声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。下面的类使用了私有访问修饰符:

public class Logger {
   private String format;
   public String getFormat() {
      return this.format;
   }
   public void setFormat(String format) {
      this.format = format;
   }
}

    实例中,Logger
类中的 format 变量为私有变量,所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量,定义了两个 public
方法:getFormat() (返回 format的值)和 setFormat(String)(设置 format 的值)。

    被声明为
public 的类、方法、构造方法和接口能够被任何其他类访问。如果几个相互访问的 public 类分布在不同的包中,则需要导入相应
public 类所在的包。由于类的继承性,类所有的公有方法和变量都能被其子类继承。以下函数使用了公有访问控制:

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

    Java 程序的 main() 方法必须设置成公有的,否则,Java 解释器将不能运行该类。

    protected 需要从以下两个点来分析说明:

  • 子类与基类在同一包中:被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问;

  • 子类与基类不在同一包中:那么在子类中,子类实例可以访问其从基类继承而来的 protected 方法,而不能访问基类实例的protected方法。

    protected
访问修饰符不能修饰类和接口,方法和成员变量能够声明为 protected,但是接口的成员变量和成员方法不能声明为
protected。子类能访问 protected 修饰符声明的方法和变量,这样就能保护不相关的类使用这些方法和变量。下面的父类使用了
protected 访问修饰符,子类重写了父类的 openSpeaker() 方法:

class AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // 实现细节
   }
}
 
class StreamingAudioPlayer extends AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // 实现细节
   }
}

    如果把
openSpeaker() 方法声明为 private,那么除了 AudioPlayer 之外的类将不能访问该方法。如果把
openSpeaker() 声明为 public,那么所有的类都能够访问该方法。如果我们只想让该方法对其所在类的子类可见,则将该方法声明为
protected。protected 是最难理解的一种 Java 类成员访问权限修饰词,更多详细内容请查看 Java protected 关键字详解。这里在下就不赘述了。

    在访问控制和继承的时候,请注意以下方法继承的规则:

  • 父类中声明为 public 的方法在子类中也必须为 public。

  • 父类中声明为 protected 的方法在子类中要么声明为 protected,要么声明为 public,不能声明为 private。

  • 父类中声明为 private 的方法,不能够被继承。

   
同时呢,为了实现一些其他的功能,Java 也提供了许多非访问修饰符。static 修饰符,用来修饰类方法和类变量。final
修饰符,用来修饰类、方法和变量,final
修饰的类不能够被继承,修饰的方法不能被继承类重新定义,修饰的变量为常量,是不可修改的。abstract
修饰符,用来创建抽象类和抽象方法。synchronized 和 volatile
修饰符,主要用于线程的编程。知道了这些,我们就来看看这些具体是什么鬼。

    首先来看static:

  • 静态变量:

    static 关键字用来声明独立于对象的静态变量,无论一个类实例化多少对象,它的静态变量只有一份拷贝。静态变量也被称为类变量。局部变量不能被声明为 static 变量。

  • 静态方法:

    static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据,然后计算这些数据。

    对类变量和方法的访问可以直接使用 classname.variablenameclassname.methodname 的方式访问。如下例所示,static修饰符用来创建类方法和类变量:

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");
   }
}

    运行结果如下:

Starting with 0 instances
Created 500 instances

    再来看final修饰符。首先是final变量,final 变量能被显式地初始化并且只能初始化一次。被声明为 final 的对象的引用不能指向不同的对象。但是 final 对象里的数据可以被改变。也就是说 final 对象的引用不能改变,但是里面的值可以改变。final 修饰符通常和 static 修饰符一起使用来创建类常量。

public class Test{
  final int value = 10;
  // 下面是声明常量的实例
  public static final int BOXWIDTH = 6;
  static final String TITLE = "Manager";
 
  public void changeValue(){
     value = 12; //将输出一个错误
  }
}

    再来看final方法,类中的 final 方法可以被子类继承,但是不能被子类修改。声明 final 方法的主要目的是防止该方法的内容被修改。如下所示,使用 final 修饰符声明方法:

public class Test{
    public final void changeName(){
       // 方法体
    }
}

    然后就要看final类了。final 类不能被继承,没有类能够继承 final 类的任何特性。

public final class Test {
   // 类体
}

final完事了之后,我们来看abstract修饰符,首先来看抽象类。抽象类不能用来实例化对象,声明抽象类的唯一目的是为了将来对该类进行扩充。一个类不能同时被
abstract 和 final
修饰。如果一个类包含抽象方法,那么该类一定要声明为抽象类,否则将出现编译错误。抽象类可以包含抽象方法和非抽象方法:

abstract class Caravan{
   private double price;
   private String model;
   private String year;
   public abstract void goFast(); //抽象方法
   public abstract void changeColor();
}

   
然后来看抽象方法。抽象方法是一种没有任何实现的方法,该方法的的具体实现由子类提供。抽象方法不能被声明成 final 和
static。任何继承抽象类的子类必须实现父类的所有抽象方法,除非该子类也是抽象类。如果一个类包含若干个抽象方法,那么该类必须声明为抽象类。抽象类可以不包含抽象方法。抽象方法的声明以分号结尾,例如:public abstract sample();

public abstract class SuperClass{
    abstract void m(); //抽象方法
}
 
class SubClass extends SuperClass{
     //实现抽象方法
      void m(){
          .........
      }
}

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

public synchronized void showDetails(){
.......
}

    序列化的对象包含被 transient 修饰的实例变量时,java 虚拟机(JVM)跳过该特定的变量。该修饰符包含在定义变量的语句中,用来预处理类和变量的数据类型:

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

public int b; // 持久化   

    volatile

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

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

    通常情况下,在一个线程调用 run() 方法(在 Runnable 开启的线程),在另一个线程调用 stop() 方法。如果 第一行 中缓冲区的 active 值被使用,那么在 第二行 的 active 值为 false 时循环不会停止。但是以上代码中我们使用了 volatile 修饰 active,所以该循环会停止。

    JAVA 的类(外部类)有 2 种访问权限: public、default。而方法和变量有 4 种:public、default、protected、private。其中默认访问权限和 protected 很相似,有着细微的差别。

  • public 意味着任何地方的其他类都能访问。
  • default 则是同一个包的类可以访问。
  • protected 表示同一个包的类可以访问,其他的包的该类的子类也可以访问。
  • private 表示只有自己类能访问。

    修饰符:abstract、static、final

  • abstract: 表示是抽象类。 使用对象:类、接口、方法
  • static: 可以当做普通类使用,而不用先实例化一个外部类。(用他修饰后,就成了静态内部类了)。 使用对象:类、变量、方法、初始化函数(注意:修饰类时只能修饰 内部类 )
  • final: 表示类不可以被继承。 使用对象:类、变量、方法

    整个世界都打包成一块,同时划分为四个层次:

联合国(public)【其他包】、国家(protected)【继承子孙】、洲际(default)【同一包】、个人(private)【当前类】。联合国制定规则所有人都可以用,国家制定的只有在国家内可以用,各联邦洲因地制宜有制定当地民法,个人制定的就给个人使用。

    static全局变量与普通的全局变量:static全局变量只初使化一次,防止在其他文件单元中被引用。static局部变量和普通局部变量:static局部变量只被初始化一次,下一次依据上一次结果值。static函数与普通函数:static函数在内存中只有一份,普通函数在每个被调用中维持一份拷贝。

    静态变量并不是说其就不能改变值,不能改变值的量叫常量。 其拥有的值是可变的 ,而且它会保持最新的值。说其静态,是因为它不会随着函数的调用和退出而发生变化。即上次调用函数的时候,如果我们给静态变量赋予某个值的话,下次函数调用时,这个值保持不变。

关于修饰符,我们可以有如下理解:1.分为“访问修饰符”和“非访问修饰符”。顾名思义,“访问修饰符”就是和访问权限有关得修饰符。2.访问修饰符中一些值得注意得地方:Private
访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据,被声明为 public
的类、方法、构造方法和接口能够被任何其他类访问,protected 访问修饰符不能修饰类和接口,方法和成员变量能够声明为
protected,但是接口的成员变量和成员方法不能声明为
protected。3.关于static修饰符的理解,那么我们怎么理解静态变量呢?简单来说静态变量就是一个类的公有属性。在这里可以打个拙劣的比方:假设“班里的学生”是一个类,班里的任何一个同学都相当于一个对象。那么所有学生的学费是一样的对吧?”学费“就相当于一个”静态变量“,其特征是它不属于任何一个”对象“(即学生)的专有属性,是大家”公有“的,若是变了,那就所有的同学的学费都会变。我们假设每个同学都有修改学费的权力,那么任何一个同学修改了学费(这个静态变量),所有同学的学费就都会变。另外:静态方法只能使用类的静态变量。

    当对象被序列化时(写入字节序列到目标文件)时,transient阻止实例中那些用此关键字声明的变量持久化;当对象被反序列化时(从源文件读取字节序列进行重构),这样的实例变量值不会被持久化和恢复:

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable; //定义一个需要序列化的类 class People implements Serializable{
String name; //姓名
transient Integer age; //年龄
public People(String name,int age){
this.name = name;
this.age = age;
} public String toString(){
return "姓名 = "+name+" ,年龄 = "+age;
} } public class TransientPeople {
public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
People a = new People("李雷",30);
System.out.println(a); //打印对象的值
ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("d://people.txt"));
os.writeObject(a);//写入文件(序列化)
os.close();
ObjectInputStream is = new ObjectInputStream(new FileInputStream("d://people.txt"));
a = (People)is.readObject();//将文件数据转换为对象(反序列化)
System.out.println(a); // 年龄 数据未定义
is.close();
}
}

    运行结果如下:

姓名 = 李雷 ,年龄 = 30
姓名 = 李雷 ,年龄 = null

    volatile可以用在任何变量前面,但不能用于final变量前面,因为final型的变量是禁止修改的。使用的场景之一,单例模式中采用DCL双锁检测(double checked locking)机制,在多线程访问的情况下,可使用volatitle修改,保证多线程下的可见性。缺点是性能有损失,因此单线程情况下不必用此修饰符。

class Singleton{
private volatile static Singleton instance = null;
private Singleton() {
} public static Singleton getInstance() {
if(instance==null) {
synchronized (Singleton.class) {
if(instance==null)
instance = new Singleton();
}
}
return instance;
}
}

    关于final变量,我们得知道如下:

  • 1、 final 修饰符通常和 static 修饰符一起使用来创建类常量。用final修饰的成员变量表示常量,值一旦给定就无法改变!
  • 2、 final修饰的变量有三种:静态变量、实例变量和局部变量,分别表示三种类型的常量。final变量定义的时候,可以先声明,而不给初值,这中变量也称为final空白,无论什么情况,编译器都确保空白final在使用之前必须被初始化。但是,final空白在final关键字final的使用上提供了更大的灵活性,为此,一个类中的final数据成员就可以实现依对象而有所不同,却有保持其恒定不变的特征。

    最后就来看下final以及final static修饰的变量的初始化方式:

    //-----------------成员变量------------------//
//初始化方式一,在定义变量时直接赋值
private final int i = 3; //初始化方式二,声明完变量后在构造方法中为其赋值
//如果采用用这种方式,那么每个构造方法中都要有j赋值的语句
private final int j; public FinalTest() {
j = 3;
} //如果取消该构造方法的注释,程序就会报错,因此它没有为j赋值
/*public FinalTest1(String str) { }*/ //为了方便我们可以这样写
public FinalTest(String str) {
this(); //调用无参构造器
} //下面的代码同样会报错,因为对j重复赋值
/*public FinalTest1(String str1, String str2) {
this();
j = 3;
}*/ //初始化方式三,声明完变量后在构造代码块中为其赋值
//如果采用此方式,就不能在构造方法中再次为其赋值
//构造代码块中的代码会在构造函数之前执行,如果在构造函数中再次赋值,
//就会造成final变量的重复赋值
private final int k; {
k = 4;
} //-----------------类变量(静态变量)------------------//
//初始化方式一,在定义类变量时直接赋值
public final static int p = 3; //初始化方式二,在静态代码块中赋值
//成员变量可以在构造函数中赋值,但是类变量却不可以。
//因此成员变量属于对象独有,每个对象创建时只会调用一次构造函数,
//因此可以保证该成员变量只被初始化一次;
//而类变量是该类的所有对象共有,每个对象创建时都会对该变量赋值
//这样就会造成变量的重复赋值。
public final static int q; static {
q = 3;
}

好啦,这次的分享到这里就结束了。如果感觉不错的话,请多多点赞支持哦。。。

  原文链接: https://blog.csdn.net/luyaran/article/details/80107890

java入门---修饰符&访问修饰符&非访问修饰符的更多相关文章

  1. java中方法的控制修饰符也分为:可访问控制符和非访问控制符两类。

    3 .方法的控制修饰符也分为:可访问控制符和非访问控制符两类. 可访问控制符有 4 种:公共访问控制符: public :私有访问控制符: private :保护访问控制符: protected :私 ...

  2. AJPFX关于java中可访问控制符和非访问控制符的详细总结

    1.类的修饰符分为:可访问控制符和非访问控制符两种. 可访问控制符是:公共类修饰符 public 非访问控制符有:抽象类修饰符 abstract :最终类修饰符 final 1 )公共类修饰符 pub ...

  3. Java 非访问修饰符

    除了访问性修饰符,我们还有非访问性修饰符.这里主要说明static与final修饰符,其他修饰符以后用到再说. 一.static修饰符 static修饰符是用来修饰方法与变量. 1.创建StaticT ...

  4. Java学习笔记(4)--- 变量类型,修饰符

    1.变量类型: a.定义: 和C++差不多,就是: type identifier [ = value][, identifier [= value] ...]: type为Java数据类型.iden ...

  5. Java入门系列之访问修饰符作用范围

    前言 之前以为Java和C#中访问修饰符差不多一样,后面才了解到还是有些差异,本节只讲解学习Java中访问修饰符一些需要注意的地方或者从概念上不太好理解我们会通过实际例子来说明,若有错误之处,还请批评 ...

  6. Java中的四种权限修饰符及六种非访问修饰符(简识)

    一.是哪四种访问权限修饰符呢? public > protected > [default] > private (公共的 ) (受保护的) (默认的) (私有的) 二.简单认识四种 ...

  7. static 静态域 类域 静态方法 工厂方法 he use of the static keyword to create fields and methods that belong to the class, rather than to an instance of the class 非访问修饰符

    总结: 1.无论一个类实例化多少对象,它的静态变量只有一份拷贝: 静态域属于类,而非由类构造的实例化的对象,所有类的实例对象共享静态域. class Employee { private static ...

  8. Java入门 - 语言基础 - 07.修饰符

    原文地址:http://www.work100.net/training/java-modifier-type.html 更多教程:光束云 - 免费课程 修饰符 序号 文内章节 视频 1 概述 2 访 ...

  9. 2020重新出发,JAVA入门,标识符&修饰符

    标识符(Identifier ) 标识符是程序员用来命名变量,方法,类或标签的单词,其实就是我们在开发过程中凡是自己可以命名的一些单词就是标识符 标识符命名规则 标识符由字母(a-z,A-Z),数字( ...

随机推荐

  1. Using shared access signatures (SAS) From Microsoft

    A shared access signature (SAS) provides you with a way to grant limited access to objects in your s ...

  2. windows server 2008/2012安装PostgreSQL过程及问题总结

    今天第一次接触在Windows Server2008/2012 下安装PostgreSQL,遇到的问题总结如下: 1.首先,在安装的时候,我更改安装目录改为自定义的E盘,安装时报错:libintl.d ...

  3. ZOJ-3279 Ants 树状数组 + 二分

    题目链接: https://cn.vjudge.net/problem/ZOJ-3279 题目大意: 有1到n 那个level 每一个level有a[i]只蚂蚁两种操作 p a b 把第a个level ...

  4. 学习python第一天总纲

    1).python基础语法:4周课程(结束阶段考试) 2).前端知识点:html.css.javascript(js).jQuery 3).Linux(系统).数据库(关系型&非关系型) 4) ...

  5. Autorelease 性能测试

    __weak NSString *string_weak_ = nil; - (void)viewDidLoad { [super viewDidLoad]; // 场景 1 NSString *st ...

  6. Web项目打成war包部署到tomcat时报MySQL Access denied for user 'root'@'localhost' (using password: YES)错误解决方案

    Web项目使用使用root账号root密码进行部署,通过Eclipse加载到Tomcat服务器可以发布成功,打成war包放到tomcat的webapps目录无法发布成功,报错: jdbc.proper ...

  7. MyBatis(2)-全局配置文件

    本文的代码是在MyBatis(1)-简单入门基础之上进行学习的,如有不懂请先看此博文MyBatis(1)-简单入门! 1)配置文件的安装 --->在联网的情况下,点击去下载http://myba ...

  8. 【问题】 百度地图marker不在中心点处

    问题: var map = new BMap.Map("mapshow"); map.centerAndZoom(point, 15); 显示百度地图时,map.centerAnd ...

  9. Linux文件目录命令

    Linux文件目录命令 pwd,查看当前工作目录的完整路径 pwd:/root ls,用来打印当前目录的清单,可以指定其他目录 -a:列出目录下所有的文件,包括以"."开头的隐藏文 ...

  10. [AHOI2001]多项式乘法

    \([Link](https://www.luogu.org/problemnew/show/P2553)\) \(\color{red}{\mathcal{Description}}\) 给出两个多 ...