Java 面向对象编程之四个关键字

Myth丶恋晨 2022-04-12 02:08 186阅读 0赞

**this，super，static，final**是四个常见的类的关键字，怎么样来描述类的属性和行为？  
如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。怎么去引用里面的父类对象呢？使用super来引用，this指的是当前对象的引用，super是当前对象里面的父对象的引用。static和final可以用来修饰变量，方法，类，他们有各自的特点。

## **1. this** ##

this代表对象的引用(谁调用就代表谁)， 必须放在非静态方法里面，this是自身的一个对象，代表对象本身， 指向对象本身的一个指针。  
参考 [Java关键字this][Java_this]  
**主要作用：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70]

(1)this调用本类中的属性，也就是类中的成员变量；

Public Class Student { 
         String name; //定义一个成员变量name
         private void SetName(String name) { //定义一个参数(局部变量)name
          this.name=name; //将局部变量的值传递给成员变量
         }
       } //   this这个关键字其代表的就是对象中的成员变量或者方法。

(2)this调用本类中的其他方法；

public class Student { //定义一个类，类的名字为student。 
     public Student() { //定义一个方法，名字与类相同故为构造方法
      this(“Hello!”);
        }
     public Student(String name) { //定义一个带形式参数的构造方法
        }
    }

(3)this调用本类中的其他构造方法，调用时要放在构造方法的首行。

ublic Class Student {
     String name; //定义一个成员变量name
     private void SetName(String name) { //定义一个参数(局部变量)name
    this.name=name; //将局部变量的值传递给成员变量
    }
    Return this
    }

## **2. super** ##

super主要作用：

1：主要存在于子类方法中，用于指向子类对象中父类对象。
       2：访问父类的属性
       3：访问父类的函数
       4：访问父类的构造函数

super主要有两种用法：  
　　1）super.成员变量/super.成员方法;  
　　2）super(parameter1,parameter2…)  
第一种用法主要用来在子类中调用父类的同名成员变量或者方法；第二种主要用在子类的构造器中显示地调用父类的构造器，要注意的是，如果是用在子类构造器中，则必须是子类构造器的第一个语句。  
super是一个关键字，代表父类的存储空间标识。(可以理解为父亲的引用)  
**程序实例：**

//父类
    class FatherClass {
        public int value;
        public void f() {
            value=100;
            System.out.println("父类的value属性值="+value);
        }
    }
     // 子类ChildClass从父类FatherClass继承  
    class ChildClass extends FatherClass {
        /**
         * 子类除了继承父类所具有的valu属性外，自己又另外声明了一个value属性，
         * 也就是说，此时的子类拥有两个value属性。
         */
        public int value;
          //在子类ChildClass里面重写了从父类继承下来的f()方法里面的实现，即重写了f()方法的方法体。     
        public void f() {
            super.f();//使用super作为父类对象的引用对象来调用父类对象里面的f()方法
            value=200;//这个value是子类自己定义的那个valu，不是从父类继承下来的那个value
            System.out.println("子类的value属性值="+value);
            System.out.println(value);//打印出来的是子类自定义的那个value的值，这个值是200
            /**
             * 打印出来的是父类里面的value值，由于子类在重写从父类继承下来的f()方法时，
             * 第一句话“super.f();”是让父类对象的引用对象调用父类对象的f()方法，
             * 即相当于是这个父类对象自己调用f()方法去改变自己的value属性的值，由0变了100。
             * 所以这里打印出来的value值是100。
             */
            System.out.println(super.value);
        }
    }
    /**测试类*/
    public class tEST1 {
        public static void main(String[] args) {
            ChildClass cc = new ChildClass();
            cc.f();
        }
    }

运行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 1]

## 3. static ##

static关键字的中文意思是静态的， 可以修饰字段、方法、内部类。使用该关键字修饰的内容，在面向对象中static修饰的内容是隶属于类，而不是直接隶属于对象的，故而生命周期与类相同，即在整个程序执行周期有效。所以static修饰的成员变量一般称作类成员变量，而static修饰的方法一般称作静态方法，普通变量和方法属于对象。  
主要有四种用法：  
（1）用来修饰成员变量，将其变为类的成员，从而实现所有对象对于该成员的共享；  
（2）用来修饰成员方法，将其变为类方法，可以直接使用“类名.方法名”的方式调用，常用于工具类；  
（3）静态块用法，将多个类成员放在一起初始化，使得程序更加规整，其中理解对象的初始化过程非常关键；  
（4）静态导包用法，将类的方法直接导入到当前类中，从而直接使用“方法名”即可调用类方法，更加方便。

public class Person {
        String name;
        static  int age;
        public String toString() {
            return "Name:" + name + ", Age:" + age;
        }
           public static void main(String[] args) {
            Person p1 = new Person();
            p1.name = "zhangsan";
            p1.age = 10;
            Person p2 = new Person();
            p2.name = "lisi";
            p2.age = 12;
            System.out.println(p1);
            System.out.println(p2);
        }
        /**Output
         * Name:zhangsan, Age:10
         * Name:lisi, Age:12
         *///
    }

内存分析：：：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 2]

## 4. final ##

final是一个关键字，用于修饰类，成员变量，成员方法。  
特点：它修饰的类不能被继承。它修饰的成员变量是一个常量。它修饰的成员方法是不能被子类重写的。  
final修饰的常量定义一般都有书写规范,被final修饰的常量名称,所有字母都大写。  
final修饰成员变量,必须初始化,初始化有两种，显示初始化；构造方法初始化,不能两个一起初始化

**-final关键字 主要用法有以下四种：**

