JAVA基础--面向对象08

一、final关键字

　　　　有的时候不想别人重写我的方法，使用final关键字修饰该方法，final：最后的，最终的，可以修饰类、修饰函数、修饰变量，修饰类：该类不能被继承；直接写在class关键字前面

修饰函数：函数不能被重写；直接写在函数返回值类型前面；

修饰变量：变量的值不能被修改，可以成为常量；直接写在变量的数据类型前面；

因为被final修饰的变量的值不能改变，所以被fianl修饰的变量有叫做常量；

此时，我们给他的命名的书写规范：全部字母都要大写；多个单词，可以使用下划线（_）分开；

如： private static final double PI = 3.14;

变量的值不能改变，指的是直接保存在变量中的内容不能改变；

如果被final修饰的变量是一个引用类型的数据，那么通过这个引用改变堆空间中的数据，不会报错；

二、抽象类

　　1. 抽象类的产生　

　　　　需求：创建类描述猫和狗的行为；

　　　　猫的行为：抓老鼠；吃鱼；

　　　　狗的行为：看家；吃骨头；

分析：

因为猫和狗都是动物，所以可以让猫和狗分别继承动物类，然后将共同东西抽取到动物类中；

小结：当事物的功能描述不清，只能表示有这个功能时，就应该使用抽象修饰该功能，这个功能就是抽象的功能；

如果一个类中有抽象的功能，那么这个类也是抽象的类；

　　2. 抽象的特点

　　　　a. 抽象类不能实例化　　　　　

　　　　　　因为抽象类，表示一个描述不清的事物，所以不能实例化；

　　　　　　b.子类继承抽象类，必须实现父类的所有抽象函数，否则子类也是抽象的　　　　　

　　　　　　　　抽象类，必须由子类去继承，继承的子类必须实现父类中所有的抽象方法；

　　c. 抽象函数必须放在抽象类中　

　　　　因为类中有抽象函数，表示描述不清的功能，所以整个类所描述的事物，也是描述不清的，所以需要将类也定义为抽象的；

　　c. 注意事项

　　　　c.1 抽象类一定是父类吗？

　　　　　是，因为抽象类就是通过不同的子类向上抽取共性信息得倒的，抽线类必须由子类去继承和重写抽象函数；

　　　 c.2 抽象类中有构造方法吗？　　　　　

　　　　必须有，因为抽象类需要由子类去继承，子类实例化的时候，要调用父类的构造函数,抽象类的构造函数作用是初始化本类中的成员变量的；

　　c.3 抽象类中可以不书写抽象方法吗？　　

　　　　可以；可以只有非抽象的成员；

　　　　同样，不能实例化；

　　c.4 抽象类中可以定义非抽象的方法吗？（抽象类中可以书写普通方法和成员变量）　　　

　　　　抽象类中除了抽象函数，还可以定义所有一般类中可以定义的成员；

　　c.5 抽象关键字abstract不能和哪些修饰符关键字共存？　　

　　　　因为抽象的函数只有被继承的子类重写了，才可以使用，所以不能和private以及final关键字一起使用；

　　　　static：因为静态的函数可以直接使用类名调用，所以也不能使用static修饰抽象函数；

　　c.6 抽象类什么时候使用？

　　　　当描述的功能不确定，不知道具体怎么实现的时候，就需要使用抽象函数，这是类也是抽象的；

　　　　不想实例化这个类（包括自己也不行），但是允许别人继承，也可以使用抽象类；

　　3. 抽象类应用　　　　

　　　　需求：描述Hr和程序员：

　　　　有共同的

三、多态

　　1. 多态的引入

　　狗；哈士奇；二哈；动物；生物；汪星人；畜生……　　　

　　生活中的一个实实在在的事物，我们可以使用不同的状态去描述，这就是多态；　　　

　　而且我们在生活中，我们更习惯使用抽象的、一般化的概念来描述一个具体的事物；

