面向对象基础小结

Posted macro-renzhansheng

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了面向对象基础小结相关的知识,希望对你有一定的参考价值。

1.量化:我们最终是要对一个事物进行量化。
     连续型:一个连续的值,数不过来
     离散型:一个可以数的过来的值
    
2.分类的过程
     1)属性(特征):状态信息
     2)方法(行为):无法量化的一个过程

3.类:一个抽象的概念,是对事物的划分,不是具体的东西。
     类是具有相同属性和方法的一组对象的集合。
     类是对象的抽象,对象是类的具体。
4.对象:一个实实在在存在的东西,是一个你看得见摸得着的东西,是一个你能指名道姓的东西,是一个一说你就知道具体是什么的东西。
    
5.从编程角度来讲:
     类:是一个文件
         一个.java文件
         用class来声明类
         类的首字母必须大写
     对象:程序中的一个数据
         对象也是一种变量,叫引用类型变量
         对象的声明过程,完全符合一般变量的声明过程。【new +构造():真正的对象】
       

程序中区分不同的个体,或者如何描述个体的特征:
     属性:对象具有的各种特征,静态的。
     方法:描述对象执行的操作。动态的。
     --由一组属性和方法构成,描述客观存在的一个“实体”(对象)
     --具有相同属性和方法的一组对象的集合,类是对象的抽象化描述,对象是类的具体实例。(类)
    
对象和类是面向对象编程的核心。
     -所有的java程序都是以类class为组织单元,一个Java文件就是一个类。
     真正执行程序时通过类的具体化对象来完成的。
    
方法调用注意:
     基本数据类型传递变量的值
     引用数据类型传递是地址

结构化开发:面向过程
     面向功能划分的软件结构
     从上到下,按步执行
     最小的粒度是方法
     步骤繁琐,制约了软件的可维护性和可扩展性
     代码一次成型,后续修改非常麻烦
    
面向对象开发
     把软件系统看成各种对象的集合
     系统结构稳定
     子系统相对独立
     软件较好的可维护性,可扩展性强
    
面向过程编程:
     关注点在于每一个细节,每一步的具体操作。
面向对象:
     关注点在于整个事件的参与对象,将系统中的参与者全部看成模块化的对象。
    
面向对象程序设计:OOP
     编程思想,思维模式:将程序中的所有参与者模块化为对象,然后通过各种对象之间的相互作用关系来完成程序的需求。
类:对象的模板,抽象化的对象    如:Scanner工具类
对象:类的具体实例化

方法:
        void:关键字
        有值:声明一个类型
        如果返回值不是void,那么在方法当中,必须执行一次,也之恩那个执行一次return
         return执行之后,后面的代码会报错!

1. 修饰符 返回值类型 方法名(形参列表){方法体}
         形参列表:形参是指,传递给方法的参数类型。
         实参:调用的时候,具体传递值。
         参数传递:
             实参和形参的个数要对应
             类型位置要一一对应
             形参属于局部变量
        
         ***不定长参数:
             形参的定义方式:类型 ... 变量名
             实参的传递:类型统一,个数随意(0-n)
             不定长参数处理,当成一个数组处理。
             一个参数列表中,不定长参数只能有一个,而且只能放最后
             一般来说:不定长参数用的不多。--Java中没有默认值!

     2.地址传参******
         什么是地址?           
             实例化对象后————new(),就是新的对象。
             如果是对象之间的赋值,那么赋值的是堆内存的地址。
             在使用引用数据类型之前,请务必做好空值判断。
         引用传参
            
     3.构造方法:
         1.构造方法:描述一个对象的生成过程
         2.虚拟机默认会添加无参构造;如果显示声明过,则会覆盖。

     4.无论是构造方法,还是普通方法,都可以重载。
        
         在方法当中,直接调用变量名,优先取局部变量!
    
    This关键字:-->计算机组成等等底层的重要性!
         这方面未来有希望!!!(突破基础理论+应用)
       
         this:当前对象本身
             --理解:this.wait()
                   this.notifyAll()
         this()只能写在第一行————只能调用一次构造。
     作用域:
         1.代码块:写在一对花括号中间的。
         2.Java的作用域,叫块级作用域
         3.成员变量:直接卸载类当中,也叫:全局变量,处于犬奴作用域当中。
         4.局部变量:在方法当中(包括构造函数,静态代码块中)
         5.里面可以调用外面的,外面不可以调用里面的,平级之间按相互不干扰。
         6.成员变量会有初值:参考数组
         7.局部变量没有初值,必须初始化!!!
         8.局部变量不可以有访问修饰符*****
         9.局部变量的优先级是高于全局变量的
        

封装

封装:将类的某些信息隐藏在类的内部,不允许外部程序直接访问;
         外部只能通过该类提供的特定方法来实现对隐藏信息的操作和访问。
         如何实现封装:
             1.修改属性的访问权限,设置为private(私有)
             2.创建共有public的getter和setter方法
                 getter:让外部来获取属性的方法
                 setter:让外部来修改属性的方法
             3.setter方法中加入属性控制语句,以确保属性的正确性和合理性。


