前言

一、11 种常见的 Java 修饰符

1、修饰符应用表

2、访问权限对比

public > protected > default > private

说明：以下仅介绍我们常用的 7 种修饰符语法说明以及开发应用说明，另外 4 种用法查看修饰符应用表即可。

二、public 修饰符

语法说明：

1. 修饰类、方法、变量。可以在任意位置访问，公共的。

开发应用：

1. 开发中，通常类和业务方法都使用 public 修饰。

三、private 修饰符

语法说明：

1. 修饰方法、变量、还可以修饰内部类。只能在本类中访问，私有的。

开发应用：

1. 开发中，通常实体类（Entity,Vo）中的成员变量使用 private 修饰，会提供访问这些变量的方法 getter 或
   setter，原则上要求不准定义私有的方法。
2. 一个实体数据的表通常对应一个实体类。

四、protected 修饰符

语法说明：

1. 修饰方法、变量、还可以修饰内部类。
2. 同一个包可以访问、子类可以访问（子类和父类不在同一个包也可以访问）。

开发应用：

1. 开发中，通常方法或变量是用来继承的，都使用 protected 修饰。
2. 在继承中，方法的重写，子类方法的访问权限必须大于或等于父类方法的访问权限。

class Fu {
	public void play() {
	}
}

class Son extends Fu {
	void play() {
	}
}

五、default(不加任何访问权限修饰符)

语法说明：

1. 修饰类、方法、变量。
2. 只能在同一个包中访问，子类也必须在同一个包中。

开发应用：

1. 项目中，类、方法、变量根据需求，通常都会指定访问权限。

六、static 修饰符

1、static 修饰成员变量（静态变量/类变量）

语法说明：

1. Java 中 可以通过 static 关键字修饰变量达到全局变量的效果。
2. static 修饰的变量(静态变量)属于类，在类第一次通过类加载器到 jvm 时被分配至方法区。
3. 没有 static 修饰的变量，称为实例变量。

1.1、类变量和实例变量的区别

• 实例变量，在创建对象之后，被分配到堆内存中，实例变量属于某个具体的对象。当创建对象，实例变量出现在堆内存中，当对象被垃圾回收，实例变量立即释放内存。

比如：我们创建两个对象。

Cell c1 = new Cell(4,5);
Cell c2 = new Cell(5,6);

当创建对象 c1，c2 时，实例变量(4,5)，(5,6)出现在堆内存中，当对象 c1，c2 被垃圾回收，实例变量立即释放内存。

• 类变量，被存储在方法区中，“只有一份”，被所有对象共享。当类被加载的时候，立即被存储在方法区中，当类被卸载，类变量立即释放内存。

开发应用：

1. 类变量可以由类名直接访问，开发中推荐使用类名的全称。

比如：我们定义一个实体类。

public class Student {
	// 实例变量，在创建对象之后，被分配到堆内存中，实例变量属于某个具体的对象
	// 当创建对象，实例变量出现在堆内存中，当对象被垃圾回收，实例变量立即释放内存
	String name;

	// 类变量，被存储在方法区中，"只有一份",被所有对象共享
	static String jtName;

	public void print() {
		System.out.println(this.name);
		System.out.println(jtName);
	}
}

下次使用静态变量 jtName 时，我们直接使用 Student 这个类名直接调用即可。同时我们也就可以理解下面两个对象的属性取值是一样的。

public class Demo01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student stu1 = new Student();
		stu1.name = "张三";
		stu1.jtName = "王老师";

		Student stu2 = new Student();

		// 一般直接取类名
		// stu2.jtName = "卢老师";
		Student.jtName = "卢老师";
		System.out.println(stu1.name);// 张三
		System.out.println(stu2.name);// null
		System.out.println(stu1.jtName);// 卢老师
		System.out.println(stu2.jtName);// 卢老师
	}
}

2、static 修饰成员方法（静态方法/类方法）

静态方法：static 修饰的方法属于类方法，不需要创建对象就可以调用。static 方法中不能使用 this 和 super 等关键字，不能调用非 static 方法，只能访问所属类的静态成员变量和静态方法。静态方法(类方法),当类被加载，静态方法立即被加载到方法区中，类方法可以由类名直接调用。

