Java面向对象--关键字(super、static、final)

Java关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用做变量名、方法名、类名、包名和参数。本篇博客介绍super、static和final关键字的具体用法。

---

目录：

☍ super关键字

☍ static关键字

☍ final关键字

---

☍ super关键字

super关键字的使用

在Java类中使用super来调用父类中的指定操做:

☃ super可用于访问父类中定义的属性

☃ super可用于调用父类中定义的成员方法

☃ super可用于在子类构造器中调用父类的构造器

super.变量名;  //调用父类属性
super.方法名(参数列表);   //调用父类方法
super(参数列表);   在构造器中调用父类构造器

✦ 若是子类和父类没有同名成员，使用时能够省略super

注意：

➥ 尤为当子父类出现同名成员(同名属性和方法)时，能够用super代表调用的是父类中的成员

➥ super的追溯不只限于直接父类，还包括间接父类（父类的父类...）

➥ super和this的用法相像，this表明本类对象的引用，super表明父类的内存空间的标识

✦ 使用this访问属性和方法时，若是在本类中未找到，会从父类中查找，super则是直接从父类中寻找

✦ 总结而言this和super主要就是解决成员重名问题，若不重名使用时均可以省略

super关键字调用父类的构造器

☃ 子类中全部的构造器默认都会访问父类中空参的构造器

☃ 当父类中没有空参数的构造器时，子类的构造器必须经过this(参 参
表 数列表)或者super( 参数列表)语句指定调用本类或者父类中相应的
构造器。而且this()和super()只能在构造器中出现一个，且必须放在构造器的首行

☃ 若是子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错

public class Person{
    private String name;
    private int age;
    public Person(String name){
        this.name = name;
    }
    public Person(String name, int age){
        this(name);
        this.age = age;
    }
}

public class Student extends Person{
    private char sex;
    public Student(String name,int age,char sex){
        super(name,age);
        this.sex = sex;
    }
    public Student(String name,char sex){
        super(name);
        this.sex = sex;
    }
    public Student(String sex){
       // this.sex = sex;   编译出错，父类没有空参构造函数super();
    }
}

this和super的区别

	区别	this/this(参数列表)	super/super(参数列表)
1	访问属性	访问本类中的属性，若是本类没有此属性则从父类中继续查找	直接访问父类中的属性
2	调用访问	访问本类中的方法，若是本类没有此方法则从父类中继续查找	直接访问父类中的方法
3	调用构造器	调用本类构造器，必须放在构造器的首行	调用父类构造器，必须放在子类构造器的首行

---

☍ static关键字（重点）

static关键字概述

当咱们编写一个类时，其实就是在描述其对象的属性和行为，而并无产生实质上的对象，只有经过new关键字才会产生出对象，这时系统才会分配内存空间给对象，其方法才能够供外部调用。咱们有时候但愿不管是否产生了对象或不管产生了多少对象的状况下，某些特定的数据在内存空间里只有一份,例如全部中国人对象都拥有一个国籍‘中国’，这个属性没必要在声明中国人对象像时去为每个对象都单独分配一个用于表明国家名称的变量。

static关键字声明的属性和方法是静态变量和静态方法，或者称为类属性和类方法，是做用于全局的，声明为static的属性和方法在内存中是惟一的，任何该类对象对类属性和方法的修改都会影响其余对象的调用结果。

static属性和方法的设计思想

☃ 类属性做为该类各个对象之间共享的变量。在设计类时,分析 哪
些属性 不因对象的不一样而改变，将这些属性设置为类属性。相应的方法设置为类方法。

☃ 若是方法与调用者无关，则这样的方法一般被声明为类方法，因为不须要建立对象就能够调用类方法，从而简化了方法的调用。

static关键字的使用和特色

☃ 在Java类中，可用static修饰成员变量、方法、代码块、内部类

特色：

➥ 随着类的加载而加载，优先于对象存在

➥ 修饰的成员，被全部对象所共享

➥ 访问权限容许时，可不建立对象，直接被类调用

➥ 因为类只会加载一次，因此静态成员在内存中也只会存在一个。存在方法区的静态域中

静态变量和静态方法

☃ 静态变量由该类的全部实例共享 ，没有对象的实例时,能够经过“类.静态变量”的方式调用

☃ 没有对象的实例时，能够用“类名.方法名()”的形式访问由static修饰的类方法

例子：

