一篇文章带你入门Java修饰符

目录

• 定义
• 分类
• 访问控制修饰符
• 非访问控制修饰符
• 修饰符的使用说明
• 修饰类
• 修饰方法
• 访问控制修饰符
• 非访问控制修饰符
• 修饰变量
• 总结

定义

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：不是哥、哎、哥。。。。。。哥。

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注我们的更多内容！