文章目录
 
Java中super关键字
Java中final关键字

 
Java中super关键字
 
super 可以理解为是指向自己父（超）类对象的一个指针，而这个超类指的是离自己最近的一个父类。
 
super关键字的作用：
 
调用父类的构造方法
调用父类的成员方法
 
注意：
 
1、super只能应用在成员方法和构造方法中，不能应用在静态方法中（和this是一样的），如果在构造方法中使用super，必须放在方法的第一行。

2、构造方法不存在覆盖的概念，构造方法可以重载。

3、关于构造方法的执行顺序：先执行父类的再执行子类的，必须完成父类的所有初始化，才能创建子类。

4、程序运行时机优先级是：类加载-->静态代码块运行-->静态变量初始化-->对应的构造函数运行
 
为什么会有super关键字
 
因为子类必须要调用父类的构造方法，先把父类构造完成，因为子类依赖于父类，没有父，也就没有子
有时候需要在子类中，显示的调用父类的成员方法和父类的构造方法。
子类中即使我们没有显示的调用父类的无参构造方法，那么它也会默认使用super()调用父类的无参构造方法，此种情况下子类如果显示的设置了有参构造器，必须显示设置无参构造器，否则编译时将会失败。
 
super和this在构造方法中的使用：
 
super(参数)：调用父类中的某一个构造函数（必须为构造函数中的第一行）。
this(参数)：调用本类中的构造函数（必须为构造函数中的第一行）。
 
Java中final关键字
 
final表示不可改变的含义
 
final关键字使用总结：
 
 
使用final关键字修饰的类不能被继承
 
 
使用final关键字修饰的方法不能被覆盖（重写）
 
 
使用final关键字修饰的变量，在使用前必须显示初始化。对于final修饰的成员变量，我们有且只有两个地方可以给它赋值，一个是声明该成员时赋值，另一个是在构造方法中赋值，在这两个地方我们必须给它们赋初始值。
 
 
使用final关键字修饰的变量（基本类型）一旦赋值，不能被改变。如果使用final关键字修饰的引用类型，那么这个引用只能指向一个对象，也就是说这个引用不能通过 ** new对象** 方式再次赋值，但被指向的对象中属性值是可以修改的
 
private static final Integer number = 6666;
public void addNumber(){
	//number不能进行修改，因为number使用final修饰了，变量（基本类型）一旦被赋值，就不能被改变
	number = 8888;
}

final Person person = new Person();
person.name = "张三";
System.out.println(person.name);

//再次new创建新对象引用时，不能编译通过
//person引用使用final修饰，限制了person指向堆区中的内存地址不能被修改(也就是person只能指向堆中唯一一个对象)，但是，person指向的对象的属性值是可以修改的
person = new Person();
 
 
构造方法不能被final修饰
 
 
会影响Java类的初始化，final定义的静态变量调用时不会执行java的类初始化方法，也就是说不会执行static代码块等相关语句，这是由java虚拟机规定的。
 
 
 
 
写博客是为了记住自己容易忘记的东西，另外也是对自己工作的总结，希望尽自己的努力，做到更好，大家一起努力进步！

 如果有什么问题，欢迎大家一起探讨，代码如有问题，欢迎各位大神指正！

 给自己的梦想添加一双翅膀，让它可以在天空中自由自在的飞翔！
 

 
文章目录
 
1 super关键字
1.1 super用于方法
1.1.1 用于构造方法
1.1.2 用于普通方法
1.1.2 用于属性
  
  
2 super与this关键字的区别
2.1 概念上
2.2 查找范围
2.3 特殊之处
 

 
1 super关键字
 
1.1 super用于方法
 
1.1.1 用于构造方法
 

 子类的构造函数里，其实默认调用的是父类的无参构造，此时super()可写可不写。
 
 当子类向调用父类的有参构造时，super（参数列表）必须要写，要告诉编辑器调用的是哪个有参构造！
 
 在子类构造方法中调用父类构造方法必须是第一行语句！
 
