第六章面向对象（高级篇）

第六章面向对象（高级篇）

一、继承的基本概念

                 ①作用：可以继承父类的成员，还可以扩充已有类的功能

                 ②继承格式：class 父类{}         //定义父类

                                                 class 子类 extends父类{}   //使用extends关键字实现继承

                 ③PS：     1、只允许多层继承，而不能多重继承

                                  2、子类是不能直接访问父类的私有成员的

 

二、继承的进一步研究

                 ①子类对象实例化过程：子类对象实例化之前必须首先调

                   用父类中的构造方法后再调用子类自己的构造方法（隐

                   含了一个super()的语法）

                 ②方法的覆写：子类定义了与父类中同名的方法

                            1、子类覆写的方法不能拥有比父类方法更加严格的

                                  访问权限

                            2、当方法被覆写之后，子类对象调用的方法将是被                                覆写后的方法

                            3、子类无法覆写父类中的private方法

                 ③属性的覆盖：子类定义了与父类中同名的属性

                            1、在子类中直接访问时一定是采用“就近访问原则”

                            2、父类与子类空间是独立的，所以子类并没有覆盖

                                  父类属性

                 ④super关键字的作用：

                            1、调用父类的构造方法：super(); 必须放在子类构

                                  造方法的首行

                            2、调用父类的普通方法：super.方法名();

                            3、调用父类的属性：super.属性;

 

 

方法重载与覆写的区别

序号	区别点	重载	覆写
1	单词	Overloading	Overriding
2	定义	方法名称相同，参数的类型或个数不同	方法名称、参数类型、返回值类型全部相同
3	对权限没有要求	被覆写的方法不能拥有更严格的权限
4	范围	发生在一个类中	发生在继承类中

 

 

this与super的区别

序号	区别点	this	super
1	属性访问	访问本类中的属性，如果本类中没有此属性，则从父类中继续查找	直接访问父类中的属性
2	方法访问	访问本类中的方法，如果本类中没有此方法，则从父类中继续查找	直接访问父类中的方法
3	调用构造	调用本类构造，必须放在构造方法的首行	调用父类构造，必须放在子类构造方法的首行
4	特殊	表示当前对象	无此概念

 

 

三、final关键字

                 ①final称为完结器

                 ②使用final声明的类不能有子类（class前加final）

                 ③使用final声明的方法不能被子类所覆写（方法返回值前

                   加final）

                 ④使用final声明的变量即成为常量，常量不可修改，且要

                   求全部字母大写（常量数据类型前加final）

                 ⑤若一个程序中变量使用public static final声明，则此变量

                   称为全局常量

 

四、抽象类的基本概念

                 ①作用：模板

                 ②目的：要设计者依据它的格式来修改并创建新的类。

                 ③定义及使用规则：

                            1、包含一个抽象方法的类必须是抽象类

                            2、抽象类和抽象方法都要使用abstract关键字声明

                            3、抽象方法只需要声明而不需要实现

                            4、抽象类必须被子类继承，子类（如果不是抽象类）

                               必须覆写抽象类中的全部抽象方法

                 ④定义格式：     abstract class 抽象类名称{

                                                               属性；

                                                               访问权限返回值类型方法名称(参数){

                                                        [return 返回值]；

                                                                }    

                                    访问权限 abstract返回值类型方法名称(参数)；

                                                         }

        ⑤注意事项：

              1、抽象类中不一定有抽象方法

              2、抽象类不能用final或static关键字声明

              3、抽象方法不要用private声明（但抽象类可以）

              4、抽象类存在构造方法

              5、一个子类只能继承一个抽象类

              6、抽象方法只有方法的声明，没有方法体“{…}”

 

五、接口的基本概念

        ①定义：由全局常量和公共的抽象方法所组成的特殊的类

        ②定义格式：   interface 接口名称{

                                    全局常量；

                                    公共抽象方法；

                             }

        ③实现格式对比：

              1、子类继承抽象类：

                        class 子类 extends 抽象类{}

              2、子类实现接口：

                        class 子类 implements接口A，接口B{}

              3、子类继承抽象类实现接口：

                            class 子类 extends 抽象类 implements 接口A，接口B{}

              4、接口继承接口：

                        interface 子接口 extends父接口A，父接口B{}

        ④注意事项：

              1、在接口中如果不写public也是默认public

              2、接口定义可简化，去掉public static final和

                 public abstract

              3、一个类可以继承一个抽象类和多个接口

              4、一个接口不能继承抽象类但是可以继承多个接口

              5、一个抽象类可以继承多个接口

              6、抽象类实现接口时，可以不覆写其中的抽象方法，

                由抽象类的子类去覆写

 

