修饰符

java中的修饰符分为类修饰符，字段修饰符，方法修饰符 java字段修饰符

java中的修饰符分为类修饰符，字段修饰符，方法修饰符。根据功能的不同，主要分为以下几种。1、权限访问修饰符public,protected,default,private,这四种级别的修饰符都可以用来修饰类、方法和字段。包外子类包内类内...


 java中的修饰符分为类修饰符，字段修饰符，方法修饰符。根据功能的不同，主要分为以下几种。 1、权限访问修饰符 public,protected,default,private,这四种级别的修饰符都可以用来修饰类、方法和字段。 包外 子类 包内 类内 public yes yes yes yes protected no yes yes yes default no no yes yes private no no no yes 2、final修饰符 final的意思是不可变，他可以修饰类、字段、方法。修饰类后类不能被扩展(extends)，也就是不能被继承。修饰字段后字段的值不能被改变，因此如果有final修饰字段，应该对字段进行手动初始化。修饰方法后该方法不能被改变，也就是重写。 3、abstract修饰符 abstract是抽象的意思，用来修饰类和方法，修饰类后，该类为抽象类，不能被实例化，必需进行扩展。修饰方法后，该方法为抽象方法必须被子类重写(override)。
 4、static修饰符 static用来修饰内部类，方法，字段。修饰内部类说明该内部类属于外部类而不属于外部类的某个实例。修饰字段说明该字段属于类而不属于类实例。修饰方法说明该方法属于类而不属于类实例。
 类修饰符
 Public
 可以从其他类中访问
 obstract
 本类不能被实例化
 final
 不能再声明子类
 构造器修饰符
 Public
 可以从所有的类中访问
 Protected
 只能从自己的类和它的子类中访问
 Private
 只能在本类中访问
 域修饰符
 Public
 可以从所有的类中访问
 Protected
 只能从本类和它的子类中访问
 Private
 只能从本类中访问它
 Static
 对该类的所有实例只能有一个域值存在
 transient
 不是一个对象持久状态的一部份
 Volatile
 可以被异步的线程所修改
 final
 必须对它赋予初值并且不能修改它
 局部变量修饰符
 final
 必须对它赋予初值并且不能修改它
 方法修饰符
 Public
 可以从所有的类中访问它
 Protected
 只能从本类及其子类中访问它
 Private
 只能从本类中访问它
 abstract
 没有方法体，属于一个抽象类
 final
 子类不能覆盖它
 static
 被绑定于类本身而不是类的实例
 native
 该方法由其他编程语言实现
 asnchronized
 在一个线程调用它之前必须先给它加
 、、、、、、、、、、、、、、、、
 关于Java中各种修饰符与访问修饰符的说明
 类：
 访问修饰符修饰符class类名称extends父类名称 implement接口名称
 (访问修饰符与修饰符的位置可以互换)
 访问修饰符
 名称
 说明
 备注
 public
 可以被所有类访问(使用)
 public类必须定义在和类名相同的同名文件中
 package
 可以被同一个包中的类访问(使用)
 默认的访问权限，可以省略此关键字，可以定义在和public类的同一个文件中
 private
 修饰内部类
 修饰符
 名称
 说明
 备注
 final
 使用此修饰符的类不能够被继承
 abstract
 如果要使用abstract类，之前必须首先建一个继承abstract类的新类，新类中实现abstract类中的抽象方法。
 类只要有一个abstract方法，类就必须定义为abstract，但abstract类不一定非要保护abstract方法不可
 变量
 l Java中没有全局变量，只有方法变量、实例变量(类中的非静态变量)、类变量(类中的静态变量)。
 l 方法中的变量不能够有访问修饰符。所以下面访问修饰符表仅针对于在类中定义的变量。
 l 声明实例变量时，如果没有赋初值，将被初始化为null(引用类型)或者0、false(原始类型)。
 l 可以通过实例变量初始化器来初始化较复杂的实例变量，实例变量初始化器是一个用{}包含的语句块，在类的构造器被调用时运行，运行于父类构造器之后，构造器之前。
 l 类变量(静态变量)也可以通过类变量初始化器来进行初始化，类变量初始化器是一个用static{}包含的语句块，只可能被初始化一次。
 访问修饰符
 名称
 说明
 备注
 public
 可以被任何类访问
 protected
 可以被同一包中的所有类访问
 可以被所有子类访问
 子类没有在同一包中也可以访问
 private
 只能够被当前类的方法访问
 缺省
 无访问修饰符
 可以被同一包中的所有类访问
 如果子类没有在同一个包中，也不能访问
 修饰符
 名称
 说明
 备注
 static
 静态变量(又称为类变量，其它的称为实例变量)
 可以被类的所有实例共享。
 并不需要创建类的实例就可以访问静态变量
 final
 常量，值只能够分配一次，不能更改
 注意不要使用const，虽然它和C、C++中的const关键字含义一样
 可以同static一起使用，避免对类的每个实例维护一个拷贝
 transient
 告诉编译器，在类对象序列化的时候，此变量不需要持久保存
 主要是因为改变量可以通过其它变量来得到，使用它是为了性能的问题
 volatile
 指出可能有多个线程修改此变量，要求编译器优化以保证对此变量的修改能够被正确的处理
 方法
 访问修饰符修饰符返回类型方法名称(参数列表)throws违例列表
 l 类的构造器方法不能够有修饰符、返回类型和throws子句
 l 类的构造器方法被调用时，它首先调用父类的构造器方法，然后运行实例变量和静态变量的初始化器，然后才运行构造器本身。
 l 如果构造器方法没有显示的调用一个父类的构造器，那么编译器会自动为它加上一个默认的super()，而如果父类又没有默认的无参数构造器，编译器就会报错。super必须是构造器方法的第一个子句。
 l 注意理解private构造器方法的使用技巧。
 访问修饰符
 名称
 说明
 备注
 public
 可以从所有类访问
 protected
 可以被同一包中的所有类访问
 可以被所有子类访问
 子类没有在同一包中也可以访问
 private
 只能够被当前类的方法访问
 缺省
 无访问修饰符
 可以被同一包中的所有类访问
 如果子类没有在同一个包中，也不能访问
 修饰符
 名称
 说明
 备注
 static
 静态方法(又称为类方法，其它的称为实例方法)
 提供不依赖于类实例的服务
 并不需要创建类的实例就可以访问静态方法
 final
 防止任何子类重载该方法
 注意不要使用const，虽然它和C、C++中的const关键字含义一样
 可以同static一起使用，避免对类的每个实例维护一个拷贝
 abstract
 抽象方法，类中已声明而没有实现的方法
 不能将static方法、final方法或者类的构造器方法声明为abstract
 native
 用该修饰符定义的方法在类中没有实现，而大多数情况下该方法的实现是用C、C++编写的。
 参见Sun的Java
 Native接口(JNI)，JNI提供了运行时加载一个native方法的实现，并将其于一个Java类关联的功能
 synchronized
 多线程的支持
 当一个方法被调用时，没有其它线程能够调用该方法，其它的synchronized方法也不能调用该方法，直到该方法返回
 接口
 访问修饰符interface接口名称extends接口列表
 l 接口不能够定义其声明的方法的任何实现
 l 接口中的变量总是需要定义为“public
 static
 final 接口名称”，但可以不包含这些修饰符，编译器默认就是这样，显示的包含修饰符主要是为了程序清晰
 访问修饰符
 名称
 说明
 备注
 public
 所有
 无访问修饰符(默认)
 同一个包内

