本篇文章为大家展示了Java中有哪些常用修饰符，内容简明扼要并且容易理解，绝对能使你眼前一亮，通过这篇文章的详细介绍希望你能有所收获。一、abstract 抽象的抽象类：被abstract 修饰的类语法： abstrac
本篇文章为大家展示了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) { 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) { //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.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.eat(); Dog.eat(); } }//定义动物类class Animal{ String sex = "狗妖"; public static void eat() { System.out.println("动物吃"); }}class Dog extends Animal{ String sex = "母";//成员变量 public static void eat() { String sex = "公"; //局部变量 System.out.println(super.sex); } }初始代码块：定义在类中 方法外 用于在创建对象时 和 成员变量 按照从上向下的顺序执行初始化的操作 也叫做 动态代码块语法：｛初始化代码块 ｝案例：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; 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; 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中有哪些常用修饰符，你们学到知识或技能了吗？如果还想学到更多技能或者丰富自己的知识储备，欢迎关注编程网精选频道。
--结束END--
本文标题: Java中有哪些常用修饰符
本文链接: https://www.lsjlt.com/news/278906.html(转载时请注明来源链接)
有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341
下载Word文档到电脑，方便收藏和打印～
2024-05-02
2024-05-02
2024-05-02
2024-05-02
2024-05-02
2024-05-02
2024-05-02
2024-05-02
2024-05-02
2024-05-02
回答
回答
回答
回答
回答
回答
回答
回答
回答
回答
官方手机版
微信公众号
商务合作
0