java之this，super和代码块精选

Posted 2022-08-23 磊哥的Java历险记

前言：

本篇主要讲两块，一个是ｔｈｉｓ和ｓｕｐｅｒ的用法，再一个就是代码块的概念，文章每一部分的概念解释，代码，演示效果，都会贴在文章的对应地方，帮助大家理解和加深印象！

一.介绍

在编程语言里面每一个定义的方法里，都会有一个this关键字，这个this关键不是由在那儿定义来决定的，而是由谁来执行的决定的。这是判断this关键。

比如说吃饭这个方法它是由上帝来定义的，世界上所有的人来执行。吃饭这个行为发生的时候，主体就是在吃饭的这个人，也就是要有人执行吃饭这个行为。 有时候我们需要在一个行为（方法）里，能明确知道这个行为是谁来执行的，确切的说就是我要知道谁在吃饭。

在JAVA类中使用super来引用父类的成分，如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。怎么去引用里面的父类对象呢？使用super来引用，super是当前对象里面的父对象的引用。

二.知识点介绍

1、this

2、Super

3、This/super区别

4、代码块

三.知识点详解   

1、this

this是自身的一个对象，代表对象本身，可以理解为：指向对象本身的一个指针。

三种用法：（this的用法在java中大体可以分为3种）

(1) 普通的直接引用：

this相当于是指向当前对象本身。

代码演示：

package com.Test;

    public class Test 
        String s = "磊哥的java历险记-@51博客";

        public Test(String s1) 
            System.out.println("s = " + s1);
            //this当前对象，调用s属性
            System.out.println("1 -> this.s = " + this.s);
            //把参数值赋给成员变量，成员变量的值改变
            this.s = s1;
            System.out.println("2 -> this.s = " + this.s);
        

        public static void main(String[] args) 
            Test x = new Test("HelloWorld!");
            //验证成员变量值的改变
            System.out.println("s=" + x.s);
        
    

(2) 形参与成员名字重名，用this来区分：

代码演示：

package com.Test;

        //创建人类
        class Person 
            private int age = 10;
            public Person()
                System.out.println("初始化年龄："+age);
            
            //get方法
            public int GetAge(int age)
                this.age = age;
                return this.age;
            
        
        //主方法 
        public class Test 
            public static void main(String[] args) 
                //创建Person对象
                Person Lei = new Person();
                //对象调用方法，打印输出
                System.out.println("磊哥的年龄是： "+Lei.GetAge(25));
            
        

（3）引用构造函数

这个和super放在一起讲，见下面。

（4）用到一些内部类和匿名类

如事件处理，当在匿名类中用this时，这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名。

代码演示：

package com.Test;

public class Test 
    int i = 1;
    private  final  static  String name = "磊哥的java历险记-@51博客";
    public Test() 
        //创建线程,线程问题后面会讲，现在就是测试用一下
        Thread thread = new Thread() 
            public void run() 
                for (int j=0;j<5;j++) 
                    Test.this.run();//调用外部类的方法
                    try 
                        //线程睡眠1000毫秒
                        sleep(1000);
                     catch (InterruptedException ie) 
                    
                
            
        ; // 注意这里有分号
        //线程开始
        thread.start();

    
    public void run() 
        System.out.println("i = " + i);
        i++;
    
    //主方法调用
    public static void main(String[] args)
            throws Exception 
        new Test();
        System.out.println("============="+name+"=============");

    

（5）this同时传递多个参数

代码演示：

package com.Test;

public class Test 
        String x;
        String y;

        static void showtest(Test tc) //实例化对象
            System.out.println(tc.x + " \\n" + tc.y);
        
        void seeit() 
            showtest(this);
        

        public static void main(String[] args) 
            Test p = new Test();
            p.x = "磊哥的java历险记";
            p.y = "@51博客";
            p.seeit();
        
    

2、super

super可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。

super也有三种用法：

(1)普通的直接引用

与this类似，super相当于是指向当前对象的父类，这样就可以用super.xxx来引用父类的成员。

(2)子类中的成员变量或方法与父类中的成员变量或方法同名

代码演示：

package com.Test;

public class Test 
        String name;
        void value() 
            name = "磊哥的java历险记";
        
    
    //继承父类
    class City extends Test 
        String name;
        void value() 
            name = "_@51博客";
            super.value();      //调用父类的方法
            System.out.println(super.name);
            System.out.println(name);

        

        public static void main(String[] args) 
            City c=new City();
            c.value();
        
    

可以看到，这里既调用了父类的方法，也调用了父类的变量。若不调用父类方法value()，只调用父类变量name的话，则父类name值为默认值null。

(3)引用构造函数

