溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
本篇文章為大家展示了Java中有哪些常用修飾符，內容簡明扼要并且容易理解，絕對能使你眼前一亮，通過這篇文章的詳細介紹希望你能有所收獲。
抽象類：被abstract 修飾的類
語法： abstract class 類名｛｝
抽象方法 ： 被abstract 修飾的方法
定義語法：
訪問修飾符 abstract 返回值類型 方法名（參數列表）；
abstract 訪問修飾符 返回值類型 方法名（參數列表）；
特點：
1.當一個類中存在抽象方法 那么這個類也必須是抽象的
2.一個抽象類中可以有抽象方法也可以有非抽象方法
3.如果一個類繼承了抽象類，這個類如果不想成為抽象類，那么這個類必須實現抽象類中的所有抽象方法
4.抽象類不能創建對象，但是可以聲明引用，抽象類的對象是存在的，是由子類創建子類對象時調用父類構造方法創建的，是無法自己手動去new 抽象類的對象的
抽象類的好處：強制使用多態
案例：
public class Demo{
public static void main(String[] args) {
}
}
abstract class Animal{
//抽象方法
public abstract void eat();
public abstract void sleep();
public void m1() {
System.out.println("m1");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("狗吃屎");
}
public void sleep(){
System.out.println("狗睡");
}
}
案例：
public class Demo{
public static void main(String[] args) {
Animal a = new Dog();
}
}
abstract class Animal{
public Animal() {
System.out.println("動物類的構造被調用 創建了 對象");
}
//抽象方法
abstract public void eat();
public abstract void sleep();
public void m1() {
System.out.println("m1");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("狗吃屎");
}
public void sleep(){
System.out.println("狗睡");
}
}static修飾成員變量：類變量 靜態變量 靜態屬性
定義語法：
訪問修飾符 static 數據類型 變量名 = 變量值；
static 訪問修飾符 數據類型 變量名 = 變量值；
訪問的方式（特點）
1.類變量可以用 類名.屬性名 訪問
2.可以通過創建對象 用引用去訪問 （不推薦）
案例：
public class Demo{
public static void main(String[] args) {
Test t1 = new Test();
Test t2 = new Test();
t1.a++;
t1.b++;
System.out.println(t2.a);//10
System.out.println(t2.b);//21
}
}
class Test{
int a = 10;//實例變量
static int b = 20;//類變量
}
案例2:
public class Demo{
public static void main(String[] args) {
/*Test t1 = new Test();
Test t2 = new Test();
t1.a++;
t1.b++;
System.out.println(t2.a);
System.out.println(t2.b);*/
System.out.println(Test.b);//20
}
}
class Test{
int a = 10;//實例變量
static int b = 20;//類變量
}static修飾成員方法： 靜態方法
語法：
訪問修飾符 static 返回值類型 方法名（形參列表）｛
方法的實現；
｝
static 訪問修飾符 返回值類型 方法名（形參列表）｛
方法的實現；
｝
特點：
1.靜態的方法中 不可以直接訪問非靜態的成員（成員變量 和 成員方法）
2.如果要訪問非靜態的成員 必須創建對象 通過引用取訪問
3.靜態方法可以通過 類名.方法名（） 訪問 也可以通過引用去訪問（不建議）
4.靜態的方法可以被繼承 靜態的方法不能被非靜態的方法所覆蓋 只能被靜態方法覆蓋 但是沒有多態（引用是什么類型 調用的方法就是這個類型中的方法）
5.在靜態方法中是不可以使用 this 和 super 關鍵字 因為 this 和 super都是和對象有關的 而靜態的成員和對象無關 先于對象存在
案例：關于靜態方法 訪問非靜態的成員
public class Demo{
public static void main(String[] args) {
/*Test t1 = new Test();
Test t2 = new Test();
t1.a++;
t1.b++;
System.out.println(t2.a);
System.out.println(t2.b);*/
//System.out.println(Test.b);//20
}
}
class Test{
int a = 10;//實例變量
static int b = 20;//類變量
//靜態方法
public static void m1() {
m2();
//System.out.println(a);
}
//成員方法
public void m2() {
}
}
案例：關于 靜態方法的使用 和 通過引用去訪問非靜態的成員
public class Demo{
public static void main(String[] args) {
//Test.m1();
Test t = new Test();
t.m1();
}
}
class Test{
int a = 10;//實例變量
static int b = 20;//類變量
//靜態方法
public static void m1() {
Test t = new Test();
System.out.println(t.a);
t.m2();
}
//成員方法
public void m2() {
System.out.println("m2");
}
}
案例：關于 靜態方法被繼承
public class Demo{
public static void main(String[] args) {
/*Dog d = new Dog();
d.eat();*/
Dog.eat();
}
}
//定義動物類
class Animal{
public static void eat() {
System.out.println("動物吃");
}
}
class Dog extends Animal{
}
案例：關于 靜態方法中是否能使用 this 和 super
public class Demo{
public static void main(String[] args) {
/*Dog d = new Dog();
d.eat();*/
//Dog.eat();
/*Animal a = new Dog();
a.eat();*/
Dog.eat();
}
}
//定義動物類
class Animal{
String sex = "狗妖";
public static void eat() {
System.out.println("動物吃");
}
}
class Dog extends Animal{
/*static String name = "金毛";
static int age = 3;*/
String sex = "母";//成員變量
public static void eat() {
String sex = "公"; //局部變量
System.out.println(super.sex);
/*System.out.println(name);
System.out.println(age);
System.out.println("狗吃");*/
}
}初始代碼塊：定義在類中 方法外 用于在創建對象時 和 成員變量 按照從上向下的順序執行初始化的操作 也叫做 動態代碼塊
語法：
｛初始化代碼塊 ｝
案例：
public class Demo{
public static void main(String[] args) {
Test t = new Test();
System.out.println(t.a);
System.out.println(t.b);
System.out.println(t.c);
}
}
class Test{
int a = 10;
int c;
int b;
{//初始化屬性的
c = 30;
b = 20;
}
}
static 修飾初始化代碼塊：靜態代碼塊
靜態代碼塊的作用：在類加載時 和靜態的屬性 按照順序執行 為類進行初始化操作
語法：
static{
}
案例：
public class Demo{
public static void main(String[] args) {
System.out.println(Test.a);
System.out.println(Test.b);
}
}
class Test{
static int a = 20;
static{
b = 40;
}
static int b;
}
注意：靜態變量 時有默認值 先進行賦默認值 再初始化
==================================================================
類加載：當jvm第一次使用一個類時 需要通過classpath 找到.class = 字節碼文件
讀入這個類中的信息（包名 類名 屬性 方法 靜態的變量 靜態的方法 。。。）并保存在虛擬機中 類加載只進行一次
類加載的時機：
1.創建對象時
2.類名訪問靜態成員（靜態屬性 靜態方法）
3.子類進行類加載時 會先進行父類的類加載
案例：關于 1和2 兩種情況類加載
public class Demo{
public static void main(String[] args) {
//1.創建對象
//Test t = new Test();
//2. 訪問靜態的成員
System.out.println(Test.a);
}
}
class Test{
static int a = 20;
static{
System.out.println("父類 類加載了");
}
}
案例：關于 3 情況的類加載
public class Demo{
public static void main(String[] args) {
//創建子類的對象
//Sub s = new Sub();
System.out.println(Sub.b);
}
}
class Test{
static int a = 20;
static{
System.out.println("父類 類加載了");
}
}
class Sub extends Test{
static int b = 30;
static{
System.out.println("子類進行類加載了");
}
}修飾變量
局部變量：final修飾的局部變量只能賦值一次 值一旦賦值不可以改變
常量的定義：
public static final double PI = 3.14159265457;
案例：
public class Demo{
public static void main(String[] args) {
int a = 20;//局部變量
final int b = 10;
a++;
b++;
System.out.println(a);
System.out.println(b);
}
}
public class Demo{
public static void main(String[] args) {
final int a ;//聲明
a = 10;
a = 20;//報錯
System.out.println(a);
}
}
實例變量
特點：
1.final修飾的實例變量沒有默認值
2.final修飾的實例變量只能賦值一次
3.final修飾的實例變量可以在構造方法中初始化 但是要保證每個構造都必須能夠為這個變量初始化
案例：
public class Demo{
public static void main(String[] args) {
Animal a = new Animal(250);
//System.out.println(a.a);//0
System.out.println(a.b);
}
}
class Animal{
/*int a = 10;//實例變量
final int b = 20;*/
int a;
final int b = 20;
public Animal(int b) {
this.b = b;
}
}
public class Demo{
public static void main(String[] args) {
Animal a = new Animal(250);
//System.out.println(a.a);//0
System.out.println(a.b);
}
}
class Animal{
/*int a = 10;//實例變量
final int b = 20;*/
int a;
final int b ;
public Animal(int b) {
this.b = b;
}
public Animal() {
b = 30;
}
}
類變量
特點：
1.final修飾的類變量沒有默認值
2.final修飾的類變量可以通過靜態代碼塊進行初始化
案例：
public class Demo{
public static void main(String[] args) {
System.out.println(Animal.a);
System.out.println(Animal.b);
}
}
class Animal{
static int a ;
final static int b ;
static{
b = 250;
}
}修飾方法
成員方法：
特點：
1.final修飾的成員方法可以重載
2.final修飾的成員方法不可以被覆蓋
語法：
public final void m1() {
}
final public void m1() {
}
案例：
public class Demo{
public static void main(String[] args) {
}
}
class Animal{
public void m1() {
System.out.println("m1");
}
}
class Dog extends Animal{
public final void m1() {
System.out.println();
}
}
靜態方法：
特點：
1.final修飾的靜態方法可以重載
2.final修飾的靜態方法不可以被覆蓋
案例：
public class Demo{
public static void main(String[] args) {
}
}
class Animal{
public final static void m1() {
System.out.println("m1");
}
public final static void m1(int a) {
System.out.println("m1");
}
}
class Dog extends Animal{
}修飾類
語法：
final class Animal{
}
特點：final修飾的類沒有子類 俗稱斷子絕孫類
jdk的類庫中有哪些final修飾的類？
String Math System
案例：
public class Demo{
public static void main(String[] args) {
}
}
class Dog extends System{
}class Animal{
public final static void m1() {
System.out.println("m1");
}
public final static void m1(int a) {
System.out.println("m1");
}}
class Dog extends Animal{
}
##### 修飾類
```java
語法：
final class Animal{
}
特點：final修飾的類沒有子類 俗稱斷子絕孫類
jdk的類庫中有哪些final修飾的類？
String Math System
案例：
public class Demo{
public static void main(String[] args) {
}
}
class Dog extends System{
}
上述內容就是Java中有哪些常用修飾符，你們學到知識或技能了嗎？如果還想學到更多技能或者豐富自己的知識儲備，歡迎關注億速云行業資訊頻道。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
