final笔记

final
abstract  --》 抽象




动物 有行为，run


Tiger  --》四个脚跑
鱼     --》 鳍 游
鸟     --》 翅膀 飞


在某些情况下，我们不同的子类有不一样的实现行为，如果子类不重写父类的方法， 会导致行为不完善。
例如对于动物来说，所有的动物都有跑 run的方法
但是每一个不同种类的动物，都有不一样的run的实现，有时候我们需要强制性让子类方法重写。


通过abstract关键字


（1）对于方法来说：加上了抽象关键字abstract之后，这个方法本身就没有意义，只需要让别人知道我这个方法的声明
如何来区分一个方法：（1）返回值 （2）方法名 （3）形参列表
abstract void run();


(2) 有抽象方法的类，一定是抽象类
抽象类，不一定有抽象方法


如果类中的方法用abstract修饰了，那么这个类本身也要用abstract修饰，成为抽象类


（3）抽象类 不允许被实例化


 (4) 抽象类 是否可以有构造方法？ 是的
 子类可以通过super调用父类的构造方法，对从父类继承的属性，进行初始化


 (5)抽象关键字，是否可以和final关键字一起使用？
 不能，因为abstract关键字 是要求子类一定要重写父类的方法，但是final是不允许重写的


 (6)抽象关键字，是否可以和private关键字一起使用？
 不能，因为private是私有的，不能被继承的内容，代表根本不存在方法重写，因此不能一起使用


 (7)抽象关键字，是否可以和static一起使用？
 不能，因为static是静态修饰符，代表不需要实例化对象，直接用类名就可以调用方法， 那么如果是抽象方法，没有方法实现
 调用方法会出错，所以编译器禁止 abstract和static一起使用


 (8) 构造方法不允许被继承，所以也没有重写， 不能用abstract修饰












*/
class Test
{
public static void main(String[] args) 
{
Tiger t = new Tiger("华南虎", 2);

t.run();


Fish f = new Fish();
f.setStrain("鲫鱼");
f.run();




}






}


abstract class Animal
{
private String strain;
private int age;


public Animal(){


}


public Animal(String strain, int age){


this.strain = strain;
this.age = age;


}


    //构造方法不允许被继承，所以也没有重写， 不能用abstract修饰
//abstract public Animal(String strain);




//给定setter 和 getter
public void setStrain(String strain){


this.strain = strain;


}


public void setAge(int age){


this.age = age;
}


public String getStrain(){


return this.strain;


}


public int getAge(){


return this.age;


}


/*
void run(){


System.out.println(strain + "种类的动物在跑");


}
*/
abstract void run();


// Animal.test();
//abstract static void test();


}




class Tiger extends Animal
{


public Tiger(String strain, int age){


super(strain, age);
}

void run(){


System.out.println(getStrain() + "老虎四个脚在跑");




}

}


class Fish extends Animal
{
void run(){


System.out.println("鱼在水里游");




}
}