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("我正在丢沙包。。。");
    }
}