（1）用来修饰数据，包括成员变量和局部变量，该变量只能被赋值一次且它的值无法被改变。对于成员变量来讲，我们必须在声明时或者构造方法中对它赋值；  
（2）用来修饰方法参数，表示在变量的生存期中它的值不能被改变；  
（3）修饰方法，表示该方法无法被重写；  
（4）修饰类，表示该类无法被继承。  
重写（覆盖）：在子类中定义某方法与其父类有相同的名称，返回类型和参数（有继承关系）  
重载：JAVA中一个类可以有多个同名方法，参数类型或个数等可以不同。（没有继承关系）

*  **final和private的区别：**  
    1.final修饰的类可以访问；  
    private不可以修饰外部类，但可以修饰内部类（其实把外部类私有化是没有意义的）。  
    2.final修饰的方法不可以被子类重写；  
    private修饰的方法表面上看是可以被子类重写的，其实不可以，子类是看不到父类的私有方法的。  
    3.final修饰的变量只能在显示初始化或者构造函数初始化的时候赋值一次，以后不允许更改；  
    private修饰的变量，也不允许直接被子类或一个包中的其它类访问或修改，但是他可以通过set和get 方法对其改值和取值。

***- \[ \]super和this的异同：***

**This指向本类，super指向父类**  
（1） super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）  
this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）  
（2）super:　它引用**当前对象的直接父类中的成员**（用来访问直接父类中被隐藏的父类中成员数据或 函数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参）  
this：它**代表当前对象名**（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）  
（3）调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。  
super()和this()类似,区别是，**super()从子类中调用父类的构造方法，this()在同一类内调用其它方法。super()和this()均需放在构造方法内第一行**。尽管可以用this调用一个构造器，但却不能调用两个。  
this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。  
this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。  
**从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。**

class Person { 
        public static void prt(String s) { 
           System.out.println(s); 
        } 
           Person() { 
           prt("父类·无参数构造方法： "+"A Person."); 
        }//构造方法(1) 
            Person(String name) { 
           prt("父类·含一个参数的构造方法： "+"A person's name is " + name); 
        }//构造方法(2) 
    } 
        public class tEST1 extends Person { 
        tEST1() { 
           super(); // 调用父类构造方法（1） 
           prt("子类·调用父类”无参数构造方法“： "+"A chinese coder."); 
        }     
        tEST1(String name) { 
           super(name);// 调用父类具有相同形参的构造方法（2） 
           prt("子类·调用父类”含一个参数的构造方法“： "+"his name is " + name); 
        }     
        tEST1(String name, int age) { 
           this(name);// 调用具有相同形参的构造方法（3） 
           prt("子类：调用子类具有相同形参的构造方法：his age is " + age); 
        }  
        public static void main(String[] args) { 
           tEST1 cn = new tEST1(); 
           cn = new tEST1("codersai"); 
           System.out.println();
           cn = new tEST1("codersai", 18); 
        } 
    }

运行结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 3]

**示例代码二：**

public class Test {
        Person person = new Person("Test");
        static{
            System.out.println("test static");
        }
         public Test() {
            System.out.println("test constructor");
        }
             public static void main(String[] args) {
            new MyClass();
        }
    } 
    class Person{
        static{
            System.out.println("person static");
        }
        public Person(String str) {
            System.out.println("person "+str);
        }
    }
    class MyClass extends Test {
        Person person = new Person("MyClass");
        static{
            System.out.println("myclass static");
        }     
        public MyClass() {
            System.out.println("myclass constructor");
        }
    }

运行结果如下：

> test static  
> myclass static  
> person static  
> person Test  
> test constructor  
> person MyClass  
> myclass constructor

过程分析：首先加载Test类，因此会执行Test类中的static块。接着执行new MyClass()，而MyClass类还没有被加载，因此需要加载MyClass类。在加载MyClass类的时候，发现MyClass类继承自Test类，但是由于Test类已经被加载了，所以只需要加载MyClass类，那么就会执行MyClass类的中的static块。在加载完之后，就通过构造器来生成对象。而在生成对象的时候，必须先初始化父类的成员变量，因此会执行Test中的Person person = new Person()，而Person类还没有被加载过，因此会先加载Person类并执行Person类中的static块，接着执行父类的构造器，完成了父类的初始化，然后就来初始化自身了，因此会接着执行MyClass中的Person person = new Person()，最后执行MyClass的构造器。

引用：  
[https://www.cnblogs.com/dolphin0520/p/3799052.html][https_www.cnblogs.com_dolphin0520_p_3799052.html]

[https://www.cnblogs.com/dotgua/p/6354151.html?utm\_source=itdadao&utm\_medium=referral][https_www.cnblogs.com_dotgua_p_6354151.html_utm_source_itdadao_utm_medium_referral]

[Java_this]: https://www.cnblogs.com/lzq198754/p/5767024.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70]: /images/20220412/d16c730b90b241afa23e0389ac83ac9a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 1]: /images/20220412/89d2c4e117824042ac0f21faf085b305.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 2]: /images/20220412/146e100aca5a4f4b8109d9a5cad95cc3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 3]: /images/20220412/53bf3ad54d0d467f903f1b2ebbb426a3.png
[https_www.cnblogs.com_dolphin0520_p_3799052.html]: https://www.cnblogs.com/dolphin0520/p/3799052.html
[https_www.cnblogs.com_dotgua_p_6354151.html_utm_source_itdadao_utm_medium_referral]: https://www.cnblogs.com/dotgua/p/6354151.html?utm_source=itdadao&utm_medium=referral