收起

展开全文

weixin_36340890 2021-02-28 07:35:23

vue 事件修饰符 & 按键修饰符 vue.js 前端 javascript 修饰符

事件修饰符 在事件处理程序中调用event.preventDefault()或event.stopPropagation()是非常常见的需求。 .stop 阻止单击事件传播即阻止了事件冒泡，相当于调用了event.stopPropagation方法（通俗讲就是阻止事件...

事件修饰符

在事件处理程序中调用 event.preventDefault() 或 event.stopPropagation() 是非常常见的需求。

.stop

阻止单击事件传播即阻止了事件冒泡，相当于调用了event.stopPropagation方法（通俗讲就是阻止事件向上级DOM元素传递）

<div @click="show(1)">
  <div @click="show(2)">测试</div>
</div>

点击“测试”输出

<div @click="show(1)">
  <div @click.stop="show(2)">测试</div>
</div>

点击“测试”输出

.prevent

阻止了事件默认行为，相当于调用了event.preventDefault方法

默认事件指对DOM的操作会引起自动执行的动作，比如点击超链接的时候会进行页面的跳转，点击表单提交按钮时会重新加载页面等，使用".prevent"修饰符可以阻止这些事件的发生。

<!-- 提交事件不再重载页面 -->
<form v-on:submit.prevent="onSubmit"></form>

<!-- 修饰符可以串联 -->
<a v-on:click.stop.prevent="doThat"></a>

.capture

捕获冒泡，即有冒泡发生时，有该修饰符的dom元素会先执行，如果有多个，从外到内依次执行，然后再按自然顺序执行触发的事件。(让事件触发从包含这个元素的顶层开发往下依次触发)

<!-- 添加事件监听器时使用事件捕获模式 -->
<!-- 即内部元素触发的事件先在此处理，然后才交由内部元素进行处理 -->
<div v-on:click.capture="doThis">...</div>

.once

2.1.4新增

设置事件只能触发一次，比如按钮的点击等。

<!-- 点击事件将只会触发一次 -->
<a v-on:click.once="doThis"></a>

.self

注意:使用修饰符时，顺序很重要；相应的代码会以同样的顺序产生。因此，用 v-on:click.prevent.self 会阻止所有的点击，而 v-on:click.self.prevent 只会阻止对元素自身的点击。

<!-- 只当在 event.target 是当前元素自身时触发处理函数 -->
<!-- 即事件不是从内部元素触发的 -->
<div @click.self="doThat">...</div>

.passive

2.3.0新增

该修饰符大概意思用于对DOM的默认事件进行性能优化，根据官网的例子比如超出最大范围的滚动条滚动的。

以移动端监听元素滚动事件说明，在监听元素滚动事件的时候，会一直触发onscroll事件让页面变的越来越卡，因此在我们使用这个修饰符后，相当于给onscroll事件增加了.lazy修饰符

<!-- 滚动事件的默认行为 (即滚动行为) 将会立即触发 -->
<!-- 而不会等待 `onScroll` 完成  -->
<!-- 这其中包含 `event.preventDefault()` 的情况 -->
<div v-on:scroll.passive="onScroll">...</div>

不要把 .passive 和 .prevent 一起使用，因为 .prevent 将会被忽略，同时浏览器可能会向你展示一个警告。请记住，.passive 会告诉浏览器你不想阻止事件的默认行为。

.native

在父组件中给子组件绑定一个原生的事件，就将子组件变成了普通的HTML标签，不加'. native'事件是无法触发的。

让组件变成像html内置标签那样监听根元素的原生事件，否则组件上使用v-on只会监听自定义事件

按键修饰符

在监听键盘事件时，我们经常需要检查详细的按键。Vue 允许为 v-on 在监听键盘事件时添加按键修饰符

