JAVA学习笔记(十二)-final关键字与abstract关键字

final关键字

/*
* final关键字
* 可以修饰：变量、类、方法
*
* 1.被final修饰的变量，称为常量
*  常量在使用前必须赋值，但只能被赋值一次，初始化后不能再修改
*  a.可以在声明时直接赋值
*  b.也可以在声明后再赋值，但必须在构造方法或代码中赋值
*  c.静态常量（static final修饰）也可以在声明后赋值，但必须在静态代码块中赋值
*  常量命名规范：大写
*
* 2.被final修饰的方法
*  不能被子类重写
*
* 3.被final修饰的类
* 该类不能被继承，即不能存在子类
* final类中的方法默认都是final方法
*
* 4.被final修饰的参数
* 只能读取，不能被修改
*
*/
public class Test01
{
final int c=2; //final修饰的成员属性没有初始值
final String name;
final int d;
final static int X; //静态常量
static final double PI=3.1415;//静态常量

public Test01(){
name="tom";//在构造方法中对final变量进行初始化
}

{
d=13;//在代码块中对final变量进行初始化
}

static{
X=18; //在静态代码块中对静态常量进行初始化
}

public static void main(String[] args)
{
final int a=5;//常量
//a=10; final修饰的变量不能被多次赋值
final int b;//空final
b=25;//声明后再赋值

B bb=new B();
bb.show1();
bb.show2();
bb.print(5);
}
}

/*
* 父类
*/
class A{
public void show1(){
System.out.println("父类中show1");
}

//final修饰的方法不能被子类重写，但可以被子类继承
public final void show2(){
System.out.println("父类中的show2");
}
}

/*
* 子类
*/
class B extends A{
//重写父类的show1方法
public void show1(){
System.out.println("子类重写后的show1");
}

//final修饰参数，只能读取，不能被修饰
public void print(final int num){
System.out.println(num);
}
}

abstract关键字

/*
* abstract关键字
* 可以修饰：类、方法
*
* 1.被abstract修饰的类，称为抽象类
*   不能被实例化，即不能使用new创建一个对象
*   抽象类可以有构造方法，但不是用来创建对象的，而是用来初始化成员属性
*
* 2.被abstract修饰的方法，称为抽象方法
*   只有方法的声明，没有方法的实现
*   抽象方法必须在抽象类中
*   抽象类中可以有抽象方法，也可以没有抽象方法
*   子类必须实现父类中的抽象方法
*
*/
public class Test02
{
public static void main(String[] args)
{
// 创建一个小学生对象
/*
* Pupil pupil = new Pupil("张三", 7, "哭"); pupil.show(); pupil.play();
*/

// 创建一个学生对象
// Student stu=new Student("李四",8);//Student是抽象类，不能被实例化

GradeTwo gt = new GradeTwo("王炜", 9, "丢沙包");
gt.play();
}
}

/*
* Student父类，抽象类
*/
abstract class Student
{
String name;
int age;

public Student(String name, int age)
{
super();
this.name = name;
this.age = age;
}

public void show()
{
System.out.println("姓名：" + name + "，年龄：" + age);
}

// 抽象方法，不能有方法体，只有方法的声明
public abstract void play();
}

/*
* Pupil类，继承自Student 如果子类未实现父类中的所有的抽象方法，那么子类依然是一个抽象类
*/
abstract class Pupil extends Student
{
String hobby;

public Pupil(String name, int age, String hobby)
{
super(name, age);
this.hobby = hobby;
}

public void show()
{
System.out.println("我是小学生，姓名：" + name + "，年龄：" + age + "，爱好：" + hobby);
}

// 实现父类中的抽象方法，即把抽象方法的方法体写了
/*
* public void play(){ System.out.println("我正在打滚。。。"); }
*/
}

/*
* 二年级类，继承自小学生类
*/
class GradeTwo extends Pupil
{
public GradeTwo(String name, int age, String hobby)
{
super(name, age, hobby);
}

public void play()
{
System.out.println("我正在丢沙包。。。");
}
}