java修饰符
文章目录
java修饰符
java中的修饰符分类:
一，权限修饰符：private, default, protected, public
private：
default：
protected：
public：
二，状态修饰符：static, final
static修饰符
语法格式：
特点
static静态变量
静态变量与非静态变量的区别
static静态方法
final 修饰符
1、final关键字通常与static修饰符一起使用来创建类常量
2、 final 修饰成员变量
3、final 关键字修饰方法时，则该方法不能被重写
4、final 关键字修饰类时，该类不能被继承
三，抽象修饰符：abstract
abstract修饰符
抽象类：
抽象方法：

java中的修饰符分类:

权限修饰符: private, default, protected, public
状态修饰符: static, final
抽象修饰符: abstract

一，权限修饰符：private, default, protected, public
private：
如果实体使用private修饰符声明，那么实体将只能由定义实体的类中的包含的代码访问。它的访问权限仅限于类的内部，是一种封装的体现。这样，就不能从类的外边直接访问他们，我们提供set和get方法，保证类中数据域的安全。
default：
默认修饰符，什么都不加，实际上它限制的范围就是一个包内可以访问。如果不在一个包内，即使继承关系任然是不能访问的。它是针对本包访问而设计的，任何处于本包下的类，接口，异常等，都可以互相访问，即使是父类没有用protected修饰的成员也可以
protected：
经常需要允许子类访问定义在父类中的数据和方法，但是不允许非子类访问这些数据和方法，这种情况下就可以使用protected，它允许任何包中的子类访问父类。
public：
具有最大的访问权限，可以访问任何一个CLASSPATH下的类，接口、异常等。它往往对于对外的情况，也就是对象或类对外的一种接口形式。

二，状态修饰符：static, final
static修饰符
static的主要作用在于创建独立于具体对象的域变量或者方法。
语法格式：
修饰变量：static 数据类型 变量名
修饰方法：【访问权限修饰符】 static 方法返回值 方法名(参数列表)
特点
static可以修饰变量，方法被static修饰的变量或者方法是独立于该类的任何对象，也就是说，这些变量和方法不属于任何一个实例对象，而是被类的实例对象所共享。
在类被加载的时候，就会去加载被static修饰的部分。被static修饰的变量或者方法是优先于对象存在的，也就是说当一个类加载完毕之后，即便没有创建对象，也可以去访问。
static静态变量
static修饰的成员变量叫做静态变量，也叫做类变量，说明这个变量是属于这个类的，而不是属于是对象，没有被static修饰的成员变量叫做实例变量，说明这个变量是属于某个具体的对象的。
静态变量与非静态变量的区别


静态变量可以直接使用类名调用。


静态变量被所有对象共享，在内存中只有一个副本，在类初次加载的时候才会初始化。


静态变量一旦变化，所有的实例的静态变量值都会变化。


非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响


非静态方法可以调用静态变量、静态方法和非静态变量、非静态方法。


static静态方法

被static修饰的方法也叫做静态方法，因为对于静态方法来说是不属于任何实例对象的，那么就是说在静态方法内部是不能使用this的。
由于这个特性，在静态方法中不能访问类的非静态变量和非静态方法，因为非静态方法/变量都是须依赖具体的对象才能够被调用。
在静态方法中不能访问非静态方法和非静态变量，但是在非静态方法中是可以访问静态方法/静态变量。

final 修饰符
final 关键字可以用于修饰类，方法和变量
1、final关键字通常与static修饰符一起使用来创建类常量
2、 final 修饰成员变量

必须要赋初始值，而且是只能初始化一次。
被fianl修饰的成员变量赋值，有两种方式：1、直接赋值 2、全部在构造方法中赋初值。
如果修饰的成员变量是基本类型，则表示这个变量的值不能改变。
如果修饰的成员变量是一个引用类型，则是说这个引用的地址的值不能修改，但是这个引用所指向的对象里面的内容还是可以改变的。

