文章目录
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虚拟机规定的。



写博客是为了记住自己容易忘记的东西，另外也是对自己工作的总结，希望尽自己的努力，做到更好，大家一起努力进步！


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


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

super关键字的讲解
文章目录
super关键字的讲解
1. super 关键字可以理解为：父类的
2. 可以用来调用的结构：
3. super调用属性、方法：
4. super调用构造器：
5. 代码实现:


b站学习视频以及笔记-尚硅谷_Java零基础教程
java入门必备-适合初学者的全套完整版教程(宋红康主讲)

1. super 关键字可以理解为：父类的
2. 可以用来调用的结构：
属性、方法、构造器
3. super调用属性、方法：
3.1 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."

3.2 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。

3.3 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。
4. super调用构造器：
4.1  我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器

4.2 "super(形参列表)"的使用，必须声明在子类构造器的首行！

4.3 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)“只能二一，不能同时出现

4.4 在构造器的首行，没显式的声明"this(形参列表)“或"super(形参列表)”，则默认调用的是父类中空参的构造器：super()

4.5 在类的多个构造器中，至少一个类的构造器中使用了"super(形参列表)”，调用父类中的构造器
5. 代码实现:
父类
public class Person {
	String name;
	int age;
	int id = 1001;//身份证号
	
	public Person(){
		System.out.println("我无处不在！");
	}
	
	public Person(String name){
		this.name = name;
	}
	
	public Person(String name,int age){
		this(name);
		this.age = age;
	}
	
	public void eat(){
		System.out.println("人：吃饭");
	}
	public void walk(){
		System.out.println("人：走路");
	}
}

子类
public class Student extends Person{
	
	String major;
	int id = 1002;//学号
	
	public Student(){
		super();//调用父类无参构造方法
	}
	public Student(String major){
		super();//调用父类无参构造器
		this.major = major;
	}
	
	public Student(String name,int age,String major){
//		this.name = name;
//		this.age = age;
		super(name,age);//调用父类有参构造器
		this.major = major;
	}
	
	//重写
	@Override
	public void eat() {
		System.out.println("学生：多吃有营养的食物");
	}
	
	public void study(){
		System.out.println("学生：学习知识");
		this.eat();
		super.eat();//父类eat方法
		walk();//调用父类方法
	}
	
	public void show(){
		System.out.println("name = " + name + ", age = " + age);
		System.out.println("id = " + this.id);
		System.out.println("id = " + super.id);
	}
}


测试类
public class SuperTest {
	public static void main(String[] args) {
		
		Student s = new Student();//调用父类构造器
		s.show();//Student类的重写show方法
		
		System.out.println();
		
		s.study();//Student类的重写study方法
		
		Student s1 = new Student("Tom", 21, "IT");
		s1.show();
		
		System.out.println("************");
		Student s2 = new Student();//调用父类构造器
		
	}
}

Java中super关键字的使用(在实例方法中)
super和this都可以使用在实例方法中，并且都不能使用在静态方法当中，“this”大部分情况下都是可以省略的，只有在方法中区分局部变量和实例变量的时候不能省略。那“super”什么时候可以省略，什么时候不能省略呢？
//书
public class Book {
//书名
String name;
//构造方法
public Book(){
super();
}
public Book(String name){
super();
this.name = name;
}
}
//纸质书
public class PaperBook extends Book {
//构造方法
public PaperBook(){
super();
}
public PaperBook(String name){
super();
this.name = name;
}
//打印书名
public void printName(){
System.out.println("this.name->书名 ： " + this.name);
System.out.println("super.name->书名 ： " + super.name);
}
}
public class BookTest {
public static void main(String[] args) {
PaperBook book1 = new PaperBook("零基础学Java卷I");
book1.printName();
}
}
运行结果如下图所示：
图14-11：super和this
我们发现printName()方法中的super.name和this.name最终输出结果是一样的，这是为什么呢？请看以上程序执行的内存图：
图14-12：父类的构造方法执行结束之后的内存图
图14-13：子类的构造方法执行结束之后的内存图
通过以上内存结构图发现this.name和super.name实际上是同一块内存空间，所以它们的输出结果是完全一样的。接下来，我们再把以上的PaperBook类修改一下：
//纸质书
public class PaperBook extends Book {
String name; //在子类中也定义了一个name属性
//构造方法
public PaperBook(){
super();
}
public PaperBook(String name){
super();
this.name = name;//这里的this.name代表子类的name
}
//打印书名
public void printName(){
System.out.println("this.name->书名 ： " + this.name);
System.out.println("super.name->书名 ： " + super.name);
}
}
运行结果如下图所示：
图14-14：super和this的区别
为什么super.name是null呢，我们一起来看看以上程序的内存图：
图14-15：父类Book的构造方法执行之后的内存图
图14-16：子类PaperBook的构造方法执行结束之后的内存图
通过以上内存图可以清楚的看到，父类Book的构造方法在执行的时候给super.name赋值null，子类PaperBook的构造方法在执行的时候给this.name赋值“零基础学Java卷I”，由于在子类PaperBook中定义了重名的变量name导致在当前对象中有两个name，一个是从父类中继承过来的，一个是自己的，如果此时想访问父类中继承过来的name则必须使用super.name，当直接访问name或者this.name都表示访问当前对象自己的name。
通过以上的学习，大家知道super在什么情况下不能省略了吗？当父类中有该实例变量，子类中又重新定义了同名的实例变量，如果想在子类中访问父类的实例变量，super不能省略。实例方法是这样吗？我们可以来测试一下，请看代码：
public class Vip {
//Vip默认继承Object
//重写从Object类中继承过来的toString()方法
public String toString(){
return "我是金牌会员";
}
public void test(){
System.out.println(super.toString());
System.out.println(this.toString());
System.out.println(toString());
}
}
public class VipTest {
public static void main(String[] args) {
Vip vip = new Vip();
vip.test();
}
}
运行结果如下图所示：
图14-17：运行结果
通过以上测试得出最终结论：父类和子类中有同名实例变量或者有同名的实例方法，想在子类中访问父类中的实例变量或实例方法，则super是不能省略的，其它情况都可以省略。

