Java基础系列17-面向对象之关键字(final,static)

x33g5p2x  于2021-12-18 转载在 其他  
字(3.6k)|赞(0)|评价(0)|浏览(407)

一. final和static关键字

1.1 final关键字的概述及特点

final关键字是最终的意思,可以修饰类,成员变量(在类中,方法外),成员方法。
  修饰类,类不能被继承
  修饰变量,变量就成了常量,只能被赋值一次
  修饰方法,方法不能被重写

代码:
final1

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-28
  6. * @remark 父类 final关键字的概述及特点
  7. *
  8. */
  9. public class final1 {
  10. public final void method() {
  11. System.out.println("method father");
  12. }
  13. }

final2

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-28
  6. * @remark 子类 final关键字的概述及特点
  7. *
  8. */
  9. public class final2 extends final1 {
  10. public final int age = 20;
  11. public void show() {
  12. //age=10; //The final field final2.age cannot be assigned
  13. System.out.println(age);
  14. }
  15. //final 修饰的父类方法不能被重写
  16. //java.lang.VerifyError: class Java_study.final2 overrides final method method.
  17. /*
  18. @Override
  19. public void method(){
  20. System.out.println("method son")
  21. }
  22. */
  23. }

final3

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-28
  6. * @remark 测试类 final关键字的概述及特点
  7. *
  8. */
  9. public class final3 {
  10. public static void main(String[] args) {
  11. final2 son = new final2();
  12. son.show();//20
  13. son.method();//method father
  14. }
  15. }

测试记录:

  1. 20
  2. method father

1.2 static关键字的概述及特点

静态static的概述:
  当在定义类的时候,类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时,这个方法没有访问到对象的特有数据时,方法创建这个对象有些多余。可是不创建对象,方法又调用不了,这时就会想,那么我们能不能不创建对象,就可以调用方法呢?
  可以的,我们可以通过static关键字来实现。static它是静态修饰符,一般用来修饰类中的成员。

静态static的特点:
  被类的所有对象共享
    这也是我们判断是否使用静态关键字的条件
  可以通过类名调用
  优先于对象存在
  随着类的加载而加载

代码:
static1

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-28
  6. * @remark 学生类
  7. *
  8. */
  9. public class static1 {
  10. public String name;
  11. public int age;
  12. //public String graduateFrom;//毕业院校
  13. public static String graduateFrom;//毕业院校
  14. public void show() {
  15. System.out.println(name + "---" + age + "---" + graduateFrom);
  16. }
  17. }

static2

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-28
  6. * @remark 学生类测试类
  7. *
  8. */
  9. public class static2 {
  10. public static void main(String[] args) {
  11. //B: 可以直接通过类名直接访问
  12. static1.graduateFrom = "五道口职业技术学院";
  13. static1 s1 = new static1();
  14. s1.name = "杜兰特";
  15. s1.age = 32;
  16. //E:不应该通过实例访问静态成员
  17. //s1.graduateFrom = "传智学院";
  18. s1.show();//杜兰特---32--五道口职业技术学院
  19. }
  20. }

测试记录:

  1. 杜兰特---32---五道口职业技术学院

1.3 static方法的访问特点及注意事项

静态方法的访问特点:
  静态方法只能访问静态的成员变量和静态的成员方法
  静态方法的注意事项
    在静态方法中是没有this,super关键字的
      静态的内容是随着类的加载而加载

this 和 super 是随着对象的创建而存在

1.4 为什么静态成员、静态方法中不能用this和super关键字

  1. 在问题之前先讲super的用法:
    1.1 super 的用法跟 this 类似,this 代表对本类对象的引用,指向本类已经创建的对象;而 super 代表对父类对象的引用,指向父类对象;
    1.2 静态优先于对象存在;
    1.3 由上面的 1.1 和 1.2 知:
     因为静态优先于对象存在,所以方法被静态修饰之后方法先存在,而方法里面要用到super指向的父类对象,但是所需的父类引用对象晚于该方法出现,也 就是super所指向的对象没有,当然就会出错。
     综上,静态方法中不可以出现super关键字。
  2. 在静态方法中是不能使用this预定义对象引用的,即使其后边所操作的也是静态成员也不行.
    因为this代表的是调用这个函数的对象的引用,而静态方法是属于类的,不属于对象,静态方法成功加载后,对象还不一定存在
  3. 你要明白对象和类的区别。
    this和super是属于对象范畴的东西,而静态方法是属于类范畴的东西
    所有的成员方法,都有一个默认的的参数this(即使是无参的方法),只要是成员方法,编译器就会给你加上this这个参数如:
    Class A中
    void method1(){}    实际上是这样的--------> void method1(A this)
    void method2(int x){} 实际上是这样的--------> void method2(A this, intx)
    而静态方法与对象无关,根本不能把对象的引用传到方法中,所以不能用this
  4. 在一个类中定义一个方法为static,则为静态方法,那就是说,无需本类的对象即可调用此方法,调用一个静态方法就是“类名.方法名”
    既然"无需本类的对象即可调用静态方法",而this和super关键字都是用于本类对象的-----调用静态方法无需本类的对象这句话很清楚表明:静态方法中不能用this和super关键字
  5. 静态方法是存放在内存中的数据段里,this 和 super 调用的是堆空间里的应用对象,不能调用数据段区域里的数据,因此静态方法中不能用 this 和 super 关键字
  6. 静态方法和静态类不属于单个对象,而是类的所有对象共享使用,而 this 代表当前对象
  7. 静态方法等公用同一段存储区

代码:
static3

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-28
  6. * @remark 学生类 static方法的访问特点及注意事项
  7. */
  8. public class static3 {
  9. //非静态的成员变量
  10. private String name = "杜兰特";
  11. //今天的成员变量
  12. private static int age = 30;
  13. // A.非静态的成员方法
  14. public void show() {
  15. //a1.非静态的成员方法能访问非静态的成员变量
  16. this.name = "刘德华";
  17. System.out.println(name);
  18. //a2.非静态的成员方法能访问静态的成员变量
  19. System.out.print(age);
  20. //a3.非静态的成员方法能访问非静态的成员方法
  21. show3();
  22. //a4.非静态的成员方法能访问静态的成员方法
  23. show4();
  24. }
  25. // B. 静态的成员方法
  26. public static void show2() {
  27. //c1:静态成员方法中不能出现this,super这样的关键字
  28. //this.age;
  29. //this.name;
  30. //b1.静态成员方法不能访问非静态成员变量
  31. //System.out.println(name);
  32. //b2. 静态的成员方法能访问静态的成员变量
  33. System.out.println(age);
  34. //b3. 静态的成员方法能访问静态的成员方法
  35. show3();
  36. //b4. 静态成员方法不能访问非静态成员方法
  37. //show4();
  38. }
  39. }

参考:

  1. https://blog.csdn.net/qq_43529621/article/details/115303081

相关文章