　酒：啤酒；白酒；黄酒；红酒……

　　饭：米饭；面条；饺子；包子……

　　使用一般化、抽象化的概念指代一个具体的事物，就是多态在生活中的体现；

　　2. JAVA中的多态

　　　　上面代码中红框部分使用了多态，结论：在java中，多态，指的是父类型引用指向子类实例对象；（接口类型引用指向实现类对象）

　　　　a. 多态的使用前提　　　　

　　　　　　生活中的前提：被指代的事物确实是用于描述它的那个概念的一个特例；

　　　　　　Java中的前提：必须是继承关系（或者接口实现关系）；

　　　　b. 多态的好处　　　　

　　　　　　生活中：使用多态指代事物，能够指代的范围更广泛，到了实际操作的时候，就有更多的选择；

　　　　　　　　　　Java中的好处：

　　　　　　　　　　描述猫和狗的行为，同时需要提供测试方法；

　　　　　　　　　　首先描述和测试猫

　　　　接下来描述和测试狗的行为

　　　　问题：每添加一个被测试的类型的对象，都需要单独创建一个专门的功能，而且在这些测试功能中，实现是类似的；

　　　　问题就是，代码复用性差，程序扩展性差；　

　　　　解决：考虑使用多态，直接创建一个测试父类型的方法，然后就可以接受不同类型的对象；

 1 /*
 2     描述猫和狗的行为，同时需要提供测试方法；
 3 */
 4 //描述动物
 5 abstract class Animal
 6 {
 7     abstract void eat();
 8     abstract void sleep();
 9 }
10 
11 
12 //描述猫的行为
13 class Cat extends Animal
14 {
15     //吃
16     void eat(){
17         System.out.println("吃鱼");
18     }
19     //睡觉
20     void sleep(){
21         System.out.println("猫咪睡着了");
22     }
23 }
24 //描述狗的行为
25 class Dog extends Animal
26 {
27     //吃
28     void eat(){
29         System.out.println("吃骨头");
30     }
31     //睡觉
32     void sleep(){
33         System.out.println("狗狗睡着了");
34     }
35 }
36 //创建测试类测试
37 class Test2
38 {
39     //测试动物的行为
40     public static void testAnimal(Animal animal){
41         animal.eat();
42         animal.sleep();
43     }
44 
45     public static void main(String[] args) 
46     {
47         //使用多态指向猫的对象
48         Animal cat = new Cat();
49         testAnimal(cat);
50     
51         //使用多态指向狗的对象
52         Animal dog = new Dog();
53         testAnimal(dog);
54     }
55 }

　　小结：使用多态，可以提高程序的扩展性，降低代码的冗余；

　　c. 多态的弊端

　　　　使用父类型引用指向子类对象，不能通过父类性引用访问子类特有属性和行为；

　　3. 多态的类型转换

　　　　a. 多态的类型转换　　　　　

　　　　　　自动向上转型：将子类性对象赋值给父类型引用，可以自动进行；提升了子类对象的类型；

　　　　　　强制向下转型：将父类型引用转为子类性引用，降低了引用的类型，需要强制转换；

　　　　　　结论：是用强制向下转型，可以解决多态使用的弊端；

　　　　b. 强制向下转型的问题

　　c. instanceof 关键字　　

　　　　instanceof：比较运算符；

　　　　运算符左边是一个指向一个对象的引用（左边就是一个变量名），右边是一个类名，运算符表示的意思就是：判断左边的对象的类型是不是右边的类；

　　　　结论：使用instanceof关键字，可以实时判断一个对象的类型，就可以避免强制类型转换中容易出现的类型转换异常；

　　d. 多态中成员的特点　　　

　　　　程序分为编译和运行两个阶段，程序中的成员，又分为静态和非静态两种，所以，要分不同情况讨论；

　　　　在使用多态的程序中，编译时，不管是什么成员，编译器都看的是父类型的引用；