3、final 关键字修饰方法时，则该方法不能被重写

一个类的private方法会隐式的被指定为final方法。
如果父类中有final修饰的方法，那么子类不能去重写。

4、final 关键字修饰类时，该类不能被继承

被final修饰的类，final类中的成员变量可以根据自己的实际需要设计为fianl。
final类中的成员方法都会被隐式的指定为final方法。

三，抽象修饰符：abstract
abstract修饰符
用abstract关键字来修饰该类[抽象类]，用abstract来修饰该方法[抽象方法]。
抽象类：

抽象类是为了把相同的但不确定的东西的提取出来，为了以后的重用。定义成抽象类的目的，就是为了在子类中实现抽象类。
抽象类不能被实例化。因为抽象类中方法未具体化，除此之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。
抽象类中不一定要包含abstract方法。也就是抽象中可以没有abstract方法。

抽象方法：

用abstract来修饰该的抽象方法只包含一个方法名，不能有方法主体。
抽象方法没有定义，方法名后面直接跟一个分号，而不是花括号。
一旦类中包含了abstract方法，那类该类必须声明为abstract类。

Java 修饰符

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


访问修饰符
非访问修饰符

访问控制修饰符
Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

帮助理解：

public：在当前类	，同一包内，子孙类(同一包)，子孙类(不同包)，其他包中都是可以访问到的
protected :：在当前类	同一包内	，子孙类(同一包)，子孙类(不同包)可以访问到的，其他包是不可以的
default当前类	同一包内	，子孙类(同一包)可以访问到的，	子孙类(不同包)和其他包是不可以的
private当前类可以访问到，同一包内，子孙类(同一包)，子孙类(不同包)和其他包都是不可以访问到的

1：默认访问修饰符-不使用任何关键字
//变量和方法的声明可以不使用任何修饰符。
	void demo(){
		int i=10;
	}

2：私有访问修饰符-private*
私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。
声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。

