Java基础——修饰符（学习分享）

朱雀 2022-12-28 04:22 174阅读 0赞

### 文章目录 ###

*  修饰符
 *   *  介绍
     *   *  什么是修饰符
         *  分类
         *   *  访问权限修饰符
             *  非访问修饰符

# 修饰符 #

## 介绍 ##

### 什么是修饰符 ###

> 一般用来定义类、方法、变量，通常在语句的最前端。  
> 修饰符决定了一个类、方法、变量的可使用程度。

### 分类 ###

> 访问修饰符  
> 非访问修饰符

#### 访问权限修饰符 ####

> 可以用来保护对类、变量、构造方法、普通方法的访问。  
> ![在这里插入图片描述][20201214210504396.png]

*  public（公有访问修饰符）

> 可以修饰类、变量、构造方法、接口、普通方法。
> 
>  *  同一包内的类之间共享。
>  *  不同包之间导包后也可共享。
>  *  继承关系能共享。

//public修饰类
    public class TestPublic{ 
    	public String name;//public修饰类变量
    	public TestPublic(){ }//public修饰构造方法
    	public void test1(){ }//public修饰普通方法
    }
    //public修饰接口
    public interface TestInterface{ 
    //抽象类是有抽象方法，也有非抽象方法。
    //接口中的方法都是默认抽象的，接口其实可以理解成一种特殊的抽象类。
    //接口中的成员变量默认都是public static final修饰的。所有的属性都是静态的常量。
    //接口中的所有方法默认都是public abstract修饰的。
    //接口没有构造方法(构造方法用于创建对象)。
    	(public static final) String name = "小明";//默认public static final修饰变量
    	(public abstract) void test();//默认public abstract修饰方法
    }

*  protected（受保护的访问修饰符）（仅子类可见性）

> 可以修饰类中的变量、方法、构造方法。  
> 不能修饰接口中的变量、方法。  
> 不能修饰类和接口。  
> 同包的不同类之间共享（这里的不同类指的是子类）。  
> 不同包中的子类共享。

public class TestProtected{ 
    	protected int age;//protected修饰成员变量（子类可见）
    	protected void getAge(){ }//protected修饰方法（子类可见）
    	protected void TestProtected(){ }//protected修饰构造方法
    }
    public interface TestInterface{ 
    	//protected不能修饰接口、接口的变量、接口中的方法。
    	(public static final) int age = 10;//默认public static final修饰变量
    	(public abstract) void getAge();//默认public abstract修饰方法
    }

*  default（默认访问修饰符）

> 不使用任何关键字。  
> 可以修饰变量、方法。  
> 同包内的类间相互可见。  
> 接口隐式声明的变量是public static final修饰的。  
> 接口里的方法默认情况是public修饰的。

public class TestDefault{ 
    	int age;//修饰变量
    	void getAge(){ }//修饰方法
    	TestDefault(){ }//修饰构造方法
    }
    public interface TestInterface{ 
    	(public static final) int age; //默认public static final修饰变量
    	(public abstract) void getAge();//默认public abstract修饰方法
    }

*  private（私有访问修饰符）

> 最严格的访问级别。  
> 可以修饰类的变量、方法、构造方法。  
> 不能修饰接口的变量和方法。  
> 不能用来声明类和接口。  
> 只能被当前类访问。  
> 外部类可以通过公共的getter方法访问声明的private属性。

> 主要功能：
> 
>  *  隐藏类的实现细节和保护类的数据。

public class TestPrivate{ 
    	private int age;//private修饰变量
    	private TestPrivate(){ }//private修饰构造方法
    	private void getAge(){ }//private修饰普通方法
    }
    public interface TestInterface{ 
    	(public static final) int age; //默认public static final修饰变量
    	(public abstract) void getAge();//默认public abstract修饰方法
    }

#### 非访问修饰符 ####

*  static：静态的

> 修饰类变量、类方法。  
> 声明独立于对象的静态变量：
> 
>  *  静态变量只有一份拷贝。
>  *  也叫做类变量。
>  *  可以直接使用变量名，也可以用类名+点+静态变量名的方式调用。
> 
> 独立于对象的静态方法：
> 
>  *  不能使用类的非静态变量。
>  *  可以直接调用静态方法名，也可以直接用类名+点+静态方法名的方式调用。

