面向对象4

1：复习

         1.1：继承

                   java中是单继承，可以多层继承。

                   子类可以继承父类的所有的属性和方法，如果想访问父类的属性和方法，可以用super.

                   this和super的区别

                   static的用法

                   final的用法。

                   方法重写和方法重载的区别

2：抽象类：abstract

         2.1：抽象方法：只能方法声明没有方法体的方法。

                   面向对象分析的过程中，分析到顶层的类时，会发现父类不知道子类是如何实现某一些具体的行为，但是父类肯定子类有这些行为，那么如果父类不清楚这个行为是如何实现的，这个时候这个行为就不应该写方法体，那么没有方法体的方法就叫抽象方法。如果一个类中出现了抽象方法，那么这个类就必须声明为抽象类。

                   抽象类不一定会有抽象方法，但是抽象方法一定在出现在抽象类中。

         2.2：抽象类是不能实例化的。但是抽象类也有构造方法。

                  如果父类是抽象类，那么子类要么重写父类的所有抽象方法，要么自己为抽象类。

         2.3：this.super,static,final,abstract

                   this和super在调用构造方法的时候不能相遇

                   static和final常一起使用来修饰常量。

                   final和abstract不能相遇。因为它们是相反的，final 一定不能让你改，而abstract一定要你修改。

3：接口:interface

         3.1：当一个类中的所有方法都是抽象方法的时候，这样的类可以定义为接口。

         3.2：类与接口是实现关系   implements

                  实现接口的类要么为抽象类，要么实现这个接口中的所有的抽象方法。

                   在java，类可以多实现，可以实现多个接口。

                   接口与接口是继承关系。java中，类与类是单继承，接口与接口是多继承，类与接口是多实现。类在继承的时候可以同时再去实现接口。

　　　3.3：接口中的方法默认都是公共的抽象方法，方法前面的public abstract也是默认添加上，可写不可写。一般的情况下，为了提供可读性，最好是加上。接口中的成员变量是公共的静态常量，不能够修改值。public static final是默认添加上的。

                   接口中一般都会有公共的常量和抽象方法。

 

　　3.4：一些作用

　　　　1提供了程序的扩展性。

　　　　2接口中定义的是规则。

　　　　3接口降低了程序的耦合度。

4：多态

         4.1：多态：多种形态。

         4.2：多态的代码体现：父类的引用指向子类的对象。

         4.3：发生多态后的影响

                            Animal animal = new Dog();//向上转型

                            那么animal对象只能访问Animal类中有的成员，不能访问Animal类中没有的成员。如果需要访问Dog类中的成员，必须进行强制类型转换:很多时候也叫向下转型。

                            如果不进行判断就进行强制类型转换，这个时候会出现运行时的错误:ClassCastException异常(类型转换异常)

                            判断对象是哪种类型

                                     对象名    instanceOf   类名:如果对象是后面的类创建出来的，则返回true,否则返回false.

         4.4：多态的好处。

                   在前期设计时，并不知道这个类会出现哪些子类，但是它知道不管多少子类，他们都会有确定的行为，那么设计的时候就可以写父类，后面不管出现多少子类对象，它都是父类的一种。这样代码就可以不用去修改，提高了代码的可维护性和可扩展性。

         4.5：多态的前提：必须要有继承或者实现的关系。       

         4.6：多态的弊端：发生多态后，只能调用父类有的方法，不能调用自己的方法，如果需要调用自己的方法，需要强制类型转换(向下转型).

         4.7：多态的细节。

                   发生多态后

                                编译的时候     运行的时候

调用普通方法      看左边                   看右边

访问普通成员变量  看左边                   看左边

访问静态成员变量  看左边        看左边

访问静态方法       看左边                看左边

         发生多态后，编译的时候看左边，运行的时候，普通方法看右边的，其他的

         都看左边。

 

阅读以下代码，输出哪些内容？

 1 public class Dervied extends Base {
 2 
 3     private String name = "dervied";
 4 
 5     public Dervied() {
 6         tellName();
 7         printName();
 8     }
 9     
10     public void tellName() {
11         System.out.println("Dervied tell name: " + name);
12     }
13     
14     public void printName() {
15         System.out.println("Dervied print name: " + name);
16     }
17 
18     public static void main(String[] args){
19         
20         new Dervied();    
21     }
22 }
23 
24 class Base {
25     
26     private String name = "base";
27 
28     public Base() {
29         tellName();
30         printName();
31     }
32     
33     public void tellName() {
34         System.out.println("Base tell name: " + name);
35     }
36     
37     public void printName() {
38         System.out.println("Base print name: " + name);
39     }
40 }

Dervied tell name: null
Dervied print name: null
Dervied tell name: dervied
Dervied print name: dervied

 

5：简单工厂模式。

         把工厂看做一个类，这个工厂的生产看做方法；这个工厂有它的生产方法，只要你把你的需求告诉工厂，工厂就会用它的生产方法帮你完成需求。