键盘修饰符用来修饰键盘的事件（如：onkeyup、onkeydown等），键盘的事件触发需要相对应的keyCode。然而keyCode存在很多，因此为了使用方便Vue给我们提供了别名的修饰符，分为以下两种：

普通按键（enter、delete、space、tab、esc…）

系统修饰键（ctrl、shift、alt…）

也可以直接用按键的代码来做修饰符（如：enter为13）

<!-- 只有在 `key` 是 `Enter` 时调用 `vm.submit()` -->
<!-- 键修饰符，键别名 -->
<input @keyup.enter="submit">
<!-- 键修饰符，键代码 -->
<input @keyup.13="onEnter">

为了在必要的情况下支持旧浏览器，Vue 提供了绝大多数常用的按键码的别名：

.enter
.tab
.delete (捕获“删除”和“退格”键)
.esc
.space
.up
.down
.left
.right

同样vue监听按键事件也可以添加其他的按键：只要加上相应的按键的名称就行了

例如：@keyup.tab="";@keyup.delet = "";

里面写按键触发执行的事件就可以了。

参考来源:Vue常用的修饰符及使用的场景_Arvin-wm的博客-CSDN博客_vue常用的修饰符及作用

收起

展开全文

yuan_jlj 2021-12-02 13:46:14

C# 访问修饰符和声明修饰符 c# 后端

一、访问修饰符的基本说明 1.public: 公有的，是类和类成员的访问修饰符，访问不受限制 2.private: 私有的，是一个成员访问修饰符，不能修饰类，只有在声明它的类和结构内部可以访问 3.internal: 内部的，是类和类...

一、访问修饰符的基本说明 
1.public: 公有的，是类和类成员的访问修饰符，访问不受限制 
2.private: 私有的，是一个成员访问修饰符，不能修饰类，只有在声明它的类和结构内部可以访问 
3.internal: 内部的，是类和类成员的访问修饰符，同一个程序集中的所有类都可以访问，可访问性低于public 
4.protected: 受保护的，是一个成员访问修饰符，只能在它的类和派生类中访问 
5.protected internal: 访问限于当前程序集或派生类 
6.private protected: 访问限于当前程序集中该类的派生类或该类内部 
private、protected、protected internal或private protected不能修饰类 
什么是程序集呢？ 
简而言之，一个程序集就是一个项目，一个命名空间，一个dll文件 
注意点: 
如果在成员声明中未指定访问修饰符，则使用默认的访问修饰符 
类/枚举/接口/结构体默认访问修饰符是internal，仅限该程序集内部访问 
默认的成员可访问性 该成员允许声明的可访问性
class private  public
 protected
 internal
 private
 protected internal
struct private public
 internal
 private
interface public 无
enum public 无 
Example: 
namespace TestModifier
{
    public class Class1
    {
        //访问不受限制
        public string namePublic = null;
        //当前程序集
        internal string nameInternal = null;
        //只能在类内部访问
        private string namePrivate = null;
        //只能在该类及其派生类内部使用
        protected string nameProtected = null;
        //当前程序集及派生类
        protected internal string nameProtectedInternal = null;
        //C# 7.2 该类及其派生类内部使用
        private protected string namePrivateProtected = null;
    }

    class Class2 : Class1
    {
        private string name1;
        private string name2;
        private string name3;
        private string name4;
        private string name5;
        public void Method1()
        {
            name1 = new Class1().namePublic;
            name2 = new Class1().nameInternal;
            name3 = new Class1().nameProtectedInternal;
            //派生类
            name4 = base.nameProtected;
            //派生类
            name5 = base.namePrivateProtected;
        }
    }
}
 
二、声明修饰符 
1.partical: 在整个同一程序集中定义分部类和分部方法。在处理大型项目或自动生成的代码（如 Windows 窗体设计器提供的代码）时，在多个文件间拆分类、结构或接口类型可能会非常有用。分部类型可以包含分部方法。 
分部类: 
 处理大型项目时，使一个类分布于多个独立文件中可以让多位程序员同时对该类进行处理
 
 当使用自动生成的源文件时，你可以添加代码而不需要重新创建源文件。 Visual Studio 在创建Windows 窗
 体、Web 服务包装器代码等时会使用这种方法。 你可以创建使用这些类的代码，这样就不需要修改由
 Visual Studio生成的文件
 
 若要拆分类定义，请使用 partial 关键字修饰符
  
class Program
{
    /// <summary>
    /// 声明修饰符
    /// partical: 分部类和分部方法
    /// </summary>
    /// <param name="args"></param>
    static void Main(string[] args)
    {
        A a = new A();
        a.GetParticalMethod("xiaomi");
    }

    /// <summary>
    /// 分部方法:
    /// 分部类型各部分中的签名必须匹配
    /// 方法必须返回void
    /// 不允许使用访问修饰符.分部方法是隐式专用的，仅限内部使用
    /// </summary>
    partial class A
    {
        //定义分部方法
        partial void MethodA(string s);

        /// <summary>
        /// 运行分部方法
        /// </summary>
        public void GetParticalMethod(string s)
        {
            MethodA(s);
        }
    }

    partial class A
    {
        partial void MethodA(string s)
        {
            Console.WriteLine("Something happened: {0}", s);
        }
    }
}
 
