黑马程序员——学习日记之面向对象特征

                           ------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------


一、继承

1、概述

        继承是面向对象的一个重要特征。当多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继那个类即可。这时,多个类可以称为子类,单独的这个类称为父类或者超类。 这样类与类之间就存在了继承的关系。子类可以直接访问父类中的非私有的属性和行为。在代码中通过extends关键字表示继承关系。

例: class Son extends Father{}  //这也是在代码中的书写格式。

注意:千万不要为了获取其他类中的功能,简化代码而继承。必须是类与类之间有所属关系才可以继承。这种所属关系的表示为is a

 

2、特点

        1,提高了代码的复用性。

        2,让类与类之间产生了关系。有了这个关系,提供了多态的前提。

注:Java语言中,只支持单继承,不支持多继承。

       原因:因为类与类多继承的话,容易带来安全隐患。如:当多个父类中定义了相同功能,当功能内容不同时,子类对象不确定要运行哪个一个。

        但是Java保留了这种机制,并用另一种体现形式来完成。叫多实现。

 

3、继承的应用

        Java类中虽然不支持多继承,但可以多层继承。也就是一个继承体系。如儿子继承父亲,父亲继承爷爷等。用代码体现就是:

           class A{}

           class B extends A{}

           class C extends B{}

      那么如何使用一个继承体系中的功能呢?

      想要使用体系,先查体系中父类的描述,因为父类中定义的是该体系中的共性功能。通过了解共性功能,就可以知道该体系的基本功能。这样这个体系就可以基本使用了。

      在具体调用时,要创建最子类的对象。原因:

      一是因为有可能父类不能创建对象。

      二是创建子类对象可以使用更多的功能,包括基本的也包括特有的。

 简单一句就是:查阅父类功能,创建子类对象使用功能。


子父类出现后,类成员的特点:

        类成员:变量,函数,构造函数。

1,变量

       如果子类中出现非私有的同名成员变量时,子类要访问本类中的变量,用this。子类要访问父类中的同名变量,用super

        super的使用和this的使用几乎一致,且两者都存在于方法区中。

              this表示本来对象的引用。    

              super表示父类对象的引用。

2,函数——覆盖

       当子类出现和父类一模一样的函数时,当子类对象调用该函数,会运行子类函数的内容。如同父类的函数被覆盖一样。这种情况是函数的另一个特性:重写(覆盖)。

       当子类继承父类,沿袭了父类的功能,到子类中。但是子类虽具备该功能,但是功能的内容却和父类不一致,这时,没有必要定义新功能,而是使用覆盖特性,保留父类的功能定义,并重写功能内容。子类同时具有父类方法中的内容时,可以用super.方法();


注:1、子类覆盖父类,必须保证子类权限大于等于父类权限,才可以覆盖,否则编译失败。

         2、静态只能覆盖静态。

         3、父类中的私有方法不能被重写。

小知识点:

       重载:只看同名函数的参数列表。

       重写:子父类方法要一模一样。

3,构造函数。

       在对子类对象进行初始化时,父类的构造函数也会运行。那是因为子类的每一个构造函数默认第一行有一条隐式的语句super();

        super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();


       为什么子类一定要访问父类中的构造函数。

        因为父类中的数据子类可以直接获取,所以子类对象在建立时,需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时,要先访问一下父类中的构造函数。

       如果要访问父类中指定的构造函数,可以通过手动定义super语句的方式来指定。在上面的示例中已经有了很好的体现。

       注:super语句一定定义在子类构造函数中的第一行。


构造函数结论:

       子类的所有构造函数,默认都会访问父类中空参数的构造函数。因为子类每一个构造函数内的第一行都有一句隐式super();当父类中没有空参数的构造函数时,子类必须手动通过supe语句或者this语句形式来指定要访问的构造函数。当然子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。


小知识点:

为什么this()和super()不能在同一个构造函数中?

       因为它两不能在同一行。

为什么不能再同一行?

       因为初始化动作要先做。在子类构造函数中必有一个this语句或者super语句。


知识点:final关键字

       继承的出现,打破了对象的封装性,使得子类可以随意复写父类中的功能。这也是继承的一大弊端。所以就引出了一个新的关键字——final(最终)。

        final作为一个修饰符。具有以下特点:

        1,可以修饰类、函数、变量。

        2,被final修饰的类不可以被继承。这样就可以避免被继承、被子类复写功能。

        3,被final修饰的方法不可以被复写。

        4,被final修饰的变量是一个常量只能赋值一次,既可以修饰成员变量,又可以修饰局部变量, 当在描述事物时,一些数据的出现值是固定的,那么这时为了增强阅读性,都给这些值起个名字。方便于阅读。而这个值不需要改变,所以加上final修饰。作为常量:常量的书写规范所有字母都大写,如果由多个单词组成,单词间通过_连接。

        5,内部类定义在类中的局部位置上时,只能访问该局部被final修饰的局部变量。


二、抽象类


定义: 抽象就是从多个事物中将共性的,本质的内容抽取出来,Java中可以定义没有方法体的方法,该方法的具体实现由子类完成,该方法称为抽象方法,包含抽象方法的类就是抽象类。


1、抽象类的特点

        1、抽象类和抽象方法必须用abstract关键字来修饰。

        2、抽象方法只有方法声明,没有方法体,定义在抽象类中。

         格式:修饰符abstract返回值类型  函数名(参数列表);

        3、 抽象类不可以被实例化,也就是不可以用new创建对象。原因如下:

         抽象类是具体事物抽取出来的,本身是不具体的,没有对应的实例。

          而且抽象类即使创建了对象,调用抽象方法也没有意义。

        4、抽象类通过其子类实例化,而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象,否则该子类也是抽象类。

  注:抽象类中可以有非抽象的方法。