运行时，所有成员变量都是用的是父类型的；静态函数使用的是父类型的，非静态函数使用的是子类重写的；

总结：在使用多态时，成员的特点：

编译期：不管什么成员，只要用到了，都要检查父类中有没有；

运行期：所有成员变量和静态函数都是使用的父类的，非静态函数使用的是子类重写的；

静态成员不参与多态，只有非静态成员才与多态，因为多态是和对象有关的；

编译时都要看等号左边；

运行时，只有非静态函数看等号右边；

　　f.多态练习

 1 /*
 2     需求：描述老板让Hr、程序员干活；
 3 */
 4 //描述Hr
 5 class Hr
 6 {
 7     void work(){
 8         System.out.println("人事管理");
 9     }
10 }
11 
12 //描述程序员
13 class Programmer
14 {
15     void work(){
16         System.out.println("敲代码改变世界！");
17     }
18 }
19 //描述老板
20 class Boss
21 {
22     //老板让Hr干活
23     void letHrWork(Hr hr){
24         hr.work();
25     }
26 
27     //老板让程序员干活
28     void letProWork(Programmer pro){
29         pro.work();
30     }
31 }
32 
33 class Test5
34 {
35     public static void main(String[] args) 
36     {
37         Boss boss = new Boss();
38         
39         Hr hr = new Hr();
40         boss.letHrWork(hr);
41         
42         Programmer pro = new Programmer();
43         boss.letProWork(pro);
44     }
45 }

传统的做法，太麻烦，需要一个一个去做；

而实际生活中不是这样，老板一个命令，所有干活的都要去工作，所以考虑从使用多态　

 1 //描述打工的
 2 abstract class Worker
 3 {
 4     abstract void work();
 5 }
 6 //描述Hr
 7 class Hr extends Worker
 8 {
 9     void work(){
10         System.out.println("人事管理");
11     }
12 }
13 //描述程序员
14 class Programmer extends Worker
15 {
16     void work(){
17         System.out.println("敲代码改变世界！");
18     }
19 }
20 //描述老板
21 class Boss
22 {
23     void letWorkerWork(Worker worker){
24         worker.work();
25     }
26 }
27 
28 class Test6
29 {
30     public static void main(String[] args) 
31     {
32         Boss boss = new Boss();
33         
34         Worker hr = new Hr();
35         boss.letWorkerWork(hr);
36         
37         Worker pro = new Programmer();
38         boss.letWorkerWork(pro);
39     }
40 }

多态总结：

　　概念：一种事物可以有多种表示形态；而且一般习惯使用更抽象、更一般化的形态表示这个事物；

　　多态在Java中的体现：父类型引用指向子类实例对象；接口引用指向实现类对象；

　　多态的前提：必须有继承或者接口实现的关系；

　　多态的好处：提高代码的复用性，提高程序的扩展性；

　　多态的弊端：不能使用子类对象特有的属性和功能；

　　解决多态弊端的方法：使用强制类型转换；

　　使用强制类型转换容易出现类型转换异常，解决的办法是转换前使用比较运算符：instanceof判断；

　　多态使用中成员的特点：

　　编译时，所有成员都看父类；

　　运行时，只有非静态成员函数看子类；

　　静态成员不参与多态；

四、接口

　　　1. 接口的引用　　　　　

　　需求：分别描述以下三种动物的行为：

　　　　狗：吃；叫；

　　　　猫：吃；叫；

　　　　猪：吃；叫；

　　接下来，需求升级：

　　　　狗和猫经过训练，都学会了表演；

　　2. 接口代码体现　　

　　　　a. 接口的声明格式

　　　　接口使用关键字：interface声明；

　　　　b. 接口中能书写的成员　　　　

　　　　　　接口和类不同，在接口中可以书写的内容，都已经被Java固定了：

　　　　　　成员变量：只能使用一下修饰符：public static final;

　　　　　　也就是说，接口中的成员变量，都是常量；

