其他分享
首页 > 其他分享> > 关键字

关键字

作者:互联网

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