2.static: 声明属于类型本身而不是属于特定对象的成员 
3.abstract: 指示被修改的实现已丢失或不完整。abstract修饰符可用于类、方法、属性、索引、事件。 
抽象类不能实例化，其抽象成员必须由派生自抽象类的非抽象类实现
派生自抽象类的非抽象类，必须包含全部已继承的抽象方法和访问器的实际实现
抽象类中既可以有抽象方法也可以有普通方法，但抽象方法必须放在抽象类中
抽象类能够继承普通类和接口。继承的普通类中有虚方法时，可以重载为普通方法，也可以重载为抽象方法；当继承接口时，可以实现该接口为普通方法或者抽象方法
实现接口的抽象类有可能将接口方法映射到抽象方法上
抽象类可能包含抽象方法和访问器
无法使用 sealead 修饰符来修改抽象类，因为两个修饰符的含义相反。sealead 修饰符阻止类被继承，而 abstract 修饰符要求类被继承
在方法或属性声明中使用 abstract 修饰符，以指示该方法或属性不包含实现
抽象方法是隐式的虚拟方法
只有抽象类中才允许抽象方法声明
由于抽象方法声明不提供实际的实现，因此没有方法主体；方法声明仅以分号结尾，且签名后没有大括号 ({ }) 
namespace AbstractModifier
{
    class Program
    {
        static void Main(string[] args)
        {
            AbstractClassTest test = new B();
            //调用继承基类的方法
            test.M();
            //调用虚拟方法重载的抽象方法
            test.N();
            //调用接口抽象方法实现
            test.Test();

            Console.Read();
        }
    }

    public class A
    {
        public void M()
        {
            Console.WriteLine("测试");
        }

        public virtual void N()
        {
            Console.WriteLine("方法名为N");
        }
    }

    public interface I
    {
        void Test();
    }
    /// <summary>
    /// 抽象类继承类A，实现接口I
    /// </summary>
    public abstract class AbstractClassTest : A, I
    {
        /// <summary>
        /// 重载的普通方法
        /// </summary>
        //public override void N()
        //{
        //    base.N();
        //}
        /// <summary>
        /// 接口方法的实现的普通方法
        /// </summary>
        //public void Test()
        //{
        //    throw new NotImplementedException();
        //}

        /// <summary>
        /// 重载的抽象方法
        /// </summary>
        public abstract override void N();
        /// <summary>
        /// 接口方法的实现的抽象方法
        /// </summary>
        public abstract void Test();
    }

    public class B : AbstractClassTest
    {
        public override void N()
        {
            Console.WriteLine("抽象重载方法的实现");
        }

        public override void Test()
        {
            Console.WriteLine("接口方法的实现的抽象方法的实现");
        }
    }
}
 

 

 
namespace AbstractModifier
{
    /// <summary>
    /// 抽象类
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            var o = new DerivedClass();
            o.AbstractMethod();
            Console.WriteLine($"x = {o.X}, y = {o.Y}");

            Console.Read();
        }
    }

    public abstract class BaseClass
    {
        protected int _x = 10;
        protected int _y = 10;
        public abstract void AbstractMethod();
        public abstract int X { get; }
        public abstract int Y { get; }
    }

    public class DerivedClass : BaseClass
    {
        public override int X => _x + 10;

        public override int Y => _y + 10;

        public override void AbstractMethod()
        {
            base._x++;
            base._y++;
        }
    }
}
 
输出结果: 
x = 21, y = 21 
4、sealed: 
 密封类禁止继承，普通类中的方法或属性也可用 sealed 修饰，但普通类中的方法或属性必须与 override 关键字结合使用，那么该普通类中的方法或属性在其基类中必须与virtual关键字结合使用
 
 可以对替代基类中的虚方法或属性的方法或属性使用 sealed 修饰符。 这使你可以允许类派生自你的类并防止它们替代特定虚方法或属性。
  
public class A
{
    protected virtual int m { get; set; }
    protected virtual void Test1()
    {
        Console.WriteLine("这是虚方法1");
    }

    protected virtual void Test2()
    {
        Console.WriteLine("这是虚方法2");
    }
}

public class B : A
{
    protected override sealed int m { get => base.m; set => base.m = value; }
    protected override sealed void Test1()
    {
        base.Test1();
    }

    protected override void Test2()
    {
        base.Test2();
    }
}

public sealed class C : B
{
    /// <summary>
    /// 这里只能重载Test2，其父类的Test1方法重载为密封方法了
    /// </summary>
    protected override void Test2()
    {
        base.Test2();
    }
}
 
5.virtual: 修改方法、属性、索引器或事件声明，并使它们可以在派生类中被重写 
虚拟成员的实现可由派生类中的替代成员更改
调用虚拟方法时，将为替代的成员检查该对象的运行时类型。将调用大部分派生类中的该替代成员，如果没有派生类替代该成员，则它可能是原始成员 
6.override: 扩展或修改继承的抽象或虚拟实现的方法、属性、索引器或事件需要 override 修饰符 
override 方法提供从基类继承的方法的新实现。通过 override 声明重写的方法称为重写基方法
override 方法必须具有与重写基方法相同的签名。 从 C# 9.0 开始，override 方法支持协变返回类型。具体而言，override 方法的返回类型可从相应基方法的返回类型派生。在 C# 8.0 和更早版本中，
 override 方法和重写基方法的返回类型必须相同
不能重写非虚方法或静态方法。 重写基方法必须是 virtual 、 abstract 或 override
override 声明不能更改 virtual 方法的可访问性。override 方法和 virtual 方法必须具有相同级别访问修饰符。不能使用 new 、 static 或 virtual 修饰符修改 override 方法
重写属性声明必须指定与继承的属性完全相同的访问修饰符、类型和名称。重写属性必须为 virtual 、 abstract 或 override。从 C# 9.0 开始，只读重写属性支持协变返回类型。 
class Program
{
    static void Main(string[] args)
    {
        Shape square = new Square(2);
        Console.WriteLine($"Area of Square is {square.GetArea()}");

        Console.Read();
    }
}
    public abstract class Shape
{
    public abstract int GetArea();
}

