super、this 、final用法

最新推荐文章于 2024-11-13 17:26:18 发布

weixin_33881041

最新推荐文章于 2024-11-13 17:26:18 发布

阅读量102

点赞数

文章标签： python java

原文链接：https://my.oschina.net/yangzhiwei256/blog/3017313

版权

2019独角兽企业重金招聘Python工程师标准>>>

Java super

作用：显示或隐士调用父类构造方法，缺省默认super()

构造方法：方法名和类名相同,属性public,无返回值

构造方法可多个,以重载的形式出现，对象创建默认以无参的构造函数为入口创建，可以隐藏

子类继承父类

注意：super父类接口一定会执行

若父类只有无参构造函数，子类继承父类在子类的构造函数可以隐式通过super调用父类构造函数(可省略)

原因：子类继承父类实例化时是先从父类先开始实例化的，构造函数就是对象实例化的入口

父类只存在1个有参构造函数，那么子类构造函数中必须显示调用父类的接口(super：参数必须一致)
若父类存在多个构造函数，子类继承只需要继承父类的一个构造函数使用接口即可 (如果父类存在一个无参构造函数，可隐士调用)

注意：一般为了提高程序的健壮性，在创建有参的构造函数时一般一起显示创建无参的构造函数，使得创建无参的构造函数时不会报错，若对象必须使用参数才能初始化，只需创建一个有参构造函数即可，可以约束对象实例的创建流程

package com.zhiwei.basic;
class ParentCase{
	
	private String name="parent";
	public ParentCase(){
		System.out.println("父类无参构造函数"+name);
	}
	
	public ParentCase(String name){
		this.name=name;
		System.out.println("父类有参构造函数"+name);
	}
	
}

public class SonCase extends ParentCase{

	public SonCase(){
		super();
	}
	
	public SonCase(String name) {
		super(name);
		System.out.println("子类有参构造函数:son");
	}
	
	public static void main(String[] args) {
		new SonCase("son");
		new SonCase();
	}
	
}

-------------------------结果-----------------------------

父类有参构造函数son
子类有参构造函数:son
父类无参构造函数parent

Java this

作用：标识当前调用方法的对象（普通方法/构造方法）

注意：this()函数调用只能放在构造无参构造函数的第1句，否则编译报错,静态函数没有this指针，类属性和方法没有放在同一个存储区，一般用this区分

package com.zhiwei.basic;
public class BasicThis {
	
	public static void main(String[] args) {
		
		TestThis aa=new TestThis();
		aa.setName("hello");
		
		TestThis bb=new TestThis();
		bb.setName("Java");

		//测试this()无参构造函数的用法
		TestThis cc=new TestThis();
		System.out.println(cc);
	}
}

class TestThis{
	
	private String name;

	public String getName() {
		return name;
	}
    
	/**
	 * 打印引用该对象的自定义参数
	 * @param name
	 */
	public void setName(String name) {
		this.name = name; 
		System.out.println(this);
	}

	public TestThis(String name) {
		super();
		this.name = name;
	}
	
	/**
	 * 表示无参构造行数时默认调用TestThis(String str)的构造方法来初始化对象
	 * 这种形式在Tomcat、Spring等框架中设置默认配置中经常使用
	 * 
	 */
	public TestThis() {
		 this("张三");   
	}
    
	/**
	 *重写toString方法打印自定义参数
	 *证明this表示对当前方法的引用对象 
	 */
	@Override
	public String toString() {
		return "TestThis [name=" + name + "]";
	}
}

--------------------------结果------------------------------

TestThis [name=hello]
TestThis [name=Java]
TestThis [name=张三]

结果分析：第一段：

TestThis [name=hello]
TestThis [name=Java]

因为重写toString方法打印对象的属性name的值，因为name为public修饰只属于类的实例，打印的内容分别为自定义参数hello和Java,表明this表示的是两个不同的对象，也就是自定义的两个对象实例

第二段：

TestThis [name=张三]
TestThis cc=new TestThis();

对象创建时并未指定初始化参数，但是却打印出该对象的name属性值，这表明该对象初始化时调用this()，而this调用有参的构造函数进行初始化工作

final

用法：

修饰基础类型值不能改变，因此基础类型直接传递的是内存空间值，并且作为成员变量属性初始化必须指定初始值
修饰对象类型：引用不可变，但是引用指向的内存空间值是可变的

package com.zhiwei.base;

import java.util.ArrayList;
import java.util.List;

/**
 * final： 修饰的类不可继承，方法不可被重写
 *
 * final: 基础类型final修饰时值不会改变，作为成员属性初始化必须指定初始值，
 * 修饰的是对象时对象引用(指向地址)不可变，但是对象自身可改变(Java编程思想)
 *
 * String: 不可变因为被final修饰，存储在常量池中，提高安全性
 *
 * final和static区别：
 * final的变量对象不可改变，final修饰的类和方法不能被继承和重写
 * static:声明的变量存储在静态代码区，值可以改变，不过从属于对象本身而已，所有对象实例共享
 * */
public class FinalTest{

    public static void main(String[] args) {
        //赋值的本质就是将一个指针指向对象的可控的存储空间
        String str1 = "123456";
        String str2 = "123456";

        //true:表明str1和str2指向常量池中同一个对象："123456"
        System.out.println("str1==str2:" + (str1 == str2));

        str1 = "abcd";

        //abcd:因为str1指向新的存储空间，原来的"123456"对象未改变
        System.out.println("str1:" + str1);
        String str4 = "abcd";

        //true:因为它们又指向同一个对象
        System.out.println("str1==str4:" + (str1 == str4));

        //创建新的对象，存储在JVM 堆中
        String str3 = new String("123456");
        System.out.println("str1==str3:" + (str1 == str3));

        //final 修饰对象类型，list指向ArrayList的内存空间，指向不变，对应的内存空间值改变是OK的
        final List<String> list = new ArrayList<>();
        list.add("hello");
        System.out.println(list);
    }
}

转载于:https://my.oschina.net/yangzhiwei256/blog/3017313