final修饰符与多态

知识点
一、final 最终的
可以修饰属性、方法、类
1、final修饰的属性，表示常量，初始化以后值不能改变。final修饰
引用数据类型的变量，引用地址不能改变。
2、final修饰类，不能被继承。比如：String
3、final修饰方法，不能被重写

1 public class FinalDemo {
2     public static final String NAME="张三";//静态常量
3     public static void main(String[] args) {
4         final int n=100;//常量
5         //n=200；//final修饰的常量，复值以后不能改变
6         final Object obj=new Object();//所有类的父类
7 //        o=new Object();
8     }

1 public  class Foo {
2    public final void   function(){
3        System.out.println("方法被调用");
4    }

 1 public class TestFoo extends Foo/*extends Stringextends Foo*/{
 2     //经过final修饰的方法不能被重写也无法继承
 3     /*@Override
 4     public void function() {
 5     }*/
 6     
 7     public static void main(String[] args) {
 8          Foo foo=new Foo();
 9          foo.function();
10     }

二、多态
多态：同一个引用类型，使用不同的实例而执行不同操作。
父类引用指向子类对象。
多态步骤：
使用多态实现思路
编写具有继承关系的父类和子类
子类重写父类方法
使用父类的引用指向子类的对象
多态语法：
向上转型
Pet pet = new Dog();
实现多态的两种形式：
使用父类作为方法形参实现多态
使用父类作为方法返回值实现多态

 1 package day20190304;
 2 
 3 /**
 4  * 狗类，继承Pet类
 5  * 
 6  * @author Administrator
 7  *
 8  */
 9 public class Dog extends Pet {
10     private String strain;
11 
12     public Dog() {}
13 
14     public Dog(String name, int health, int love, String strain) {
15         super(name, health, love);
16         this.strain = strain;
17     }
18 
19     public String getStrain() {
20         return strain;
21     }
22 
23     public void setStrain(String strain) {
24         this.strain = strain;
25     }
26 
27 
28     public String printInfo() {
29         return getName() + " " + getHealth() + " " 
30     + getLove() + " " + strain;
31     }
32 
33     @Override
34     public void eat() {
35         setHealth(this.getHealth()+3);
36         System.out.println("吃饱了，健康值增长为"+getHealth());
37     }
38     /**
39      * 狗接飞盘
40      */
41     public  void  catchingFlyDisc(){
42         this.setLove(this.getLove()+5);
43         this.setHealth(this.getHealth()-10);
44         System.out.println("玩一会，健康值减少10，亲密度增加5");
45     }
46 }

 1 package day20190304;
 2 
 3 
 4 /**
 5  * 企鹅类，继承Pet类
 6  * 
 7  * @author Administrator
 8  *
 9  */
10 public class Penguin extends Pet {
11     private String sex;
12 
13     public Penguin() {
14     }
15 
16     public Penguin(String name, int health, int love, String sex) {
17         super(name, health, love);
18         this.sex = sex;
19     }
20 
21     public String getSex() {
22         return sex;
23     }
24 
25     public void setSex(String sex) {
26         this.sex = sex;
27     }
28 
29     @Override
30     public String printInfo() {
31         return getName()+" "+getHealth()+" "
32       +getLove()+" "+sex;
33     }
34 
35     @Override
36     public void eat() {
37         setHealth(this.getHealth()+5);
38         System.out.println("吃饱了，健康值增长为"+getHealth());
39     }
40     /**
41      * 企鹅游泳
42      */
43     public  void  swimming(){
44         this.setLove(this.getLove()+5);
45         this.setHealth(this.getHealth()-10);
46         System.out.println("玩一会，健康值减少10，亲密度增加5");
47     }
48 }

 1 package day20190304;
 2 
 3 
 4 /**
 5  * 父类，宠物类
 6  * 
 7  * @author Administrator
 8  *抽象类
 9  */
10 public abstract class Pet {
11     private String name;
12     private int health;
13     private int love;
14 
15     protected Pet() {
16     }
17 
18     protected Pet(String name, int health, int love) {
19         this.name = name;
20         this.health = health;
21         this.love = love;
22     }
23 
24     public String getName() {
25         return name;
26     }
27 
28     public void setName(String name) {
29         this.name = name;
30     }
31 
32     public int getHealth() {
33         return health;
34     }
35 
36     public void setHealth(int health) {
37         this.health = health;
38     }
39 
40     public int getLove() {
41         return love;
42     }
43 
44     public void setLove(int love) {
45         this.love = love;
46     }
47     /**
48      * 显示所有信息
49      * @return
50      */
51     public  abstract  String  printInfo();
52     /**
53      * 宠物吃东西
54      */
55     public  abstract  void  eat();
56 }

 1 package day20190304;
 2 
 3 /**
 4  * 主人类
 5  * 
 6  * @author Administrator
 7  *
 8  */
 9 public class Master {
10     /**
11      * 给宠物喂食
12      * 
13      * @param pet
14      */
15     public void feed(Pet pet) {
16         pet.eat();
17     }
18 
19     /**
20      * 和宠物玩耍
21      * 
22      * @param pet
23      */
24     public void play(Pet pet) {
25         // System.out.println(pet instanceof Penguin);
26         if (pet instanceof Penguin) {//判读是否为企鹅类型
27             Penguin penguin = (Penguin) pet;
28             penguin.swimming();
29         } else if (pet instanceof Dog) {
30             // 将父类对象还原为子类对象，强制类型转换
31             Dog dog = (Dog) pet;
32             dog.catchingFlyDisc();// 调用狗自己的方法
33         }
34     }
35 
36     /*
37      * public Pet getPet(String petNo){ return new Dog(); }使用多态优化返回值类型
38      */
39 }

 1 package day20190304;
 2 
 3 public class TestPet {
 4 
 5     public static void main(String[] args) {
 6         // 父类引用指向子类对象空间
 7         // Pet pet=new Dog();
 8         Dog dog = new Dog("来福", 80, 80, "田园犬");
 9         Penguin penguin = new Penguin("球球", 80, 80, "Q仔");
10         // 主人对象
11         Master master = new Master();
12         master.play(dog);// 和宠物玩耍
13         master.play(penguin);
14 
15         master.feed(dog);// 给宠物喂食
16 
17         // System.out.println(dog.printInfo());
18 
19     }
20 
21 }

final修饰符与多态

猜你喜欢