1.1.2 用于普通方法
 

   用于在子类中明确调用父类被覆写的方法！
 
1.1.2 用于属性
 

   表示调用父类中的属性！
 
2 super与this关键字的区别
 
Java中this关键字详解
 
2.1 概念上
 
this：访问本类中的属性及方法。
 super: 由子类访问父类中的属性、方法。
 
2.2 查找范围
 
this：先找本类，如果本类没有就调用父类。
 super：不查找本类直接调用父类。
 
 
 
2.3 特殊之处
 
this：可以表示当前对象！
 super：不可以 ！

在Java中this关键字和super关键字*
 
一个对象对应一个this，this是一个变量，是一个引用。this保存当前对象的内存地址指向自身。
 super关键字代表的就是“当前对象”的那部分父类型特征。
 
this和super出现在实例方法和构造方法中。this的语法是：“this.”、“this（）”、super的语法是：“super.”、“super()”。this和super不能使用在静态方法中。this.在区分局部变量和实例变量时不能省略；super.在“父类中有，子类中又有，如果在子类中访问‘父类的特征’时”，super.不能省略。
 
this()和super()都只会出现在构造方法的第一行,前者是通过当前的构造方法去调用”本类“中的其它构造方法，目的是实现代码复用。后者是通过当前的构造方法去调用”父类“中的构造方法，目的是创建子类对象时先初始化父类型特征。
 
当一个构造方法第一行既没有this()又没有super()的话，系统默认会有一个super()
 
public class Super {
    public static void main(String[] args) {
        C c = new C();
    }
}
class A {
    //这个无参构造方法是B类的父类--A类的无参构造器，所以最后执行这个方法的语句
    //这个类似于栈，最后调用的最先出栈，即最先执行，故最先输出 “1”
    public A() {
        System.out.println("A类的无参构造方法执行");
    }
}
class B extends A {
    public B() {
        System.out.println("B类的无参构造方法执行");
    }
    public B(String name) {
        //super(name); 在B类中找带String参数的构造方法，所以第四个执行这条语句
        //super()  其实这块也有super，只不过是系统默认分配，看不到而已这块的super找它父类的无参构造方法
        System.out.println("B类的String类参数构造方法执行");
    }
}
class C extends B {
    public C () {
        this("zhangsan");
        // new C 时先执行这条语句
        System.out.println("C类的无参构造方法执行");
    }
    public C (String name) {
        // this("zhangsan");会在C类中找带String参数的构造方法，所以第二个执行这条语句
        this(name,20);
        System.out.println("C类的String类参数构造方法执行");
    }
    public C (String name, int age) {
        // this(name,20);会在C类中找带String，int参数的构造方法，所以第三个执行这条语句
        super(name);
        // 找它父类的方法 在B类中
        System.out.println("C类的String类和int类参数构造方法执行");
    }
}
 

 super(实际参数) 【调用父类的构造方法】
 super.方法名（实际参数）【访问父类方法】

Java中super关键字及super()的使用：
 
1、super的使用：
 
（1）super是一个关键字。
 
（2）super和this很类似，我们对比着学习。
 
 
2、先复习一下this关键字的使用。
 
（1）this能出现在实例方法和构造方法中；
 （2）this的语法是“this.”和“this()”；
 （3）this不能出现在静态方法中；
 （4）this大部分情况下是可以省略的；
 （5）this.什么时候不能省略呢？
 在区分局部变量和实例变量时不能省略。例如：
 
Public void setName(String name){
	this.name = name;
}
 
（6）this()只能出现在构造方法的第一行，通过当前的构造方法去调用“本类”中的对应的构造方法，目的是：代码复用。
 
 
3、super关键字：
 
（1）super能出现在实例方法和构造方法中。
 
（2）super的语法是“super.”和“super()”。
 
（3） super不能出现在静态方法中。
 
（4） super大部分情况下是可以省略的。
 