实例方法：没有static修饰的方法，实例方法，当创建对象之后，实例方法立即被加载到方法区中，多个实例共享一份实例方法。

2.1、静态方法与实例方法的区别和结论

• 类方法中，不能使用this关键字,类方法中不隐含调用该方法对象的参数。
• 实例方法可以直接调用静态方法，静态方法不可以直接访问实例成员，必须创建对象，由对象访问。

结论：所有对象共享的数据，定义为静态变量，否则定义为实例变量方法，方法中没有访问实例成员，可以定义为静态方法。

开发应用：

1. 项目中，通常工具类中的方法，都是静态的。

3、static 静态代码段

语法说明：

1. JVM在加载类时会执行 static 静态代码段，常用于初始化静态变量。
2. static代码只会在类被加载时执行且执行一次。
3. 静态优于对象。

开发应用：

1. 开发中，通常用于加载静态资源，读取配置文件等操作，在静态代码段中实现。

比如：我们定义一个工具类如下。

public class SomeUtil {

	// 默认的无参构造
	public SomeUtil() {
		System.out.println("创建对象！");
	}

	// 静态优于对象
	// 静态代码段 当类被加载，立即被执行，一个类在同一个进程中，只加载一次
	static {
		System.out.println("加载静态资源！");
	}

	// 实例代码段
	{
		System.out.println("实例代码段！");
	}

	public static void do1() {
		System.out.println("do1....");
	}

	public static void do2() {
		System.out.println("do2....");
	}

	public static void do3() {
		System.out.println("do3....");
	}

	public static void main(String[] args) {
		SomeUtil.do1();
		SomeUtil.do2();
		SomeUtil.do3();
		SomeUtil s1 = new SomeUtil();
		SomeUtil s2 = new SomeUtil();
	}
}

执行 main 方法，根据输出的内容我们可以明确看出执行的顺序。静态代码段只执行一次，然后是静态方法被执行，最后是 new 的对象执行无参构造和实例代码段，new 一次执行一次。同时也可以得出我们的结论：静态优于对象。

4、static 内部类

语法说明：

1. static 内部类可以不依赖外部类实例对象而被实例化，而内部类需要在外部类实例化后才能被实例化。
2. 静态内部类不能访问外部类的普通变量，只能访问外部类的静态成员变量和静态方法。

七、final 修饰符

语法说明：

1. final 类，不能被继承。
2. final 方法，不能被重写。
3. final 修饰的变量，是常量。

开发应用：

1. 开发中，使用 final 定义数据字典。

比如：在如下 Card 类中我们定义数据字典，用于 main 函数的输出和查询。

备注：数据字典是指对数据的数据项、数据结构、数据流、数据存储、处理逻辑等进行定义和描述，其目的是对数据流程图中的各个元素做出详细的说明，使用数据字典为简单的建模项目。简而言之，数据字典是描述数据的信息集合，是对系统中使用的所有数据元素的定义的集合。

public class Card {

	// 开发中，使用final定义数据字典。
	public static final int SPADE = 1;
	public static final int HEART = 2;

	public static final int BLACK = 5;
	public static final int FLOWER = 6;

	public static final int THREE = 0;
	public static final int EIGHT = 5;
	public static final int JACK = 8;
	public static final int QUEEN = 9;
	public static final int KING = 10;
	public static final int ACE = 11;
	public static final int DUCE = 12;
	public static final int JOKER = 13;

	private int suit;
	private int num;

	public Card() {
	}

	public Card(int suit, int num) {
		this.suit = suit;
		this.num = num;
	}

	public int getSuit() {
		return suit;
	}

	public void setSuit(int suit) {
		this.suit = suit;
	}

	public int getNum() {
		return num;
	}

	public void setNum(int num) {
		this.num = num;
	}

	public static void main(String[] args) {
		Card card = new Card(Card.HEART, Card.THREE);
		System.out.println(card.getNum());
	}
}

八、abstract 修饰符

语法说明：