public class StaticTest {
/*
 * static关键字
 * 一、static:静态的，类的
 * 二、static能够用来修饰属性，方法，代码块，内部类
 * 三、static静态变量（类属性）
 *   3-一、属性：按是否使用了static修饰，分为静态属性 vs 非静态属性（实列变量）
 *  	实例变量：咱们建立了类的多个独享，每一个独享都独立拥有类中的非静态属性，当修改其中一个对象中的非静态属性时，
 *  		        不会致使其余对象中一样的属性值的改变
 *  	静态变量：咱们建立子类的多个对象，多个对象共享同一个静态变量，当经过某一个都对象修改静态变量时，
 *   		        会致使其余对象调用此惊天变量时，是调用修改过的变量
 *   3-二、static修饰的其余说明
 *      （1）、静态变量随着类的加载而加载
 *      （2）、静态比变量的加载早于都对象的建立，能够经过类.静态变量的方式调用
 *      （3）、因为类只会加载一次，因此静态变量在内存中也只会存在一个。存在方法去的静态域中
 * 四、static静态方法（类方法）
 * 	4-一、随着类的加载而加载，能够经过‘类.静态方法（）’的方式调用
 * 	4-二、静态方法中，只能调用静态的成员
 *  	非静态方法中，能调用静态和非静态的成员
 *  
 * 注意：
 * 一、在静态的方法中，不能使用this和supper关键字
 * 二、不能重写静态方法
 * 
 * 开发中何时使用
 * 一、属性能够被多个对象共享，不会随着对象的不一样而不一样
 * 二、开发中，操做静态属性的方法一般设置为static方法
 * 三、工具类中的方法，习惯声明为static的，好比：Math、Arrays、Collections
 */
	static double PI = 3.14;
	static int distance;
	char nuit;
	public static void main(String[] args) {
		Chinese c1 = new Chinese();
		c1.name = "张三";
		c1.age = 30;
		Chinese c2 = new Chinese();
		c2.name = "李四";
		c2.age = 30;
		c1.nation = "CHN";
		System.out.println(c2.name + "国籍：" + c2.nation);
		 // 本类中不用建立对象就能够访问静态成员
		System.out.println("PI:" + PI);
		run();
		//调用其余类的静态变量和静态方法
		System.out.println(Chinese.nation);
		Chinese.eat();
	}
	
	public static void run() {
		//nuit = '米'; 错误，在static 方法内部只能访问类的 的static修饰的属性或方法
		//this.distance = 3000;tatic方法中不能有this和supper
		distance = 1000;
		System.out.println("跑了：" + distance);
	}
}

class Chinese{
		String name;
		int age;
		static String nation;
		
		public static void eat() {
			System.out.println("吃饭");
		}
}

注意：

➥ 在static方法内部只能访问类的的static修饰的属性或方法，不能访问类的非static的结构

➥ 由于不须要实例就能够访问static 方法，所以static 方法内部不能有this和supper

➥ static 修饰的方法不能被重写

---

☍ final关键字

final关键字的使用

在Java中声明类、变量和方法时，可以使用关键字final来修饰,表示“最终的”。

☃ final标记的类不能被继承。提升安全性，提升程序的可读性。

​ ☄ 例如：String类、System类、StringBuffer类

☃ final 标记的方法不能被子类重写

​ ☄ 例如：Object类中的getClass()方法

☃ final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只能被赋值一次，赋值后不可在其余类和方法中更改。

​ ☄ final标记的成员变量必须在声明时或在每一个构造器中或代码块中显式赋值，而后才能使用。

☄ 例如：Math中的PI(public static final double PI = 3.14159265358979323846;)

/*final：最终的
 * 一、final能够用来修饰的结构：类、方法和变量
 * 二、final用来修饰类：final类不能被其余类继承，好比String类，System类，Buffer类
 * 三、final用来修饰方法：不能被子类重写，如：Object类中的getClass()方法
 * 四、final用来修饰变量，此时的变量称为常量
 * 	4-一、final能够赋值的位置：显示初始化，代码块中初始化，构造器中初始化（声明的每一个构造器中都要初始化final属性）
 * 	4-二、final修饰形参时，代表形参是一个常量，当咱们在调用方法时赋值后，在方法体内能使用该形参，但不可修改
 * 
 * static final 修饰属性：全局常量
 * static final 修饰方法：全局方法
 */
public class finalDemo {
	//必需要给final变量赋值，赋值后不可再修改
	//final int MAX; 错误
	final double R = 1.314;  //显示赋值
	final double PI;
	final String NATION;
	{  //代码块赋值
		NATION = "China";
	}
	public finalDemo() {
		PI =  3.1415926;   //构造器赋值
	}
	public finalDemo(int n) {
		PI = n;   //此处还需初始化，由于PI为常量，在调用重载构造器时，系统不肯定是否给PI赋过值适合不一样对象又不一样的final属性
		//this.R = n;   不可使用this.fianl属性的方式初始化，
		//由于this指向当前对象，一旦对象建立，fianl属性的值也应当已经肯定，不可再修改
	}
	public void setPI() {
		//this.PI = 3.14;  不能够修饰final属性的值
	}
	//fianl常量形参
	public void setNum(final int num) {
		//num = 32;  错误，不可修改
		System.out.println("num:" + num);
	}
}

final class  FinalA{	
}

/*final类不能被继承
class B extends FinalA{	
}*/

class A{
	final public void shout() {
		System.out.println("hello world");
	}
}
class B extends A{
	/*不能重写final方法
	 * public void shout() {
		System.out.println("hello China");
	}*/
}

---

本博客与CSDN博客༺ཌ༈君☠纤༈ད༻同步发布