六、对象的多态性

        ①多态性    方法的多态性     重载

                                    覆写

                    对象的多态性     向上转型：子类->父类

                                    向下转型：父类->子类

        ②转型格式：

              对象向上转型：父类 父类对象 = 子类实例

                    对象向下转型：子类 子类对象 =(子类)父类实例

                   

                    例：B extends A

                    向上转型：A a = new B()；

                    向下转型：A a = new B()；   B b = (B)a；

        ③注意事项：

              1、向上转型，程序会自动完成，而对于向下转型，

                 必须明确地指明要转型的子类类型

              2、发生向上转型后，父类对象调用的其实是被子类

                 覆写过的方法，且父类对象无法调用子类自定义

                 的其他方法

              3、要想调用子类自己的方法，一定要用子类的实例

                 化对象，此时可向下转型

              4、在进行对象向下转型前，必须首先发生对象向上

                 转型

              5、通过子类实例化的对象同时也是子类和父类的实

                 例，但是如果直接使用了父类实例化本类对象，

                 则一定就不再是子类实例了

 

七、instanceof关键字

        ①定义：用来判断一个对象是哪个类的实例的关键字

        ②使用格式：   对象 instanceof 类 —>返回boolean类型

        ③作用：在向下转型前使用instanceof关键字来判断是哪

               个子类的实例，以保证程序运行时不出现类转换异

               常

 

八、抽象类与接口的应用

        ①为抽象类和接口实例化：使用对象的多态性

        ②抽象类的实际应用——模板设计：用抽象类作一张空白

          表，子类只需填表即可

        ③接口的实际应用——制定标准：接口制定了一个标准，

          只要符合标准的就可以接进来

        ④设计模式——工厂设计：为使客户端（主方法）一直适

          用，不需要更改，可在主方法与具体子类之间加入一个

          负责处理不同实例的过渡端，这个过渡端即为工厂类

        ⑤设计模式——代理设计：由代理主题来操作真实主题，

          真实主题执行具体的业务操作，而代理主题负责其他相

          关的处理

        ⑥设计模式——适配器设计：想实现一个接口，但不想覆

          写其中所有方法时，可以先用一个抽象类（适配器）实

          现此接口，覆写所有方法，但方法体都为空（{}），然后

          再用子类类来继承此抽象类，即可覆写所需的方法

        ⑦内部类的扩展：

              1、一个抽象类的内部可以定义多个接口和抽象类

              2、一个接口的内部可以定义多个接口和抽象类

              3、实现此种结构时，必须外层内层分别用不同的子

                类去实现或继承

              4、在主方法中实例化的格式有不同

              例：     interface A{

                                abstract class B{

                                   public abstract void printB();

                                 };

                             }

                            class X implements A{

                                class Y extends B{

                                    public void printB(){

                                        system.out.print(“hello->B”)

                             }

                                };

                            }

                            public class Demo{

                                public static void main(String args[]){

                                    A.B b = new X().new Y();

                                    b.printB();

                                }

                            }

 

 

 

抽象类与接口的关系

序号	区别点	抽象类	接口
1	定义	包含抽象方法的类	抽象方法和全局常量的集合
2	组成	构造方法、普通方法、抽象方法、常量、变量	常量、抽象方法
3	使用	子类继承抽象类（extends）	子类实现接口（implements）
4	关系	抽象类可以实现多个接口	接口不能继承抽象类，但允许继承多个接口
5	常见设计模式	模板设计	工厂设计、代理设计
6	对象	都通过对象的多态性产生实例化对象
7	局限	抽象类有单继承局限	接口没有此局限
8	实际	作为一个模板	作为一个标准或表示一种能力
9	选择	如果抽象类和接口都可以使用，则优先使用接口，避免单继承的局限
10	特殊	一个抽象类中可以包含多个接口，一个接口中可以包含多个抽象类

 

 

九、Object 类

        ①定义：所有类的公共父类

        ②主要方法：

              1、public Object()：构造方法

              2、public int hashCode()：取得Hash码

              3、public boolean equals(Object obj)：对象比

                 较，默认的是比较对象的地址，但可以覆写此方

                 法，比较地址和内容

              4、public String toString()：对象打印时调用，

                 默认是打印对象的地址，但可以覆写此方法，打

                 印我们所需的对象相关信息

③接收对象：一切的引用数据类型（包括数组和接口）都可以使用Object进行接收。很多类库设计上都采用Object作为方法的参数

④一个好的类的设计应覆写Object类的上述主要方法

 

十、包装类

        ①定义：把8种基本数据类型包装成一个类的形式

        ②作用：把基本数据类型变成对象

        ③装箱：把一个基本数据类型变成包装类的过程

                 Integer i = new Integer(30)；->手动装箱

                        Integer i = 30；->自动装箱

        ④拆箱：把一个包装类变成基本数据类型的过程

                 int temp = i.intValue()；->手动拆箱

                        int temp = i；->自动拆箱

        ⑤应用：最常用的是把字符串变成基本数据类型

                 String（纯数字）-> int：

                        int i = Integer.parseInt(str)；

                        String（纯数字）-> float：

                        float f = Float.parseFloat(str)；

 

序号	基本数据类型	包装类	父类
1	int	Integer	Number
2	short	Short
3	long	Long
4	byte	Byte
5	float	Float
6	double	Double
7	char	Character	Object
8	boolean	Boolean

 

十一、匿名内部类：

        ①定义：没有一个具体名称的内部类（在接口和抽象类的

          应用上发展起来）

        ②作用：接口的实现类只使用一次的情况下，则可使用匿

          名内部类创建不具有名称的对象，并利用它访问类中的

          成员