JAVA修饰符总结

JAVA修饰符总结
Java修饰符用于控制类、方法、变量和构造方法的访问级别和特性。

Java提供了多种修饰符，包括访问修饰符、非访问修饰符和继承修饰符。

本篇文章将对这些修饰符进行总结，并提供一些使用示例。

一、访问修饰符
Java提供了四种访问修饰符：public、protected、default（默认）和private。

这些修饰符的使用不仅可以控制类的访问级别，还可以控制
方法、变量和构造方法的访问级别。

1. public修饰符
public修饰符具有最高的访问级别，被public修饰的类、方法、变
量和构造方法可以被所有其他类访问。

示例代码：
```
public class MyClass
public void myMetho
System.out.println("This method can be accessed by any other class.");
}
public class OtherClass
public static void main(String[] args)
obj.myMethod(;
}
```
2. protected修饰符
protected修饰符限制了对同一包内的其他类的访问，以及对其他包中的子类的访问。

示例代码：
```
package mypackage;
public class MyClass
protected void myMetho
System.out.println("This method can be accessed by classes in the same package and subclasses in other packages.");
}
package otherpackage;
import mypackage.MyClass;
public class SubClass extends MyClass
public static void main(String[] args)
obj.myMethod(;
}
```
3. default（默认）修饰符
默认修饰符是指当没有使用任何访问修饰符时，所使用的修饰符。

默认修饰符限制了对同一包内的其他类的访问。

示例代码：
```
package mypackage;
class MyClass
void myMetho
System.out.println("This method can be accessed by classes in the same package.");
}
public class OtherClass
public static void main(String[] args)
MyClass obj = new MyClass(;
obj.myMethod(;
}
```
4. private修饰符
private修饰符具有最低的访问级别，被private修饰的类、方法、变量和构造方法只能被自己所在的类访问。

示例代码：
```
public class MyClass
private int myVar;
private void myMetho
System.out.println("This method can only be accessed by this class.");
}
public static void main(String[] args)
MyClass obj = new MyClass(;
obj.myVar = 10; // 正确
obj.myMethod(; // 正确
}
```
二、非访问修饰符
Java提供了四种非访问修饰符：final、abstract、static和synchronized。

这些修饰符用于控制变量、方法、类和接口的行为。

1. final修饰符
final修饰符可以用于修饰类、方法和变量。

- 当用final修饰一个类时，该类不能被继承。

示例代码：
```
public final class MyClass
//类定义
```
- 当用final修饰一个方法时，该方法不能被子类重写。

示例代码：
```
public class MyClass
public final void myMetho
//方法定义
}
public class SubClass extends MyClass
// 重写myMethod(方法将会导致编译错误
```
- 当用final修饰一个变量时，该变量成为常量，只能被赋值一次。

示例代码：
```
public class MyClass
final int myVar = 10; // 常量
public void myMetho
myVar = 20; // 不能再次赋值，将导致编译错误
}
```
2. abstract修饰符
abstract修饰符只能用于修饰类和方法。

- 当用abstract修饰一个类时，该类为抽象类，不能被实例化。

示例代码：
```
public abstract class MyClass
//类定义
```
- 当用abstract修饰一个方法时，该方法为抽象方法，只有方法的
声明，没有方法的实现。

示例代码：
```
public abstract class MyClass
public abstract void myMethod(;
```
3. static修饰符
static修饰符可以用于修饰变量、方法、代码块和内部类。

- 当用static修饰一个变量时，该变量为静态变量，属于类的变量，而不是对象的变量。

示例代码：
```
public class MyClass
static int myVar; // 静态变量
public static void main(String[] args)
MyClass obj1 = new MyClass(;
MyClass obj2 = new MyClass(;
obj1.myVar = 10;
obj2.myVar = 20;
System.out.println(obj1.myVar); // 输出20
System.out.println(obj2.myVar); // 输出20
}
```
- 当用static修饰一个方法时，该方法为静态方法，可以直接通过类名调用，不需要实例化对象。

示例代码：
```
public class MyClass
static void myMetho
System.out.println("This is a static method.");
}
public static void main(String[] args)
MyClass.myMethod(; // 直接调用静态方法
}
```
- 当用static修饰一个代码块时，该代码块为静态代码块，只在类加载时执行一次。

示例代码：
```
public class MyClass
static
System.out.println("This is a static block.");
}
public static void main(String[] args)
System.out.println("This is the main method.");
}
```
4. synchronized修饰符
synchronized修饰符可以用于修饰方法和代码块，用于实现多线程的同步。

- 当用synchronized修饰一个方法时，该方法为同步方法，在该方法被一个线程执行期间，其他线程无法访问该方法。

示例代码：
```
public class MyClass
public synchronized void myMetho
//方法定义
}
```
- 当用synchronized修饰一个代码块时，该代码块为同步代码块，在同一时刻只能有一个线程执行该代码块。

示例代码：
```
public class MyClass
public void myMetho
synchronized (this)
//代码块定义
}
}
```
三、继承修饰符
Java提供了两种继承修饰符：extends和implements。

1. extends修饰符
extends是用于类之间的继承关系的修饰符，用于定义一个类继承于一些类。

示例代码：
```
public class SuperClass
//超类定义
public class SubClass extends SuperClass
//子类定义
```
2. implements修饰符
implements是用于类和接口之间的实现关系的修饰符，用于定义一个类实现一个或多个接口。

示例代码：
```
public interface MyInterface
void myMethod(;
public class MyClass implements MyInterface
public void myMetho
//方法实现
}
```
综上所述，Java的修饰符可以通过访问修饰符、非访问修饰符和继承修饰符控制类、方法、变量和构造方法的访问级别和特性。

这些修饰符的灵活使用可以增强代码的可读性、安全性和可维护性。