JAVA基础13-final与抽象类

final(最终的)

1. final可以用来修饰的结构：类和方法，变量
2. final修饰的类不能被其他类所继承（Sting类，System类，StringBuffer类）
3. final用来修饰方法，表名方法不能被重写
4. final修饰变量，此时变量就成为常量了

• final修饰属性可以考虑赋值的位置
  • 显示初始化
  • 代码块初始化
  • 构造器中初始化（构造器中初始化后对象就出生了，也就必须有值了）

public class FinalTest {
    final int TOP=0;
    final int RIGHT;
    final int BOTTOM;
//    final int LEFT;
    {
        RIGHT=1;
    }
    FinalTest(){
        BOTTOM=2;
    }
    FinalTest(int n){
        BOTTOM=n;
    }
//    public void setLEFT(){
//        LEFT=3;
//    }
// 不能赋值与方法，应为能调用方法时，对象已经创建完毕，里面属性必须有值了
}

• final修饰局部变量
  • final修饰形参后，表明是一个常量
  • 在方法体内部，只能调用不能再重新赋值

5. static和final用来修饰属性，表明是一个全局常量

abstract抽象类

1. abstract可以修饰的结构：类和方法
2. abstract修饰的类：抽象类
   1. 此类不能实例化
   2. 抽象类中一定有构造器，便于子类实例化时调用
   3. 提供抽象类的子类，让子类对象实例化，完成相关的操作
3. abstract修饰的方法：抽象方法
   1. 抽象方法只有方法的声明，没有方法体
   2. 包含抽象方法的类，一定是一个抽象类（因为抽象方法不能外部调用）
   3. 当子类重写了父类所有抽象方法后，方可实例化
   4. 若子类没重写，那么子类也应该用abstract修饰成抽象类

public class AbstractTest {
    public static void main(String[] args) {
//        Person p1=new Person(); 抽象类就不能实例化了
//        p1.eat();
        Student s1=new Student("jack");
        System.out.println(s1.name);
        s1.walk();

    }
}

abstract class Person{
    String name;
    public Person(String name){
        this.name= name;
    }
    public void eat(){
        System.out.println("吃饭");
    }
    public abstract void walk(); // 抽象方法
}
class Student extends Person{
    public Student(String name){
        super(name);
    }
    public void walk(){ // 必须重写父类中的抽象方法
        System.out.println("学生走路");
    }
}

4. 使用abstract注意
   1. abstract不能修饰构造器，属性
   2. abstract不能有私有方法，静态方法，final的方法和属性
5. 匿名类

public class AbstractTest2 {
    public static void main(String[] args) {
        method(new Student()); // 匿名对象
        Person p1=new Person() { // 创建了匿名子类对象
            @Override
            public void walk() {
                System.out.println("匿名重写子类");
            }
        };
        method(p1);
    }
    public static void method(Person s){
        s.walk();
    }
}

模板方法设计模式

1. 在软件开发中，整体步骤是固定的，通用的，这些就可以在父类中写好。而对于那些异变的，可以抽象出来在子类中实现
2. 实例：

public class TemplateTest {
    public static void main(String[] args) {
        subTemplate sub1=new subTemplate();
        sub1.code();
        sub1.spendTime();
    }
}
abstract class Template{
    // 计算某段代码执行所需时间
    public void spendTime(){
        long start=System.currentTimeMillis();
        this.code(); // 未知的，异变的，在子类中重写
        long end =System.currentTimeMillis();
        System.out.println("花费时间为" + (end -start));
    }
    public abstract void code();

}
class subTemplate extends Template{
    public void code(){
        for(int i=2;i <= 1000; i++) {
            boolean isFlag=true;
            for (int j = 2 ; j <= Math.sqrt(i); j ++ ) {
                if(i%j == 0) {
                    isFlag = false;
                    break;
                }
            }
            if (isFlag){
                System.out.println(i);
            }
        }
    }
}