Java基础：super、final、static关键字的使用

一、super

1、介绍：

super关键字是为了调用父类的属性或方法！

2、用法：

1）表示父类属性

使用：super.属性—明确表示从父类中调用属性

2）表示父类方法

a.表示父类构造方法：

无参构造： super( )，此时super( )可以省略。
有参构造： super(方法参数);此时不能省略，且必须处于构造方法的首行。注：此时不存在this的构造器调用！

b.表示父类被覆写的方法：

super.方法名(参数);

案例：

package test.aiti;

//公众号：挨踢小子

class Animal{
	public String name="佩奇";
	public void eat() {
		System.out.println("我喜欢吃肉!");
	}
	public void eat(String name) {
		System.out.println("我喜欢吃!"+name);
	}
}

class Pig extends Animal{
	public void eat() {
		System.out.println(super.name);//表示父类属性
		super.eat();//表示父类方法
		System.out.println("我喜欢吃草!");
	}
}
 
//公众号：挨踢小子

public class App 
{
    public static void main( String[] args )
    {
    	Pig pig =new Pig();
    	pig.eat();
    	pig.eat("面包");
    	 
    }
}

输出结果

佩奇
我喜欢吃肉!
我喜欢吃草!
我喜欢吃!面包

二、final

用法：final关键字表示的不可变的。主要用于修饰：数据、方法、类。
借鉴：https://www.cnblogs.com/xiaoxiaoyihan/p/4974273.html

1、final数据

final属性：

基本数据： 这种常数必须是基本数据类型。前置关键字final声明。定义时必须提供一个值

class Aiti{
    final String name;  // name未初始化，编译出错
}

POJO: 引用地址不能改变，但是对象本身可以修改处理。

//公众号：挨踢小子

class Aiti{
    String name = "挨踢";
} 
public class Demo { 
    public static void main(String[] args) {
        final Aiti p = new Aiti();
        p = new Aiti();   // Error:无法为最终变量p分配值
    }
}

但是可以这样

//公众号：挨踢小子

class Aiti{
    String name = "挨踢";
} 
public class Demo { 
    public static void main(String[] args) {
        final Aiti p = new Aiti();
       p.name = "挨踢小子";
    }
}

特殊情况：空白final，尽管被声明为final，但是却未得到一个初始值。即便如此，空白final还是必须在使用之前得到初始化

//公众号：挨踢小子

class Aiti{}

public class Demo {
    final int i;
    final Aiti p;

    Demo() {
        i = 1;
        p = new Aiti();
    }

    Demo(int x) {
        i = x;
        p = new Aiti();
    }

    public static void main(String[] args) {
        Demo at= new  Demo();
    }
}

1、final方法

final方法主要有两个方面的作用：
1、防止任何继承类覆盖方法。保证方法的行为在继承期间保持不变，不可被覆盖和改写。

2、提高程序执行的效率。将一个方法设成final后，编译器就会忽略为执行方法调用机制而采取的常规代码插入方法(将自变量压入堆栈；跳至方法代码并执行它；跳回来；清除堆栈自变量；最后对返回值进行处理)。它会用方法主体内实际代码的一个副本来替换方法调用。这样可以避免方法调用时的系统开销。若方法体太大，可能效率也得不到提升。

//公众号：挨踢小子

class Aiti {
    public final void eat() {
        //...
    }
}
public class at extends Aiti{
    public void eat() {}   //Cannot override the final method from Aiti
}

类内所有的private方法都自动成为final。由于不能访问一个private方法，所以它绝对不会被覆盖。

1、final类

将类定义成final后，结果只是禁止被继承。由于禁止了继承，所以一个final类中的所有方法都默认为final。

//公众号：挨踢小子

final class Aiti{
}

public class at extends Aiti{ // The type at cannot subclass the final class Aiti
}

三、static

用法：static 主要有4中使用情况：成员变量、成员方法、代码块和内部类
功能：static 修饰的属性和方法永远只有独一份，和对象无关，static叫做类数据，和对象无关，非static叫对象，和类无关

1、静态变量

静态变量： 只要静态变量所在的类被加载，这个静态变量就会被分配空间，因此就可以被使用了。对静态变量的引用有两种方式，分别是“类.静态变量"和”对象.静态变量"。

实例变量： 实例变量属于对象，只有对象被创建后，实例变量才会被分配内存空间，才能被使用，它在内存中存在多个复制，只有用“对象.实例变量”的方式来引用

2、静态方法

同理： static方法是类的方法，不需要创建对象就可以被调用，而非static方法是对象的方法，只有对象被创建出来后才可以被使用。
注意： 静态方法只能访问静态成员（包括成员变量和成员方法），非静态方法可以访问静态也可以访问非静态，静态方法中不可以定义this，super关键字；因为静态优先于对象存在，所以静态方法中不可以出现this，super关键字。

3、静态常量

//公众号：挨踢小子

public static String name="挨踢小子";//静态变量
public static final String sex="男";//静态常量

4、静态代码块

static修饰代码块在类加载时就会执行，且只会加载执行一次，之后不再执行。执行顺序：静态代码块–非静态代码块–构造方法。非静态代码块在每次实例化对象时都会执行一次。

案例：

package test.aiti;

//公众号：挨踢小子

class Obj{
		static {
			 System.out.println("------------------------------");
			 System.out.println("关注：挨踢小子");
			 System.out.println(Obj.name+"003");
	    	 System.out.println(Obj.sex+"004");
		}
		public static String name="挨踢小子";
		public static final String sex="男";
}
 
public class App 
{
	static {
		 System.out.println("挨踢小子，666");
		 System.out.println(Obj.name+"001");
		 System.out.println(Obj.sex+"002");
	}
	
    public static void main( String[] args )
    {
    	 System.out.println("++++++++++++++++++++++++++++++++");
    	 System.out.println(Obj.name);
    	 System.out.println(Obj.sex);
    }
}

输出结果

挨踢小子，666
------------------------------
关注：挨踢小子
null003
男004
挨踢小子001
男002
++++++++++++++++++++++++++++++++
挨踢小子
男