static修饰符:静态修饰符
         1.成员变量——静态变量,通过类名直接调用
         2.成员方法——静态方法,通过类名直接调用
         3.代码块:写在类中,方法之外,并且用{}包裹起来的一段代码。
             当程序中访问该类时,自动执行代码块中的语句。
         JVM加载该类时,执行该代码块,只执行一次。
        
         --用static修饰的成员变量也叫做类变量,表示该变量不再属于某个对象,而是属于该类,所有的对象共享该属性。(内存中只有一份)
         实例变量——不用static修饰
        
     静态方法:
         1.不能访问非静态方法、属性
         2.不能使用this关键字(实例化对象)

    ---静态关键字描述的是一种共有的信息,不属于任何一个实例对象,属于类,被所有的实例对象所共用。
     类的构造函数:给成员变量赋值,初始化
     类的静态代码块:给静态变量赋值   

继承

protected:同包 和 子类可见
不写(默认的):同包可见
private:同类可见

-最终类,不可被继承
-最终方法,不可被重写

继承:子类对父类的继承
     父类:
     子类:使用extends继承父类,除了私有和父类构造以外的所有成员。

单根继承原则:每个类,只能有一个直接的父类。

this:对象本身
super:代表父类对象(包含 继承链上的所有)对象
     -super可以调用父类的构造、属性和方法。
    
     1.默认情况下,子类构造将默认调用父类的空参构造 。
     2.如果父类没有空参构造,则子类需指定(显示)调用某个构造。
     -如果不在同一个包里,默认的成员则无法继承,但是可以继承protected的成员;
     -如果在同一个包里,则除了私有以外,都可以继承。
    
     3.使用this和super可以用来区分:父类和子类当中的成员。
         如果该成员是继承来的,那么也可以使用this来调用。
     4.为了防止父类和子类属性之间的相互污染。【属性】
    
     5.如果说,在子类当中不满足父类的某个方法,需要对该方法进行修改或补充,那么可以通过方法重写来实现。
         -当子类重写了父类的某个方法后,子类调用重写后的方法;父类调用原本的方法。
         -当父类当中有某个成员方法被多次重写,那么子类优先调用最近的那个!
        
         -构造方法不能被重写
         -重写可以理解为“覆盖”
          --访问权限不能严于父类。
          --返回值和父类相同,或者是父类返回值的子类。
          --参数列表相同
          --方法名一样
          --重写是父子之间。
         
     **父类当中的静态方法不能被子类覆盖为非静态;父类中非静态不能被覆盖为静态。
       ---实际应用当中:重写就是子类重写父类当中同样的方法。

实例化对象问题!
         --初始源头   
         -实例化一个子类对象时,一定会优先实例化其父类对象。
             并且实例化父类对象的操作是系统自动完成的,不需要我们自己编写代码!
                 --super()默认存在,不需要显示调用,跟无参构造相同。默认存在,不需要显示定义。
                     如果显示调用,super()必须写在第一行,否则语法报错。       
         -在子类中可以使用super调用方法,也可以访问属性,只能访问父类的公有的信息(包括间接父类),私有是无法访问的。


        子类的构造函数中可以通过super来访问父类的所有公有信息(属性、方法、构造方法)
         子类的普通方法中通过super可以访问属性和方法,但是不能调用构造方法。

Java中的每一个类,都是一个子类(Object除外),但 不是每一个类都是父类。

super 与 this的区别:
     相同点:super和this都可以访问类中的属性、方法、构造方法
         super、this访问构造方法时,必须写在第一行。
         super、this访问构造方法时,必须写在构造方法中!
     不同点:super时子类访问父类,维护两个类之间的关系。&& this是自己访问自己,维护一个类的关系。
         super 不能访问私有属性和方法,this可以访问私有属性和方法。


通过无参构造创建子类对象时
     -子类无参构造默认调用父类的无参构造。
     -手动调用父类的有参构造,会将默认的无参构造覆盖
通过有参构造创建子类对象时
     -子类有参构造默认调用父类的无参构造 ****
     -手动调用父类的有参构造,会将默认的无参构造覆盖

多态:同一个引用类型,因为实例不同,表现的形式也不同。

向上转型:父类声明指向子类对象。
     1.向上转型:父类声明
        (1)只能调用子类重写的方法,
         (2)或者本身实现,没有被子类覆盖的方法。

         ---子类特有的方法无法被调用,
         ?强转一下,应该可以?
         (3)向上转型,属于自动类型转换。
         **多个子类实现重写的方法,优先调用距离实现类最近的!
     2.向下转型:强制将父类型变为子类型。
         (1)前提:向上转型后,才能向下转型。
         (2)向下转型之前,一定要判断实例的类型。// class cast exception
         (3)向下转型属于强制类型转换!

多态——业务需求,频繁更改代码,可维护性、可扩展性比较差的问题
     :一个事物,多种表现形式。
     多态在实际使用中,需要建立继承关系,建立接口和实现类的关系。 *****
    