super（参数）：调用父类中的某一个构造函数（应该为构造函数中的第一条语句）。

this（参数）：调用本类中另一种形式的构造函数（应该为构造函数中的第一条语句）。

代码演示：

package com.Test;

class Test 
    public static void prt(String s) 
        System.out.println(s);
    
    //构造方法(1)
    Test() 
        prt("父类·无参数构造方法： ");
    
    //构造方法(2)
    Test(String name) 
        prt("父类·含一个参数的构造方法： ");
    

class Chinese extends Test 
    Chinese() 
        super(); // 调用父类构造方法（1）
        prt("子类·调用父类”无参数构造方法“： ");
    
    Chinese(String name) 
        super(name);// 调用父类具有相同形参的构造方法（2）
        prt("子类·调用父类”含一个参数的构造方法“： "+name);
    
    Chinese(String name, int age) 
        this(name);// 调用具有相同形参的构造方法（3）
        prt("子类：调用子类具有相同形参的构造方法：his age is " + age+"  昵称："+name);
    
    public static void main(String[] args)
    
        Chinese cn = new Chinese();
        cn = new Chinese("磊哥的java历险记");
        cn = new Chinese("磊哥的java历险记", 25);
    

3、this/super区别

(1) super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）

(2) this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）

(3) super:super.变量名    super.成员函数据名（实参）

(4) this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）

(5) 调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。

(6) super()和this()类似,区别是，super()从子类中调用父类的构造方法，this()在同一类内调用其它方法。

(7) super()和this()均需放在构造方法内第一行。

(8) 尽管可以用this调用一个构造器，但却不能调用两个。

(9) this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。

(10) this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。

(11)  从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

4.代码块

    在Java中，我们想解决一定的问题，需要很多代码才能解决，这个时候，我们就需要使用””将我们的代码整理成一块儿代码，那么“”括起来的代码被称为代码块。

(1) 、局部代码块

    普通代码块就是直接定义在方法或语句中，以””划定的代码区域，此时只需要关注作用域的不同即可，方法和类都是以代码块的方式划定边界的。

代码演示：

package com.Test;

class Test
    public static void main(String[] args) 
        //第一个代码块
        
            String x = "磊哥的java历险记";
            System.out.println("普通代码块: " + x);
        

        //第一个代码块
        String x= "磊哥的java历险记_@51博客";
        System.out.println("代码块之外: " + x);
    
    

(2)、构造代码块

    直接定义在类中成员位置的代码块，优先于构造方法执行,构造代码块用于执行所有对象均需要的初始化动作，每创建一个对象均会执行一次构造代码块。

代码演示：

public classPerson 
       privateString name;
       privateint age;
       static
           System.out.println("静态代码块执行了");
       
       
           System.out.println("构造代码块执行了");
       
       Person()
       System.out.println("Person无参数的构造函数执行");
       
       Person(intage)
           this.age= age;
           System.out.println("Person（age）参数的构造函数执行");
       
    
    classPersonDemo
       publicstatic void main(String[] args) 
           Personp = new Person();
           Personp1 = new Person(23);
       
    

(3)、静态代码块

    静态代码块是定义在成员位置，使用static修饰的代码块。

特点：

它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。

    该类不管创建多少对象，静态代码块只执行一次。

    可用于给静态变量赋值，用来给类进行初始化。

  代码演示：

package com.Test;

public class Test 
        private String name;
        private int age;
        //静态代码块 磊哥的java历险记_@51博客
        static
            System.out.println("静态代码块执行了");
        
    
    class Person
        private String name;
        //成员代码块 又叫构造代码块 对象级别的代码块，每次创建对象都会执行一次
        
            System.out.println("我是构造代码块");
        
        //静态代码块 类级别的代码块，只有第一次创建对象时才运行，之后创建对象就不执行了
        static
            System.out.println("静态代码块");
        

        public Person(String name)
            super();
            this.name = name;
        

        public Person()
            super();
        

        public String getName() 
            return name;
        

        public void setName(String name)
            this.name = name;
        
    

    class TestDemo
        public static void main(String[] args)
            int a =10;
            //局部代码块限定变量作用域范围
            
                System.out.println(a);
                int b =20;
                System.out.println(b);
            
            //  System.out.println(b);
            Person p = new Person();
            Person p2 = new Person("磊哥");
            Person p3 = new Person("磊哥");
            Person p4 = new Person("磊哥");
            Person p5 = new Person("磊哥");
        
    

 代码截图和结果大家自己看：

 结语：

代码和举例都是一些简单易懂的例子，希望我的文章能给兄弟们带来收获，哪怕一点也行，如果有模拟问题可以在下面评论，看到就会回复！

感谢大家的持续关注！