java修饰符

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类。

final修饰符
final主要用法有以下四种：
一、用来修饰数据，包括成员变量和局部变量，该变量只能被赋值一次且它的值无法被改变。对于成员变量来讲，我们必须在声明时、构造方法或者初始化块中对它赋值；

1.	public class FinalMemberVariables {
2.	    // final 修饰的实例变量
3.	    // 必须在非静态初始化块、声明该实例变量或构造器中指定初始值，
4.	
5.	    //声明该实例变量指定初始值
6.	    final int INT_A=10;
7.	    //初始化块指定初始值
8.	    final int INT_B;
9.	    {
10.	
11.	        INT_B=11;
12.	    }
13.	    final int INT_C;
14.	    //构造器中指定初始值
15.	    public FinalMemberVariables(){
16.	        INT_C=12;
17.	    }
18.	
19.	    //final 修饰 类变量
20.	    //必须在静态初始化块中指定初始值或声明该类变量时指定初始值，
21.	    final static String STR_A="123";
22.	    final static String STR_B;
23.	    static{
24.	        STR_B="123456";
25.	    }
26.	}

二、用来修饰局部变量，表示在变量的生存期中它的值不能被改变、

1.	/**
2.	 * final 修饰 局部变量
3.	 * @author sxj
4.	 *
5.	 */
6.	public class FinalLocalVariable {
7.	    //final修饰局部变量时，既可以在定义时指定默认值，也可以不指定默认值。
8.	    public static void main(String[] args) {
9.	
10.	        //在定义时指定默认值
11.	        //不能再后面的代码中为变量赋值
12.	        final int INT_A=10;
13.	        //下面的赋值语句非法
14.	        //INT_A=12;
15.	
16.	        //定义时不指定默认值
17.	        //可以在后面的代码中赋值一次
18.	        final String STR_A;
19.	        STR_A="123";
20.	        //下面的赋值语句非法
21.	        //STR_A="456";
22.	    }
23.	
24.	
25.	    public void test(final int num){
26.	        // 不能对final修饰的形参赋值
27.	        //num=10;
28.	    }
29.	}

三、修饰方法，表示该方法无法被重写；

1.	/**
2.	 * final 修饰的方法不能被重写Override
3.	 * @author sxj
4.	 *
5.	 */
6.	public class FinalMethod {
7.	    public void print(){
8.	        System.out.println("FinalMethod---print方法");
9.	    }
10.	
11.	    public final void finalPrint() {
12.	        System.out.println("FinalMethod--finalPrint方法");
13.	    }
14.	}
15.	
16.	
17.	class FinalMethodTow extends FinalMethod{
18.	    public void print(){
19.	        System.out.println("FinalMethodTow--print方法");
20.	    }
21.	
22.	    //下面的代码有错误，无法重写final修饰的方法
23.	//    public void finalPrint() {
24.	//        System.out.println("FinalMethodTow--finalPrint方法");
25.	//    }
26.	}

四、 修饰类，表示该类无法被继承。

1.	/**
2.	 * final 修饰的类不能被继承
3.	 * @author sxj
4.	 *
5.	 */
6.	public final class FinalClass {
7.	    int age=10;
8.	}
9.	
10.	//classDemo2 无法继承 FinalClass
11.	//class classDemo2 extends FinalClass{
12.	//
13.	//}

Java 抽象类
在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法、初始化块和构造方法和普通类一样。
由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。
一、抽象方法
抽象方法只包含一个方法名，而没有方法体，使用abstract修饰。
格式：

1. [修饰符] abstract 返回类型 方法名();
   • 修饰符 (public protected private)三选一
   二、示例代码

1.	public abstract class Animal {
2.	
3.	    //成员变量
4.	    protected int weight =0;
5.	
6.	    {
7.	        System.out.println("初始化块");
8.	    }
9.	    //构造器
10.	    public Animal(){
11.	        System.out.println("Animal 的构造器");
12.	    }
13.	
14.	    public Animal(int weight) {
15.	        this.weight=weight;
16.	        System.out.println("Animal 的构造器");
17.	    }
18.	
19.	    // 定义一个普通方法 休息
20.	    public void sleep() {
21.	        System.out.println("休息");
22.	    }
23.	
24.	
25.	    //抽象方法 没有方法体
26.	    public abstract void running();
27.	
28.	    public abstract String sayWeiget();
29.	}

三、总结

1. 抽象类必须使用abstract修饰符来修饰，
   抽象方法也必须使用abstract修饰符来修饰，
   抽象方法不能有方法体。
2. 抽象类不能被实例化，
   无法使用new关键字来调用抽象类的构造器创建抽象类的实例。
3. 抽象类可以包含成员变量、
   方法（普通方法和抽象方法都可以）、
   构造器、初始化块、
   内部类（接 口、枚举）5种成分。
4. 抽象类的构造器不能用于创建实例，主要是用于被其子类调用。
5. 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类
6. abstract static不能同时修饰一个方法

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 修饰符

1. 静态变量

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

1. 静态方法

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

final 修饰符

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

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

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

abstract 修饰符、

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

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

抽象方法

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

synchronized 修饰符

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