abstaract关键字【抽象类】

1、概念：

​ 不能实例化（创建对象）的类就是抽象类，用abstract修饰

2、构成：

abstract class 类名{
  成员变量
  构造方法
  成员方法
  非抽象方法
  抽象方法
}

3、要求：

（1）抽象类和抽象方法必须用关键字abstract修饰

（2）抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类

（3）abstract修饰的方法没有方法体，且子类必须重写

（4）抽象类不能实例化，因为abstract类中有abstract方法

（5）抽象类的子类：

可以是一个抽象类，可以重写也可以不重写父类的抽象方法。

可以是一个具体类，这个类必须重写抽象类中的所有抽象方法（可以实例化。）

final关键字

1、概述

final表示最终的，用来修饰变量，方法和类

2、特性

（1）final 修饰的局部变量只能被赋值一次
（2）final 修饰的成员变量
（3）final 修饰的基本类型变量是一个常量(只能被赋值一次)，引用类型变量不可修改地址，如对象
（4）final 修饰的方法不能被重写
（5）final 修饰的类不能被继承

3、特点

final修饰可以保证安全性，比如数组的长度属性，String类，这些都是final修饰的，保证不可变

举例：

package com.fc.j._final;
/*
 * final修饰的局部变量
 */
public class FinalDemo1 {
	public static void main(String[] args) {
		// 测试final修饰的修饰的变量
		final int num;
		
		num = 10;
		
		System.out.println(num);
		
		/*
		 * 被final修饰的变量只能赋值一次
		 * 
		 * The final local variable num may already have been assigned
		 * 
		 * 被final修饰的局部变量num可能已经被赋值
		 */
		// num = 20;
	}
}

// final修饰的类不能被继承，断子绝孙
class Father {
	/*
	 * final 修饰的成员变量必须在声明时就赋值
	 * 
	 * The blank final field age may not have been initialized
	 * 空白的final成员变量可能未被初始化
	 */
	 // final int age;
	final int age = 16;
	
	public final void play() {
		System.out.println("下棋");
	}
}

class Son extends Father {
	/*
	 *  Cannot override the final method from Father
	 *  无法重写被final修饰的方法
	 */
//	@Override
//	public final void play() {
//		
//	}
}

Supper关键字

1、概述

（1）super指父类对象，用来区分父类和子类，用于调用父类的属性和方法

（2）用法和this非常类似：this指当前对象，super指父类对象

2、总结

（1）super指父类对象，对比this关键字，使用方法都一样

（2）super() 和this() 代码不能共存(都必须在首行)，但是实际效果其实是可以的，如果不写 super() 也会自动调用

（3）父类的属性要交给父类的构造方法去操作，没什么事就不要去使用 super() 来调用父类的构造方法了

举例：

调用父类的属性和方法

public class Father {
	public int age = 60;
	
	public void play() {
		System.out.println("下象棋");
	}
}

public class Son extends Father {
	public int age = 16;
	
	@Override
	public void play() {
		System.out.println("玩游戏");
	}
	
	public void showAge() {
		int age = 20;
		System.out.println("局部变量：" + age);
		System.out.println("当前对象成员变量：" + this.age);
		System.out.println("父类对象成员变量：" + super.age);
	}
	
	public void callPlay() {
		// 调用当前对象的方法
		this.play();
		// 调用父类对象的方法
		super.play();
	}
}

public class Demo {
	public static void main(String[] args) {
		Son son = new Son();
		
		son.showAge();
		
		son.callPlay();
	}
}

调用父类的构造方法

默认调用父类的无参构造，且必须在代码的第一行

class Father {
	private String name;

	public Father() {
		System.out.println("Father's Constrator be performed");
	}
    
    public Father(String name) {
        System.out.println("Father's Constrator be performed with name");
    }
}

class Son extends Father {
	private int age;

	public Son() {
        super();
		System.out.println("Son's Constrator be performed");
	}
    
    public Son(String name, int age) {
        super(name);
        this.age = age;
		System.out.println("Son's Constrator be performed with name and age");
	}
}

public class TestSon {
	public static void main(String[] args) {
		Son son = new Son();
	}
}
注意：
super() 和this() 代码不能共存(都必须在首行)，但是实际效果其实是可以的，如果不写 super() 也会自动调用

标签：age,public,关键字,修饰,println,super,final
来源： https://www.cnblogs.com/mshkkx/p/16527833.html