/// <summary>
/// 正方形
/// </summary>
public class Square : Shape
{
    private int side;
    /// <summary>
    /// 设置正方形边长
    /// </summary>
    /// <param name="n">正方形边长</param>
    public Square(int n) => side = n;
    /// <summary>
    /// 返回正方形边长
    /// </summary>
    /// <returns></returns>
    public override int GetArea() => side * side;
}
 
7.new: 做修饰符该关键字可以显式隐藏从基类继承的成员。隐藏继承的成员时，该成员的派生版本将替换基类版本，作运算符，用于创建对象和调用构造函数 
虽然可以不使用 new 修饰符来隐藏成员，但将收到编译器警告。如果使用 new 来显式隐藏成员，将禁止此警告 
如果用父类新建子类，如: Base dclass= new Derived();dclass.Method()是调用了基类的method()方法，而不是子类的 
override 可以覆盖基类的方法，让基类的方法以子类的内容实现；而 new 不用来覆盖基类的方法，而是全新定义一个子类的方法，这个方法只属于子类，与基类的方法无关，只是名字上相同而已 
public class BaseC
{
    public int x;
    public void Invoke() { }
}
public class DerivedC : BaseC
{
    public new void Invoke() { }
}
 
8.extern: 声明在外部实现的方法。extern 修饰符的常见用法是在使用 Interop 服务调入非托管代码时与 DllImport 特性一起使用。在这种情况下，还必须将方法声明为 static

收起

展开全文

qq_39806817 2021-10-26 19:39:11

Java修饰符及其作用对象 java对象修饰符