（5）super.什么时候不能省略呢？
 别急，我们想一下this指向的是什么，是当前对象自己。super和this类似，它指向了当前对象自己的父类型特征（也就是继承过来的那些东西）。
 
super和this区别是：this可以看做一个引用变量，保存了改对象的地址，是当前对象整体，而super代表的是父类型特征，是子类局部的一些东西，这些继承过来的东西已经在子类里面了，你可以输出整体this，但不能输出父类型特征super。因为super指向的东西不是一个整体，没法打印输出。
 
System.out.println(this);  //输出this.toString()的值
System.out.println(super);  //编译报错，需要'.'
 
当在子类对象中，子类想访问父类的东西，可以使用“super.”的方式访问。例如：方法覆盖后，子类内部虽然重写了父类的方法，但子类也想使用一下父类的被覆盖的方法，此时可以使用“super.”的方式。当子类中出现和父类一样的属性或者方法，此时，你要想去调用父类的那个属性或者方法，此时“super.”不能省略。
 
this和super都只能在对象内部使用。
 this代表当前对象本身，super代表当前对象的父类型特征。
 
 
总结：“this.”是一个实例对象内部为了区分实例变量和局部变量。
 而“super.”是一个实例对象为了区分是子类的成员还是父类的成员。
 父类有，子类也有，子类想访问父类的，“super.”不能省略。**
 
 
（6）super()只能出现在构造方法的第一行，通过当前的构造方法去调用“父类”中的对应的构造方法，目的是：创建子类对象时，先初始化父类型特征。
 
用通俗的话来讲，要想有儿子，得先有父亲。
 
 
我们来看下面代码：
 写两个类，Animal和Cat，Cat继承Animal。
 
//父类，Animal类
class Animal {
	//构造函数
	public Animal() {
		System.out.println("Animal类的无参数构造函数执行");
	}
}

//子类，Cat类
class Cat extends Animal{
	//构造函数
	public Cat() {
		System.out.println("Cat类的无参数构造函数执行");
	}
}
 
执行下面一行代码：
 
Cat c1 = new Cat(); 
 
运行输出结果为：
     Animal类的无参数构造函数执行
     Cat类的无参数构造函数执行
 
我们发现实例化一个子类的对象，也就是调用了子类的构造方法，为什么父类的无参数构造方法也执行了，并在子类构造方法执行之前就已经执行了父类的无参数构造方法，好奇怪。
 
刚刚在上面的super关键字的使用第6点，我已经说了，super()和this()方法一样，都只能在构造方法的第一行出现。我们猜想，难道子类的构造方法第一行有一个隐形的super()方法？答案是肯定的。
 
我们把子类的构造方法的第一行给它加上super()：
 
//子类，Cat类
class Cat extends Animal{
	//构造函数
	public Cat() {
		super();
		System.out.println("Cat类的无参数构造函数执行");
	}
}
 
再执行下面代码：
 
Cat c1 = new Cat(); 
 
运行输出结果为：
     Animal类的无参数构造函数执行
     Cat类的无参数构造函数执行
 
和刚才的子类构造方法没加super()是一样的。
 
所以说当子类的构造方法内第一行没有出现“super()”时，系统会默认给它加上无参数的"super()"方法。
 
 
阅读仔细的人会发现，为什么是没有“this()和super()”就写上“super()”？有“this()”就不能写上“super()”吗？那我问你，当构造方法第一行有"this()"时，你还能手动添加“super()”吗？显然不行，因为“this()”也只能出现在第一行，你不能在它前面写任何代码。所以我们又得出一个结论：构造方法中“this()”和“super()”不能同时出现，也就是“this()”和“super()”都只能出现在构造方法的第一行。
 