1. 抽象的，可以修饰类，修饰方法。

抽象类：

• 抽象类存在的意义在于被继承。
• 抽象类不可以创建对象。
• abstract 不能和 final 一起使用 。

抽象方法：

• 抽象方法，只有定义没有实现。
• 如果一个类中有抽象方法，这个类必须是抽象类。
• 一个抽象类中，可以没有抽象方法。
• 抽象类的子类，必须实现父类中所有的抽象方法。

开发应用：

1. 抽象类中既可以有默认实现的方法，又可以有没有实现的方法。
2. 接口的适配器——用子类去实现接口中的方法。

九、接口（特殊的抽象类）

语法说明：

1. 特殊的抽象类接口中的方法都是抽象方法 接口中的变量都是静态常量。
2. 定义接口使用 interface 关键字。
3. 实现接口使用 implements 关键字。
4. 类实现了接口，必须实现接口中所有的方法。

public interface MyInterface {
	// 接口是高一级别的抽象。不能被实例化，所以只能定义常量
	// 定义了变量需要实例化，赋值才能使用，跟接口违背
	// 特殊的抽象类 接口中的方法都是抽象方法 接口中的变量都是静态常量
	int I = 10;

	// 如果类中所有的方法都是抽象方法，使用接口
	void method1();

	void method2();
}

import java.io.Serializable;

/**
 * 其实适配器只是一个类，它实现了某种接口，提供了方法体。 
 * 这样，再用到这个接口时，可以直接继承适配器，这样就不需要把接口中的每一个方法再填充一遍了。
 * 只需要在这个类中复写一下需要用的方法。这样简单，方便。
 * 
 * @author bailu
 *
 */
public class MyImpClass implements MyInterface, Serializable {
	
	// Serializable序列化
	private static final long serialVersionUID = 1L;

	// 重写接口的方法——适配器，
	@Override
	public void method1() {
		System.out.println(I);

	}

	@Override
	public void method2() {
	}
}

开发应用：

1. 如果类中所有的方法都是抽象方法，使用接口。

1、抽象类和接口的区别

• 抽象类中，可以定义抽象方法和非抽象方法。接口中，所有的方法都是抽象方法。
• 一个类只能继承一个抽象类。一个类可以实现多个接口，多个接口使用逗号分隔。

比如：如下的类既实现了接口 MyInterface，同时实现了 Serializable 序列化序列化。

import java.io.Serializable;

/**
 - 其实适配器只是一个类，它实现了某种接口，提供了方法体。 
 - 这样，再用到这个接口时，可以直接继承适配器，这样就不需要把接口中的每一个方法再填充一遍了。
 - 只需要在这个类中复写一下需要用的方法。这样简单，方便。
 - 
 - @author bailu
 -  */
public class MyImpClass implements MyInterface, Serializable {
	
	// Serializable序列化
	private static final long serialVersionUID = 1L;

	// 重写接口的方法——适配器，
	@Override
	public void method1() {
		System.out.println(I);

	}

	@Override
	public void method2() {
	}
}

• 抽象类之间也可以继承，但是也只是支持单继承。接口之间也可以继承，一个接口可以继承多个接口。

开发应用：

1. 接口是用来制定标准或规范。

2. 可以降低组件之间的耦合度，扩展组件的功能。

3. 体现了设计模式中的开闭原则。

2、什么是适配器？

适配器只是一个类，它实现了接口，提供了方法体。再用到这个接口时，可以直接继承适配器，这样就不需要把接口中的每一个方法再填充一遍了，只需要在这个类中复写一下需要用的方法。接口很好地体现了设计模式中的开闭原则。

比如：我们做一个在线商城系统，就需要调用第三方支付——银行或者是支付宝的支付接口。我们就需要第三方为我们提供接口，里面定义了抽象的方法以及实现接口的方法——适配器，我们通过调用适配器里面的方法来完成支付。

ZsBankInter obj = 获取实现类对象;
obj.send();
京东、淘宝
银行接口ZsBankInter  
send() 
类
class DoSend implements ZsBankInter{
  	send()具体的方法
}

总结