//这是一个普通类
    public class TestModifierStatic { 
    	public String name;//非静态变量
    	public static int age = 10;//静态变量（类变量）
    	//静态方法，可以在未实例化对象前直接调用方法名；也可以采用TestModifierStatic.getAge()的方式调用
    	public static int getAge(){ 
    		//静态方法中不能调用非静态的变量，否则编译报错：
    		//Cannot make a static reference to the non-static field TestModifierStatic.name
    // System.out.println(TestModifierStatic.name);//编译报错
    		System.out.println("静态变量是："+TestModifierStatic.age);//静态变量是：10
    		System.out.println("这里是静态方法");//这里是静态方法
    		return age;//可以直接使用静态变量
    	}
    	//非静态方法，只能在实例化对象后通过对象+点+方法名的方式调用
    	public void getName(String name){ 
    		//非静态方法中可以使用非静态变量，也可以使用静态变量
    		System.out.println(name);//王二 非静态变量
    		System.out.println(age);//10 静态变量
    		System.out.println("这里是非静态方法");//这里是非静态方法
    	}
    	
    	public static void main(String[] args) { 
    		//静态方法可以在未实例化对象前直接调用
    		getAge();
    		
    // getName();//编译报错：Cannot make a static reference to the non-static method getName() from the type TestModifierStatic
    		//非静态方法之后在实例化之后才能调用
    		TestModifierStatic tms = new TestModifierStatic();
    		tms.getName("王二");
    	}
    }

*  abstract：抽象的

> 声明抽象类、抽象方法。

*  final：最终的

> 修饰类、方法、变量。  
> 修饰的类不能被继承。  
> 修饰的方法不能被重写。  
> 修饰的变量为常量，不能被修改。  
> 变量能被显示的初始化，并且只初始化一次。  
> 声明的final对象的引用不能指向不同的对象，对象中的数据可以改变。  
> final通常和static共用声明类常量。

//final修饰的类，表示最终的类，不能被继承
    public final class TestModifierFinal { }
    //编译错误，final修饰的类是最终类，不能被继承
    //The type TestMain cannot subclass the final class TestModifierFinal
    public class TestMain extends TestModifierFinal{ }

//final修饰的变量为常量，要初始化
    //public final String name;//final修饰的变量需要初始化，否则编译错误：The blank final field name may not have been initialized
    public final String name = "李二";//final修饰变量为常量，要初始化

//final修饰的方法不能被重写
    public  class TestModifierFinal { 
    	public final String name = "李二";//final修饰变量为常量，要初始化
    	public final static int age = 10;//final 组合static声明类常量
    	//final修饰的方法，表示最终方法，不能被重写
    	public final void getName(){ 
    		System.out.println(name);//李二
    		System.out.println(age);//10
    		System.out.println("final修饰的方法");//final修饰的方法
    	}
    	//普通方法
    	public void getAge(){ 
    		System.out.println(name);//李二
    		System.out.println(age);//10
    		System.out.println("普通方法");//普通方法
    	}
    	public static void main(String[] args) { 
    		TestModifierFinal tmf = new TestModifierFinal();
    		tmf.getName();
    		tmf.getAge();
    		/*运行结果为： 李二 10 final修饰的方法 李二 10 普通方法*/
    	}
    }
    public class TestMain extends TestModifierFinal{ 
    	//final修饰的父类方法不能被重写
    	//编译错误：Cannot override the final method from TestModifierFinal
    // public void getName(){}
    	public void getAge(){ 
    		System.out.println("子类重写父类方法");//子类重写父类方法
    	}
    	public static void main(String[] args) { 
    		TestModifierFinal tmf = new TestMain();
    		tmf.getAge();
    		tmf.getName();//子类不能重写父类的final方法，但是可以调用
    		/*运行结果为： 子类重写父类方法 李二 10 final修饰的方法*/
    	}
    }

*  synchronized：