在《Java关键字分类解析》...Java的关键字里总共有11种修饰符，但实际上还有一种访问修饰符(Access Modifier)，那就是“没有修饰”的修饰符，也就是不加任何修饰符在作用对象上。这种修饰符没有固定名称，以下都是...


 在《Java关键字分类解析》一文里已经对Java的所有关键字进行了分类归组，并对部分关键字做了一些简单的介绍分析。不过对于修饰符这部分值得更详细的探讨，所以本文就来讲述下这些修饰符在Java中的功能及应用。
 Java的关键字里总共有11种修饰符，但实际上还有一种访问修饰符(Access Modifier)，那就是“没有修饰”的修饰符，也就是不加任何修饰符在作用对象上。这种修饰符没有固定名称，以下都是出现过的的名字：“默认(default)”、“无修饰(No Modifier)”、“包私有(Package-Private)”、“包可见(Package)”。本文将以(package)来表示该隐形的修饰符，然后针对一共12种修饰符来作阐述。
 对于所有Java的概念，可以应用修饰符的对象有三种：类(Class)、方法(Method)、变量(Variable)。进一步考虑，Java可以在类的定义里定义另一个类，所以对于类定义的位置又分出：顶层类(Top-level Class)，即直接定义在文件包下的类；和嵌套类(Nested Class)。对于变量，根据其是定义在类中还是方法中，可分别定义为：类字段(Class Field)和局部变量(Local Variable)。
 再进一步分类的话，嵌套类还可以分成静态嵌套类(Static Nested Class)和内部类(Inner Class)，不过这只是static修饰符起的效果，所以不进一步区分。同样的对于方法也不区分静态方法和对象方法，对字段也不分静态字段(Static Field)和实例变量(Instance Variable)。对于局部变量，其实还可以细分出方法参数(Method Parameter)，但它的效果基本跟方法内直接定义的变量效果一致，所以不做区分。这里也不对接口(interface)进行讨论，因为它基本相当于是完全抽象类(abstract class)。
 这样就得到了5种基本的修饰符作用对象，但不是所有的修饰符都可以作用在每一种对象上，所以把12种修饰符在Java中实际可作用的对象总结成下表：
 Modifier
 Class
 Method
 Variable
 Top-Level Class
 Nested Class
 Class Field
 Local Variable
 private
 NO
 YES
 YES
 YES
 NO
 protected
 NO
 YES
 YES
 YES
 NO
 public
 YES
 YES
 YES
 YES
 NO
 (package)
 YES
 YES
 YES
 YES
 –
 abstract
 YES
 YES
 YES
 NO
 NO
 final
 YES
 YES
 YES
 YES
 YES
 native
 NO
 NO
 YES
 NO
 NO
 static
 NO
 YES
 YES
 YES
 NO
 strictfp
 YES
 YES
 YES
 NO
 NO
 synchronized
 NO
 NO
 YES
 NO
 NO
 transient
 NO
 NO
 NO
 YES
 NO
 volatile
 NO
 NO
 NO
 YES
 NO
 注解和接口(Annotation & Interface)
 在Java Syntax表中可以找到12种不同的修饰符，不包括(package)，但包含了注解(Annotation)。由于注解可以进行自定义，也不同于本文主要讨论的修饰符针对一个作用对象只能出现一次(或没有)，注解可以有多个同时作用在同一个对象上，所以不对注解做详细介绍。
 另一方面，Java也有一个系统类叫Modifier，它内部定义了12种静态常量，其中11中对应着11种关键字指定的修饰符，另外一种也不是(package)，而是interface。
 /**
 * The {@code int} value representing the {@code public} modifier.
 */
 public static final int PUBLIC = 0x1;
 /**
 * The {@code int} value representing the {@code private} modifier.
 */
 public static final int PRIVATE = 0x2;
 /**
 * The {@code int} value representing the {@code protected} modifier.
 */
 public static final int PROTECTED = 0x4;
 /**
 * The {@code int} value representing the {@code static} modifier.
 */
 public static final int STATIC = 0x8;
 /**
 * The {@code int} value representing the {@code final} modifier.
 */
 public static final int FINAL = 0x10;
 /**
 * The {@code int} value representing the {@code synchronized} modifier.
 */
 public static final int SYNCHRONIZED = 0x20;
 /**
 * The {@code int} value representing the {@code volatile} modifier.
 */
 public static final int VOLATILE = 0x40;
 /**
 * The {@code int} value representing the {@code transient} modifier.
 */
 public static final int TRANSIENT = 0x80;
 /**
 * The {@code int} value representing the {@code native} modifier.
 */
 public static final int NATIVE = 0x100;
 /**
 * The {@code int} value representing the {@code interface} modifier.
 */
 public static final int INTERFACE = 0x200;
 /**
 * The {@code int} value representing the {@code abstract} modifier.
 */
 public static final int ABSTRACT = 0x400;
 /**
 * The {@code int} value representing the {@code strictfp} modifier.
 */
 public static final int STRICT = 0x800;
 这些静态常量其实只是比特位标记，Java库的Class、Method、Field都有getModifiers()方法返回指定对象所拥有的修饰符。Modifier类里还有许多静态方法来辅助检测指定的修饰符是否存在。虽然没有任何判定(package)修饰符的方法，但其实检测对象没有public、protected、private任一种修饰符，那就说明它是(package)修饰符了。
 自Java 7开始，Modifier还提供方法返回可应用于各对象的修饰符的汇总，对于这些源码提供的信息也侧面反应出了表的内容：
 /**
 * Returns a mask of all the modifiers that may be applied to classes.
 * @since 1.7
 */
 public static int classModifiers() {
 return PUBLIC | PROTECTED | PRIVATE | ABSTRACT | STATIC | FINAL | STRICT;
 }
 /**
 * Returns a mask of all the modifiers that may be applied to constructors.
 * @since 1.7
 */
 public static int constructorModifiers() {
 return PUBLIC | PROTECTED | PRIVATE;
 }
 /**
 * Returns a mask of all the modifiers that may be applied to fields.
 * @since 1.7
 */
 public static int fieldModifiers() {
 return PUBLIC | PROTECTED | PRIVATE | STATIC | FINAL | TRANSIENT | VOLATILE;
 }
 /**
 * Returns a mask of all the modifiers that may be applied to interfaces.
 * @since 1.7
 */
 public static int interfaceModifiers() {
 return PUBLIC | PROTECTED | PRIVATE | ABSTRACT | STATIC | STRICT;
 }
 /**
 * Returns a mask of all the modifiers that may be applied to methods.
 * @since 1.7
 */
 public static int methodModifiers() {
 return PUBLIC | PROTECTED | PRIVATE | ABSTRACT | STATIC | FINAL | SYNCHRONIZED | NATIVE | STRICT;
 }
 对于interface是修饰符，想必主要是为了区别类和接口。其实Modifier还有很多非公开的常量定义，这些都不在本文讨论范围。本文的也不将interface认定为修饰符，所以研究对象还是基于表中罗列的12种修饰符。
 访问修饰符(Access Modifier)
 对于访问修饰符，Java开发者都不会陌生，它们的作用主要是限制类自身和其成员的可访问域。下表就是对于访问限制的总结：
 Modifier
 Class
 Package
 Subclass
 World
 public
 YES
 YES
 YES
 YES
 protected
 YES
 YES
 YES
 NO
 (package)
 YES
 YES
 NO
 NO
 private
 YES
 NO
 NO
 NO
 (想起大学刚学Java的时候，我还是将这些修饰符跟现实生活来对照进行记忆，而现在对它们的理解则已经成了条件反射式。)
 回看之前的表格可以看到对于顶层类(Top-level Class)，只有public和(package)，所以这里也提一条对于类定义的限制：
 一个文件只能有一个(可以没有)公开顶层类，且该类必须和文件同名。
 万能的final(Omni-final)
 几乎所有修饰符都有不能应用的对象，唯独final是可以作用在所有对象上都可以修饰，但是它们的意义不完全相同。
 类(class): 用final修饰的类不能定义子类。
 方法(Method): 用final修饰的方法不能被子类覆盖。
 变量(Variable): 用final修饰的变量只能被初始化一次，之后变量不能再被赋值。
 互斥修饰符(Mutually Exclusive Modifiers)
 对一个指定的作用对象而言，可以拥有多个不同的修饰符，但不是所有修饰符都可以同时修饰一个对象的，很多修饰符之间都有互斥性。比如4种访问修饰符之间就是互斥的，只能限定一个且只有一个访问修饰符。但访问修饰符和基础修饰符之间没有任何互斥关系。
 abstract几乎和其他所有基础修饰符都有互斥关系，毕竟abstract表示所修饰对象表示其内容将由子类决定，自身没有具体实现。唯一的例外就是在修饰类的时候，abstract可以和strictfp组合使用。这也可以理解，因为抽象类可以有部分方法是被实现的。
 volatile修饰符只能作用在类字段上，它基本用在多线程编程方面，用以表明线程要访问字段的值时必须获取其最新的内容。它和final不能同时修饰一个字段，因为final表示字段在初始化话只能读不能写，也就不用担心它有新的值。
 修饰符的互斥约束基本就这些，其实也不用去记忆它们，现代的Java编译器都能在编译时就告诉开发者哪些是不合法的修饰符组合，IDE也会对这些违规写法抛出错误来提醒开发者。
 修饰符的申明顺序(Declaration Order of Modifiers)
 当某个对象的修饰符满足了上述的所有条件，那这些修饰符就可以合法存在并对这个对象起作用。不过之于多个修饰在申明顺序，Java编译器并没用做强制的规定。
 比如想要定义一个公开的不加入到序列化的静态常量，下边在制定类中的定义方式都是有效的(即使说static和transient放在一起一般没什么意义)：
 public static final transient int zero = 0;
 static transient public final int one = 1;
 final public transient static int two = 2;
 transient final static public int three = 3;
 但为了保持编写风格的一致性，以及代码的可读性，对于修饰符的申明顺序还是有要求的。其实前面Modifier提供的修饰符汇总方法就可以反映出修饰符的申明顺序。另外，在Java Language Specification的Classes一章里也对类修饰符、方法修饰符、字段修饰符的罗列顺序也就是通常申明时要遵循的顺序。归总如下(这里将注解也包括进来)就是
 Annotation
 public
 protected
 private
 static
 abstract
 final
 native
 synchronized
 transient
 volatile
 strictfp
 这个顺序也不用记忆，虽然编译器不会对它们进行约束，但有很多Checkstyle工具都会帮助开发者设定代码风格限定条件，并对不符合条件的写法抛出错误指示。

