Java修饰符：修饰符用来定义类、方法或者变量，通常放在语句的最前端。
主要分为2类：
访问控制修饰符
非访问控制修饰符
可以使用访问控制符来保护对类、变量、方法和构造方法的访问。分为以下4中权限：private，default，protected，public。
权限说明：
| 修饰符 | 当前类 | 同包 | 子类(不同包) | 不同包(其他类) |
|---|---|---|---|---|
| private | Y | |||
| default | Y | Y | ||
| protected | Y | Y | Y | |
| public | Y | Y | Y | Y |
| 修饰符 | 说明 |
|---|---|
| static | 用来修饰类方法和类变量。 |
| final | 用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。 |
| abstract | 用来创建抽象类和抽象方法。 |
| synchronized volatile |
主要用于线程的编程。 |
1.public 将一个类声明为公共类，他可以被任何对象访问，一个程序的主类必须是公共类，一个.java文件中只能有一个public类，而且文件名必须与该类相同。
public class Learn9 {
public static void main(String[] args) {
}
}
假如类名与文件名不一致
如果一个 .java 文件中两个public类呢？
报错跟刚才一样，就是公共类必须独立占用一个java文件。
1.把下面修饰类的public去掉就可以了。
♀ 小AD：明哥，我有个问题？
♂ 明世隐：请放！
♀ 小AD：文明点啊哥，就知道欺负人家，我就想说这一个类里面怎么还可以再放一个类的，也没看到报错。
♂ 明世隐：这个是可以的，就比如我可以带你双排、三排、5排，甚至可以。。。，但是你必须搞清楚谁是大哥，谁是小老弟。
♀ 小AD：哥我知道，你就是那个大哥，只有你可以抛头露面、带头冲锋，用public修饰。
♂ 明世隐：算你识相，不然我单排去了。
♀ 小AD：是是是，哥回头请你吃奶茶！
♂ 明世隐：说谎的人要吞一千根针哦。
♀ 小AD：。。。
♂ 明世隐：一般也不这样写，写成单独的普通类，这种内部类写法主要是一个功能模块的方便或者相关的封装。
♂ 明世隐：其实他们虽然放在一起，也只是编译时概念，编译完成后也是独立的class文件。
♀ 小AD：哦
♂ 明世隐：就比如刚才写的代码
2.默认的，把一个类声明为默认的，可以被同一个包中的其他类使用。
3.abstract，将一个类声明为抽象类，抽象类中可以有抽象方法，也可以没有。抽象类只能被继承不能被实例化。
4.final，将一个类声明为最终（即非继承类），表示他不能被其他类继承。
5.外部类不能使用protected、private、static等修饰符，内部类可以使用。
♀ 小AD：我开始懵逼了。
♂ 明世隐：很正常，因为抽象类、最终类的你都没接触过，不过不要紧，你现阶段只要有个印象，不需要去记，后面单独再讲这个，你只需要知道public修饰类就行了。
♀ 小AD：好，这样就比较好弄。
1.private
在Learn10类中创建私有方法test
private void test() {
System.out.println("learn10 test方法被调用");
}
主方法main 调用这个方法
public class Learn10 {
public static void main(String[] args) {
System.out.println("learn10 main");
new Learn10().test();
}
private void test() {
System.out.println("learn10 test方法被调用");
}
}
运行
在同包下的 Learn9 类看能否调用此方法
同包下的类都不能调用private了，更别说其他包了。
2.default
把Learn10类中创建方法test改成默认的，也就是把private删除
public class Learn10 {
public static void main(String[] args) {
System.out.println("learn10 main");
new Learn10().test();
}
void test() {
System.out.println("learn10 test方法被调用");
}
}
public class Learn9 {
public static void main(String[] args) {
System.out.println("learn9 main");
new Learn10().test();
}
}
可以看到本类和同包下的类可以访问的，其他包的试一下。
建立包adc，并创建类XiaoLuBan，调用test方法：
3.protected
把Learn10类中创建方法test改成protected的，然后发现跟上面的是一样的，其他包中也不行，但实际上这个在子类中是可以的，子类的问题下次再研究。
4.public
方法修饰改成public
public class Learn10 {
public static void main(String[] args) {
System.out.println("learn10 main");
new Learn10().test();
}
public void test() {
System.out.println("learn10 test方法被调用");
}
}
public class Learn9 {
public static void main(String[] args) {
System.out.println("learn9 main");
new Learn10().test();
}
}
import learnJava.Learn10;
public class XiaoLuBan {
public static void main(String[] args) {
new Learn10().test();
}
}
发现public是都可以用。
♀ 小AD：明哥，是不是又只要记住public。
♂ 明世隐：对，public确实很常用，但是private也蛮经常用。
♀ 小AD：是不是跟排位排队一样的，没排到之前大家都可能排到，公共的。
♂ 明世隐：你咋啥都要往这方面想？
♀ 小AD：没办法，我天生丽质。private就是比如我两双排，固定组合，总不能把你T出去，我跟别人排吧。
♂ 明世隐：你这么一说，我瞬间觉得以前我学代码的时候，不香了。
♀ 小AD：那可不，我是人见人爱、花见花。。。
♂ 明世隐：花见花凋零！
1.抽象方法控制符abstract
abstract 修饰的方法称为抽象方法。抽象方法仅有方法头，没有方法体和具体实现。
2.静态方法控制符static
指定不需要实例化就可以调用的一个方法，即在内存中只有一份，通过类名即可调用。
3.最终方法控制符final
最终方法是功能和内部语句不能更改的方法，即最终方法不能重写覆盖。
4.本地方法控制符native
指定此方法的方法体是用其他语言在程序外部编写的。
5.同步方法控制符synchronized
同步修饰符，在多个线程中，该修饰符用于在运行前，对它所属的方法加锁，以防止其他线程的访问，运行结束后解锁。
♂ 明世隐：abstract等后面讲接口的时候来说明，我们比较常用就是 static 了。
♀ 小AD：这个我知道，main方法就是用static修饰的。
♂ 明世隐：用static修饰的调用就不需要每次都实例化，可以直接调用。
♀ 小AD：为啥不用实例化，我之前看你的调用方法都是要 new *** 这样的 。
♂ 明世隐：嗯，new 类名 就是实例化，static 方法在类第一次加载的时候，static就已经在内存中了，直到程序结束后，该内存才会释放。不需要再消耗资源反复创建对象。
♀ 小AD：我觉得我听懂了。
♂ 明世隐：那你说说看
♀ 小AD：比如我们两双排，你邀请我后，每盘结束以后是不是不需要重新再拉我了，默认就在队伍里面，不需要你每次点击邀请，重复力气。（符合两个条件：1.第一次就加载。2.不需要重复占用资源。）
♂ 明世隐：我草，给我个痛快吧，受不了了。
♀ 小AD：我这才学多久你就受不了了。
♂ 明世隐：我只能说你是大聪明！
♀ 小AD：哥，我肯定你是在夸我。
♂ 明世隐：对对对！看一下static调用实例。
public class Learn9 {
public static void main(String[] args) {
System.out.println("learn9 main");
Learn9.test();
}
static void test(){
System.out.println("learn9 static test");
}
}
运行
1.public（公共访问控制符），指定该变量为公共的，它可以被任何对象的方法访问。
定义public变量a，看看访问情况
在同类中
public class Learn10 {
public int a=10;
public static void main(String[] args) {
System.out.println("learn10 main");
new Learn10().test();
}
void test(){
System.out.println(a);
}
}
同包别的类
public class Learn9 {
public static void main(String[] args) {
System.out.println("learn9 main");
System.out.println(new Learn10().a );
}
}
不同包中
import learnJava.Learn10;
public class XiaoLuBan {
public static void main(String[] args) {
System.out.println(new Learn10().a );
}
}
可以看到都是可以访问的。
2.protected（保护访问控制符）指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。
把变量a改成 protected
可以观察到在其他包中不能访问到
3.default(默认权限），指定该变量只对同包可见，对不同包（含不同包的子类）不可见。
改成default，和上面的情况一样（子类的情况先不管）
4.private（私有访问控制符）指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。
改成private后只有本类中的方法可以访问到这个变量。
5.final，最终修饰符，指定此变量的值不能变。
把a定义成final后，想对这个变量进行赋值操作，就会编译错误。
6.static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。
♀ 小AD：明哥这次还是要重点关注public咯
♂ 明世隐：额。。不要一概而论，变量常用private修饰符。
♀ 小AD：那不是只能在本类中才能访问吗？我其他类调用怎么办？
♂ 明世隐：你知道private只能在本类中访问，说明private你是熟悉了。
♀ 小AD：对啊 ，那怎么取这个变量呢？
♂ 明世隐：用set get方法来存取呢。
♀ 小AD：那你还不是要把set get方法设置成public的吗？有嘛区别？多此一举。
♂ 明世隐：你有此问题，说明你是个爱动脑的娃儿，但是你段位怎么就上不去了呢？
♀ 小AD：哥，你咋回事绕到那边去了。
♂ 明世隐：意思就是说，我们一般不能直接开放给别人访问变量，通过set get 访问更安全，我们可以在set get方法中做相应的修饰，就不会被随意的设置上值了。
实例1：
直接修改属性方式
public class XiaoLuBan {
private String yanzhi = "";
public static void main(String[] args) {
XiaoLuBan xiaoLuBan = new XiaoLuBan();
xiaoLuBan.yanzhi="丑八怪";
System.out.println(xiaoLuBan.niDeYanZhi());
}
public String niDeYanZhi(){
return yanzhi;
}
}
实例2：
通过set方式
public class XiaoLuBan {
private String yanzhi = "";
public static void main(String[] args) {
XiaoLuBan xiaoLuBan = new XiaoLuBan();
//xiaoLuBan.yanzhi="丑八怪";
xiaoLuBan.setYanzhi("丑八怪");
System.out.println(xiaoLuBan.niDeYanZhi());
}
public void setYanzhi(String yanzhi) {
if("美女".equals(yanzhi)){
this.yanzhi = yanzhi;
}else if("五百年一遇的美女".equals(yanzhi)){
this.yanzhi = yanzhi;
}else{
this.yanzhi = "大美女";
}
}
public String niDeYanZhi(){
return yanzhi;
}
}
♀ 小AD：原来是这样啊，直接设置比较死板，还容易有问题。
♂ 明世隐：对啊，所以推荐set get方法来使用变量，变量设置为private。
♀ 小AD：比如你的钱，是私有的，如果设置为public的，那我可以拿了吧。
♂ 明世隐：你想的美，你问你嫂子拿去吧，我创建一个方法，通过你嫂子拿。
♀ 小AD：我怕我要被打。
♂ 明世隐：知道就好！哥给你展示一下怎么用。
/**
* 明哥类
*
*/
public class MingGe {
private int money=10000000;
public void getMoneyFromMingSao(String user) {
System.out.println("明哥的资产："+money);
if("明哥".equals(user)){//如果是明哥，给1000
money-=1000;
System.out.println("1000");
}else if("小鲁班".equals(user)){//如果是小鲁班，找打
System.out.println("找打吧你");
}else{
System.out.println("给你 0 元");
}
System.out.println("取钱后明哥的资产："+money);
}
public static void main(String[] args) {
new MingGe().getMoneyFromMingSao("明哥");
}
}
public class MingGe {
private int money=10000000;
public void getMoneyFromMingSao(String user) {
System.out.println("明哥的资产："+money);
if("明哥".equals(user)){//如果是明哥，给1000
money-=1000;
System.out.println("1000");
}else if("小鲁班".equals(user)){//如果是小鲁班，找打
System.out.println("找打吧你");
}else{
System.out.println("给你 0 元");
}
System.out.println("取钱后明哥的资产："+money);
}
public static void main(String[] args) {
//new MingGe().getMoneyFromMingSao("明哥");
new MingGe().getMoneyFromMingSao("小鲁班");
}
}
♀ 小AD：明哥，你在家里的地位有那么高吗？我才不信
♂ 明世隐：你不看哥我是谁，哥拿捏的好。
♀ 小AD：切。。。，打排位还不让嫂子知道，还说你拿捏的好。
♂ 明世隐：你不是一样吗，还说这个，今天你的星就免了，拜拜了您嘞。
♀ 小AD：不是哥、哎、哥。。。。。。哥。
本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注的更多内容！