> 是一种同步锁。  
> 声明的方法同一时间只能被一个线程访问。
> 
>  *  修饰代码块：被修饰的代码块被称作同步语句块；作用范围时\{\}内；作用对象是调用同步语句块的对象。
>  *  修饰方法：被修饰的方法称为同步方法；作用范围是整个方法；作用对象是调用这个方法的对象。
>  *  修饰静态方法：被修饰的静态方法叫做静态同步方法；作用范围是整个静态方法；作用对象是整个类的所有对象。
>  *  修饰类：作用范围是整个类；作用对象是整个类中的所有对象。

*  synchronized修饰代码块

public class TestModifierSynchronized implements Runnable{ 
    	private static int count;//声明一个全局变量 计数器
    	//声明构造方法
    	public TestModifierSynchronized() { 
            count = 0;
        }
    	//重写run()方法
    	@Override
    	public void run() { 
    		// TODO Auto-generated method stub
    		synchronized (this) { 
    			for (int i = 0; i < 5; i++) { 
    				try { 
    					System.out.println("线程名："+Thread.currentThread().getName()+":"+(count++));
    					Thread.sleep(100);//相邻两个线程休眠100毫秒
    				} catch (Exception e) { 
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    	public int getCount(){ 
    		return count;
    	}
    }
    public static void main(String[] args) { 
    	//方式一：同时访问一个对象
    	TestModifierSynchronized tms1 = new TestModifierSynchronized();
    	Thread t1 = new Thread(tms1,"sync_thread-1");
    	Thread t2 = new Thread(tms1,"sync_thread-2");
    	t1.start();
    	t2.start();
    	/*运行结果为： 线程名：sync_thread-1:0 线程名：sync_thread-1:1 线程名：sync_thread-1:2 线程名：sync_thread-1:3 线程名：sync_thread-1:4 线程名：sync_thread-2:5 线程名：sync_thread-2:6 线程名：sync_thread-2:7 线程名：sync_thread-2:8 线程名：sync_thread-2:9*/
    	
    	/*总结：两个并发线程访问同一个对象中的synchronized代码，同一时刻只有一个线程执行； 另一个线程阻塞，等当前线程执行完毕整个代码块，另一个线程才能执行该代码块。这两个线程 是互斥的，执行synchronized代码块时锁定了当前对象，执行完代码块才能释放对象所，下 一个线程才能获取对象所并执行。*/
    
    	//方式二：同时访问多个对象
    	TestModifierSynchronized tms2 = new TestModifierSynchronized(); 
    	TestModifierSynchronized tms3 = new TestModifierSynchronized(); 
    	Thread t3 = new Thread(tms2,"sync_thread-3");
    	Thread t4 = new Thread(tms3,"sync_thread-4");
    	t3.start();
    	t4.start();
    	/*运行结果为： 线程名：sync_thread-3:1 线程名：sync_thread-4:0 线程名：sync_thread-3:3 线程名：sync_thread-4:2 线程名：sync_thread-4:4 线程名：sync_thread-3:5 线程名：sync_thread-3:7 线程名：sync_thread-4:6 线程名：sync_thread-3:8 线程名：sync_thread-4:9*/
    	
    	/*总结：因为是两个线程分别创意一个对象去执行的，所以说每个线程都是锁定了自己创建的对象， 他们相互之间没有联系。*/
    }

*  synchronized修饰普通方法

public class TestModifierSynchronized2 implements Runnable{ 
    	private static int count = 0;//全局变量 计数器
    	//synchronized修饰普通方法
    	public synchronized void testRun(){ 
    		for (int i = 0; i < 5; i++) { 
    			try { 
    				System.out.println("线程名 ：" + Thread.currentThread().getName() + " 当前计数器 ：" + (count++));
    				Thread.sleep(1000);
    			} catch (InterruptedException e) { 
    				e.printStackTrace();
    			}
    		}
    	}
    	//重写run方法
    	@Override
    	public void run() { 
    		testRun();
    	}
    }
    public static void main(String[] args){ 
    	TestModifierSynchronized2 tms21 = new TestModifierSynchronized2();
    	Thread t5 = new Thread(tms21,"sync_thraf-5");
    	Thread t6 = new Thread(tms21,"sync_thraf-6");
    	t5.start();
    	t6.start();
    	/*运行结果为： 线程名 ：sync_thraf-5 当前计数器 ：0 线程名 ：sync_thraf-5 当前计数器 ：1 线程名 ：sync_thraf-5 当前计数器 ：2 线程名 ：sync_thraf-5 当前计数器 ：3 线程名 ：sync_thraf-5 当前计数器 ：4 线程名 ：sync_thraf-6 当前计数器 ：5 线程名 ：sync_thraf-6 当前计数器 ：6 线程名 ：sync_thraf-6 当前计数器 ：7 线程名 ：sync_thraf-6 当前计数器 ：8 线程名 ：sync_thraf-6 当前计数器 ：9*/
    	
    	/*总结：synchronized修饰普通方法时的效果和修饰代码块的效果是一样的。*/
    	
    	TestModifierSynchronized2 tms22 = new TestModifierSynchronized2();
    	TestModifierSynchronized2 tms23 = new TestModifierSynchronized2();
    	Thread t7 = new Thread(tms22,"sync_thrad-7");
    	Thread t8 = new Thread(tms23,"sync_thrad-8");
    	t7.start();
    	t8.start();
    	/*运行结果为： 线程名 ：sync_thrad-7 当前计数器 ：1 线程名 ：sync_thrad-8 当前计数器 ：0 线程名 ：sync_thrad-7 当前计数器 ：2 线程名 ：sync_thrad-8 当前计数器 ：3 线程名 ：sync_thrad-8 当前计数器 ：4 线程名 ：sync_thrad-7 当前计数器 ：5 线程名 ：sync_thrad-8 当前计数器 ：6 线程名 ：sync_thrad-7 当前计数器 ：7 线程名 ：sync_thrad-7 当前计数器 ：8 线程名 ：sync_thrad-8 当前计数器 ：9*/
    	
    	/*总结：synchronized修饰普通方法时的效果和修饰代码块的效果是一样的。*/
    }

*  synchronized修饰静态方法

public class TestModifierSynchronized3 implements Runnable{ 
    	private static int count = 0;//全局变量 计数器
    	//重写run方法
    	@Override
    	public void run() { 
    		testRun();
    	}
    	//synchronized修饰静态方法
    	public synchronized static void testRun(){ 
    		for (int i = 0; i < 5; i++) { 
    			try { 
    				System.out.println("线程名："+Thread.currentThread().getName()+" 当前计数器:"+(count++));
    				Thread.sleep(1000);//睡眠时间
    			} catch (Exception e) { 
    				e.printStackTrace();
    			}
    		}
    	}
    }
    public static void main(String[] args){ 
    	TestModifierSynchronized3 tms31 = new TestModifierSynchronized3();
    	Thread t9 = new Thread(tms31,"sync_thread-9");
    	Thread t10 = new Thread(tms31,"sync_thread-10");
    	t9.start();
    	t10.start();
    	/*运行结果为： 线程名：sync_thread-9 当前计数器:0 线程名：sync_thread-9 当前计数器:1 线程名：sync_thread-9 当前计数器:2 线程名：sync_thread-9 当前计数器:3 线程名：sync_thread-9 当前计数器:4 线程名：sync_thread-10 当前计数器:5 线程名：sync_thread-10 当前计数器:6 线程名：sync_thread-10 当前计数器:7 线程名：sync_thread-10 当前计数器:8 线程名：sync_thread-10 当前计数器:9*/
    	
    	/*总结：因为调用了静态方法，静态方法属于类，只在加载类的时候执行一次，所以多个线程并发执行的时候 会竞争同一个对象的锁。*/
    	
    	TestModifierSynchronized3 tms32 = new TestModifierSynchronized3();
    	TestModifierSynchronized3 tms33 = new TestModifierSynchronized3();
    	Thread t11 = new Thread(tms32,"sync_thread-11");
    	Thread t12 = new Thread(tms33,"sync_thread-12");
    	t11.start();
    	t12.start();
    	/*运行结果为： 线程名：sync_thread-11 当前计数器:0 线程名：sync_thread-11 当前计数器:1 线程名：sync_thread-11 当前计数器:2 线程名：sync_thread-11 当前计数器:3 线程名：sync_thread-11 当前计数器:4 线程名：sync_thread-12 当前计数器:5 线程名：sync_thread-12 当前计数器:6 线程名：sync_thread-12 当前计数器:7 线程名：sync_thread-12 当前计数器:8 线程名：sync_thread-12 当前计数器:9*/
    	
    	/*总结：因为调用了静态方法，静态方法属于类，只在加载类的时候执行一次，所以多个线程并发执行的时候 会竞争同一个对象的锁。*/
    }

*  synchronized修饰类

public class TestModifierSynchronized4 implements Runnable{ 
    	private static int count;
    	//构造方法
    	public TestModifierSynchronized4() { 
    		count = 0;
    	}
    	//重写方法
    	@Override
    	public void run() { 
    		testRun();
    	}
    	//synchronized修饰类
    	public void testRun(){ 
    		synchronized (TestModifierSynchronized4.class) { 
    			for (int i = 0; i < 5; i++) { 
    				try { 
    					System.out.println("线程名："+Thread.currentThread().getName()+" 计数器:"+(count++));
    					Thread.sleep(1000);//设置休眠时间
    				} catch (Exception e) { 
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    }
    public static void main(String[] args){ 
    	TestModifierSynchronized4 tms41 = new TestModifierSynchronized4();
    	Thread t13 = new Thread(tms41,"sync_thrad-13");
    	Thread t14 = new Thread(tms41,"sync_thrad-14");
    	t13.start();
    	t14.start();
    	/*运行结果为： 线程名：sync_thrad-13 计数器:0 线程名：sync_thrad-13 计数器:1 线程名：sync_thrad-13 计数器:2 线程名：sync_thrad-13 计数器:3 线程名：sync_thrad-13 计数器:4 线程名：sync_thrad-14 计数器:5 线程名：sync_thrad-14 计数器:6 线程名：sync_thrad-14 计数器:7 线程名：sync_thrad-14 计数器:8 线程名：sync_thrad-14 计数器:9*/
    	
    	/*总结：synchronized修饰类，给整个类加锁，所有的对象用同一把锁。*/
    	
    	TestModifierSynchronized4 tms42 = new TestModifierSynchronized4();
    	TestModifierSynchronized4 tms43 = new TestModifierSynchronized4();
    	Thread t15 = new Thread(tms42,"sync_thrad-15");
    	Thread t16 = new Thread(tms43,"sync_thrad-16");
    	t15.start();
    	t16.start();
    	/*运行结果为： 线程名：sync_thrad-15 计数器:0 线程名：sync_thrad-15 计数器:1 线程名：sync_thrad-15 计数器:2 线程名：sync_thrad-15 计数器:3 线程名：sync_thrad-15 计数器:4 线程名：sync_thrad-16 计数器:5 线程名：sync_thrad-16 计数器:6 线程名：sync_thrad-16 计数器:7 线程名：sync_thrad-16 计数器:8 线程名：sync_thrad-16 计数器:9*/
    	
    	/*总结：synchronized修饰类，给整个类加锁，所有的对象用同一把锁。*/
    }

*  volatile：

> 只能修饰变量。  
> 修饰的成员变量每次被线程访问时，都会从内存中重读该成员变量的最新值。  
> 当成员变量发生变化时，强迫线程将变化值回写到共享内存中。

private volatile static int num = 0;

参考地址：  
[https://blog.csdn.net/u012723673/article/details/80613557][https_blog.csdn.net_u012723673_article_details_80613557]  
[https://www.jb51.net/article/100962.htm][https_www.jb51.net_article_100962.htm]  
[https://blog.csdn.net/qq\_38011415/article/details/89047812][https_blog.csdn.net_qq_38011415_article_details_89047812]

[20201214210504396.png]: /images/20221120/3362a0151c804296a32e75a61f676a25.png
[https_blog.csdn.net_u012723673_article_details_80613557]: https://blog.csdn.net/u012723673/article/details/80613557
[https_www.jb51.net_article_100962.htm]: https://www.jb51.net/article/100962.htm
[https_blog.csdn.net_qq_38011415_article_details_89047812]: https://blog.csdn.net/qq_38011415/article/details/89047812