　　　　　　成员函数：只能使用修饰符：public abstract ;

　　　　　　也就是说，接口中的方法，都是公共和抽象的；

　　　　　　这些修饰符，是Java在语法层面固定的，我们可以省略不写，编译器会帮我们加上；

　　　　　　要写，就只能这么写，不能改写；

　　　　　　、

　　　　c. 接口的实现

　　　　　　接口和抽象类一样，都无法实例化，需要使用一个类来实现接口，使用关键字：implements

　　　　d. 多态使用接口　　　

　　　　　　一般开发中，都会通过多态的方式使用接口；

　　　　　　接口类型的引用指向实现类的对象；

　　　　3. 接口的多实现 & 多继承　　　　　

　　　　　　接口的多实现

　　　　　　小结：一个类可以实现多个接口，多个接口之间使用逗号分开；

　　　　　　如果一个类实现了接口，就必须实现接口中的所有方法，否则这个类应该定义为抽象的；

　　　　　　当使用其中一个接口来利用多态的形式使用实现类的对象时，只能访问属于这个接口的属性和方法；

　　　　　　接口的多继承

　　　　　　接口和类之间是实现的关系，接口和接口之间是继承的关系；而且接口支持多继承；

　　4. 接口的使用思想

　　　　a. 作用总结：　　　　

　　　　　　a.1、接口可以描述事物不属于继承体系中的扩展的功能；

　　　　　　a.2、通过多态的方式使用接口，可以提高程序的扩展性；

　　　　　　a.3、接口实现了java中的多继承；

　　　　b. 使用接口定义规则

　　　　　　规则，就是规范，是一种约定；

五、接口和抽象类的区别

　　1. 接口和抽象类的区别　　　

　　　　　a. 从声明上：

　　　　　　抽象类是一个类，使用class声明；还需要使用关键字abstract修饰；

　　　　　　接口不是一个类，使用interface声明；

　　　　b. 从能够书写的成员上看：

　　　　　　抽象类是一个类，可以书写类中可以书写的成员，和抽象函数；

　　　　　　接口只能书写成员变量和抽象函数，而且修饰符是固定的；

　　　　c.从有无构造函数上看：

　　　　　　抽象类必须有构造函数；

　　　　　　接口没有构造函数

　　　　d.从作用上看：

　　　　　抽象类是父类，用来描述所有子类的共性信息的，只是描述的有些功能是不具体的；

　　　　　接口是用来描述不属于继承体系的扩展功能的；还可以定义规则；

　　　　e.继承关系上：

　　　　　抽象类和类之间是继承关系，只支持单继承和多重继承；

　　　　　接口和类之间是实现关系，一个实现类可以实现多个接口；

　　　　　接口和接口之间是继承关系，可以多继承和多重继承；

　　2.接口和抽象类的使用练习　　　

　　　　需求：描述手机和电脑，都有开机、关机和可以玩游戏的功能；

 1 //表示可以玩游戏的接口
 2 interface PlayGame
 3 {
 4     //表示具有玩游戏的功能
 5     public void palyGame();
 6 }
 7 //表示电子产品
 8 abstract class ElecPro
 9 {
10     //所有的电子产品都可以开机关机，不同的电子产品开关机的实现不同
11     //所以要是抽象的
12     public abstract void open();
13     public abstract void close();
14 }
15 //描述手机
16 class Phone extends ElecPro implements PlayGame
17 {
18     public void open(){
19         System.out.println("手机开机");
20     }
21     public void close(){
22         System.out.println("手机关机");
23     }
24     public void palyGame(){
25         System.out.println("手机玩游戏");
26     }
27 }
28 //描述电脑
29 class Computer extends ElecPro implements PlayGame
30 {
31     public void open(){
32         System.out.println("电脑开机");
33     }
34     public void close(){
35         System.out.println("电脑关机");
36     }
37     public void palyGame(){
38         System.out.println("电脑玩游戏");
39     }
40 }