练习如下:定义Animal 类,定义cat和mouse类继承Animal类
[java]  view plain copy
  1. public class demo {  
  2.   
  3.     public static void main(String[] args) {  
  4.         new Cat("Tow","白色",2).shou();  
  5.           
  6.         new mouse("jerry","棕色").shou();  
  7.     }  
  8.   
  9. }  
  10. abstract class Animals  
  11. {    
  12.     String name;//姓名    
  13.     String colour;  //颜色  
  14.      
  15.         
  16.     //自定义构造函数初始化    
  17.     Animals(String name,String colour)    
  18.     {    
  19.         this.name = name;    
  20.         this.colour = colour;    
  21.           
  22.     }    
  23.         
  24.     public abstract void shou();//抽象的方法    
  25.     
  26. }    
  27.     
  28. //猫类,继承动物类    
  29. class Cat extends Animals    
  30. {    
  31.     private int age;    
  32.     Cat(String name,String colour,int age)//子类的构造方法    
  33.     {    
  34.         super(name,colour);//调用超类中的构造器    
  35.         this.age = age;    
  36.     }    
  37.     public void shou()//猫类的方法内容    
  38.     {    
  39.         System.out.println("I'm "+name+"   I'm "+age+"years old");    
  40.     }    
  41. }    
  42.     
  43. //老鼠类,继承动物类    
  44. class mouse extends Animals  
  45. {    
  46.     mouse(String name,String colour)    
  47.     {    
  48.         super(name,colour);    
  49.     }    
  50.     public void shou()//老鼠类的方法内容    
  51.     {    
  52.         System.out.println("I'm "+name);    
  53.     }    
  54. }    
  55.     

三、接口


1、概述

       接口,可以被认为是一个特殊的抽象类。当抽象类中的方法都是抽象的,那么该类可以通过接口的形式来表示。接口使用interface来表示,子类中用implements实现。格式为:

         interface 接口名{}   

        子类名 implements接口名{}

格式特点:

        1.接口中常见定义:常量,抽象方法。

        2.接口中的成员都有固定修饰符,编码时可不写,编译器会自动加上。

               常量:public static final

               方法:public abstract

        3,接口中的成员都是public的。

 

二、特点

        1,接口是对外暴露的规则。

        2,接口是程序的功能扩展。

        3,接口的出现降低耦合性。

        4,接口可以用来多实现。这也是对多继承不支持的转换形式。java支持多实现。

        5,类与接口之间是实现关系,而且类可以继承一个类的同时实现多个接口。

        6, 接口与接口之间可以有继承关系。而且可以多继承。

注:1,接口不可以创建对象的,因为有抽象方法。需要被子类实现(implements),子类对接口中的抽象方法全都覆盖后,子类才可以实例化。否则子类是一个抽象类。

        2,实现多个接口时,接口中不可以有返回不同类型的同名抽象函数。这样子类实现时将不能复写。

 

三、接口与抽象类

       共性:都是不断向上抽取出来的抽象的概念。

       区别:

                1,抽象类体现继承关系,一个类只能单继承。

                    接口体现实现关系,一个类可以多实现。同时接口与接口之间有继承关系。

                2,抽象类是继承,是 "is a "关系。

                    接口是实现,是 "like a"关系。

                3,抽象类中可以定义非抽象方法,供子类直接使用。

                    接口的方法都是抽象,接口中的成员都有固定修饰符。

                4,抽象类中可以私有变量或方法。

                    接口中的常量和方法都是public修饰的权限。


四、多态。


 多态可以理解为事物存在的多种体现形态。

1、多态的体现

       1、父类的引用指向了自己子类的对象。 

        2、父类的引用也可以接收自己的子类对象。


2、多态的前提

       1、类与类之间必须有关系,要么继承,要么实现。

        2、存在覆盖。父类中有方法被子类重写。

 

3、多态的利与弊

        利:提高了程序的可扩展性和后期可以维护性。

        弊:只能使用父类中的引用访问父类中的成员。也就是说使用了多态,父类型的引用在使用功能时,不能直接调用子类中的特有方法。


4、多态的应用

        1、定义好工具类,即将共同行为封装在一个类中。

        2、对类型进行抽取,---->多态的产生。

        3、操作同一父类型,对其中的子类型均可操作


实例如下:

[java]  view plain copy
  1. public class duotaiDemo {  
  2.   
  3.     public static void main(String[] args) {  
  4.         Person2 per=new chiness("黑马",20);//父类引用指向子类对象  
  5.         per.shou();//调用子类方法   注:前提是此方法为子类覆盖了父类中的方法  
  6.           
  7.           
  8.     }  
  9.   
  10. }  
  11. class Person2  
  12. {  
  13.     String name=null;  
  14.     int age=0;  
  15.     Person2(String name,int age){  
  16.         this.name=name;  
  17.         this.age=age;  
  18.     }  
  19.     public void shou(){}  
  20. }  
  21. class chiness extends Person2  
  22. {  
  23.     chiness(String s,int a){  
  24.         super(s,a);  
  25.     }  
  26.     public void shou()//覆盖父类方法  
  27.     {  
  28.         System.out.print(name);  
  29.     }  
  30. }  

你可能感兴趣的:(黑马程序员——学习日记之面向对象特征)