继承和方法重写是实现多态的基础。
     1.定义方法形参(形式参数)的数据类型为父类;实际调用为传入子类的实参
     2.定义方法时,返回值类型为父类,外部调用该方法时使用子类接收

多态衍生:抽象类

抽象类不能在外部实例化!!!
         --但是可以通过实例化继承子类,自动实现实例化抽象类。

没有抽象的构造方法,也没有抽象的静态static 方法。
抽象类中可以包含非抽象的构造方法,    创建子类实例对象时可以调用。


面向对象编程
     开发期间:类是构成Java程序的单位,Java程序通过类来组织其结构
     运行期间:对象是Java程序在运行时的单位,运行期间的Java程序是通过多个对象之间的相互作用关系来完成需求,动态。
    
null:空指针,内存地址的一个值,指空,不存在。
垃圾回收机制GC:是一个独立的巡查线程,GC是一个定时任务,隔一段时间执行一次。

基本数据类型在栈内存中开辟空间,同时直接将具体数值(而不是地址)保存在栈中
     --int numb = null;报错
引用类型在栈中开辟空间,同时在堆中开辟空间,创建对象,将对象地址保存在栈中。

抽象类

在class前加关键字abstract,用于表示当前类为抽象类。

      
     **在抽象类中,可以有普通方法,也可以有抽象方法。
         -抽象方法之只能在抽象类当中声明。
         -在修饰符和返回值之间,添加关键字 abstract,抽象方法没有方法体。
         -不需要立即实现。
        
     ***没有抽象的属性
     抽象类不可被实例化
     抽象方法必须在子类当中被实现,除非子类也是抽象类。
     ——在抽象类的子类当中,只要有一个子类实现了抽象方法,其后代不必一定实现该抽象方法。
    
     抽象类可以有构造?
     -原理:
         抽象类的构造函数用来初始化抽象类的一些字段,
         而这一切都在抽象类的派生类实例化之前发生。
         不仅如此,抽线类的构造函数还有一种巧妙应用:就是在其内部实现子类必须执行的代码。

综合应用——面向接口编程

面向接口编程是常见的一种开发方式。
     -面向接口编程就是将程序的业务逻辑提取出来,以接口的形式去对接不同的业务模块,接口只串联不实现,真正的业务逻辑交给接口
         的实现类来完成,当用户需求发生变更时,只需切换不同的实现类即可。
     (连接松散,低耦合)
    
“低耦合---高内聚”
     低耦合:降低模块之间的链接的紧密程度,模块之间是一种非常松散的状态,利于维护和扩展。
     高内聚:将相关的业务逻辑尽量集中到一个模块中。
    
面向接口编程的优点:
     1.能够最大限度地解耦,降低程序地耦合性
     2.使程序易于扩展
     3.有利于程序的后期维护

如何使用接口:
     默认都是抽象方法,abstract可省略;
     接口中可以定义成员变量,但是有如下要求:
         1.不能定义private、protected的权限修饰符,可以使用public 、默认修饰的成员变量
         2.成员变量必须被初始化(final***)
         3.接口中的成员变量必须是静态static,同时该成员变量还必须是一个常量!
         (static final都可以省略)

成员变量:定义在类中,方法体外的变量,属性。   
局部变量:定义在方法提中的变量
区别:
     1.作用域不同:变量的使用范围
         局部变量仅限于定义它的方法中,方法外无法访问。
         成员变量的作用域在整个类中都是可见的。
    
     2.初始值不同
         属性、成员变量都有一个初始值,初始值根据属性的数据类型来决定。
         基本数据类型:byteintshortlong :0
         char:‘ ‘
         boolean:false
         String引用类型:null

方法重载:(方法允许重名)
     1.同一个类 ***
     2.方法名相同
     3.参数列表不同,个数、数据类型不同
     4.与返回值、访问权限无关。

== 和 equals()的区别?
     ==:栈内存中的值是否相等
         如果数据是基本数据类型,比较的是数据的值是否相等,
         如果是引用类型,比较的是引用地址(数据的内存地址是否相等)
     equals():Object类中定义的一个方法,默认方法体是通过==进行判断的(只能使用引用数据类型进行调用)
         默认是比较数据的内存地址
         重写,按照实际。(equals()方法经常会被Object的子类进行重写,比较典型,
             String类中的重写--字符串的值是否相等进行判断,改为判断String的数组内容进行比较)

switch(num):num为除long型以外的整数+String(jdk>7)+char
     --switch{},为独立的作用域
         --无需依次比较,一次找到目标
     --default:当所有条件都不满足的时候,执行default
         可以有,也可以没有;可放置在任意位置;
             -习惯放在首位、末尾,如果不在末尾需要加break;

循环:
     四大要素:
         初始化变量
         判断条件
         循环体
         迭代:无限趋近目标       

以上是关于面向对象基础小结的主要内容,如果未能解决你的问题,请参考以下文章

面向对象基础知识点小结

面向对象基础

Java基础02 面向对象

面向对象进阶小结

Java基础语法——面向对象

Java面向对象小结