一、super关键字
在JAVA类中使用super来引用父类的成分，用this来引用当前对象，如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。怎么去引用里面的父类对象呢？使用super来引用，this指的是当前对象的引用，super是当前对象里面的父对象的引用。
class Student {
public int age;
public void std(){ //声明Student类的方法std()
age = 15;
System.out.println("学生平均年龄为："+age);
}
}
class ThisStudent extends Student{
public int age;
public void std(){
super.std();  //使用super作为父类对象的引用对象来调用父类对象里面的Std()方法
age = 18;
System.out.println("这个学生的年龄为："+age);
System.out.println(super.age);  //使用super作为父类对象的引用对象来调用父类对象中的age值
System.out.println(age);
}
}
public class TestDif {
public static void main(String[] args) {
ThisStudent a = new ThisStudent();
a.std();
}
}
执行结果：
学生平均年龄为：15
这个学生的年龄为：18
15
18
二、上述程序的内存分析
ThisStudent a = new ThisStudent();
程序执行到这里时，首先在栈空间里面会产生一个变量a，a里面的值是什么这不好说，总而言之，通过这个值我们可以找到new出来的ThisStudent对象。由于子类ThisStudent是从父类Student继承下来的，所以当我们new一个子类对象的时候，这个子类对象里面会包含有一个父类对象，而这个父类对象拥有他自身的属性age。这个age成员变量在Student类里面声明的时候并没有对他进行初始化，所以系统默认给它初始化为0，成员变量(在类里面声明)在声明时可以不给它初始化，编译器会自动给这个成员变量初始化，但局部变量(在方法里面声明)在声明时一定要给它初始化，因为编译器不会自动给局部变量初始化，任何变量在使用之前必须对它进行初始化。
子类在继承父类age属性的同时，自己也单独定义了一个age属性，所以当我们new出一个子类对象的时候，这个对象会有两个age属性，一个是从父类继承下来的age，另一个是自己的age。在子类里定义的成员变量age在声明时也没有给它初始化，所以编译器默认给它初始化为0。因此，执行完第一句话以后，系统内存的布局如下图所示：
a.std();
当new一个对象出来的时候，这个对象会产生一个this的引用，这个this引用指向对象自身。如果new出来的对象是一个子类对象的话，那么这个子类对象里面还会有一个super引用，这个super指向当前对象里面的父对象。所以相当于程序里面有一个this，this指向对象自己，还有一个super，super指向当前对象里面的父对象。
这里调用重写之后的std()方法，方法体内的第一句话：“super.std();”是让这个子类对象里面的父对象自己调用自己的f()方法去改变自己age属性的值，父对象通过指向他的引用super来调用自己的std()方法，所以执行完这一句以后，父对象里面的age的值变成了15。接着执行“age=18；”这里的age是子类对象自己声明的value，不是从父类继承下来的那个age。所以这句话执行完毕后，子类对象自己本身的age值变成了18。此时的内存布局如下图所示：
方法体内的最后三句话都是执行打印age值的命令，前两句打印出来的是子类对象自己的那个age值，因此打印出来的结果为18，最后一句话打印的是这个子类对象里面的父类对象自己的age值，打印出来的结果为15。
到此，整个内存分析就结束了，最终内存显示的结果如上面所示。
(参考自孤傲苍狼)