收起

展开全文

weixin_39621456 2021-04-23 22:35:00

Vue中的事件修饰符，按键修饰符 vue 事件修饰符按键修饰符
文章目录修饰符1.事件修饰符2.按键修饰符 修饰符 1.事件修饰符 vue中提供的事件修饰符一共有4种 .stop：用来阻止事件冒泡（防止事件向父标签传递） .prevent：用来阻止标签的默认行为 .self：只监听自身标签触发的...
收起
weixin_46841376 2021-07-13 22:57:29
java修饰符详解 java
关键字，修饰符，标识符关键字： Java关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者...
收起
weixin_42689765 2021-09-15 00:42:32
（转）java中的类和方法的修饰符
Java程序在定义类时，除了使用class关键字标识之外，还可以在class之前增加若干类的修饰符来修饰限定所定义的类的特性。类的修饰符分为访问控制符和非访问控制符两大类。修饰符之间的先后排列次序对类的性质没有任何...
收起
weixin_35724224 2021-03-22 16:11:51
java的修饰符
类修饰符访问修饰符：公共类修饰符public非访问控制符：抽象类修饰符 abstract 、最终类修饰符 final(1)公共类修饰符 public ： Java 语言中类的访问控制符只有 public 即公共的。每个 Java 程序的有且只有一个类是...
收起
weixin_42134234 2021-03-17 12:37:28
Java 语言的类、属性、方法各有哪些修饰符？简述各修饰符的区别 java属性修饰符
1、类的修饰符分为：可访问控制符和非访问控制符两种。可访问控制符是：公共类修饰符 public非访问控制符有：抽象类修饰符 abstract ；最终类修饰符 final1、公共类修饰符 public ： Java 语言中类的可访问控制符...
收起
weixin_30786631 2021-02-12 19:58:05
vue修饰符(事件修饰符、v-model修饰符、键盘修饰符、自定义键盘修饰符) vue
事件修饰符 .stop: 阻止事件冒泡，相当于调用了 event.stopPropagation()方法 <button @click.stop="test"></button> .prevent: 阻止默认行为，相当于调用了 event.preventDefault()方法，比如表单...
收起
qq_48960335 2021-06-20 21:55:16
类修饰符 抽象类 java 设计模式编程语言封装
1、类的修饰符分为：可访问控制符和非访问控制符两种。可访问控制符是：公共类修饰符 public protect 非访问控制符有：抽象类修饰符 abstract ；最终类修饰符 final 1、公共类修饰符 public ： Java 语言中类的可...
收起
sdfgegefdg 2021-03-31 16:48:18
干货：Java中的访问修饰符详解
java语言提供了很多修饰符，主要分为以下两类：访问修饰符非访问修饰符修饰符用来定义类、方法或者变量，通常放在语句的最前端。我们通过下面的例子来说明：public classClassName {//...}private booleanmyFlag;...
收起
weixin_39903538 2021-03-06 16:48:38
Java中的final修饰符
1.什么时候可以选择final修饰符如果想让一个类不被其他类继承，不允许在有子类，这时候就要考虑用到final来修饰。2.用final修饰的类首先大家要明白，用final修饰的类是不能被继承的，下面来看一个错误案例。eg：...
收起
weixin_28738165 2021-04-22 01:31:21
Vue事件修饰符和按键修饰符用法总结前端
今天给大家介绍Vue的事件修饰符、按键修饰符 、鼠标修饰符！事件修饰符 stop 阻止事件继续传播 <div @click.stop="handleClick">hello word</div> prevent 阻止标签默认行为 <div @click....
收起
weixin_42321819 2021-10-20 17:30:40
Java的类，方法，变量等等的默认修饰符是什么 java类默认修饰符
MMTTMM访问控制修饰符Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java支持4种不同的访问权限。默认的，也称为default，在同一包内可见，不使用任何修饰符。私有的，以private修饰符指定，...
收起
weixin_42469649 2021-02-12 18:35:55
Java变量与修饰符
Java变量类型java变量定义：type variablename,[variable name = value]=value局部变量：方法中的变量局部变量声明在方法中访问修饰符不能用于局部变量局部变量在栈上分配局部变量没有默认值，所以被声明...
收起
weixin_34297863 2021-02-13 00:33:26
Java基本语法（标识符、修饰符、关键字）
关键字不能做标识符 4）.java标识符中对字母大小写要求敏感实例：合法标识符举例：age、$salary、_value、__1_value 不合法标识符举例：123abc、-salary 二、修饰符 像其他语言一样，Java可以使用修饰符用来定义类...
收起
weixin_39780255 2021-03-13 02:27:09
接口修饰符及其内部修饰符 java
接口的修饰符能用public,不能用private,protected,static修饰 jdk1.8之后，接口内的方法可以使用static和default方法修饰
收起
weixin_46624670 2021-11-13 10:06:54
Java入门：Java修饰符的作用区别 java 修饰符作用
关于修饰符的的区别与用途这个是初学者经常模糊的地方，所以在本文中会简单清晰的讲解一下Java中修饰符的作用、区别。对于初学者，或许会写一点小的程序，但是确不知道修饰符是什么有什么用。但其实修饰符只要写过...
收起
weixin_29695991 2021-02-28 12:44:10
Java中常见的修饰符 java
文章目录一、访问修饰符1、public2、protected3、default4、private5、访问修饰范围图二、非访问修饰符1、final修饰符2、abstract修饰符接口（扩展一下）3、static修饰符 修饰符是用于限定类型以及类型成员的声明的...
收起
m0_51649818 2021-08-03 08:48:39
C# 4个方位修饰符和8个声明修饰符详解
一、访问修饰符 （添加到类、结构或者成员声明的关键词，控制访问权限） 4个方位修饰符 1.Private：私有的，是一个成员访问修饰符。只有在声明它们的类和结构中才可以访问。注:类或者成员默认的访问权限。 2....
收起
u011127019 2021-04-10 12:02:25
Java语言中的修饰符 java语言修饰符$
Java语言共提供了10种修饰符，分别为public、... native修饰符 nvative关键字只能用于修饰方法，在一个方法前面加上native修饰符即表明该方法为一个本地方法，本地方Java语言共提供了10种修饰符，分别为public、pr...
收起
weixin_42656416 2021-03-11 16:55:33
vue事件修饰符，六次实操带你快速了解与应用~ vue vue事件修饰符 vue按键修饰符前端
今天总结了vue常见的事件修饰符，学习面试都是常遇到的，快来看看吧~???? 先引用vue官网的话说----在事件处理程序中调用 event.preventDefault() 或 event.stopPropagation() 是非常常见的需求。尽管我们可以在...
收起
luo1831251387 2021-08-07 09:21:59
浅谈Java中各种修饰符与访问修饰符的说明
下面是常规的一些类的修饰符和访问修饰符：一：类访问修饰符 修饰符 class 类名称 extends 父类名称 implement 接口名称（访问修饰符与修饰符的位置可以互换）访问修饰符 名称说明备注 public 可以被所有的类...
收起
weixin_35519039 2021-03-09 07:07:18
Vue按键修饰符,鼠标按钮修饰符 vue
如果用了封装组件的话，比如element，这个时候使用按键修饰符需要加上.native覆盖原有封装的keyup事件即可比如：可以理解为该修饰符的作用就是把一个vue组件转化为一个普通的HTML标签 2.5.0 新增 .exact 修饰符...
收起
qq_25857899 2021-01-26 15:27:24
java中的类和方法的修饰符 java 类修饰符
java中的类和方法的修饰符Java程序在定义类时，除了使用class关键字标识之外，还可以在class之前增加若干类的修饰符来修饰限定所定义的类的特性。类的修饰符分为访问控制符和非访问控制符两大类。修饰符之间的先后...
收起
weixin_39828193 2021-02-28 16:27:54
Java中，权限修饰符的权限测试
=============================================================================1、1 /*2 权限修饰符的权限测试：34 权限修饰符 本类中同一个包下的子类和无关类不同包下的子类不同包下的无关类5 private Yes ...
收起
weixin_39794347 2021-03-06 19:23:01
Java 默认修饰符 总结 java 修饰符默认
Java 默认修饰符总结1.类(class)可见性修饰符：public—在所有类中可见，在其他包中可以用import导入。缺省—就是没有修饰符，在同一个包中的类中可见，在其他包中不能用import导入。修饰符：final—终态类，表示该...
收起
weixin_34150870 2021-02-28 12:44:41

java中的修饰符分为类修饰符，字段修饰符，方法修饰符 java字段修饰符

vue 事件修饰符 & 按键修饰符 vue.js 前端 javascript 修饰符

事件修饰符

.stop

.prevent

.capture

.once

按键修饰符

C# 访问修饰符和声明修饰符 c# 后端

一、访问修饰符的基本说明

什么是程序集呢？

二、声明修饰符

Java修饰符及其作用对象 java对象修饰符

Vue中的事件修饰符，按键修饰符 vue 事件修饰符 按键修饰符

java修饰符详解 java

（转）java中的类和方法的修饰符

java的修饰符

Java 语言的类、属性、方法各有哪些修饰符？简述各修饰符的区别 java属性修饰符

vue修饰符(事件修饰符、v-model修饰符、键盘修饰符、自定义键盘修饰符) vue

类修饰符抽象类 java 设计模式 编程语言 封装

干货：Java中的访问修饰符详解

Java中的final修饰符

Vue事件修饰符和按键修饰符用法总结 前端

Java的类，方法，变量等等的默认修饰符是什么 java类默认修饰符

Java变量与修饰符

Java基本语法（标识符、修饰符、关键字）

接口修饰符及其内部修饰符 java

Java入门：Java修饰符的作用区别 java 修饰符作用

Java中常见的修饰符 java

C# 4个方位修饰符和8个声明修饰符详解

Java语言中的修饰符 java语言修饰符$

vue事件修饰符，六次实操带你快速了解与应用~ vue vue事件修饰符 vue按键修饰符 前端

浅谈Java中各种修饰符与访问修饰符的说明

Vue按键修饰符,鼠标按钮修饰符 vue

java中的类和方法的修饰符 java 类修饰符

Java中，权限修饰符的权限测试

Java 默认修饰符总结 java 修饰符默认

	默认的成员可访问性	该成员允许声明的可访问性
class	private	public protected internal private protected internal
struct	private	public internal private
interface	public	无
enum	public	无