上面谈的都是无参数的“super”方法，我们也可以在构造方法的第一行使用有参数的“super(父类构造函数的参数列表)”，但值得注意的是，当子类构造方法执行有参数的“super(参数列表)”方法，你得确保父类中也有对应的有参数构造方法，不然会编译报错。同样我要提醒一下，当子类构造方法的第一行执行super()无参数方法，那么父类中一定要有无参数构造方法，有的人可能会在父类中写了有参数的构造方法，却忽略了写无参数构造方法，那么在子类构造方法内就会报错，因为当你在一个类中写了有参数的构造方法时，无参数构造方法就会不存在，你需要自己补上无参数的构造方法，这是一个良好的编程习惯。
 
无论你子类构造方法有没有“this()”和“super()”方法，实例化子类对象一定一定会执行对应的父类构造方法，即不管实例化了一个怎样的孩子，它一定会先实例化一个对应的父亲。
 
 
下面给道例题练习一下this()和super()方法：
 
public class MyTest {
	
	public static void main(String[] args) {
		new Cat(); 
	}
}

//父类，Animal类
class Animal {
	//构造函数
	public Animal() {
		super();
		System.out.println("1：Animal类的无参数构造函数执行");
	}
	public Animal(int i) {
		super();
		System.out.println("2：Animal类的有int参数构造函数执行");
	}
}

//子类，Cat类
class Cat extends Animal{
	//构造函数
	public Cat() {
		this("");
		System.out.println("3：Cat类的无参数构造函数执行");
	}
	public Cat(String str) {
		super(5);
		System.out.println("4：Cat类的有String参数构造函数执行");
	}
}
 
输出结果为：
 2：Animal类的有int参数构造函数执行
 4：Cat类的有String参数构造函数执行
 3：Cat类的无参数构造函数执行
 
我们又可以得出一个结论：不管你创建什么对象，Object对象的无参数构造方法一定会先执行，因为Object是所有类的根类。
 
 
说了这么多，super()到底什么时候使用？来看下面代码：
 
public class MyTest {
	
	public static void main(String[] args) {
		Cat c1 = new Cat(3); 
		System.out.println("名字：" + c1.getName() + "，年龄：" + c1.getAge());
	}
}

//父类，Animal类
class Animal {
	//私有属性：名字
	private String name;
	
	//setter and getter
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	
	//构造函数
	public Animal() {
		
	}
	public Animal(String name) {
		this.name = name;
	}
}

//子类，Cat类
class Cat extends Animal{
	//私有字段：年龄
	private int age;
	
	//setter and getter
	public void setAge(int age) {
		this.age = age;
	}
	public int getAge() {
		return age;
	}
	
	//构造函数
	public Cat() {
		
	}
	public Cat(int age) {
		this.age = age;
	}
}
 
输出结果：名字：null，年龄：3
 
我们也知道，没有给c1的name赋值嘛，当然为默认值null啦。
 确实如此，所以我们给Cat加一个构造方法，给name和age都赋值。
 如下：
 
public Cat(String name, int age) {
	this.name = name; //报错
	this.age = age
}
 
显然这样做是会报错的，因为name已经被父类封装成private的了，不能直接访问，可能有的人会这样做：
 
public Cat(String name, int age) {
	setName(name);
	this.age = age;
}
 
显然这样做的确可以做到给父类的name赋值，但这样做是不建议的，我们在构造方法中通常只调用构造方法，不会去调用实例方法，况且当不止一个变量时，用set方法时，我们就要调用好多个实例方法去完成多个变量的赋值。这时候为什么不考虑使用super()方法呢？如下：
 
public Cat(String name, int age) {
	super(name);
	this.age = age;
}
 
这样就显得文雅，美观多了。
 
 
总结：
 1、this和super一样，都是对象内部的引用变量，只能出现在对象内部；
 
2、 this指向当前对象自己，super指向当前对象的父类型特征，故this的东西比super多，也就是super是this的一部分；
 
3、 this()和super()都只能出现在构造方法的第一行，故this()和super()方法不能共存，当一个类的构造方法第一行中没有this()，也没有super()，系统默认有super()方法；
 
4、this()是构造方法中调用本类其他的构造方法，super()是当前对象构造方法中去调用自己父类的构造方法。