public class NameDemo {
   private String name;
   public String getName() {
      return this.name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

代码NameDemo这个类中，name是一个私有变量，其他类不可以直接访问赋值，那么类中提供了两个public修饰的方法，可以使外部类访问到
3：公有访问修饰符-public

被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。
4：受保护的访问修饰符-protected（修饰符中比较需要注意的）
在这里推荐一片文章，菜鸟驿站，Java protected 关键字详解
非访问修饰符
static 修饰符

静态变量

static变量也称作静态变量。静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

静态方法

static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。但是在非静态成员方法中是可以访问静态成员方法/变量的。
final 修饰符

final变量：被 final 修饰的实例变量必须显式指定初始值，被修饰并赋值后不能再重新赋值

//final 修饰符通常和 static 修饰符一起使用来创建类常量。
public static final int a=10;


final 方法:被final修饰的方法是可以被继承，但是不能重写

abstract 修饰符、


抽象类：不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。


特别注意一个类不能同时被 abstract 和 final 修饰


抽象方法

没有任何实现的方法，该方法的的具体实现由继承类提供。
抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
如果一个类包含多个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

synchronized 修饰符

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

Java访问修饰符 


1- Java修饰符2- 覆盖访问修饰符3- 私有访问修饰符4- 私有构造函数5- 默认访问修饰符6- 受保护访问修饰符7- 公共访问修饰符8- 覆盖方法

1- Java修饰符 
在Java有两种类型的修饰符: 访问修饰符 和 非访问修饰符。
Java访问修饰符指定数据成员，方法，构造函数或类的可访问性(范围)。
有4种类型的Java访问修饰符：
private
(Default)
protected
public
有许多非访问修饰符，如 static, abstract, synchronized, native, volatile, transient 等. 在这里，我们将学习访问修饰符。
2- 访问修饰符覆盖 
下表显示如何使用访问修饰符的概述说明。

访问修饰符
类内访问
包内访问
包外仅子类访问
包外访问非子类
private
Y
N
N
N
Default
Y
Y
N
N
protected
Y
Y
Y
N
public
Y
Y
Y
Y

你可以看到更多的详细信息请按照下面的例子：
3- private访问修饰符 
私有(private)访问修饰符只能在类中访问。



你不能访问私有字段在定义类之外。 Java将在类的编译时通报错误。



4- private构造函数 
如果你创建一个类，并有一个私有的构造函数，则无法从私有构造函数来创建这个类的对象。让我们看一个说明性的例子：



5- Default访问修饰符 
如果你声明一个字段，方法，构造函数，但你不写明访问修饰符，这意味着这将使用默认(default)的访问修饰符。
默认(default)的访问修饰符的访问范围是在包里面。

// A class with default access modifier
// (Not public).
class MyClass   {

 // A field with private access modifier.
 private int myField;

 // A field with default access modifier.
 // (not specified public, protected, private).
 String myField2;

 // A method with default access modifier.
 // (not specified public, protected, private).
 void showMe()  {

 }
}


在同一个包，你可以访问成员的访问修饰符是默认(default)



而且，不能访问包之外的东西，即使它们是一个子类。



注意:
对于接口，当声明一个字段或方法，需要声明为public。也可以声明默认模式，而Java中的接口默认认为 public。 

public interface MyInterface  {

   // This is a field, you can not declare private or protected.
  public static int MY_FIELD1 = 100;

  // This is a field with default access modifier
  // But Java considering this is a public.
  static int MY_FIELD2 = 200;

  // This is a method, with default access modifier
  // But Java considering this is a public.
  void showInfo();
}


6- protected访问修饰符 
保护(protected)访问修饰符作用范围是包内和包外，但要通过继承才能访问。


保护(protected)访问修饰符可以在数据成员，方法和构造上应用。但它不能在类上应用。

7- public访问修饰符 
public访问修饰符是允许所有访问。它具有比所有其他修饰符的访问范围更宽。



8- 覆盖方法 
你可以以超类的相同方法名称和参数来覆盖超类的方法。不过，不能让这种方法的访问范围有所限制。

在上面的图示：


Cat类是从Animal类扩展并覆盖move()方法; 从protected到public模式重写变更的访问范围。这是有效的。
Mouse类从Animal 类扩展并覆盖move()方法; 覆盖加入更改从protected到默认模式的范围。这减少了原来的方法的访问的范围，因此它是无效的。

转自http://www.broncho.cn/forum/viewtopic.php?f=32&t=428&sid=11ec0a0f09e44aeef55dbe94fdde393e
java初学就记录一下其中修饰符的作用吧。
类的修饰符：
1. public 可以被 所有类访问。public类必须定义在和类名相同的同名文件中。
2. final 使用此修饰符的类不能被继承。
3. abstract 如果要使用abstract类必须先建立一个继承abstract类的新类，新类中实现abstract类中的抽象方法。类中只要有一个abstract 方法，类就必须定义为abstract，但是abstract不一定非要保护abstract方法不可。

类中成员修饰符：
1. public 可以类内访问，包内访问，子类内访问，不同包间访问。
2. protected 可以类内访问，包内访问，子类内访问，不能不同包间访问。
3. (default) 可以类内访问，包内访问，不能子类内访问，不能不同包间访问。
4.private 可以类内访问，不能包内访问，不能子类内访问，不能不同包间访问。

方法修饰符
1. static 静态方法提供不依赖于类实例的服务。并不需要类的实例就可以访问静态方法。
2. final 防止任何子类重载该方法。
3. abstract 抽象方法，类中已声明而没有实现的方法。
4.native 用该修饰符定义的方法在类中没有实现，而大多数情况下该方法的实现是用C C＋＋编写的。
5. synchronized 多线程的支持，当一个此方法被调用时，没有其他线程能够调用该方法，其他的synchronized方法也不能调用该方法，直到该方法返回为止。